diff --git a/.gitignore b/.gitignore index cab742a231..189b6a39a5 100644 --- a/.gitignore +++ b/.gitignore @@ -10,14 +10,28 @@ *.tox -build - -dist - debug_script.py test_output.txt plotly/api/v2/spectacle_presentations.py -plotly/presentation_objs/ \ No newline at end of file +plotly/presentation_objs/ + +.idea + +js/node_modules/ + +# Compiled javascript +plotlywidget/static/ + +.pytest_cache + +# virtual envs +vv +venv + +# dist files +build +dist +plotly.egg-info/ diff --git a/CHANGELOG.md b/CHANGELOG.md index f938042aa3..945e8270af 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,9 +2,22 @@ All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/). -## [2.7.1] - [UNRELEASED] -### Updated -- error message for `plotly.figure_factory.create_choropleth` is now helpful to Anaconda users who do not have the correct modules installed for the County Choropleth figure factory. +## 3.0.0 - 2018-07-05 + +This is a major version with many exciting updates. See the [Introducing plotly.py 3.0.0](https://medium.com/@plotlygraphs/introducing-plotly-py-3-0-0-7bb1333f69c6) post for more information. + +### Added +- Full Jupyter ipywidgets integration with the new `graph_objs.FigureWidget` class +- `FigureWidget` figures can be updated interactively using property assignment syntax +- The full trace and layout API is generated from the plotly schema to provide a great experience for interactive use in the notebook +- Support for setting array properties as numpy arrays. When numpy arrays are used, ipywidgets binary serialization protocol is used to avoid converting these to JSON strings. +- Context manager API for animation. Run `help(go.Figure().batch_animate)` for the full doc string. +- Perform automatic retries when communicating with plot.ly services. This introduces a new required dependency on the [retrying](https://pypi.org/project/retrying/) library. +- Improved data validation covering the full API with clear, informative error messages. This means that incorrect properties and/or values now always raise a `ValueError` with a description of the error, the invalid property, and the available properties on the level that it was placed in the graph object. Eg. `go.Scatter(foo=123)` raises a validation error. See https://plot.ly/python/reference/ for a reference to all valid properties and values in the Python API. +- Error message for `plotly.figure_factory.create_choropleth` is now helpful to Anaconda users who do not have the correct modules installed for the County Choropleth figure factory. + +### Changed / Deprecated +Please see the [migration guid](migration-guide.md) for a full list of the changes and deprecations in version 3.0.0 ## [2.7.0] - 2018-05-23 ### Updated diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000000..f866789bdf --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,4 @@ +include LICENSE +include README.rst +include README.md +include plotlywidget.json diff --git a/README.md b/README.md index 6a89b1052a..c2b3d2e631 100644 --- a/README.md +++ b/README.md @@ -1,11 +1,6 @@ # plotly.py -> 📢 Announcement! -> Registration is open for a 2 day, Dash master class in Washington DC, June 9-10. -> [Register online here](https://plotcon.plot.ly/tickets/) 🎚📈🏛 - -*** - +## Overview [plotly.py](https://plot.ly/d3-js-for-python-and-pandas-charts/) is an interactive, browser-based graphing library for Python :sparkles: Built on top of [plotly.js](https://github.com/plotly/plotly.js), `plotly.py` is a high-level, declarative charting library. plotly.js ships with over 30 chart types, including scientific charts, 3D graphs, statistical charts, SVG maps, financial charts, and more. @@ -22,14 +17,42 @@ Built on top of [plotly.js](https://github.com/plotly/plotly.js), `plotly.py` is *** - [Online Documentation](https://plot.ly/python) -- [`contributing.md`](https://github.com/plotly/python-api/blob/master/contributing.md) +- [Contributing](contributing.md) +- [Changelog](CHANGELOG.md) - [Code of Conduct](CODE_OF_CONDUCT.md) +- [Version 3 Migration Guide](migration-guide.md) - [New! Announcing Dash](https://medium.com/@plotlygraphs/introducing-dash-5ecf7191b503) - [Community](https://community.plot.ly/c/api/python) *** -Code and documentation copyright 2017 Plotly, Inc. +## Installation of plotly.py Version 3 +To install plotly.py and enable Jupyter or Jupyter Lab support, run: +``` +pip install "plotly>=3.0" +pip install "notebook>=5.3" "ipywidgets>=7.2" # only necessary for Jupyter Notebook environments +``` + +If you're using older versions of `notebook` or `ipywidgets` you may need to manually activate the widget extensions (this should not be needed for `notebook>=5.3` and `ipywidgets>=7.2`) + +``` +jupyter nbextension enable --py widgetsnbextension --sys-prefix +jupyter nbextension enable --py plotlywidget --sys-prefix +``` + +In addition, to add JupyterLab support run the following commands + +``` +pip install jupyterlab +export NODE_OPTIONS=--max-old-space-size=4096 +jupyter labextension install @jupyter-widgets/jupyterlab-manager # install the Jupyter widgets extension +jupyter labextension install plotlywidget +``` + +If you're migrating from plotly.py version 2, please check out the [migration guid](migration-guide.md) + +## Copyright and Licenses +Code and documentation copyright 2018 Plotly, Inc. Code released under the [MIT license](LICENSE.txt). diff --git a/_plotly_utils/README.md b/_plotly_utils/README.md new file mode 100644 index 0000000000..6fed1b4d4d --- /dev/null +++ b/_plotly_utils/README.md @@ -0,0 +1,7 @@ +This package is for utilities that are used during code generation +and at runtime. The reason for not placing these under the main plotly/ +package is that this avoids the complications of importing the module +we're generating code into during code generation. + +This module must be independent of (it must not import from) both +plotly/ and codegen/ \ No newline at end of file diff --git a/_plotly_utils/__init__.py b/_plotly_utils/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/_plotly_utils/basevalidators.py b/_plotly_utils/basevalidators.py new file mode 100644 index 0000000000..d094e27aae --- /dev/null +++ b/_plotly_utils/basevalidators.py @@ -0,0 +1,1974 @@ +import base64 +import numbers +import textwrap +import uuid +from importlib import import_module + +import io +from copy import deepcopy + +import re + +# Optional imports +# ---------------- +import sys +from six import string_types + +np = None +pd = None + +try: + np = import_module('numpy') + + try: + pd = import_module('pandas') + except ImportError: + pass + +except ImportError: + pass + + +# back-port of fullmatch from Py3.4+ +def fullmatch(regex, string, flags=0): + """Emulate python-3.4 re.fullmatch().""" + if 'pattern' in dir(regex): + regex_string = regex.pattern + else: + regex_string = regex + return re.match("(?:" + regex_string + r")\Z", string, flags=flags) + + +# Utility functions +# ----------------- +def to_scalar_or_list(v): + if isinstance(v, (list, tuple)): + return [to_scalar_or_list(e) for e in v] + elif np and isinstance(v, np.ndarray): + return [to_scalar_or_list(e) for e in v] + elif pd and isinstance(v, (pd.Series, pd.Index)): + return [to_scalar_or_list(e) for e in v] + else: + return v + + +def copy_to_readonly_numpy_array(v, dtype=None, force_numeric=False): + """ + Convert an array-like value into a read-only numpy array + + Parameters + ---------- + v : array like + Array like value (list, tuple, numpy array, pandas series, etc.) + dtype : str + If specified, the numpy dtype that the array should be forced to + have. If not specified then let numpy infer the datatype + force_numeric : bool + If true, raise an exception if the resulting numpy array does not + have a numeric dtype (i.e. dtype.kind not in ['u', 'i', 'f']) + Returns + ------- + np.ndarray + Numpy array with the 'WRITEABLE' flag set to False + """ + + assert np is not None + + # Copy to numpy array and handle dtype param + # ------------------------------------------ + # If dtype was not specified then it will be passed to the numpy array + # constructor as None and the data type will be inferred automatically + + # TODO: support datetime dtype here and in widget serialization + # u: unsigned int, i: signed int, f: float + numeric_kinds = ['u', 'i', 'f'] + + if not isinstance(v, np.ndarray): + v_list = [to_scalar_or_list(e) for e in v] + new_v = np.array(v_list, order='C', dtype=dtype) + elif v.dtype.kind in numeric_kinds: + new_v = np.ascontiguousarray(v.astype(dtype)) + else: + new_v = v.copy() + + # Handle force numeric param + # -------------------------- + if force_numeric and new_v.dtype.kind not in numeric_kinds: + raise ValueError('Input value is not numeric and' + 'force_numeric parameter set to True') + + if dtype != 'unicode': + # Force non-numeric arrays to have object type + # -------------------------------------------- + # Here we make sure that non-numeric arrays have the object + # datatype. This works around cases like np.array([1, 2, '3']) where + # numpy converts the integers to strings and returns array of dtype + # ' 'x' for anchor-style + # enumeration properties + self.regex_replacements = [] + + # Loop over enumeration values + # ---------------------------- + # Look for regular expressions + for v in self.values: + if v and isinstance(v, string_types) and v[0] == '/' and v[-1] == '/': + # String is a regex with leading and trailing '/' character + regex_str = v[1:-1] + self.val_regexs.append(re.compile(regex_str)) + self.regex_replacements.append( + EnumeratedValidator.build_regex_replacement(regex_str)) + else: + self.val_regexs.append(None) + self.regex_replacements.append(None) + + @staticmethod + def build_regex_replacement(regex_str): + # Example: regex_str == r"^y([2-9]|[1-9][0-9]+)?$" + # + # When we see a regular expression like the one above, we want to + # build regular expression replacement params that will remove a + # suffix of 1 from the input string ('y1' -> 'y' in this example) + # + # Why?: Regular expressions like this one are used in enumeration + # properties that refer to subplotids (e.g. layout.annotation.xref) + # The regular expressions forbid suffixes of 1, like 'x1'. But we + # want to accept 'x1' and coerce it into 'x' + # + # To be cautious, we only perform this conversion for enumerated + # values that match the anchor-style regex + match = re.match(r"\^(\w)\(\[2\-9\]\|\[1\-9\]\[0\-9\]\+\)\?\$", + regex_str) + + if match: + anchor_char = match.group(1) + return '^' + anchor_char + '1$', anchor_char + else: + return None + + def perform_replacemenet(self, v): + """ + Return v with any applicable regex replacements applied + """ + if isinstance(v, string_types): + for repl_args in self.regex_replacements: + if repl_args: + v = re.sub(repl_args[0], repl_args[1], v) + + return v + + def description(self): + + # Separate regular values from regular expressions + enum_vals = [] + enum_regexs = [] + for v, regex in zip(self.values, self.val_regexs): + if regex is not None: + enum_regexs.append(regex.pattern) + else: + enum_vals.append(v) + desc = ("""\ + The '{name}' property is an enumeration that may be specified as:""" + .format(name=self.plotly_name)) + + if enum_vals: + enum_vals_str = '\n'.join( + textwrap.wrap( + repr(enum_vals), + initial_indent=' ' * 12, + subsequent_indent=' ' * 12, + break_on_hyphens=False)) + + desc = desc + """ + - One of the following enumeration values: +{enum_vals_str}""".format(enum_vals_str=enum_vals_str) + + if enum_regexs: + enum_regexs_str = '\n'.join( + textwrap.wrap( + repr(enum_regexs), + initial_indent=' ' * 12, + subsequent_indent=' ' * 12, + break_on_hyphens=False)) + + desc = desc + """ + - A string that matches one of the following regular expressions: +{enum_regexs_str}""".format(enum_regexs_str=enum_regexs_str) + + if self.array_ok: + desc = desc + """ + - A tuple, list, or one-dimensional numpy array of the above""" + + return desc + + def in_values(self, e): + """ + Return whether a value matches one of the enumeration options + """ + is_str = isinstance(e, string_types) + for v, regex in zip(self.values, self.val_regexs): + if is_str and regex: + in_values = fullmatch(regex, e) is not None + #in_values = regex.fullmatch(e) is not None + else: + in_values = e == v + + if in_values: + return True + + return False + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_array(v): + v_replaced = [self.perform_replacemenet(v_el) for v_el in v] + + invalid_els = [e for e in v_replaced if (not self.in_values(e))] + if invalid_els: + self.raise_invalid_elements(invalid_els[:10]) + + if is_homogeneous_array(v): + v = copy_to_readonly_numpy_array(v) + else: + v = to_scalar_or_list(v) + else: + v = self.perform_replacemenet(v) + if not self.in_values(v): + self.raise_invalid_val(v) + return v + + +class BooleanValidator(BaseValidator): + """ + "boolean": { + "description": "A boolean (true/false) value.", + "requiredOpts": [], + "otherOpts": [ + "dflt" + ] + }, + """ + + def __init__(self, plotly_name, parent_name, **kwargs): + super(BooleanValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + return ("""\ + The '{plotly_name}' property must be specified as a bool + (either True, or False)""".format(plotly_name=self.plotly_name)) + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif not isinstance(v, bool): + self.raise_invalid_val(v) + + return v + + +class SrcValidator(BaseValidator): + + def __init__(self, plotly_name, parent_name, **kwargs): + super(SrcValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + return ("""\ + The '{plotly_name}' property must be specified as a string or + as a plotly.grid_objs.Column object""".format(plotly_name=self.plotly_name)) + + def validate_coerce(self, v): + from plotly.grid_objs import Column + if v is None: + # Pass None through + pass + elif isinstance(v, string_types): + pass + elif isinstance(v, Column): + # Convert to id string + v = v.id + else: + self.raise_invalid_val(v) + + return v + + +class NumberValidator(BaseValidator): + """ + "number": { + "description": "A number or a numeric value (e.g. a number + inside a string). When applicable, values + greater (less) than `max` (`min`) are coerced to + the `dflt`.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "min", + "max", + "arrayOk" + ] + }, + """ + + def __init__(self, + plotly_name, + parent_name, + min=None, + max=None, + array_ok=False, + **kwargs): + super(NumberValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + # Handle min + if min is None and max is not None: + # Max was specified, so make min -inf + self.min_val = float('-inf') + else: + self.min_val = min + + # Handle max + if max is None and min is not None: + # Min was specified, so make min inf + self.max_val = float('inf') + else: + self.max_val = max + + if min is not None or max is not None: + self.has_min_max = True + else: + self.has_min_max = False + + self.array_ok = array_ok + + def description(self): + desc = ("""\ + The '{plotly_name}' property is a number and may be specified as:""" + .format(plotly_name=self.plotly_name)) + + if not self.has_min_max: + desc = desc + """ + - An int or float""" + + else: + desc = desc + """ + - An int or float in the interval [{min_val}, {max_val}]""".format( + min_val=self.min_val, max_val=self.max_val) + + if self.array_ok: + desc = desc + """ + - A tuple, list, or one-dimensional numpy array of the above""" + + return desc + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_homogeneous_array(v): + + try: + v_array = copy_to_readonly_numpy_array(v, force_numeric=True) + except (ValueError, TypeError, OverflowError): + self.raise_invalid_val(v) + + # Check min/max + if self.has_min_max: + v_valid = np.logical_and(self.min_val <= v_array, + v_array <= self.max_val) + + if not np.all(v_valid): + # Grab up to the first 10 invalid values + v_invalid = np.logical_not(v_valid) + some_invalid_els = (np.array(v, dtype='object') + [v_invalid][:10] + .tolist()) + + self.raise_invalid_elements(some_invalid_els) + + v = v_array # Always numeric numpy array + elif self.array_ok and is_simple_array(v): + # Check numeric + invalid_els = [e for e in v if not isinstance(e, numbers.Number)] + + if invalid_els: + self.raise_invalid_elements(invalid_els[:10]) + + # Check min/max + if self.has_min_max: + invalid_els = [e for e in v if + not (self.min_val <= e <= self.max_val)] + + if invalid_els: + self.raise_invalid_elements(invalid_els[:10]) + + v = to_scalar_or_list(v) + else: + # Check numeric + if not isinstance(v, numbers.Number): + self.raise_invalid_val(v) + + # Check min/max + if self.has_min_max: + if not (self.min_val <= v <= self.max_val): + self.raise_invalid_val(v) + return v + + +class IntegerValidator(BaseValidator): + """ + "integer": { + "description": "An integer or an integer inside a string. When + applicable, values greater (less) than `max` + (`min`) are coerced to the `dflt`.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "min", + "max", + "arrayOk" + ] + }, + """ + + def __init__(self, + plotly_name, + parent_name, + min=None, + max=None, + array_ok=False, + **kwargs): + super(IntegerValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + # Handle min + if min is None and max is not None: + # Max was specified, so make min -inf + self.min_val = -sys.maxsize - 1 + else: + self.min_val = min + + # Handle max + if max is None and min is not None: + # Min was specified, so make min inf + self.max_val = sys.maxsize + else: + self.max_val = max + + if min is not None or max is not None: + self.has_min_max = True + else: + self.has_min_max = False + + self.array_ok = array_ok + + def description(self): + desc = ("""\ + The '{plotly_name}' property is a integer and may be specified as:""" + .format(plotly_name=self.plotly_name)) + + if not self.has_min_max: + desc = desc + """ + - An int (or float that will be cast to an int)""" + else: + desc = desc + (""" + - An int (or float that will be cast to an int) + in the interval [{min_val}, {max_val}]""".format( + min_val=self.min_val, max_val=self.max_val)) + + if self.array_ok: + desc = desc + """ + - A tuple, list, or one-dimensional numpy array of the above""" + + return desc + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_homogeneous_array(v): + if v.dtype.kind not in ['i', 'u']: + self.raise_invalid_val(v) + + v_array = copy_to_readonly_numpy_array(v, dtype='int32') + + # Check min/max + if self.has_min_max: + v_valid = np.logical_and(self.min_val <= v_array, + v_array <= self.max_val) + + if not np.all(v_valid): + # Grab up to the first 10 invalid values + v_invalid = np.logical_not(v_valid) + some_invalid_els = (np.array(v, dtype='object') + [v_invalid][:10].tolist()) + self.raise_invalid_elements(some_invalid_els) + + v = v_array + elif self.array_ok and is_simple_array(v): + # Check integer type + invalid_els = [e for e in v if not isinstance(e, int)] + + if invalid_els: + self.raise_invalid_elements(invalid_els[:10]) + + # Check min/max + if self.has_min_max: + invalid_els = [e for e in v if + not (self.min_val <= e <= self.max_val)] + + if invalid_els: + self.raise_invalid_elements(invalid_els[:10]) + + v = to_scalar_or_list(v) + else: + # Check int + if not isinstance(v, int): + # don't let int() cast strings to ints + self.raise_invalid_val(v) + + # Check min/max + if self.has_min_max: + if not (self.min_val <= v <= self.max_val): + self.raise_invalid_val(v) + + return v + + +class StringValidator(BaseValidator): + """ + "string": { + "description": "A string value. Numbers are converted to strings + except for attributes with `strict` set to true.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "noBlank", + "strict", + "arrayOk", + "values" + ] + }, + """ + + def __init__(self, + plotly_name, + parent_name, + no_blank=False, + strict=False, + array_ok=False, + values=None, + **kwargs): + super(StringValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + self.no_blank = no_blank + self.strict = strict + self.array_ok = array_ok + self.values = values + + def description(self): + desc = ("""\ + The '{plotly_name}' property is a string and must be specified as:""" + .format(plotly_name=self.plotly_name)) + + if self.no_blank: + desc = desc + """ + - A non-empty string""" + elif self.values: + valid_str = '\n'.join( + textwrap.wrap( + repr(self.values), + initial_indent=' ' * 12, + subsequent_indent=' ' * 12, + break_on_hyphens=False)) + + desc = desc + """ + - One of the following strings: +{valid_str}""".format(valid_str=valid_str) + else: + desc = desc + """ + - A string""" + + if not self.strict: + desc = desc + """ + - A number that will be converted to a string""" + + if self.array_ok: + desc = desc + """ + - A tuple, list, or one-dimensional numpy array of the above""" + + return desc + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_array(v): + + # If strict, make sure all elements are strings. + if self.strict: + invalid_els = [e for e in v if not isinstance(e, string_types)] + if invalid_els: + self.raise_invalid_elements(invalid_els) + + if is_homogeneous_array(v): + # If not strict, let numpy cast elements to strings + v = copy_to_readonly_numpy_array(v, dtype='unicode') + + # Check no_blank + if self.no_blank: + invalid_els = v[v == ''][:10].tolist() + if invalid_els: + self.raise_invalid_elements(invalid_els) + + # Check values + if self.values: + invalid_inds = np.logical_not(np.isin(v, self.values)) + invalid_els = v[invalid_inds][:10].tolist() + if invalid_els: + self.raise_invalid_elements(invalid_els) + + elif is_simple_array(v): + if not self.strict: + v = [str(e) for e in v] + + # Check no_blank + if self.no_blank: + invalid_els = [e for e in v if e == ''] + if invalid_els: + self.raise_invalid_elements(invalid_els) + + # Check values + if self.values: + invalid_els = [e for e in v if v not in self.values] + if invalid_els: + self.raise_invalid_elements(invalid_els) + + v = to_scalar_or_list(v) + + else: + if self.strict: + if not isinstance(v, string_types): + self.raise_invalid_val(v) + else: + if not isinstance(v, string_types + (int, float)): + self.raise_invalid_val(v) + + # Convert value to a string + v = str(v) + + if self.no_blank and len(v) == 0: + self.raise_invalid_val(v) + + if self.values and v not in self.values: + self.raise_invalid_val(v) + + return v + + +class ColorValidator(BaseValidator): + """ + "color": { + "description": "A string describing color. Supported formats: + - hex (e.g. '#d3d3d3') + - rgb (e.g. 'rgb(255, 0, 0)') + - rgba (e.g. 'rgb(255, 0, 0, 0.5)') + - hsl (e.g. 'hsl(0, 100%, 50%)') + - hsv (e.g. 'hsv(0, 100%, 100%)') + - named colors(full list: + http://www.w3.org/TR/css3-color/#svg-color)", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "arrayOk" + ] + }, + """ + re_hex = re.compile('#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})') + re_rgb_etc = re.compile('(rgb|hsl|hsv)a?\([\d.]+%?(,[\d.]+%?){2,3}\)') + + named_colors = [ + "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige", + "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown", + "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", + "cornflowerblue", "cornsilk", "crimson", "cyan", "darkblue", + "darkcyan", "darkgoldenrod", "darkgray", "darkgrey", "darkgreen", + "darkkhaki", "darkmagenta", "darkolivegreen", "darkorange", + "darkorchid", "darkred", "darksalmon", "darkseagreen", "darkslateblue", + "darkslategray", "darkslategrey", "darkturquoise", "darkviolet", + "deeppink", "deepskyblue", "dimgray", "dimgrey", "dodgerblue", + "firebrick", "floralwhite", "forestgreen", "fuchsia", "gainsboro", + "ghostwhite", "gold", "goldenrod", "gray", "grey", "green", + "greenyellow", "honeydew", "hotpink", "indianred", "indigo", "ivory", + "khaki", "lavender", "lavenderblush", "lawngreen", "lemonchiffon", + "lightblue", "lightcoral", "lightcyan", "lightgoldenrodyellow", + "lightgray", "lightgrey", "lightgreen", "lightpink", "lightsalmon", + "lightseagreen", "lightskyblue", "lightslategray", "lightslategrey", + "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", + "magenta", "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", + "mediumpurple", "mediumseagreen", "mediumslateblue", + "mediumspringgreen", "mediumturquoise", "mediumvioletred", + "midnightblue", "mintcream", "mistyrose", "moccasin", "navajowhite", + "navy", "oldlace", "olive", "olivedrab", "orange", "orangered", + "orchid", "palegoldenrod", "palegreen", "paleturquoise", + "palevioletred", "papayawhip", "peachpuff", "peru", "pink", "plum", + "powderblue", "purple", "red", "rosybrown", "royalblue", "saddlebrown", + "salmon", "sandybrown", "seagreen", "seashell", "sienna", "silver", + "skyblue", "slateblue", "slategray", "slategrey", "snow", + "springgreen", "steelblue", "tan", "teal", "thistle", "tomato", + "turquoise", "violet", "wheat", "white", "whitesmoke", "yellow", + "yellowgreen" + ] + + def __init__(self, + plotly_name, + parent_name, + array_ok=False, + colorscale_path=None, + **kwargs): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + self.array_ok = array_ok + + # colorscale_path is the path to the colorscale associated with this + # color property, or None if no such colorscale exists. Only colors + # with an associated colorscale may take on numeric values + self.colorscale_path = colorscale_path + + def numbers_allowed(self): + return self.colorscale_path is not None + + def description(self): + + named_clrs_str = '\n'.join( + textwrap.wrap( + ', '.join(self.named_colors), + width=79 - 16, + initial_indent=' ' * 12, + subsequent_indent=' ' * 12)) + + valid_color_description = """\ + The '{plotly_name}' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: +{clrs}""".format( + plotly_name=self.plotly_name, clrs=named_clrs_str) + + if self.colorscale_path: + valid_color_description = valid_color_description + """ + - A number that will be interpreted as a color + according to {colorscale_path}""".format( + colorscale_path=self.colorscale_path) + + if self.array_ok: + valid_color_description = valid_color_description + """ + - A list or array of any of the above""" + + return valid_color_description + + def validate_coerce(self, v, should_raise=True): + if v is None: + # Pass None through + pass + elif self.array_ok and is_homogeneous_array(v): + + v_array = copy_to_readonly_numpy_array(v) + if (self.numbers_allowed() and + v_array.dtype.kind in ['u', 'i', 'f']): + # Numbers are allowed and we have an array of numbers. + # All good + v = v_array + else: + validated_v = [ + self.validate_coerce(e, should_raise=False) + for e in v] + + invalid_els = self.find_invalid_els(v, validated_v) + + if invalid_els and should_raise: + self.raise_invalid_elements(invalid_els) + + # ### Check that elements have valid colors types ### + elif self.numbers_allowed() or invalid_els: + v = copy_to_readonly_numpy_array( + validated_v, dtype='object') + else: + v = copy_to_readonly_numpy_array( + validated_v, dtype='unicode') + elif self.array_ok and is_simple_array(v): + validated_v = [ + self.validate_coerce(e, should_raise=False) + for e in v] + + invalid_els = self.find_invalid_els(v, validated_v) + + if invalid_els and should_raise: + self.raise_invalid_elements(invalid_els) + else: + v = validated_v + else: + # Validate scalar color + validated_v = self.vc_scalar(v) + if validated_v is None and should_raise: + self.raise_invalid_val(v) + + v = validated_v + + return v + + def find_invalid_els(self, orig, validated, invalid_els=None): + """ + Helper method to find invalid elements in orig array. + Elements are invalid if their corresponding element in + the validated array is None. + + This method handles deeply nested list structures + """ + if invalid_els is None: + invalid_els = [] + + for orig_el, validated_el in zip(orig, validated): + if is_array(orig_el): + self.find_invalid_els(orig_el, validated_el, invalid_els) + else: + if validated_el is None: + invalid_els.append(orig_el) + + return invalid_els + + def vc_scalar(self, v): + """ Helper to validate/coerce a scalar color """ + return ColorValidator.perform_validate_coerce( + v, allow_number=self.numbers_allowed()) + + @staticmethod + def perform_validate_coerce(v, allow_number=None): + """ + Validate, coerce, and return a single color value. If input cannot be + coerced to a valid color then return None. + + Parameters + ---------- + v : number or str + Candidate color value + + allow_number : bool + True if numbers are allowed as colors + + Returns + ------- + number or str or None + """ + + if isinstance(v, numbers.Number) and allow_number: + # If allow_numbers then any number is ok + return v + elif not isinstance(v, string_types): + # If not allow_numbers then value must be a string + return None + else: + # Remove spaces so regexes don't need to bother with them. + v_normalized = v.replace(' ', '').lower() + + # if ColorValidator.re_hex.fullmatch(v_normalized): + if fullmatch(ColorValidator.re_hex, v_normalized): + # valid hex color (e.g. #f34ab3) + return v + elif fullmatch(ColorValidator.re_rgb_etc, v_normalized): + # elif ColorValidator.re_rgb_etc.fullmatch(v_normalized): + # Valid rgb(a), hsl(a), hsv(a) color + # (e.g. rgba(10, 234, 200, 50%) + return v + elif v_normalized in ColorValidator.named_colors: + # Valid named color (e.g. 'coral') + return v + else: + # Not a valid color + return None + + +class ColorlistValidator(BaseValidator): + """ + "colorlist": { + "description": "A list of colors. Must be an {array} containing + valid colors.", + "requiredOpts": [], + "otherOpts": [ + "dflt" + ] + } + """ + + def __init__(self, plotly_name, parent_name, **kwargs): + super(ColorlistValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + return ("""\ + The '{plotly_name}' property is a colorlist that may be specified + as a tuple, list, one-dimensional numpy array, or pandas Series of valid + color strings""".format(plotly_name=self.plotly_name)) + + def validate_coerce(self, v): + + if v is None: + # Pass None through + pass + elif is_array(v): + validated_v = [ + ColorValidator.perform_validate_coerce(e, allow_number=False) + for e in v + ] + + invalid_els = [ + el for el, validated_el in zip(v, validated_v) + if validated_el is None + ] + if invalid_els: + self.raise_invalid_elements(invalid_els) + + v = to_scalar_or_list(v) + else: + self.raise_invalid_val(v) + return v + + +class ColorscaleValidator(BaseValidator): + """ + "colorscale": { + "description": "A Plotly colorscale either picked by a name: + (any of Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, + Jet, Hot, Blackbody, Earth, Electric, Viridis) + customized as an {array} of 2-element {arrays} + where the first element is the normalized color + level value (starting at *0* and ending at *1*), + and the second item is a valid color string.", + "requiredOpts": [], + "otherOpts": [ + "dflt" + ] + }, + """ + + named_colorscales = [ + 'Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', 'Reds', + 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', 'Hot', 'Blackbody', + 'Earth', 'Electric', 'Viridis' + ] + + def __init__(self, plotly_name, parent_name, **kwargs): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + desc = """\ + The '{plotly_name}' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + """.format(plotly_name=self.plotly_name) + + return desc + + def validate_coerce(self, v): + v_valid = False + + if v is None: + # Pass None through + pass + if v is None: + v_valid = True + elif isinstance(v, string_types): + v_match = [ + el for el in ColorscaleValidator.named_colorscales + if el.lower() == v.lower() + ] + if v_match: + v_valid = True + + elif is_array(v) and len(v) > 0: + invalid_els = [ + e for e in v + if (not is_array(e) or + len(e) != 2 or + not isinstance(e[0], numbers.Number) or + not (0 <= e[0] <= 1) or + not isinstance(e[1], string_types) or + ColorValidator.perform_validate_coerce(e[1]) is None)] + + if len(invalid_els) == 0: + v_valid = True + + # Convert to list of lists + v = [[e[0], + ColorValidator.perform_validate_coerce(e[1])] + for e in v] + + if not v_valid: + self.raise_invalid_val(v) + + return v + + def present(self, v): + # Return tuple of tuples so that colorscale is immutable + if v is None: + return None + else: + return tuple([tuple(e) for e in v]) + + +class AngleValidator(BaseValidator): + """ + "angle": { + "description": "A number (in degree) between -180 and 180.", + "requiredOpts": [], + "otherOpts": [ + "dflt" + ] + }, + """ + + def __init__(self, plotly_name, parent_name, **kwargs): + super(AngleValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + desc = """\ + The '{plotly_name}' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + """.format(plotly_name=self.plotly_name) + + return desc + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif not isinstance(v, numbers.Number): + self.raise_invalid_val(v) + else: + # Normalize v onto the interval [-180, 180) + v = (v + 180) % 360 - 180 + + return v + + +class SubplotidValidator(BaseValidator): + """ + "subplotid": { + "description": "An id string of a subplot type (given by dflt), + optionally followed by an integer >1. e.g. if + dflt='geo', we can have 'geo', 'geo2', 'geo3', + ...", + "requiredOpts": [ + "dflt" + ], + "otherOpts": [ + "regex" + ] + } + """ + + def __init__(self, plotly_name, + parent_name, + dflt=None, + regex=None, + **kwargs): + + if dflt is None and regex is None: + raise ValueError( + 'One or both of regex and deflt must be specified' + ) + + super(SubplotidValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + if dflt is not None: + self.base = dflt + else: + # e.g. regex == '/^y([2-9]|[1-9][0-9]+)?$/' + self.base = re.match('/\^(\w+)', + regex).group(1) + + if regex is not None: + # Remove leading/trailing '/' characters + self.regex = regex[1:-1] + else: + self.regex = dflt + "(\d*)" + + def description(self): + + desc = """\ + The '{plotly_name}' property is an identifier of a particular + subplot, of type '{base}', that may be specified as the string '{base}' + optionally followed by an integer >= 1 + (e.g. '{base}', '{base}1', '{base}2', '{base}3', etc.) + """.format( + plotly_name=self.plotly_name, base=self.base) + return desc + + def validate_coerce(self, v): + if v is None: + pass + elif not isinstance(v, string_types): + self.raise_invalid_val(v) + else: + # match = re.fullmatch(self.regex, v) + match = fullmatch(self.regex, v) + if not match: + is_valid = False + else: + digit_str = match.group(1) + if len(digit_str) > 0 and int(digit_str) == 0: + is_valid = False + elif len(digit_str) > 0 and int(digit_str) == 1: + # Remove 1 suffix (e.g. x1 -> x) + v = self.base + is_valid = True + else: + is_valid = True + + if not is_valid: + self.raise_invalid_val(v) + return v + + +class FlaglistValidator(BaseValidator): + """ + "flaglist": { + "description": "A string representing a combination of flags + (order does not matter here). Combine any of the + available `flags` with *+*. + (e.g. ('lines+markers')). Values in `extras` + cannot be combined.", + "requiredOpts": [ + "flags" + ], + "otherOpts": [ + "dflt", + "extras", + "arrayOk" + ] + }, + """ + + def __init__(self, + plotly_name, + parent_name, + flags, + extras=None, + array_ok=False, + **kwargs): + super(FlaglistValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + self.flags = flags + self.extras = extras if extras is not None else [] + self.array_ok = array_ok + + self.all_flags = self.flags + self.extras + + def description(self): + + desc = ("""\ + The '{plotly_name}' property is a flaglist and may be specified + as a string containing:""").format(plotly_name=self.plotly_name) + + # Flags + desc = desc + (""" + - Any combination of {flags} joined with '+' characters + (e.g. '{eg_flag}')""").format( + flags=self.flags, eg_flag='+'.join(self.flags[:2])) + + # Extras + if self.extras: + desc = desc + (""" + OR exactly one of {extras} (e.g. '{eg_extra}')""").format( + extras=self.extras, eg_extra=self.extras[-1]) + + if self.array_ok: + desc = desc + """ + - A list or array of the above""" + + return desc + + def vc_scalar(self, v): + if not isinstance(v, string_types): + return None + + # To be generous we accept flags separated on plus ('+'), + # or comma (',') + split_vals = [e.strip() for e in re.split('[,+]', v)] + + # Are all flags valid names? + all_flags_valid = all([f in self.all_flags for f in split_vals]) + + # Are any 'extras' flags present? + has_extras = any([f in self.extras for f in split_vals]) + + # For flaglist to be valid all flags must be valid, and if we have + # any extras present, there must be only one flag (the single extras + # flag) + is_valid = (all_flags_valid and + (not has_extras or len(split_vals) == 1)) + if is_valid: + return '+'.join(split_vals) + else: + return None + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_array(v): + + # Coerce individual strings + validated_v = [self.vc_scalar(e) for e in v] + + invalid_els = [ + el for el, validated_el in zip(v, validated_v) + if validated_el is None + ] + if invalid_els: + self.raise_invalid_elements(invalid_els) + + if is_homogeneous_array(v): + v = copy_to_readonly_numpy_array(validated_v, dtype='unicode') + else: + v = to_scalar_or_list(v) + else: + + validated_v = self.vc_scalar(v) + if validated_v is None: + self.raise_invalid_val(v) + + v = validated_v + + return v + + +class AnyValidator(BaseValidator): + """ + "any": { + "description": "Any type.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "values", + "arrayOk" + ] + }, + """ + + def __init__(self, + plotly_name, + parent_name, + values=None, + array_ok=False, + **kwargs): + super(AnyValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + self.values = values + self.array_ok = array_ok + + def description(self): + + desc = """\ + The '{plotly_name}' property accepts values of any type + """.format(plotly_name=self.plotly_name) + return desc + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif self.array_ok and is_homogeneous_array(v): + v = copy_to_readonly_numpy_array(v, dtype='object') + elif self.array_ok and is_simple_array(v): + v = to_scalar_or_list(v) + return v + + +class InfoArrayValidator(BaseValidator): + """ + "info_array": { + "description": "An {array} of plot information.", + "requiredOpts": [ + "items" + ], + "otherOpts": [ + "dflt", + "freeLength" + ] + } + """ + + def __init__(self, + plotly_name, + parent_name, + items, + free_length=None, + **kwargs): + super(InfoArrayValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + self.items = items + + # Instantiate validators for each info array element + self.item_validators = [] + info_array_items = (self.items + if isinstance(self.items, list) else [self.items]) + + for i, item in enumerate(info_array_items): + element_name = '{name}[{i}]'.format(name=plotly_name, i=i) + item_validator = InfoArrayValidator.build_validator( + item, element_name, parent_name) + self.item_validators.append(item_validator) + + self.free_length = free_length + + def description(self): + upto = ' up to' if self.free_length else '' + desc = """\ + The '{plotly_name}' property is an info array that may be specified as a + list or tuple of{upto} {N} elements where: +""".format(plotly_name=self.plotly_name, + upto=upto, + N=len(self.item_validators)) + + for i, item_validator in enumerate(self.item_validators): + el_desc = item_validator.description().strip() + desc = desc + """ +({i}) {el_desc}""".format(i=i, el_desc=el_desc) + + return desc + + @staticmethod + def build_validator(validator_info, plotly_name, parent_name): + datatype = validator_info['valType'] # type: str + validator_classname = datatype.title().replace('_', '') + 'Validator' + validator_class = eval(validator_classname) + + kwargs = { + k: validator_info[k] + for k in validator_info + if k not in ['valType', 'description', 'role'] + } + + return validator_class( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def validate_coerce(self, v): + if v is None: + # Pass None through + pass + elif not is_array(v): + self.raise_invalid_val(v) + elif not self.free_length and len(v) != len(self.item_validators): + self.raise_invalid_val(v) + elif self.free_length and len(v) > len(self.item_validators): + self.raise_invalid_val(v) + else: + # We have an array of the correct length + v = to_scalar_or_list(v) + for i, (el, validator) in enumerate(zip(v, self.item_validators)): + # Validate coerce elements + v[i] = validator.validate_coerce(el) + + return v + + def present(self, v): + if v is None: + return None + else: + # Call present on each of the item validators + for i, (el, validator) in enumerate(zip(v, self.item_validators)): + # Validate coerce elements + v[i] = validator.present(el) + + # Return tuple form of + return tuple(v) + + +class LiteralValidator(BaseValidator): + """ + Validator for readonly literal values + """ + def __init__(self, plotly_name, parent_name, **kwargs): + super(LiteralValidator, self).__init__(plotly_name=plotly_name, + parent_name=parent_name, + **kwargs) + + def validate_coerce(self, v): + raise ValueError("""\ +The '{plotly_name}' property of {parent_name} is read-only""".format( + plotly_name=self.plotly_name, parent_name=self.parent_name + )) + + +class ImageUriValidator(BaseValidator): + _PIL = None + + try: + _PIL = import_module('PIL') + except ImportError: + pass + + def __init__(self, plotly_name, parent_name, **kwargs): + super(ImageUriValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + def description(self): + + desc = """\ + The '{plotly_name}' property is an image URI that may be specified as: + - A remote image URI string + (e.g. 'http://www.somewhere.com/image.png') + - A data URI image string + (e.g. 'data:image/png;base64,iVBORw0KGgoAAAANSU') + - A PIL.Image.Image object which will be immediately converted + to a data URI image string + See http://pillow.readthedocs.io/en/latest/reference/Image.html + """.format(plotly_name=self.plotly_name) + return desc + + def validate_coerce(self, v): + if v is None: + pass + elif isinstance(v, string_types): + # Future possibilities: + # - Detect filesystem system paths and convert to URI + # - Validate either url or data uri + pass + elif self._PIL and isinstance(v, self._PIL.Image.Image): + # Convert PIL image to png data uri string + in_mem_file = io.BytesIO() + v.save(in_mem_file, format="PNG") + in_mem_file.seek(0) + img_bytes = in_mem_file.read() + base64_encoded_result_bytes = base64.b64encode(img_bytes) + base64_encoded_result_str = ( + base64_encoded_result_bytes.decode('ascii')) + v = 'data:image/png;base64,{base64_encoded_result_str}'.format( + base64_encoded_result_str=base64_encoded_result_str) + else: + self.raise_invalid_val(v) + + return v + + +class CompoundValidator(BaseValidator): + + def __init__(self, plotly_name, parent_name, data_class_str, data_docs, + **kwargs): + super(CompoundValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + # Save element class string + self.data_class_str = data_class_str + self._data_class = None + self.data_docs = data_docs + self.module_str = CompoundValidator.compute_graph_obj_module_str( + self.data_class_str, parent_name) + + @staticmethod + def compute_graph_obj_module_str(data_class_str, parent_name): + if parent_name == 'frame' and data_class_str in ['Data', 'Layout']: + # Special case. There are no graph_objs.frame.Data or + # graph_objs.frame.Layout classes. These are remapped to + # graph_objs.Data and graph_objs.Layout + + parent_parts = parent_name.split('.') + module_str = '.'.join(['plotly.graph_objs'] + parent_parts[1:]) + elif parent_name: + module_str = 'plotly.graph_objs.' + parent_name + else: + module_str = 'plotly.graph_objs' + + return module_str + + @property + def data_class(self): + if self._data_class is None: + module = import_module(self.module_str) + self._data_class = getattr(module, self.data_class_str) + + return self._data_class + + def description(self): + + desc = ("""\ + The '{plotly_name}' property is an instance of {class_str} + that may be specified as: + - An instance of {module_str}.{class_str} + - A dict of string/value properties that will be passed + to the {class_str} constructor + + Supported dict properties: + {constructor_params_str}""").format( + plotly_name=self.plotly_name, + class_str=self.data_class_str, + module_str=self.module_str, + constructor_params_str=self.data_docs) + + return desc + + def validate_coerce(self, v): + if v is None: + v = self.data_class() + + elif isinstance(v, dict): + v = self.data_class(**v) + + elif isinstance(v, self.data_class): + # Copy object + v = self.data_class(**v.to_plotly_json()) + else: + self.raise_invalid_val(v) + + v._plotly_name = self.plotly_name + return v + + +class CompoundArrayValidator(BaseValidator): + + def __init__(self, plotly_name, parent_name, data_class_str, data_docs, + **kwargs): + super(CompoundArrayValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + # Save element class string + self.data_class_str = data_class_str + self._data_class = None + + self.data_docs = data_docs + self.module_str = CompoundValidator.compute_graph_obj_module_str( + self.data_class_str, parent_name) + + def description(self): + + desc = ("""\ + The '{plotly_name}' property is a tuple of instances of + {class_str} that may be specified as: + - A list or tuple of instances of {module_str}.{class_str} + - A list or tuple of dicts of string/value properties that + will be passed to the {class_str} constructor + + Supported dict properties: + {constructor_params_str}""").format( + plotly_name=self.plotly_name, + class_str=self.data_class_str, + module_str=self.module_str, + constructor_params_str=self.data_docs) + + return desc + + @property + def data_class(self): + if self._data_class is None: + module = import_module(self.module_str) + self._data_class = getattr(module, self.data_class_str) + + return self._data_class + + def validate_coerce(self, v): + + if v is None: + v = [] + + elif isinstance(v, (list, tuple)): + res = [] + invalid_els = [] + for v_el in v: + if isinstance(v_el, self.data_class): + res.append(v_el) + elif isinstance(v_el, dict): + res.append(self.data_class(**v_el)) + else: + res.append(None) + invalid_els.append(v_el) + + if invalid_els: + self.raise_invalid_elements(invalid_els) + + v = to_scalar_or_list(res) + else: + self.raise_invalid_val(v) + + return v + + +class BaseDataValidator(BaseValidator): + + def __init__(self, + class_strs_map, + plotly_name, + parent_name, + set_uid=False, + **kwargs): + super(BaseDataValidator, self).__init__( + plotly_name=plotly_name, parent_name=parent_name, **kwargs) + + self.class_strs_map = class_strs_map + self._class_map = None + self.set_uid = set_uid + + def description(self): + + trace_types = str(list(self.class_strs_map.keys())) + + trace_types_wrapped = '\n'.join( + textwrap.wrap( + trace_types, + initial_indent=' One of: ', + subsequent_indent=' ' * 21, + width=79 - 12)) + + desc = ("""\ + The '{plotly_name}' property is a tuple of trace instances + that may be specified as: + - A list or tuple of trace instances + (e.g. [Scatter(...), Bar(...)]) + - A list or tuple of dicts of string/value properties where: + - The 'type' property specifies the trace type +{trace_types} + + - All remaining properties are passed to the constructor of + the specified trace type + + (e.g. [{{'type': 'scatter', ...}}, {{'type': 'bar, ...}}])""").format( + plotly_name=self.plotly_name, trace_types=trace_types_wrapped) + + return desc + + @property + def class_map(self): + if self._class_map is None: + + # Initialize class map + self._class_map = {} + + # Import trace classes + trace_module = import_module('plotly.graph_objs') + for k, class_str in self.class_strs_map.items(): + self._class_map[k] = getattr(trace_module, class_str) + + return self._class_map + + def validate_coerce(self, v): + + # Import Histogram2dcontour, this is the deprecated name of the + # Histogram2dContour trace. + from plotly.graph_objs import Histogram2dcontour + + if v is None: + v = [] + elif isinstance(v, (list, tuple)): + trace_classes = tuple(self.class_map.values()) + + res = [] + invalid_els = [] + for v_el in v: + + if isinstance(v_el, trace_classes): + # Clone input traces + v_el = v_el.to_plotly_json() + + if isinstance(v_el, dict): + v_copy = deepcopy(v_el) + + if 'type' in v_copy: + trace_type = v_copy.pop('type') + elif isinstance(v_el, Histogram2dcontour): + trace_type = 'histogram2dcontour' + else: + trace_type = 'scatter' + + if trace_type not in self.class_map: + res.append(None) + invalid_els.append(v_el) + else: + trace = self.class_map[trace_type](**v_copy) + res.append(trace) + else: + res.append(None) + invalid_els.append(v_el) + + if invalid_els: + self.raise_invalid_elements(invalid_els) + + v = to_scalar_or_list(res) + + # Set new UIDs + if self.set_uid: + for trace in v: + trace.uid = str(uuid.uuid1()) + + else: + self.raise_invalid_val(v) + + return v diff --git a/_plotly_utils/tests/resources/1x1-black.png b/_plotly_utils/tests/resources/1x1-black.png new file mode 100644 index 0000000000..0f6fbd3c20 Binary files /dev/null and b/_plotly_utils/tests/resources/1x1-black.png differ diff --git a/_plotly_utils/tests/validators/test_angle_validator.py b/_plotly_utils/tests/validators/test_angle_validator.py new file mode 100644 index 0000000000..7224e35d30 --- /dev/null +++ b/_plotly_utils/tests/validators/test_angle_validator.py @@ -0,0 +1,40 @@ +import pytest +from _plotly_utils.basevalidators import AngleValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return AngleValidator('prop', 'parent') + + +# Tests +# ----- +# ### Test acceptance ### +@pytest.mark.parametrize('val', [0] + list(np.linspace(-180, 179.99))) +def test_acceptance(val, validator): + assert validator.validate_coerce(val) == val + + +# ### Test coercion above 180 ### +@pytest.mark.parametrize('val,expected', [ + (180, -180), + (181, -179), + (-180.25, 179.75), + (540, -180), + (-541, 179) +]) +def test_coercion(val, expected, validator): + assert validator.validate_coerce(val) == expected + + +# ### Test rejection ### +@pytest.mark.parametrize('val', + ['hello', (), [], [1, 2, 3], set(), '34']) +def test_rejection(val, validator: AngleValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_any_validator.py b/_plotly_utils/tests/validators/test_any_validator.py new file mode 100644 index 0000000000..9dddc9f1c3 --- /dev/null +++ b/_plotly_utils/tests/validators/test_any_validator.py @@ -0,0 +1,51 @@ +import pytest +from _plotly_utils.basevalidators import AnyValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return AnyValidator('prop', 'parent') + + +@pytest.fixture() +def validator_aok(): + return AnyValidator('prop', 'parent', array_ok=True) + + +# Tests +# ----- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + set(), 'Hello', 123, np.inf, np.nan, {} +]) +def test_acceptance(val, validator: AnyValidator): + assert validator.validate_coerce(val) is val + + +# ### Acceptance of arrays ### +@pytest.mark.parametrize('val', [ + 23, + 'Hello!', + [], + (), + np.array([]), + ('Hello', 'World'), + ['Hello', 'World'], + [np.pi, np.e, {}] +]) +def test_acceptance_array(val, validator_aok: AnyValidator): + coerce_val = validator_aok.validate_coerce(val) + if isinstance(val, np.ndarray): + assert isinstance(coerce_val, np.ndarray) + assert coerce_val.dtype == 'object' + assert np.array_equal(coerce_val, val) + elif isinstance(val, (list, tuple)): + assert coerce_val == list(val) + assert validator_aok.present(coerce_val) == tuple(val) + else: + assert coerce_val == val + assert validator_aok.present(coerce_val) == val + diff --git a/_plotly_utils/tests/validators/test_basetraces_validator.py b/_plotly_utils/tests/validators/test_basetraces_validator.py new file mode 100644 index 0000000000..40c62e6f01 --- /dev/null +++ b/_plotly_utils/tests/validators/test_basetraces_validator.py @@ -0,0 +1,105 @@ +import pytest +from _plotly_utils.basevalidators import BaseDataValidator +from plotly.graph_objs import Scatter, Bar, Box + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return BaseDataValidator(class_strs_map={'scatter': 'Scatter', + 'bar': 'Bar', + 'box': 'Box'}, + plotly_name='prop', + parent_name='parent') + + +# Tests +# ----- +def test_acceptance(validator: BaseDataValidator): + val = [Scatter(mode='lines'), Box(fillcolor='yellow')] + res = validator.validate_coerce(val) + res_present = validator.present(res) + + assert isinstance(res, list) + assert isinstance(res_present, tuple) + + assert isinstance(res_present[0], Scatter) + assert res_present[0].type == 'scatter' + assert res_present[0].mode == 'lines' + + assert isinstance(res_present[1], Box) + assert res_present[1].type == 'box' + assert res_present[1].fillcolor == 'yellow' + + # Make sure UIDs are actually unique + assert res_present[0].uid != res_present[1].uid + + +def test_acceptance_dict(validator: BaseDataValidator): + val = (dict(type='scatter', mode='lines'), + dict(type='box', fillcolor='yellow')) + res = validator.validate_coerce(val) + res_present = validator.present(res) + + assert isinstance(res, list) + assert isinstance(res_present, tuple) + assert isinstance(res_present[0], Scatter) + assert res_present[0].type == 'scatter' + assert res_present[0].mode == 'lines' + + assert isinstance(res_present[1], Box) + assert res_present[1].type == 'box' + assert res_present[1].fillcolor == 'yellow' + + # Make sure UIDs are actually unique + assert res_present[0].uid != res_present[1].uid + + +def test_default_is_scatter(validator: BaseDataValidator): + val = [dict(mode='lines')] + res = validator.validate_coerce(val) + res_present = validator.present(res) + + assert isinstance(res, list) + assert isinstance(res_present, tuple) + assert isinstance(res_present[0], Scatter) + assert res_present[0].type == 'scatter' + assert res_present[0].mode == 'lines' + + +def test_rejection_type(validator: BaseDataValidator): + val = 37 + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid value" in str(validation_failure.value) + + +def test_rejection_element_type(validator: BaseDataValidator): + val = [42] + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid element(s)" in str(validation_failure.value) + + +def test_rejection_element_attr(validator: BaseDataValidator): + val = [dict(type='scatter', bogus=99)] + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert ("Invalid property specified for object of type " + + "plotly.graph_objs.Scatter: 'bogus'" in + str(validation_failure.value)) + + +def test_rejection_element_tracetype(validator: BaseDataValidator): + val = [dict(type='bogus', a=4)] + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid element(s)" in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_boolean_validator.py b/_plotly_utils/tests/validators/test_boolean_validator.py new file mode 100644 index 0000000000..12ebe08920 --- /dev/null +++ b/_plotly_utils/tests/validators/test_boolean_validator.py @@ -0,0 +1,27 @@ +import pytest +from _plotly_utils.basevalidators import BooleanValidator +import numpy as np + + +# Boolean Validator +# ================= +# ### Fixtures ### +@pytest.fixture(params=[True, False]) +def validator(request): + return BooleanValidator('prop', 'parent', dflt=request.param) + + +# ### Acceptance ### +@pytest.mark.parametrize('val', [True, False]) +def test_acceptance(val, validator): + assert val == validator.validate_coerce(val) + + +# ### Rejection ### +@pytest.mark.parametrize('val', + [1.0, 0.0, 'True', 'False', [], 0, np.nan]) +def test_rejection(val, validator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_color_validator.py b/_plotly_utils/tests/validators/test_color_validator.py new file mode 100644 index 0000000000..a8bcf73ce8 --- /dev/null +++ b/_plotly_utils/tests/validators/test_color_validator.py @@ -0,0 +1,204 @@ +import pytest +from _plotly_utils.basevalidators import ColorValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return ColorValidator('prop', 'parent') + + +@pytest.fixture() +def validator_colorscale(): + return ColorValidator('prop', 'parent', colorscale_path='parent.colorscale') + + +@pytest.fixture() +def validator_aok(): + return ColorValidator('prop', 'parent', array_ok=True) + + +@pytest.fixture() +def validator_aok_colorscale(): + return ColorValidator('prop', 'parent', array_ok=True, colorscale_path='parent.colorscale') + + +# Array not ok, numbers not ok +# ---------------------------- +@pytest.mark.parametrize('val', + ['red', 'BLUE', 'rgb(255, 0, 0)', 'hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', + 'hsv(0, 100%, 100%)', 'hsva(0, 100%, 100%, 50%)']) +def test_acceptance(val, validator: ColorValidator): + assert validator.validate_coerce(val) == val + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', + [set(), 23, 0.5, {}, ['red'], [12]]) +def test_rejection(val, validator: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + ['redd', 'rgbbb(255, 0, 0)', 'hsl(0, 1%0000%, 50%)']) +def test_rejection(val, validator: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array not ok, numbers ok +# ------------------------ +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['red', 'BLUE', 23, 15, 'rgb(255, 0, 0)', 'hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', + 'hsv(0, 100%, 100%)', 'hsva(0, 100%, 100%, 50%)']) +def test_acceptance_colorscale(val, validator_colorscale: ColorValidator): + assert validator_colorscale.validate_coerce(val) == val + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', + [set(), {}, ['red'], [12]]) +def test_rejection_colorscale(val, validator_colorscale: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator_colorscale.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + ['redd', 'rgbbb(255, 0, 0)', 'hsl(0, 1%0000%, 50%)']) +def test_rejection_colorscale(val, validator_colorscale: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator_colorscale.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array ok, numbers not ok +# ------------------------ +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['blue', + ['red', 'rgb(255, 0, 0)'], + np.array(['red', 'rgb(255, 0, 0)']), + ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'], + np.array(['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)']), + ['hsva(0, 100%, 100%, 50%)']]) +def test_acceptance_aok(val, validator_aok: ColorValidator): + coerce_val = validator_aok.validate_coerce(val) + + if isinstance(val, np.ndarray): + assert np.array_equal(coerce_val, val) + elif isinstance(val, list): + assert validator_aok.present(coerce_val) == tuple(val) + else: + assert coerce_val == val + + +@pytest.mark.parametrize('val', [ + 'green', + [['blue']], + [['red', 'rgb(255, 0, 0)'], ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)']], + np.array([['red', 'rgb(255, 0, 0)'], ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)']]) +]) +def test_acceptance_aok_2D(val, validator_aok: ColorValidator): + coerce_val = validator_aok.validate_coerce(val) + + if isinstance(val, np.ndarray): + assert np.array_equal(coerce_val, val) + elif isinstance(val, list): + assert validator_aok.present(coerce_val) == tuple(val) + else: + assert coerce_val == val + + +# ### Rejection ### +@pytest.mark.parametrize('val', + [[23], [0, 1, 2], + ['redd', 'rgb(255, 0, 0)'], + ['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'], + ['hsva(0, 1%00%, 100%, 50%)']]) +def test_rejection_aok(val, validator_aok: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +@pytest.mark.parametrize('val', + [[['redd', 'rgb(255, 0, 0)']], + [['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)'], + ['hsv(0, 100%, 100%)', 'purple']], + [np.array(['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)']), + np.array(['hsv(0, 100%, 100%)', 'purple'])], + [['blue'], [2]]]) +def test_rejection_aok_2D(val, validator_aok: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# Array ok, numbers ok +# -------------------- +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['blue', 23, [0, 1, 2], + ['red', 0.5, 'rgb(255, 0, 0)'], + ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'], + ['hsva(0, 100%, 100%, 50%)']]) +def test_acceptance_aok_colorscale(val, validator_aok_colorscale: ColorValidator): + coerce_val = validator_aok_colorscale.validate_coerce(val) + if isinstance(val, (list, np.ndarray)): + assert np.array_equal(list(coerce_val), val) + else: + assert coerce_val == val + + +# ### Rejection ### +@pytest.mark.parametrize('val', + [['redd', 0.5, 'rgb(255, 0, 0)'], + ['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'], + ['hsva(0, 1%00%, 100%, 50%)']]) +def test_rejection_aok_colorscale(val, validator_aok_colorscale: ColorValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok_colorscale.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# Description +# ----------- +# Test dynamic description logic +def test_description(validator: ColorValidator): + desc = validator.description() + assert 'A number that will be interpreted as a color' not in desc + assert 'A list or array of any of the above' not in desc + + +def test_description_aok(validator_aok: ColorValidator): + desc = validator_aok.description() + assert 'A number that will be interpreted as a color' not in desc + assert 'A list or array of any of the above' in desc + + +def test_description_aok(validator_colorscale: ColorValidator): + desc = validator_colorscale.description() + assert 'A number that will be interpreted as a color' in desc + assert 'A list or array of any of the above' not in desc + + +def test_description_aok_colorscale(validator_aok_colorscale: ColorValidator): + desc = validator_aok_colorscale.description() + assert 'A number that will be interpreted as a color' in desc + assert 'A list or array of any of the above' in desc diff --git a/_plotly_utils/tests/validators/test_colorlist_validator.py b/_plotly_utils/tests/validators/test_colorlist_validator.py new file mode 100644 index 0000000000..5254f3fdfd --- /dev/null +++ b/_plotly_utils/tests/validators/test_colorlist_validator.py @@ -0,0 +1,47 @@ +import pytest +import numpy as np + +from _plotly_utils.basevalidators import ColorlistValidator + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return ColorlistValidator('prop', 'parent') + + +# Rejection +# --------- +@pytest.mark.parametrize('val', + [set(), 23, 0.5, {}, 'redd']) +def test_rejection_value(validator, val): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +@pytest.mark.parametrize('val', + [[set()], [23, 0.5], [{}, 'red'], + ['blue', 'redd']]) +def test_rejection_element(validator, val): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# Acceptance +# ---------- +@pytest.mark.parametrize('val', + [['blue'], + ['red', 'rgb(255, 0, 0)'], + np.array(['red', 'rgb(255, 0, 0)']), + ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'], + np.array(['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)']), + ['hsva(0, 100%, 100%, 50%)']]) +def test_acceptance_aok(val, validator): + coerce_val = validator.validate_coerce(val) + assert isinstance(coerce_val, list) + assert validator.present(coerce_val) == tuple(val) diff --git a/_plotly_utils/tests/validators/test_colorscale_validator.py b/_plotly_utils/tests/validators/test_colorscale_validator.py new file mode 100644 index 0000000000..74ffb41877 --- /dev/null +++ b/_plotly_utils/tests/validators/test_colorscale_validator.py @@ -0,0 +1,91 @@ +import pytest +from _plotly_utils.basevalidators import ColorscaleValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return ColorscaleValidator('prop', 'parent') + + +@pytest.fixture(params=['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', 'Reds', 'Blues', + 'Picnic', 'Rainbow', 'Portland', 'Jet', 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis']) +def named_colorscale(request): + return request.param + + +# Tests +# ----- +# ### Acceptance by name ### +def test_acceptance_named(named_colorscale, validator: ColorscaleValidator): + # As-is + assert validator.validate_coerce(named_colorscale) == named_colorscale + + # Uppercase + assert (validator.validate_coerce(named_colorscale.upper()) == + named_colorscale.upper()) + +# ### Acceptance as array ### +@pytest.mark.parametrize('val', [ + ((0, 'red'),), + ((0.1, 'rgb(255,0,0)'), (0.3, 'green')), + ((0, 'purple'), (0.2, 'yellow'), (1.0, 'rgba(255,0,0,100)')), +]) +def test_acceptance_array(val, validator: ColorscaleValidator): + assert validator.validate_coerce(val) == val + +# ### Coercion as array ### +@pytest.mark.parametrize('val', [ + ([0, 'red'],), + [(0.1, 'rgb(255, 0, 0)'), (0.3, 'GREEN')], + (np.array([0, 'Purple'], dtype='object'), (0.2, 'yellow'), (1.0, 'RGBA(255,0,0,100)')), +]) +def test_acceptance_array(val, validator: ColorscaleValidator): + # Compute expected (tuple of tuples where color is + # lowercase with no spaces) + expected = [[e[0], e[1]] for e in val] + coerce_val = validator.validate_coerce(val) + assert coerce_val == expected + + expected_present = tuple([tuple(e) for e in expected]) + assert validator.present(coerce_val) == expected_present + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', [ + 23, set(), {}, np.pi +]) +def test_rejection_type(val, validator: ColorscaleValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by string value ### +@pytest.mark.parametrize('val', [ + 'Invalid', '' +]) +def test_rejection_str_value(val, validator: ColorscaleValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by array ### +@pytest.mark.parametrize('val', [ + [0, 'red'], # Elements must be tuples + [[0.1, 'rgb(255,0,0)', None], (0.3, 'green')], # length 3 element + ([1.1, 'purple'], [0.2, 'yellow']), # Number > 1 + ([0.1, 'purple'], [-0.2, 'yellow']), # Number < 0 + ([0.1, 'purple'], [0.2, 123]), # Color not a string + ([0.1, 'purple'], [0.2, 'yellowww']), # Invalid color string +]) +def test_rejection_array(val, validator: ColorscaleValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_compound_validator.py b/_plotly_utils/tests/validators/test_compound_validator.py new file mode 100644 index 0000000000..ba7b519ed8 --- /dev/null +++ b/_plotly_utils/tests/validators/test_compound_validator.py @@ -0,0 +1,61 @@ +import pytest +from _plotly_utils.basevalidators import CompoundValidator +from plotly.graph_objs.scatter import Marker + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return CompoundValidator('prop', 'scatter', + data_class_str='Marker', + data_docs='') + + +# Tests +# ----- +def test_acceptance(validator: CompoundValidator): + val = Marker(color='green', size=10) + res = validator.validate_coerce(val) + + assert isinstance(res, Marker) + assert res.color == 'green' + assert res.size == 10 + + +def test_acceptance_none(validator: CompoundValidator): + val = None + res = validator.validate_coerce(val) + + assert isinstance(res, Marker) + assert res.color is None + assert res.size is None + + +def test_acceptance_dict(validator: CompoundValidator): + val = dict(color='green', size=10) + res = validator.validate_coerce(val) + + assert isinstance(res, Marker) + assert res.color == 'green' + assert res.size == 10 + + +def test_rejection_type(validator: CompoundValidator): + val = 37 + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid value" in str(validation_failure.value) + + +def test_rejection_value(validator: CompoundValidator): + val = dict(color='green', size=10, bogus=99) + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert ("Invalid property specified for object of type " + "plotly.graph_objs.scatter.Marker: 'bogus'" in + str(validation_failure.value)) diff --git a/_plotly_utils/tests/validators/test_compoundarray_validator.py b/_plotly_utils/tests/validators/test_compoundarray_validator.py new file mode 100644 index 0000000000..0de5ef1848 --- /dev/null +++ b/_plotly_utils/tests/validators/test_compoundarray_validator.py @@ -0,0 +1,90 @@ +import pytest +from _plotly_utils.basevalidators import CompoundArrayValidator +from plotly.graph_objs.layout import Image + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return CompoundArrayValidator('prop', 'layout', + data_class_str='Image', + data_docs='') + + +# Tests +# ----- +def test_acceptance(validator: CompoundArrayValidator): + val = [Image(opacity=0.5, sizex=120), Image(x=99)] + res = validator.validate_coerce(val) + res_present = validator.present(res) + assert isinstance(res, list) + assert isinstance(res_present, tuple) + assert isinstance(res_present[0], Image) + assert res_present[0].opacity == 0.5 + assert res_present[0].sizex == 120 + assert res_present[0].x is None + + assert isinstance(res_present[1], Image) + assert res_present[1].opacity is None + assert res_present[1].sizex is None + assert res_present[1].x == 99 + + +def test_acceptance_empty(validator: CompoundArrayValidator): + val = [{}] + res = validator.validate_coerce(val) + res_present = validator.present(res) + + assert isinstance(res, list) + assert isinstance(res_present, tuple) + assert isinstance(res_present[0], Image) + assert res_present[0].opacity is None + assert res_present[0].sizex is None + assert res_present[0].x is None + + +def test_acceptance_dict(validator: CompoundArrayValidator): + val = [dict(opacity=0.5, sizex=120), dict(x=99)] + res = validator.validate_coerce(val) + res_present = validator.present(res) + + assert isinstance(res, list) + assert isinstance(res_present, tuple) + assert isinstance(res_present[0], Image) + assert res_present[0].opacity == 0.5 + assert res_present[0].sizex == 120 + assert res_present[0].x is None + + assert isinstance(res[1], Image) + assert res_present[1].opacity is None + assert res_present[1].sizex is None + assert res_present[1].x == 99 + + +def test_rejection_type(validator: CompoundArrayValidator): + val = 37 + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid value" in str(validation_failure.value) + + +def test_rejection_element(validator: CompoundArrayValidator): + val = ['a', 37] + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid element(s)" in str(validation_failure.value) + + +def test_rejection_value(validator: CompoundArrayValidator): + val = [dict(opacity=0.5, sizex=120, bogus=100)] + + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert ("Invalid property specified for object of type " + "plotly.graph_objs.layout.Image" in + str(validation_failure.value)) diff --git a/_plotly_utils/tests/validators/test_dataarray_validator.py b/_plotly_utils/tests/validators/test_dataarray_validator.py new file mode 100644 index 0000000000..45bc621703 --- /dev/null +++ b/_plotly_utils/tests/validators/test_dataarray_validator.py @@ -0,0 +1,42 @@ +import pytest +from _plotly_utils.basevalidators import DataArrayValidator +import numpy as np +import pandas as pd + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return DataArrayValidator('prop', 'parent') + + +# Tests +# ----- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + [], [1], [''], (), ('Hello, ', 'world!'), ['A', 1, 'B', 0, 'C'] +]) +def test_validator_acceptance_simple(val, validator: DataArrayValidator): + coerce_val = validator.validate_coerce(val) + assert isinstance(coerce_val, list) + assert validator.present(coerce_val) == tuple(val) + + +@pytest.mark.parametrize('val', [ + np.array([2, 3, 4]), pd.Series(['a', 'b', 'c']), np.array([[1, 2, 3], [4, 5, 6]]) +]) +def test_validator_acceptance_homogeneous(val, validator: DataArrayValidator): + coerce_val = validator.validate_coerce(val) + assert isinstance(coerce_val, np.ndarray) + assert np.array_equal(validator.present(coerce_val), val) + + +# ### Rejection ### +@pytest.mark.parametrize('val', [ + 'Hello', 23, set(), {} +]) +def test_rejection(val, validator: DataArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_enumerated_validator.py b/_plotly_utils/tests/validators/test_enumerated_validator.py new file mode 100644 index 0000000000..46a9894123 --- /dev/null +++ b/_plotly_utils/tests/validators/test_enumerated_validator.py @@ -0,0 +1,137 @@ +import pytest +import numpy as np +import pandas as pd +from _plotly_utils.basevalidators import EnumeratedValidator + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + values = ['first', 'second', 'third', 4] + return EnumeratedValidator('prop', 'parent', values, array_ok=False) + + +@pytest.fixture() +def validator_re(): + values = ['foo', '/bar(\d)+/', 'baz'] + return EnumeratedValidator('prop', 'parent', values, array_ok=False) + + +@pytest.fixture() +def validator_aok(): + values = ['first', 'second', 'third', 4] + return EnumeratedValidator('prop', 'parent', values, array_ok=True) + + +@pytest.fixture() +def validator_aok_re(): + values = ['foo', '/bar(\d)+/', 'baz'] + return EnumeratedValidator('prop', 'parent', values, array_ok=True) + + +# Array not ok +# ------------ +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['first', 'second', 'third', 4]) +def test_acceptance(val, validator): + # Values should be accepted and returned unchanged + assert validator.validate_coerce(val) == val + + +# ### Value Rejection ### +@pytest.mark.parametrize('val', + [True, 0, 1, 23, np.inf, set(), + ['first', 'second'], [True], ['third', 4], [4]]) +def test_rejection_by_value(val, validator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array not ok, regular expression +# -------------------------------- +@pytest.mark.parametrize('val', + ['foo', 'bar0', 'bar1', 'bar234']) +def test_acceptance(val, validator_re): + # Values should be accepted and returned unchanged + assert validator_re.validate_coerce(val) == val + + +# ### Value Rejection ### +@pytest.mark.parametrize('val', + [12, set(), 'bar', 'BAR0', 'FOO']) +def test_rejection_by_value(val, validator_re): + with pytest.raises(ValueError) as validation_failure: + validator_re.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array ok +# -------- +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['first', 'second', 'third', 4, + [], ['first', 4], [4], ['third', 'first'], + ['first', 'second', 'third', 4]]) +def test_acceptance_aok(val, validator_aok): + # Values should be accepted and returned unchanged + coerce_val = validator_aok.validate_coerce(val) + if isinstance(val, (list, np.ndarray)): + assert np.array_equal(coerce_val, np.array(val, dtype=coerce_val.dtype)) + else: + assert coerce_val == val + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + [True, 0, 1, 23, np.inf, set()]) +def test_rejection_by_value_aok(val, validator_aok): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Reject by elements ### +@pytest.mark.parametrize('val', + [[True], [0], [1, 23], [np.inf, set()], + ['ffirstt', 'second', 'third']]) +def test_rejection_by_element_aok(val, validator_aok): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# Array ok, regular expression +# ---------------------------- +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['foo', 'bar12', 'bar21', + [], ['bar12'], ('foo', 'bar012', 'baz'), + np.array([]), + np.array(['bar12']), + np.array(['foo', 'bar012', 'baz'])]) +def test_acceptance_aok(val, validator_aok_re): + # Values should be accepted and returned unchanged + coerce_val = validator_aok_re.validate_coerce(val) + if isinstance(val, (np.ndarray, pd.Series)): + assert np.array_equal(coerce_val, np.array(val, dtype=coerce_val.dtype)) + elif isinstance(val, (list, tuple)): + assert validator_aok_re.present(coerce_val) == tuple(val) + else: + assert validator_aok_re.present(coerce_val) == val + + +# ### Reject by elements ### +@pytest.mark.parametrize('val', + [['bar', 'bar0'], ['foo', 123]]) +def test_rejection_by_element_aok(val, validator_aok_re): + with pytest.raises(ValueError) as validation_failure: + validator_aok_re.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_flaglist_validator.py b/_plotly_utils/tests/validators/test_flaglist_validator.py new file mode 100644 index 0000000000..3b4481c67f --- /dev/null +++ b/_plotly_utils/tests/validators/test_flaglist_validator.py @@ -0,0 +1,190 @@ +import itertools +import pytest +from _plotly_utils.basevalidators import FlaglistValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture(params=[None, ['none', 'all']]) +def validator(request): + # Validator with or without extras + return FlaglistValidator('prop', 'parent', flags=['lines', 'markers', 'text'], extras=request.param) + + +@pytest.fixture() +def validator_extra(): + return FlaglistValidator('prop', 'parent', + flags=['lines', 'markers', 'text'], + extras=['none', 'all']) + + +@pytest.fixture() +def validator_extra_aok(): + return FlaglistValidator('prop', 'parent', + flags=['lines', 'markers', 'text'], + extras=['none', 'all'], + array_ok=True) + + +@pytest.fixture(params= + ["+".join(p) + for i in range(1, 4) + for p in itertools.permutations(['lines', 'markers', 'text'], i)]) +def flaglist(request): + return request.param + + +@pytest.fixture(params=['none', 'all']) +def extra(request): + return request.param + + +# Array not ok (with or without extras) +# ------------------------------------- +# ### Acceptance ### +def test_acceptance(flaglist, validator: FlaglistValidator): + assert validator.validate_coerce(flaglist) == flaglist + + +# ### Coercion ### +@pytest.mark.parametrize('in_val,coerce_val', + [(' lines ', 'lines'), # Strip outer whitespace + (' lines + markers ', 'lines+markers'), # Remove inner whitespace around '+' + ('lines ,markers', 'lines+markers'), # Accept comma separated + ]) +def test_coercion(in_val, coerce_val, validator): + assert validator.validate_coerce(in_val) == coerce_val + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', + [21, (), ['lines'], set(), {}]) +def test_rejection_type(val, validator: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + ['', 'line', 'markers+line', 'lin es', 'lin es+markers']) +def test_rejection_val(val, validator: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array not ok (with extras) +# -------------------------- +# ### Acceptance ### +# Note: Acceptance of flaglists without extras already tested above +def test_acceptance_extra(extra, validator_extra: FlaglistValidator): + assert validator_extra.validate_coerce(extra) == extra + + +# ### Coercion ### +@pytest.mark.parametrize('in_val,coerce_val', + [(' none ', 'none'), + ('all ', 'all'), + ]) +def test_coercion(in_val, coerce_val, validator_extra): + assert validator_extra.validate_coerce(in_val) == coerce_val + + +# ### Rejection by value ### +# Note: Rejection by type already handled above +@pytest.mark.parametrize('val', + ['al l', # Don't remove inner whitespace + 'lines+all', # Extras cannot be combined with flags + 'none+markers', + 'markers+lines+text+none']) +def test_rejection_val(val, validator_extra: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator_extra.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array OK (with extras) +# ---------------------- +# ### Acceptance (scalars) ### +def test_acceptance_aok_scalar_flaglist(flaglist, validator_extra_aok: FlaglistValidator): + assert validator_extra_aok.validate_coerce(flaglist) == flaglist + + +def test_acceptance_aok_scalar_extra(extra, validator_extra_aok: FlaglistValidator): + assert validator_extra_aok.validate_coerce(extra) == extra + + +# ### Acceptance (lists) ### +def test_acceptance_aok_scalarlist_flaglist(flaglist, validator_extra_aok: FlaglistValidator): + assert np.array_equal(validator_extra_aok.validate_coerce([flaglist]), + np.array([flaglist], dtype='unicode')) + + +@pytest.mark.parametrize('val', [ + ['all', 'markers', 'text+markers'], + ['lines', 'lines+markers', 'markers+lines+text'], + ['all', 'all', 'lines+text', 'none'] +]) +def test_acceptance_aok_list_flaglist(val, validator_extra_aok: FlaglistValidator): + assert np.array_equal(validator_extra_aok.validate_coerce(val), + np.array(val, dtype='unicode')) + + +# ### Coercion ### +@pytest.mark.parametrize('in_val,expected', + [([' lines ', ' lines + markers ', 'lines ,markers'], + ['lines', 'lines+markers', 'lines+markers']), + (np.array(['text +lines']), + np.array(['text+lines'], dtype='unicode')) + ]) +def test_coercion_aok(in_val, expected, validator_extra_aok): + coerce_val = validator_extra_aok.validate_coerce(in_val) + if isinstance(in_val, (list, tuple)): + expected == coerce_val + validator_extra_aok.present(coerce_val) == tuple(expected) + else: + assert np.array_equal(coerce_val, coerce_val) + assert np.array_equal( + validator_extra_aok.present(coerce_val), + coerce_val) + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', + [21, set(), {}]) +def test_rejection_aok_type(val, validator_extra_aok: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator_extra_aok.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by element type ### +@pytest.mark.parametrize('val', + [[21, 'markers'], + ['lines', ()], + ['none', set()], + ['lines+text', {}, 'markers']]) +def test_rejection_aok_element_type(val, validator_extra_aok: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator_extra_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# ### Rejection by element values ### +@pytest.mark.parametrize('val', [ + ['all+markers', 'text+markers'], # extra plus flag + ['line', 'lines+markers', 'markers+lines+text'], # Invalid flag + ['all', '', 'lines+text', 'none'] # Empty string +]) +def test_rejection_aok_element_val(val, validator_extra_aok: FlaglistValidator): + with pytest.raises(ValueError) as validation_failure: + validator_extra_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_imageuri_validator.py b/_plotly_utils/tests/validators/test_imageuri_validator.py new file mode 100644 index 0000000000..e78ebdf91c --- /dev/null +++ b/_plotly_utils/tests/validators/test_imageuri_validator.py @@ -0,0 +1,49 @@ +import base64 + +import pytest +from _plotly_utils.basevalidators import ImageUriValidator +import numpy as np +from PIL import Image + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return ImageUriValidator('prop', 'parent') + + +# Tests +# ----- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + 'http://somewhere.com/images/image12.png', + 'data:image/png;base64,iVBORw0KGgoAAAANSU', +]) +def test_validator_acceptance(val, validator: ImageUriValidator): + assert validator.validate_coerce(val) == val + + +# ### Coercion from PIL Image ### +def test_validator_coercion_PIL(validator: ImageUriValidator): + # Single pixel black png (http://png-pixel.com/) + + img_path = '_plotly_utils/tests/resources/1x1-black.png' + with open(img_path, 'rb') as f: + hex_bytes = base64.b64encode(f.read()).decode('ascii') + expected_uri = 'data:image/png;base64,' + hex_bytes + + img = Image.open(img_path) + coerce_val = validator.validate_coerce(img) + assert coerce_val == expected_uri + + +# ### Rejection ### +@pytest.mark.parametrize('val', [ + 23, set(), [] +]) +def test_rejection_by_type(val, validator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_infoarray_validator.py b/_plotly_utils/tests/validators/test_infoarray_validator.py new file mode 100644 index 0000000000..b7deed75ef --- /dev/null +++ b/_plotly_utils/tests/validators/test_infoarray_validator.py @@ -0,0 +1,163 @@ +import pytest +from _plotly_utils.basevalidators import InfoArrayValidator, type_str +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator_any2(): + return InfoArrayValidator('prop', 'parent', items=[{'valType': 'any'}, {'valType': 'any'}]) + + +@pytest.fixture() +def validator_number3(): + return InfoArrayValidator('prop', 'parent', items=[ + {'valType': 'number', 'min': 0, 'max': 1}, + {'valType': 'number', 'min': 0, 'max': 1}, + {'valType': 'number', 'min': 0, 'max': 1}]) + + +@pytest.fixture() +def validator_number3_free(): + return InfoArrayValidator('prop', 'parent', items=[ + {'valType': 'number', 'min': 0, 'max': 1}, + {'valType': 'number', 'min': 0, 'max': 1}, + {'valType': 'number', 'min': 0, 'max': 1}], free_length=True) + + +# Any2 Tests +# ---------- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + [1, 'A'], ('hello', 'world!'), [1, ()], [-1, 1] +]) +def test_validator_acceptance_any2(val, validator_any2: InfoArrayValidator): + coerce_val = validator_any2.validate_coerce(val) + assert coerce_val == list(val) + assert validator_any2.present(coerce_val) == tuple(val) + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', [ + 'Not a list', 123, set(), {} +]) +def test_validator_rejection_any2_type(val, validator_any2: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_any2.validate_coerce(val) + + assert 'must be a list or tuple.' in str(validation_failure.value) + + +# ### Rejection by length ### +@pytest.mark.parametrize('val', [ + [0, 1, 'A'], ('hello', 'world', '!'), [None, {}, []], [-1, 1, 9] +]) +def test_validator_rejection_any2_length(val, validator_any2: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_any2.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Number3 Tests +# ------------- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + [1, 0, 0.5], (0.1, 0.4, 0.99), [1, 1, 0] +]) +def test_validator_acceptance_number3(val, validator_number3: InfoArrayValidator): + coerce_val = validator_number3.validate_coerce(val) + assert coerce_val == list(val) + assert validator_number3.present(coerce_val) == tuple(val) + + +# ### Rejection by length ### +@pytest.mark.parametrize('val', [ + [1, 0], (0.1, 0.4, 0.99, 0.4), [1] +]) +def test_validator_rejection_number3_length(val, validator_number3: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3.validate_coerce(val) + + assert 'must be a list or tuple of length 3.' in str(validation_failure.value) + + +# ### Rejection by element type ### +@pytest.mark.parametrize('val,first_invalid_ind', [ + ([1, 0, '0.5'], 2), + ((0.1, set(), 0.99), 1), + ([[], '2', {}], 0) +]) +def test_validator_rejection_number3_length(val, first_invalid_ind, validator_number3: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3.validate_coerce(val) + + assert 'The prop[%d] property of parent must be a number.' % first_invalid_ind in str(validation_failure.value) + + +# ### Rejection by element value ### +# Elements must be in [0, 1] +@pytest.mark.parametrize('val,first_invalid_ind', [ + ([1, 0, 1.5], 2), + ((0.1, -0.4, 0.99), 1), + ([-1, 1, 0], 0) +]) +def test_validator_rejection_number3_length(val, first_invalid_ind, validator_number3: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3.validate_coerce(val) + + assert ('The prop[%d] property of parent must be in the range [0, 1]' % first_invalid_ind + in str(validation_failure.value)) + + +# Number3 Tests (free_length=True) +# -------------------------------- +# ### Acceptance ### +@pytest.mark.parametrize('val', [ + [1, 0, 0.5], + (0.1, 0.99), + np.array([0.1, 0.99]), + [0], [] +]) +def test_validator_acceptance_number3_free(val, validator_number3_free: InfoArrayValidator): + coerce_val = validator_number3_free.validate_coerce(val) + assert coerce_val == list(val) + assert validator_number3_free.present(coerce_val) == tuple(val) + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', [ + 'Not a list', 123, set(), {} +]) +def test_validator_rejection_any2_type(val, validator_number3_free: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3_free.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by length ### +@pytest.mark.parametrize('val', [ + (0.1, 0.4, 0.99, 0.4), [1, 0, 0, 0, 0, 0, 0] +]) +def test_validator_rejection_number3_free_length(val, validator_number3_free: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3_free.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by element type ### +@pytest.mark.parametrize('val,first_invalid_ind', [ + ([1, 0, '0.5'], 2), + ((0.1, set()), 1), + ([[]], 0) +]) +def test_validator_rejection_number3_length(val, first_invalid_ind, validator_number3_free: InfoArrayValidator): + with pytest.raises(ValueError) as validation_failure: + validator_number3_free.validate_coerce(val) + + assert ("Invalid value of type {typ} received for the 'prop[{first_invalid_ind}]' property of parent" + .format(typ= type_str(val[first_invalid_ind]), + first_invalid_ind=first_invalid_ind)) in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_integer_validator.py b/_plotly_utils/tests/validators/test_integer_validator.py new file mode 100644 index 0000000000..f88de843b6 --- /dev/null +++ b/_plotly_utils/tests/validators/test_integer_validator.py @@ -0,0 +1,153 @@ +# Array not ok +# ------------ +import pytest +from pytest import approx +from _plotly_utils.basevalidators import IntegerValidator +import numpy as np + + +# ### Fixtures ### +@pytest.fixture() +def validator(): + return IntegerValidator('prop', 'parent') + + +@pytest.fixture +def validator_min_max(): + return IntegerValidator('prop', 'parent', min=-1, max=2) + + +@pytest.fixture +def validator_min(): + return IntegerValidator('prop', 'parent', min=-1) + + +@pytest.fixture +def validator_max(): + return IntegerValidator('prop', 'parent', max=2) + + +@pytest.fixture +def validator_aok(request): + return IntegerValidator('prop', 'parent', min=-2, max=10, array_ok=True) + + +# ### Acceptance ### +@pytest.mark.parametrize('val', + [1, -19, 0, -1234]) +def test_acceptance(val, validator: IntegerValidator): + assert validator.validate_coerce(val) == val + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + ['hello', (), [], [1, 2, 3], set(), '34', np.nan, np.inf, -np.inf]) +def test_rejection_by_value(val, validator: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### With min/max ### +# min == -1 and max == 2 +@pytest.mark.parametrize('val', + [0, 1, -1, 2]) +def test_acceptance_min_max(val, validator_min_max: IntegerValidator): + assert validator_min_max.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [-1.01, -10, 2.1, 3, np.iinfo(np.int).max, np.iinfo(np.int).min]) +def test_rejection_min_max(val, validator_min_max: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator_min_max.validate_coerce(val) + + assert 'in the interval [-1, 2]' in str(validation_failure.value) + + +# ### With min only ### +# min == -1 +@pytest.mark.parametrize('val', + [-1, 0, 1, 23, 99999]) +def test_acceptance_min(val, validator_min: IntegerValidator): + assert validator_min.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [-2, -123, np.iinfo(np.int).min]) +def test_rejection_min(val, validator_min: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator_min.validate_coerce(val) + + assert 'in the interval [-1, 9223372036854775807]' in str(validation_failure.value) + + +# ### With max only ### +# max == 2 +@pytest.mark.parametrize('val', + [1, 2, -10, -999999, np.iinfo(np.int32).min]) +def test_acceptance_max(val, validator_max: IntegerValidator): + assert validator_max.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [3, 10, np.iinfo(np.int32).max]) +def test_rejection_max(val, validator_max: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator_max.validate_coerce(val) + + assert 'in the interval [-9223372036854775808, 2]' in str(validation_failure.value) + + +# Array ok +# -------- +# min=-2 and max=10 +# ### Acceptance ### +@pytest.mark.parametrize('val', + [-2, 1, 0, 1, 10]) +def test_acceptance_aok_scalars(val, validator_aok: IntegerValidator): + assert validator_aok.validate_coerce(val) == val + + +@pytest.mark.parametrize('val', + [[1, 0], [1], [-2, 1, 8], np.array([3, 2, -1, 5])]) +def test_acceptance_aok_list(val, validator_aok: IntegerValidator): + assert np.array_equal(validator_aok.validate_coerce(val), val) + + +# ### Coerce ### +# Coerced to general consistent numeric type +@pytest.mark.parametrize('val,expected', + [([1, 0], (1, 0)), + ((1, -1), (1, -1)), + (np.array([-1, 0, 5.0], dtype='int16'), [-1, 0, 5]), + (np.array([1, 0], dtype=np.int64), [1, 0])]) +def test_coercion_aok_list(val, expected, validator_aok: IntegerValidator): + v = validator_aok.validate_coerce(val) + if isinstance(val, np.ndarray): + assert v.dtype == np.int32 + assert np.array_equal(validator_aok.present(v), + np.array(expected, dtype=np.int32)) + else: + assert isinstance(v, list) + assert validator_aok.present(v) == expected + +# ### Rejection ### +# +@pytest.mark.parametrize('val', + [['a', 4], [[], 3, 4]]) +def test_integer_validator_rejection_aok(val, validator_aok: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# ### Rejection by element ### +@pytest.mark.parametrize('val', + [[-1, 11], [1.5, -3], [0, np.iinfo(np.int32).max], [0, np.iinfo(np.int32).min]]) +def test_rejection_aok_min_max(val, validator_aok: IntegerValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'in the interval [-2, 10]' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_number_validator.py b/_plotly_utils/tests/validators/test_number_validator.py new file mode 100644 index 0000000000..5c7d288706 --- /dev/null +++ b/_plotly_utils/tests/validators/test_number_validator.py @@ -0,0 +1,153 @@ +import pytest +from pytest import approx + +from _plotly_utils.basevalidators import NumberValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture +def validator(request): + return NumberValidator('prop', 'parent') + + +@pytest.fixture +def validator_min_max(request): + return NumberValidator('prop', 'parent', min=-1.0, max=2.0) + + +@pytest.fixture +def validator_min(request): + return NumberValidator('prop', 'parent', min=-1.0) + + +@pytest.fixture +def validator_max(request): + return NumberValidator('prop', 'parent', max=2.0) + + +@pytest.fixture +def validator_aok(): + return NumberValidator('prop', 'parent', min=-1, max=1.5, array_ok=True) + + +# Array not ok +# ------------ +# ### Acceptance ### +@pytest.mark.parametrize('val', + [1.0, 0.0, 1, -1234.5678, 54321, np.pi, np.nan, np.inf, -np.inf]) +def test_acceptance(val, validator: NumberValidator): + assert validator.validate_coerce(val) == approx(val, nan_ok=True) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + ['hello', (), [], [1, 2, 3], set(), '34']) +def test_rejection_by_value(val, validator: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### With min/max ### +@pytest.mark.parametrize('val', + [0, 0.0, -0.5, 1, 1.0, 2, 2.0, np.pi/2.0]) +def test_acceptance_min_max(val, validator_min_max: NumberValidator): + assert validator_min_max.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [-1.01, -10, 2.1, 234, -np.inf, np.nan, np.inf]) +def test_rejection_min_max(val, validator_min_max: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator_min_max.validate_coerce(val) + + assert 'in the interval [-1.0, 2.0]' in str(validation_failure.value) + + +# ### With min only ### +@pytest.mark.parametrize('val', + [0, 0.0, -0.5, 99999, np.inf]) +def test_acceptance_min(val, validator_min: NumberValidator): + assert validator_min.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [-1.01, -np.inf, np.nan]) +def test_rejection_min(val, validator_min: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator_min.validate_coerce(val) + + assert 'in the interval [-1.0, inf]' in str(validation_failure.value) + + +# ### With max only ### +@pytest.mark.parametrize('val', + [0, 0.0, -np.inf, -123456, np.pi/2]) +def test_acceptance_max(val, validator_max: NumberValidator): + assert validator_max.validate_coerce(val) == approx(val) + + +@pytest.mark.parametrize('val', + [2.01, np.inf, np.nan]) +def test_rejection_max(val, validator_max: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator_max.validate_coerce(val) + + assert 'in the interval [-inf, 2.0]' in str(validation_failure.value) + + +# Array ok +# -------- +# ### Acceptance ### +@pytest.mark.parametrize('val', + [1.0, 0.0, 1, 0.4]) +def test_acceptance_aok_scalars(val, validator_aok: NumberValidator): + assert validator_aok.validate_coerce(val) == val + + +@pytest.mark.parametrize('val', + [[1.0, 0.0], [1], [-0.1234, .41, -1.0]]) +def test_acceptance_aok_list(val, validator_aok: NumberValidator): + assert np.array_equal(validator_aok.validate_coerce(val), np.array(val, dtype='float')) + + +# ### Coerce ### +# Coerced to general consistent numeric type +@pytest.mark.parametrize('val,expected', + [([1.0, 0], (1.0, 0)), + (np.array([1, -1]), np.array([1.0, -1.0])), + ((-0.1234, 0, -1), (-0.1234, 0.0, -1.0))]) +def test_coercion_aok_list(val, expected, validator_aok: NumberValidator): + v = validator_aok.validate_coerce(val) + if isinstance(val, np.ndarray): + assert v.dtype == 'float' + assert np.array_equal(v, expected) + else: + assert isinstance(v, list) + assert validator_aok.present(v) == tuple(val) + + +# ### Rejection ### +# +@pytest.mark.parametrize('val', + [['a', 4]]) +def test_rejection_aok(val, validator_aok: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# ### Rejection by element ### +@pytest.mark.parametrize('val', + [[-1.6, 0.0], [1, 1.5, 2], [-0.1234, .41, np.nan], + [0, np.inf], [0, -np.inf]]) +def test_rejection_aok_min_max(val, validator_aok: NumberValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + assert 'in the interval [-1, 1.5]' in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_string_validator.py b/_plotly_utils/tests/validators/test_string_validator.py new file mode 100644 index 0000000000..f857fbf013 --- /dev/null +++ b/_plotly_utils/tests/validators/test_string_validator.py @@ -0,0 +1,192 @@ +import pytest +from _plotly_utils.basevalidators import StringValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return StringValidator('prop', 'parent') + + +@pytest.fixture() +def validator_values(): + return StringValidator('prop', 'parent', values=['foo', 'BAR', '']) + + +@pytest.fixture() +def validator_no_blanks(): + return StringValidator('prop', 'parent', no_blank=True) + + +@pytest.fixture() +def validator_strict(): + return StringValidator('prop', 'parent', strict=True) + + +@pytest.fixture +def validator_aok(): + return StringValidator('prop', 'parent', array_ok=True, strict=True) + + +@pytest.fixture +def validator_aok_values(): + return StringValidator('prop', 'parent', values=['foo', 'BAR', '', 'baz'], array_ok=True) + + +@pytest.fixture() +def validator_no_blanks_aok(): + return StringValidator('prop', 'parent', no_blank=True, array_ok=True) + + +# Array not ok +# ------------ +# Not strict +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['bar', 234, np.nan, + 'HELLO!!!', 'world!@#$%^&*()', '']) +def test_acceptance(val, validator: StringValidator): + assert validator.validate_coerce(val) == str(val) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + [(), [], [1, 2, 3], set()]) +def test_rejection(val, validator: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Valid values +# ------------ +@pytest.mark.parametrize('val', + ['foo', 'BAR', '']) +def test_acceptance_values(val, validator_values: StringValidator): + assert validator_values.validate_coerce(val) == val + + +@pytest.mark.parametrize('val', + ['FOO', 'bar', 'other', '1234']) +def test_rejection_values(val, validator_values: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_values.validate_coerce(val) + + assert 'Invalid value'.format(val=val) in str(validation_failure.value) + assert "['foo', 'BAR', '']" in str(validation_failure.value) + + +# ### No blanks ### +@pytest.mark.parametrize('val', + ['bar', 'HELLO!!!', 'world!@#$%^&*()']) +def test_acceptance_no_blanks(val, validator_no_blanks: StringValidator): + assert validator_no_blanks.validate_coerce(val) == val + + +@pytest.mark.parametrize('val', + ['']) +def test_rejection_no_blanks(val, validator_no_blanks: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_no_blanks.validate_coerce(val) + + assert 'A non-empty string' in str(validation_failure.value) + + +# Strict +# ------ +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['bar', 'HELLO!!!', 'world!@#$%^&*()', '']) +def test_acceptance_strict(val, validator_strict: StringValidator): + assert validator_strict.validate_coerce(val) == val + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + [(), [], [1, 2, 3], set(), np.nan, np.pi, 23]) +def test_rejection_strict(val, validator_strict: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_strict.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# Array ok +# -------- +# ### Acceptance ### +@pytest.mark.parametrize('val', + ['foo', 'BAR', '', 'baz']) +def test_acceptance_aok_scalars(val, validator_aok: StringValidator): + assert validator_aok.validate_coerce(val) == val + + +@pytest.mark.parametrize('val', + ['foo', + ['foo'], + np.array(['BAR', ''], dtype='object'), + ['baz', 'baz', 'baz']]) +def test_acceptance_aok_list(val, validator_aok: StringValidator): + coerce_val = validator_aok.validate_coerce(val) + if isinstance(val, np.ndarray): + assert isinstance(coerce_val, np.ndarray) + assert np.array_equal(coerce_val, + np.array(val, dtype=coerce_val.dtype)) + elif isinstance(val, list): + assert validator_aok.present(val) == tuple(val) + else: + assert coerce_val == val + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', + [['foo', ()], ['foo', 3, 4], [3, 2, 1]]) +def test_rejection_aok(val, validator_aok: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', + [['foo', 'bar'], ['3', '4'], ['BAR', 'BAR', 'hello!']]) +def test_rejection_aok_values(val, validator_aok_values: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_aok_values.validate_coerce(val) + + assert 'Invalid element(s)' in str(validation_failure.value) + + +# ### No blanks ### +@pytest.mark.parametrize('val', + ['123', + ['bar', 'HELLO!!!'], + np.array(['bar', 'HELLO!!!'], dtype='object'), + ['world!@#$%^&*()']]) +def test_acceptance_no_blanks_aok(val, validator_no_blanks_aok: StringValidator): + coerce_val = validator_no_blanks_aok.validate_coerce(val) + if isinstance(val, np.ndarray): + assert np.array_equal(coerce_val, + np.array(val, dtype=coerce_val.dtype)) + elif isinstance(val, list): + assert validator_no_blanks_aok.present(coerce_val) == tuple(val) + else: + assert coerce_val == val + + +@pytest.mark.parametrize('val', + ['', + ['foo', 'bar', ''], + np.array(['foo', 'bar', ''], dtype='object'), + [''], + np.array([''], dtype='object')]) +def test_rejection_no_blanks_aok(val, + validator_no_blanks_aok: StringValidator): + with pytest.raises(ValueError) as validation_failure: + validator_no_blanks_aok.validate_coerce(val) + + assert 'A non-empty string' in str(validation_failure.value) + diff --git a/_plotly_utils/tests/validators/test_subplotid_validator.py b/_plotly_utils/tests/validators/test_subplotid_validator.py new file mode 100644 index 0000000000..be7358befe --- /dev/null +++ b/_plotly_utils/tests/validators/test_subplotid_validator.py @@ -0,0 +1,42 @@ +import pytest +from _plotly_utils.basevalidators import SubplotidValidator +import numpy as np + + +# Fixtures +# -------- +@pytest.fixture() +def validator(): + return SubplotidValidator('prop', 'parent', dflt='geo') + + +# Tests +# ----- +# ### Acceptance ### +@pytest.mark.parametrize('val', ['geo'] + ['geo%d' % i for i in range(2, 10)]) +def test_acceptance(val, validator: SubplotidValidator): + assert validator.validate_coerce(val) == val + + +# ### Rejection by type ### +@pytest.mark.parametrize('val', [ + 23, [], {}, set(), np.inf, np.nan +]) +def test_rejection_type(val, validator: SubplotidValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert 'Invalid value' in str(validation_failure.value) + + +# ### Rejection by value ### +@pytest.mark.parametrize('val', [ + '', # Cannot be empty + 'bogus', # Must begin with 'geo' + 'geo0', # If followed by a number the number must be > 1 +]) +def test_rejection_value(val, validator: SubplotidValidator): + with pytest.raises(ValueError) as validation_failure: + validator.validate_coerce(val) + + assert "Invalid value" in str(validation_failure.value) diff --git a/_plotly_utils/tests/validators/test_validators_common.py b/_plotly_utils/tests/validators/test_validators_common.py new file mode 100644 index 0000000000..27394e31f0 --- /dev/null +++ b/_plotly_utils/tests/validators/test_validators_common.py @@ -0,0 +1,7 @@ + +# # ### Accept None ### +# def test_accept_none(validator: NumberValidator): +# assert validator.validate_coerce(None) is None + + +# Test numpy arrays readonly diff --git a/circle.yml b/circle.yml index 28413b9b88..4581301872 100644 --- a/circle.yml +++ b/circle.yml @@ -20,7 +20,8 @@ dependencies: # install everything tox knows about and the plotly package. - pip install tox - - tox --notest + - tox --notest: + timeout: 1200 - pip install -I . # we need to cd out of the project root to ensure the install worked @@ -67,4 +68,5 @@ test: virtualenv venv && source venv/bin/activate && pip install ../dist/* && - python -c "import plotly" + python -c "import plotly;import plotly.graph_objs as go;go.Scatter()" + diff --git a/codegen/__init__.py b/codegen/__init__.py new file mode 100644 index 0000000000..19165685f8 --- /dev/null +++ b/codegen/__init__.py @@ -0,0 +1,201 @@ +import json +import os.path as opath +import shutil + +from codegen.datatypes import (build_datatype_py, write_datatype_py) +from codegen.compatibility import (write_deprecated_datatypes, + write_graph_objs_graph_objs, + DEPRECATED_DATATYPES) +from codegen.figure import write_figure_classes +from codegen.utils import (TraceNode, PlotlyNode, LayoutNode, FrameNode, + write_init_py) +from codegen.validators import (write_validator_py, + write_data_validator_py, + get_data_validator_instance) + +# Import notes +# ------------ +# Nothing from the plotly/ package should be imported during code +# generation. This introduces a lot of complexity regarding when imports +# happen relative to when various stages of code generation occur. Instead, +# helpers that are only needed during code generation should reside in the +# codegen/ package, and helpers used both during code generation and at +# runtime should reside in the _plotly_utils/ package. +# ---------------------------------------------------------------------------- + + +def perform_codegen(): + # Set root codegen output directory + # --------------------------------- + # (relative to project root) + outdir = 'plotly' + + # Delete prior codegen output + # --------------------------- + validators_pkgdir = opath.join(outdir, 'validators') + if opath.exists(validators_pkgdir): + shutil.rmtree(validators_pkgdir) + + graph_objs_pkgdir = opath.join(outdir, 'graph_objs') + if opath.exists(graph_objs_pkgdir): + shutil.rmtree(graph_objs_pkgdir) + + # plotly/datatypes is not used anymore, but was at one point so we'll + # still delete it if we find it in case a developer is upgrading from an + # older version + datatypes_pkgdir = opath.join(outdir, 'datatypes') + if opath.exists(datatypes_pkgdir): + shutil.rmtree(datatypes_pkgdir) + + # Load plotly schema + # ------------------ + with open('plotly/package_data/plot-schema.json', 'r') as f: + plotly_schema = json.load(f) + + # Build node lists + # ---------------- + # ### TraceNode ### + base_traces_node = TraceNode(plotly_schema) + compound_trace_nodes = PlotlyNode.get_all_compound_datatype_nodes( + plotly_schema, TraceNode) + all_trace_nodes = PlotlyNode.get_all_datatype_nodes( + plotly_schema, TraceNode) + + # ### LayoutNode ### + compound_layout_nodes = PlotlyNode.get_all_compound_datatype_nodes( + plotly_schema, LayoutNode) + layout_node = compound_layout_nodes[0] + all_layout_nodes = PlotlyNode.get_all_datatype_nodes( + plotly_schema, LayoutNode) + + # ### FrameNode ### + compound_frame_nodes = PlotlyNode.get_all_compound_datatype_nodes( + plotly_schema, FrameNode) + frame_node = compound_frame_nodes[0] + all_frame_nodes = PlotlyNode.get_all_datatype_nodes( + plotly_schema, FrameNode) + + # ### All nodes ### + all_datatype_nodes = (all_trace_nodes + + all_layout_nodes + + all_frame_nodes) + + all_compound_nodes = [node for node in all_datatype_nodes + if node.is_compound] + + # Write out validators + # -------------------- + # # ### Layout ### + for node in all_layout_nodes: + write_validator_py(outdir, node) + + # ### Trace ### + for node in all_trace_nodes: + write_validator_py(outdir, node) + + # ### Frames ### + for node in all_frame_nodes: + write_validator_py(outdir, node) + + # ### Data (traces) validator ### + write_data_validator_py(outdir, base_traces_node) + + # Write out datatypes + # ------------------- + # ### Layout ### + for node in compound_layout_nodes: + write_datatype_py(outdir, node) + + # ### Trace ### + for node in compound_trace_nodes: + write_datatype_py(outdir, node) + + # ### Frames ### + for node in compound_frame_nodes: + write_datatype_py(outdir, node) + + # ### Deprecated ### + # These are deprecated legacy datatypes like graph_objs.Marker + write_deprecated_datatypes(outdir) + + # Write figure class to graph_objs + # -------------------------------- + data_validator = get_data_validator_instance(base_traces_node) + layout_validator = layout_node.get_validator_instance() + frame_validator = frame_node.get_validator_instance() + + write_figure_classes(outdir, + base_traces_node, + data_validator, + layout_validator, + frame_validator) + + # Write validator __init__.py files + # --------------------------------- + # ### Write __init__.py files for each validator package ### + path_to_validator_import_info = {} + for node in all_datatype_nodes: + key = node.parent_path_parts + path_to_validator_import_info.setdefault(key, []).append( + (f"._{node.name_property}", node.name_validator_class) + ) + + # Add Data validator + root_validator_pairs = path_to_validator_import_info[()] + root_validator_pairs.append(('._data', 'DataValidator')) + + # Output validator __init__.py files + validators_pkg = opath.join(outdir, 'validators') + for path_parts, import_pairs in path_to_validator_import_info.items(): + write_init_py(validators_pkg, path_parts, import_pairs) + + # Write datatype __init__.py files + # -------------------------------- + # ### Build mapping from parent package to datatype class ### + path_to_datatype_import_info = {} + for node in all_compound_nodes: + key = node.parent_path_parts + + # class import + path_to_datatype_import_info.setdefault(key, []).append( + (f"._{node.name_undercase}", node.name_datatype_class) + ) + + # submodule import + if node.child_compound_datatypes: + + path_to_datatype_import_info.setdefault(key, []).append( + (f"plotly.graph_objs{node.parent_dotpath_str}", + node.name_undercase) + ) + + # ### Write plotly/graph_objs/graph_objs.py ### + # This if for backward compatibility. It just imports everything from + # graph_objs/__init__.py + write_graph_objs_graph_objs(outdir) + + # ### Add Figure and FigureWidget ### + root_datatype_imports = path_to_datatype_import_info[()] + root_datatype_imports.append(('._figure', 'Figure')) + + optional_figure_widget_import = """ +try: + import ipywidgets + from ._figurewidget import FigureWidget +except ImportError: + pass + +""" + root_datatype_imports.append(optional_figure_widget_import) + + # ### Add deprecations ### + root_datatype_imports.append(('._deprecations', DEPRECATED_DATATYPES.keys())) + + # ### Output datatype __init__.py files ### + graph_objs_pkg = opath.join(outdir, 'graph_objs') + for path_parts, import_pairs in path_to_datatype_import_info.items(): + write_init_py(graph_objs_pkg, path_parts, import_pairs) + + +if __name__ == '__main__': + perform_codegen() diff --git a/codegen/compatibility.py b/codegen/compatibility.py new file mode 100644 index 0000000000..7dcbe9e80e --- /dev/null +++ b/codegen/compatibility.py @@ -0,0 +1,250 @@ +from io import StringIO +from os import path as opath + +from codegen.utils import format_and_write_source_py + +# Build dict with info about deprecated datatypes +DEPRECATED_DATATYPES = { + # List types + 'Data': + {'base_type': list, + 'new': ['Scatter', 'Bar', 'Area', 'Histogram', 'etc.']}, + 'Annotations': + {'base_type': list, + 'new': ['layout', 'layout.scene']}, + 'Frames': + {'base_type': list, + 'new': ['Frame']}, + + # Dict types + 'AngularAxis': + {'base_type': dict, + 'new': ['layout', 'layout.polar']}, + 'Annotation': + {'base_type': dict, + 'new': ['layout', 'layout.scene']}, + 'ColorBar': + {'base_type': dict, + 'new': ['scatter.marker', 'surface', 'etc.']}, + 'Contours': + {'base_type': dict, + 'new': ['contour', 'surface', 'etc.']}, + 'ErrorX': + {'base_type': dict, + 'new': ['scatter', 'histogram', 'etc.']}, + 'ErrorY': + {'base_type': dict, + 'new': ['scatter', 'histogram', 'etc.']}, + 'ErrorZ': + {'base_type': dict, + 'new': ['scatter3d']}, + 'Font': + {'base_type': dict, + 'new': ['layout', 'layout.hoverlabel', 'etc.']}, + 'Legend': + {'base_type': dict, + 'new': ['layout']}, + 'Line': + {'base_type': dict, + 'new': ['scatter', 'layout.shape', 'etc.']}, + 'Margin': + {'base_type': dict, + 'new': ['layout']}, + 'Marker': + {'base_type': dict, + 'new': ['scatter', 'histogram.selected', 'etc.']}, + 'RadialAxis': + {'base_type': dict, + 'new': ['layout', 'layout.polar']}, + 'Scene': + {'base_type': dict, + 'new': ['Scene']}, + 'Stream': + {'base_type': dict, + 'new': ['scatter', 'area']}, + 'XAxis': + {'base_type': dict, + 'new': ['layout', 'layout.scene']}, + 'YAxis': + {'base_type': dict, + 'new': ['layout', 'layout.scene']}, + 'ZAxis': + {'base_type': dict, + 'new': ['layout.scene']}, + 'XBins': + {'base_type': dict, + 'new': ['histogram', 'histogram2d']}, + 'YBins': + {'base_type': dict, + 'new': ['histogram', 'histogram2d']}, + 'Trace': + {'base_type': dict, + 'new': ['Scatter', 'Bar', 'Area', 'Histogram', 'etc.']}, + 'Histogram2dcontour': + {'base_type': dict, + 'new': ['Histogram2dContour']}, +} + + +def build_deprecated_datatypes_py(): + """ + Build datatype (graph_objs) class source code string for deprecated + datatypes + + Returns + ------- + str + """ + + # Initialize source code buffer + # ----------------------------- + buffer = StringIO() + + # Write warnings import + # --------------------- + buffer.write('import warnings\n') + + # Write warnings filter + # --------------------- + # Use filter to enable DeprecationWarnings on our deprecated classes + buffer.write(r""" +warnings.filterwarnings('default', + r'plotly\.graph_objs\.\w+ is deprecated', + DeprecationWarning) + + +""") + + # Write deprecated class definitions + # ---------------------------------- + for class_name, opts in DEPRECATED_DATATYPES.items(): + base_class_name = opts['base_type'].__name__ + depr_msg = build_deprecation_message(class_name, **opts) + + buffer.write(f"""\ +class {class_name}({base_class_name}): + \"\"\" + {depr_msg} + \"\"\" + def __init__(self, *args, **kwargs): + \"\"\" + {depr_msg} + \"\"\" + warnings.warn(\"\"\"{depr_msg}\"\"\", DeprecationWarning) + super({class_name}, self).__init__(*args, **kwargs)\n\n\n""") + + # Return source string + # -------------------- + return buffer.getvalue() + + +def build_deprecation_message(class_name, base_type, new): + """ + Build deprecation warning message for a deprecated class + + Parameters + ---------- + class_name : str + Name of a deprecated class + base_type: type + base class (either list or dict) + new: list of str + List of replacements that users should use instead. + Replacements may be: + - A package string relative to plotly.graph_objs. In this case the + replacement class is assumed to be named `class_name`. + e.g. `new` == ['layout`] and `class_name` == 'XAxis` corresponds + to the 'plotly.graph_objs.layout.XAxis' class + - String containing the package and class. The string is + identified as containing a class name if the final name in the + package string begins with an uppercase letter. + e.g. `new` == ['Scatter'] corresponds to the + ['plotly.graph_objs.Scatter'] class. + - The literal string 'etc.'. This string is not interpreted as a + package or class and is displayed to the user as-is to + indicate that the list of replacement classes is not complete. + + Returns + ------- + str + """ + replacements = [] + for repl in new: + + if repl == 'etc.': + replacements.append(repl) + else: + repl_parts = repl.split('.') + + # Add class_name if class not provided + repl_is_class = repl_parts[-1][0].isupper() + if not repl_is_class: + repl_parts.append(class_name) + + # Add plotly.graph_objs prefix + full_class_str = '.'.join(['plotly', 'graph_objs'] + repl_parts) + replacements.append(full_class_str) + + replacemens_str = '\n - '.join(replacements) + + if base_type == list: + return f"""\ +plotly.graph_objs.{class_name} is deprecated. +Please replace it with a list or tuple of instances of the following types + - {replacemens_str} +""" + else: + return f"""\ +plotly.graph_objs.{class_name} is deprecated. +Please replace it with one of the following more specific types + - {replacemens_str} +""" + + +def write_deprecated_datatypes(outdir): + """ + Build source code for deprecated datatype class definitions and write + them to a file + + Parameters + ---------- + outdir : + Root outdir in which the graph_objs package should reside + + Returns + ------- + None + """ + # Generate source code + # -------------------- + datatype_source = build_deprecated_datatypes_py() + filepath = opath.join(outdir, 'graph_objs', '_deprecations.py') + + # Write file + # ---------- + format_and_write_source_py(datatype_source, filepath) + + +def write_graph_objs_graph_objs(outdir): + """ + Write the plotly/graph_objs/graph_objs.py file + + This module just imports everything from the plotly.graph_objs package. + We write it for backward compatibility with legacy imports like: + + from plotly.graph_objs import graph_objs + + Parameters + ---------- + outdir : str + Root outdir in which the graph_objs package should reside + + Returns + ------- + None + """ + filepath = opath.join(outdir, 'graph_objs', 'graph_objs.py') + with open(filepath, 'wt') as f: + f.write("""\ +from plotly.graph_objs import * +""") diff --git a/codegen/datatypes.py b/codegen/datatypes.py new file mode 100644 index 0000000000..12c3aa4b5c --- /dev/null +++ b/codegen/datatypes.py @@ -0,0 +1,450 @@ +import os.path as opath +import textwrap +from io import StringIO + +from codegen.utils import (PlotlyNode, + format_and_write_source_py) + + +def get_typing_type(plotly_type, array_ok=False): + """ + Get Python type corresponding to a valType string from the plotly schema + + Parameters + ---------- + plotly_type : str + a plotly datatype string + array_ok : bool + Whether lists/arrays are permitted + Returns + ------- + str + Python type string + """ + if plotly_type == 'data_array': + pytype = 'numpy.ndarray' + elif plotly_type == 'info_array': + pytype = 'list' + elif plotly_type == 'colorlist': + pytype = 'list' + elif plotly_type in ('string', 'color', 'colorscale', 'subplotid'): + pytype = 'str' + elif plotly_type in ('enumerated', 'flaglist', 'any'): + pytype = 'Any' + elif plotly_type in ('number', 'angle'): + pytype = 'int|float' + elif plotly_type == 'integer': + pytype = 'int' + elif plotly_type == 'boolean': + pytype = 'bool' + else: + raise ValueError('Unknown plotly type: %s' % plotly_type) + + if array_ok: + return f'{pytype}|numpy.ndarray' + else: + return pytype + + +def build_datatype_py(node): + """ + Build datatype (graph_objs) class source code string for a datatype + PlotlyNode + + Parameters + ---------- + node : PlotlyNode + The datatype node (node.is_datatype must evaluate to true) for which + to build the datatype class + Returns + ------- + str + String containing source code for the datatype class definition + """ + + # Validate inputs + # --------------- + assert node.is_compound + + # Extract node properties + # ----------------------- + undercase = node.name_undercase + datatype_class = node.name_datatype_class + literal_nodes = [n for n in node.child_literals if + n.plotly_name in ['type']] + + # Initialze source code buffer + # ---------------------------- + buffer = StringIO() + + # Imports + # ------- + buffer.write( + f'from plotly.basedatatypes import {node.name_base_datatype}\n') + buffer.write( + f'import copy\n') + + + # Write class definition + # ---------------------- + buffer.write(f""" + +class {datatype_class}({node.name_base_datatype}):\n""") + + # ### Property definitions ### + child_datatype_nodes = node.child_datatypes + + subtype_nodes = child_datatype_nodes + for subtype_node in subtype_nodes: + if subtype_node.is_array_element: + prop_type = (f"tuple[plotly.graph_objs{node.dotpath_str}." + + f"{subtype_node.name_datatype_class}]") + + elif subtype_node.is_compound: + prop_type = (f"plotly.graph_objs{node.dotpath_str}." + + f"{subtype_node.name_datatype_class}") + else: + prop_type = get_typing_type( + subtype_node.datatype, subtype_node.is_array_ok) + + # #### Get property description #### + raw_description = subtype_node.description + property_description = '\n'.join( + textwrap.wrap(raw_description, + initial_indent=' ' * 8, + subsequent_indent=' ' * 8, + width=79 - 8)) + + # # #### Get validator description #### + validator = subtype_node.get_validator_instance() + if validator: + validator_description = reindent_validator_description( + validator, 4) + + # #### Combine to form property docstring #### + if property_description.strip(): + property_docstring = f"""{property_description} + + {validator_description}""" + else: + property_docstring = f" {validator_description}" + else: + property_docstring = property_description + + # #### Write get property #### + buffer.write(f"""\ + + # {subtype_node.name_property} + # {'-' * len(subtype_node.name_property)} + @property + def {subtype_node.name_property}(self): + \"\"\" +{property_docstring} + + Returns + ------- + {prop_type} + \"\"\" + return self['{subtype_node.name_property}']""") + + # #### Write set property #### + buffer.write(f""" + + @{subtype_node.name_property}.setter + def {subtype_node.name_property}(self, val): + self['{subtype_node.name_property}'] = val\n""") + + # ### Literals ### + for literal_node in literal_nodes: + buffer.write(f"""\ + + # {literal_node.name_property} + # {'-' * len(literal_node.name_property)} + @property + def {literal_node.name_property}(self): + return self._props['{literal_node.name_property}']\n""") + + # ### Private properties descriptions ### + buffer.write(f""" + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '{node.parent_path_str}' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return \"\"\"\\""") + + buffer.write(node.get_constructor_params_docstring(indent=8)) + + buffer.write(f""" + \"\"\"""") + + # ### Constructor ### + buffer.write(f""" + def __init__(self""") + + add_constructor_params(buffer, + subtype_nodes, + prepend_extras=['arg']) + + # ### Constructor Docstring ### + header = f'Construct a new {datatype_class} object' + class_name = (f'plotly.graph_objs' + f'{node.parent_dotpath_str}.' + f'{node.name_datatype_class}') + + extras = [(f'arg', + f'dict of properties compatible with this constructor ' + f'or an instance of {class_name}')] + + add_docstring(buffer, node, header=header, prepend_extras=extras) + + buffer.write(f""" + super({datatype_class}, self).__init__('{node.name_property}') + + # Validate arg + # ------------ + if arg is None: + arg = {{}} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError(\"\"\"\\ +The first argument to the {class_name} +constructor must be a dict or +an instance of {class_name}\"\"\") + + # Import validators + # ----------------- + from plotly.validators{node.parent_dotpath_str} import ( + {undercase} as v_{undercase}) + + # Initialize validators + # ---------------------""") + for subtype_node in subtype_nodes: + sub_name = subtype_node.name_property + sub_validator = subtype_node.name_validator_class + buffer.write(f""" + self._validators['{sub_name}'] = v_{undercase}.{sub_validator}()""") + + buffer.write(f""" + + # Populate data dict with properties + # ----------------------------------""") + for subtype_node in subtype_nodes: + name_prop = subtype_node.name_property + buffer.write(f""" + v = arg.pop('{name_prop}', None) + self.{name_prop} = {name_prop} if {name_prop} is not None else v""") + + # ### Literals ### + if literal_nodes: + buffer.write(f""" + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator""") + for literal_node in literal_nodes: + lit_name = literal_node.name_property + lit_parent = literal_node.parent_path_str + lit_val = literal_node.node_data + buffer.write(f""" + self._props['{lit_name}'] = '{lit_val}' + self._validators['{lit_name}'] =\ +LiteralValidator(plotly_name='{lit_name}', parent_name='{lit_parent}')""") + + buffer.write(f""" + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) + """) + + # Return source string + # -------------------- + return buffer.getvalue() + + +def reindent_validator_description(validator, extra_indent): + """ + Return validator description with modified indenting. The string that is + returned has no leading indent, and the subsequent lines are indented by 4 + spaces (the default for validator descriptions) plus `extra_indent` spaces + + Parameters + ---------- + validator : BaseValidator + Validator from which to extract the description + extra_indent : int + Number of spaces of indent to add to subsequent lines (those after + the first line). Validators description start with in indent of 4 + spaces + + Returns + ------- + str + Validator description string + """ + # Remove leading indent and add extra spaces to subsequent indent + return ('\n' + ' ' * extra_indent).join( + validator.description().strip().split('\n')) + + +def add_constructor_params(buffer, + subtype_nodes, + prepend_extras=(), + append_extras=()): + """ + Write datatype constructor params to a buffer + + Parameters + ---------- + buffer : StringIO + Buffer to write to + subtype_nodes : list of PlotlyNode + List of datatype nodes to be written as constructor params + prepend_extras : list[str] + List of extra parameters to include at the beginning of the params + append_extras : list[str] + List of extra parameters to include at the end of the params + Returns + ------- + None + """ + for extra in prepend_extras: + buffer.write(f""", + {extra}=None""") + + for i, subtype_node in enumerate(subtype_nodes): + buffer.write(f""", + {subtype_node.name_property}=None""") + + for extra in append_extras: + buffer.write(f""", + {extra}=None""") + + buffer.write(""", + **kwargs""") + buffer.write(f""" + ):""") + + +def add_docstring(buffer, node, header, prepend_extras=(), append_extras=()): + """ + Write docstring for a compound datatype node + + Parameters + ---------- + buffer : StringIO + Buffer to write to + node : PlotlyNode + Compound datatype plotly node for which to write docstring + header : + Top-level header for docstring that will preceded the input node's + own description. Header should be < 71 characters long + prepend_extras : + List or tuple of propery name / description pairs that should be + included at the beginning of the docstring + append_extras : + List or tuple of propery name / description pairs that should be + included at the end of the docstring + Returns + ------- + + """ + # Validate inputs + # --------------- + assert node.is_compound + + # Build wrapped description + # ------------------------- + node_description = node.description + if node_description: + description_lines = textwrap.wrap( + node_description, + width=79-8, + initial_indent=' ' * 8, + subsequent_indent=' ' * 8) + + node_description = '\n'.join(description_lines) + '\n\n' + + # Write header and description + # ---------------------------- + buffer.write(f""" + \"\"\" + {header} + +{node_description} Parameters + ----------""") + + # Write parameter descriptions + # ---------------------------- + # Write any prepend extras + for p, v in prepend_extras: + v_wrapped = '\n'.join(textwrap.wrap( + v, + width=79 - 12, + initial_indent=' ' * 12, + subsequent_indent=' ' * 12)) + buffer.write(f""" + {p} +{v_wrapped}""") + + # Write core docstring + buffer.write(node.get_constructor_params_docstring( + indent=8)) + + # Write any append extras + for p, v in append_extras: + v_wrapped = '\n'.join(textwrap.wrap( + v, + width=79-12, + initial_indent=' ' * 12, + subsequent_indent=' ' * 12)) + buffer.write(f""" + {p} +{v_wrapped}""") + + # Write return block and close docstring + # -------------------------------------- + buffer.write(f""" + + Returns + ------- + {node.name_datatype_class} + \"\"\"""") + + +def write_datatype_py(outdir, node): + """ + Build datatype (graph_objs) class source code and write to a file + + Parameters + ---------- + outdir : + Root outdir in which the graph_objs package should reside + node : + The datatype node (node.is_datatype must evaluate to true) for which + to build the datatype class + + Returns + ------- + None + """ + # Generate source code + # -------------------- + datatype_source = build_datatype_py(node) + + # Write file + # ---------- + filepath = opath.join(outdir, 'graph_objs', + *node.parent_path_parts, + '_' + node.name_undercase + '.py') + format_and_write_source_py(datatype_source, filepath) diff --git a/codegen/figure.py b/codegen/figure.py new file mode 100644 index 0000000000..e20dc1e27f --- /dev/null +++ b/codegen/figure.py @@ -0,0 +1,187 @@ +from io import StringIO +from os import path as opath + +from _plotly_utils.basevalidators import (BaseDataValidator, + CompoundValidator, + CompoundArrayValidator) +from codegen.datatypes import (reindent_validator_description, + add_constructor_params, add_docstring) +from codegen.utils import PlotlyNode, format_and_write_source_py + + +def build_figure_py(trace_node, base_package, base_classname, fig_classname, + data_validator, layout_validator, frame_validator): + """ + + Parameters + ---------- + trace_node : PlotlyNode + Root trace node (the node that is the parent of all of the + individual trace nodes like bar, scatter, etc.) + base_package : str + Package that the figure's superclass resides in + base_classname : str + Name of the figure's superclass + fig_classname : str + Name of the Figure class to be generated + data_validator : BaseDataValidator + DataValidator instance + layout_validator : CompoundValidator + LayoutValidator instance + frame_validator : CompoundArrayValidator + FrameValidator instance + + Returns + ------- + str + Source code for figure class definition + """ + + # Initialize source code buffer + # ----------------------------- + buffer = StringIO() + + # Get list of trace type nodes + # ---------------------------- + trace_nodes = trace_node.child_compound_datatypes + + # Write imports + # ------------- + # ### Import base class ### + buffer.write(f'from plotly.{base_package} import {base_classname}\n') + + # ### Import trace graph_obj classes ### + trace_types_csv = ', '.join([n.name_datatype_class for n in trace_nodes]) + buffer.write(f'from plotly.graph_objs import ({trace_types_csv})\n') + + # Write class definition + # ---------------------- + buffer.write(f""" + +class {fig_classname}({base_classname}):\n""") + + # ### Constructor ### + # Build constructor description strings + data_description = reindent_validator_description(data_validator, 8) + layout_description = reindent_validator_description(layout_validator, 8) + frames_description = reindent_validator_description(frame_validator, 8) + + buffer.write(f""" + def __init__(self, data=None, layout=None, frames=None): + \"\"\" + Create a new {fig_classname} instance + + Parameters + ---------- + data + {data_description} + layout + {layout_description} + frames + {frames_description} + \"\"\" + super({fig_classname} ,self).__init__(data, layout, frames) + """) + + # ### add_trace methods for each trace type ### + for trace_node in trace_nodes: + + # #### Function signature #### + buffer.write(f""" + def add_{trace_node.plotly_name}(self""") + + # #### Function params#### + add_constructor_params(buffer, + trace_node.child_datatypes, + append_extras=['row', 'col']) + + # #### Docstring #### + header = f"Add a new {trace_node.name_datatype_class} trace" + + extras = (('row : int or None (default)', + 'Subplot row index (starting from 1) for the trace to be ' + 'added. Only valid if figure was created using ' + '`plotly.tools.make_subplots`'), + ('col : int or None (default)', + 'Subplot col index (starting from 1) for the trace to be ' + 'added. Only valid if figure was created using ' + '`plotly.tools.make_subplots`')) + + add_docstring(buffer, trace_node, header, append_extras=extras) + + # #### Function body #### + buffer.write(f""" + new_trace = {trace_node.name_datatype_class}( + """) + + for i, subtype_node in enumerate(trace_node.child_datatypes): + subtype_prop_name = subtype_node.name_property + buffer.write(f""" + {subtype_prop_name}={subtype_prop_name},""") + + buffer.write(f""" + **kwargs)""") + + buffer.write(f""" + return self.add_trace(new_trace, row=row, col=col)""") + + # Return source string + # -------------------- + buffer.write('\n') + return buffer.getvalue() + + +def write_figure_classes(outdir, trace_node, + data_validator, + layout_validator, + frame_validator): + """ + Construct source code for the Figure and FigureWidget classes and + write to graph_objs/_figure.py and graph_objs/_figurewidget.py + respectively + + Parameters + ---------- + outdir : str + Root outdir in which the graph_objs package should reside + trace_node : PlotlyNode + Root trace node (the node that is the parent of all of the + individual trace nodes like bar, scatter, etc.) + data_validator : BaseDataValidator + DataValidator instance + layout_validator : CompoundValidator + LayoutValidator instance + frame_validator : CompoundArrayValidator + FrameValidator instance + + Returns + ------- + None + """ + + # Validate inputs + # --------------- + if trace_node.node_path: + raise ValueError(f'Expected root trace node.\n' + f'Received node with path "{trace_node.path_str}"') + + # Loop over figure types + # ---------------------- + base_figures = [('basewidget', 'BaseFigureWidget', 'FigureWidget'), + ('basedatatypes', 'BaseFigure', 'Figure')] + + for base_package, base_classname, fig_classname in base_figures: + + # ### Build figure source code string ### + figure_source = build_figure_py(trace_node, + base_package, + base_classname, + fig_classname, + data_validator, + layout_validator, + frame_validator) + + # ### Format and write to file### + filepath = opath.join(outdir, 'graph_objs', + f'_{fig_classname.lower()}.py') + format_and_write_source_py(figure_source, filepath) diff --git a/codegen/utils.py b/codegen/utils.py new file mode 100644 index 0000000000..2ade3566fa --- /dev/null +++ b/codegen/utils.py @@ -0,0 +1,1031 @@ +import os +import os.path as opath +import textwrap +from collections import ChainMap +from importlib import import_module +from io import StringIO +from typing import List + +from yapf.yapflib.yapf_api import FormatCode + + +# Source code utilities +# ===================== +def format_source(input_source): + """ + Use yapf to format a string containing Python source code + + Parameters + ---------- + input_source : str + String containing Python source code + + Returns + ------- + String containing yapf-formatted python source code + """ + style_config = {'based_on_style': 'google', + 'DEDENT_CLOSING_BRACKETS': True, + 'COLUMN_LIMIT': 79} + formatted_source, _ = FormatCode(input_source, style_config=style_config) + return formatted_source + + +def format_and_write_source_py(py_source, filepath): + """ + Format Python source code and write to a file, creating parent + directories as needed. + + Parameters + ---------- + py_source : str + String containing valid Python source code. If string is empty, + no file will be written. + filepath : str + Full path to the file to be written + Returns + ------- + None + """ + if py_source: + try: + formatted_source = format_source(py_source) + except Exception as e: + print(py_source) + raise e + + # Make dir if needed + # ------------------ + filedir = opath.dirname(filepath) + os.makedirs(filedir, exist_ok=True) + + # Write file + # ---------- + with open(filepath, 'wt') as f: + f.write(formatted_source) + + +def build_from_imports_py(imports_info): + """ + Build a string containing a series of `from X import Y` lines + + Parameters + ---------- + imports_info : str or list of (str, str or list of str) + List of import info + If element is a pair first entry is the package to be imported + from and the second entry is either a string of the single name + to be + + If element is a string, insert string directly + Returns + ------- + str + String containing a series of imports + """ + buffer = StringIO() + for import_info in imports_info: + + if isinstance(import_info, tuple): + from_pkg, class_name = import_info + if isinstance(class_name, str): + class_name_str = class_name + else: + class_name_str = '(' + ', '.join(class_name) + ')' + + buffer.write(f"""\ +from {from_pkg} import {class_name_str}\n""") + + elif isinstance(import_info, str): + buffer.write(import_info) + + return buffer.getvalue() + + +def write_init_py(pkg_root, path_parts, import_pairs): + """ + Build __init__.py source code and write to a file + + Parameters + ---------- + pkg_root : str + Root package in which the top-level an __init__.py file with empty + path_parts should reside + path_parts : tuple of str + Tuple of sub-packages under pkg_root where the __init__.py + file should be written + import_pairs : list of (str, str or list of str) + List of pairs where first entry is the package to be imported from. + The second entry is either a string of the single name to be + imported, or a list of names to be imported. + Returns + ------- + None + """ + # Generate source code + # -------------------- + init_source = build_from_imports_py(import_pairs) + + # Write file + # ---------- + filepath = opath.join(pkg_root, *path_parts, '__init__.py') + format_and_write_source_py(init_source, filepath) + + +# Constants +# ========= +# Mapping from full property paths to custom validator classes +CUSTOM_VALIDATOR_DATATYPES = { + 'layout.image.source': '_plotly_utils.basevalidators.ImageUriValidator', + 'frame.data': 'plotly.validators.DataValidator', + 'frame.layout': 'plotly.validators.LayoutValidator' +} + +# Mapping from property string (as found in plot-schema.json) to a custom +# class name. If not included here, names are converted to TitleCase and +# underscores are removed. +OBJECT_NAME_TO_CLASS_NAME = { + 'angularaxis': 'AngularAxis', + 'colorbar': 'ColorBar', + 'error_x': 'ErrorX', + 'error_y': 'ErrorY', + 'error_z': 'ErrorZ', + 'histogram2d': 'Histogram2d', + 'histogram2dcontour': 'Histogram2dContour', + 'mesh3d': 'Mesh3d', + 'radialaxis': 'RadialAxis', + 'scatter3d': 'Scatter3d', + 'xaxis': 'XAxis', + 'xbins': 'XBins', + 'yaxis': 'YAxis', + 'ybins': 'YBins', + 'zaxis': 'ZAxis' +} + +# Tuple of types to be considered dicts by PlotlyNode logic +dict_like = (dict, ChainMap) + + +# PlotlyNode classes +# ================== +class PlotlyNode: + """ + Base class that represents a node in the plot-schema.json file + """ + + # Constructor + # ----------- + def __init__(self, plotly_schema, node_path=(), parent=None): + """ + Superclass constructor for all node types + + Parameters + ---------- + plotly_schema : dict + JSON-parsed version of the default-schema.xml file + node_path : str or tuple + Path of from the 'root' node for the current trace type to the + particular node that this instance represents + parent : PlotlyNode + Reference to the node's parent + """ + # Save params + # ----------- + self.plotly_schema = plotly_schema + self._parent = parent + + # ### Process node path ### + if isinstance(node_path, str): + node_path = (node_path,) + self.node_path = node_path + + # Compute children + # ---------------- + # Note the node_data is a property that must be computed by the + # subclass based on plotly_schema and node_path + if isinstance(self.node_data, dict_like): + self._children = [self.__class__(self.plotly_schema, + node_path=self.node_path + (c,), + parent=self) + for c in self.node_data if c and c[0] != '_'] + + # Sort by plotly name + self._children = sorted(self._children, + key=lambda node: node.plotly_name) + else: + self._children = [] + + # Magic methods + # ------------- + def __repr__(self): + return self.path_str + + # Abstract methods + # ---------------- + @property + def node_data(self): + """ + Dictionary of the subtree of the plotly_schema that this node + represents + + Returns + ------- + dict + """ + raise NotImplementedError() + + @property + def description(self): + """ + Description of the node + + Returns + ------- + str or None + """ + raise NotImplementedError() + + @property + def name_base_datatype(self): + """ + Superclass to use when generating a datatype class for this node + + Returns + ------- + str + """ + raise NotImplementedError + + # Names + # ----- + @property + def root_name(self): + """ + Name of the node with empty node_path + + Returns + ------- + str + """ + raise NotImplementedError() + + @property + def plotly_name(self) : + """ + Name of the node. Either the base_name or the name directly out of + the plotly_schema + + Returns + ------- + str + """ + if len(self.node_path) == 0: + return self.root_name + else: + return self.node_path[-1] + + @property + def name_datatype_class(self): + """ + Name of the Python datatype class representing this node + + Returns + ------- + str + """ + if self.plotly_name in OBJECT_NAME_TO_CLASS_NAME: + return OBJECT_NAME_TO_CLASS_NAME[self.plotly_name] + else: + return self.plotly_name.title().replace('_', '') + + @property + def name_undercase(self): + """ + Name of node converted to undercase (all lowercase with underscores + separating words) + + Returns + ------- + str + """ + if not self.plotly_name: + # Empty plotly_name + return self.plotly_name + + # Lowercase leading char + # ---------------------- + name1 = self.plotly_name[0].lower() + self.plotly_name[1:] + + # Replace capital chars by underscore-lower + # ----------------------------------------- + name2 = ''.join([('' if not c.isupper() else '_') + c.lower() + for c in name1]) + + return name2 + + @property + def name_property(self): + """ + Name of the Python property corresponding to this node. This is the + same as `name_undercase` for compound nodes, but an 's' is appended + to the name for array nodes + + Returns + ------- + str + """ + return self.plotly_name + ('s' if self.is_array_element else '') + + @property + def name_validator_class(self) -> str: + """ + Name of the Python validator class representing this node + + Returns + ------- + str + """ + return (self.name_datatype_class + + ('s' if self.is_array_element else '') + + 'Validator') + + @property + def name_base_validator(self) -> str: + """ + Superclass to use when generating a validator class for this node + + Returns + ------- + str + """ + if self.path_str in CUSTOM_VALIDATOR_DATATYPES: + validator_base = f"{CUSTOM_VALIDATOR_DATATYPES[self.path_str]}" + elif self.plotly_name.endswith('src') and self.datatype == 'string': + validator_base = (f"_plotly_utils.basevalidators." + f"SrcValidator") + else: + datatype_title_case = self.datatype.title().replace('_', '') + validator_base = (f"_plotly_utils.basevalidators." + f"{datatype_title_case}Validator") + + return validator_base + + # Validators + # ---------- + def get_validator_params(self): + """ + Get kwargs to pass to the constructor of this node's validator + superclass. + + Returns + ------- + dict + The keys are strings matching the names of the constructor + params of this node's validator superclass. The values are + repr-strings of the values to be passed to the constructor. + These values are ready to be used to code generate calls to the + constructor. The values should be evald before being passed to + the constructor directly. + + """ + params = {'plotly_name': repr(self.name_property), + 'parent_name': repr(self.parent_path_str)} + + if self.is_compound: + params['data_class_str'] = repr(self.name_datatype_class) + params['data_docs'] = ( + '\"\"\"' + + self.get_constructor_params_docstring() + + '\"\"\"') + else: + assert self.is_simple + + # Exclude general properties + excluded_props = ['valType', 'description', 'dflt'] + if self.datatype == 'subplotid': + # Default is required for subplotid validator + excluded_props.remove('dflt') + + attr_nodes = [n for n in self.simple_attrs + if n.plotly_name not in excluded_props] + + for node in attr_nodes: + params[node.name_undercase] = repr(node.node_data) + + # Add extra properties + if self.datatype == 'color' and self.parent: + # Check for colorscale sibling. We use the presence of a + # colorscale sibling to determine whether numeric color + # values are permissible + colorscale_node_list = [node for node in + self.parent.child_datatypes + if node.datatype == 'colorscale'] + if colorscale_node_list: + colorscale_path = colorscale_node_list[0].path_str + params['colorscale_path'] = repr(colorscale_path) + + return params + + def get_validator_instance(self): + """ + Return a constructed validator for this node + + Returns + ------- + BaseValidator + """ + + # Evaluate validator params to convert repr strings into values + # e.g. '2' -> 2 + params = {prop: eval(repr_val) + for prop, repr_val in self.get_validator_params().items()} + + validator_parts = self.name_base_validator.split('.') + if validator_parts[0] != '_plotly_utils': + return None + else: + validator_class_str = validator_parts[-1] + validator_module = '.'.join(validator_parts[:-1]) + + validator_class = getattr(import_module(validator_module), + validator_class_str) + + return validator_class(**params) + + # Datatypes + # --------- + @property + def datatype(self) -> str: + """ + Datatype string for this node. One of 'compound_array', 'compound', + 'literal', or the value of the 'valType' attribute + + Returns + ------- + str + """ + if self.is_array_element: + return 'compound_array' + elif self.is_compound: + return 'compound' + elif self.is_simple: + return self.node_data.get('valType') + else: + return 'literal' + + @property + def is_array_ok(self) -> bool: + """ + Return true if arrays of datatype are acceptable + + Returns + ------- + bool + """ + return self.node_data.get('arrayOk', False) + + @property + def is_compound(self) -> bool: + """ + Node has a compound (in contrast to simple) datatype. + Note: All array and array_element types are also considered compound + + Returns + ------- + bool + """ + return (isinstance(self.node_data, dict_like) and + not self.is_simple and + self.plotly_name not in ('items', 'impliedEdits', 'transforms')) + + @property + def is_literal(self) -> bool: + """ + Node has a particular literal value (e.g. 'foo', or 23) + + Returns + ------- + bool + """ + return isinstance(self.node_data, (str, int, float)) + + @property + def is_simple(self) -> bool: + """ + Node has a simple datatype (e.g. boolean, color, colorscale, etc.) + + Returns + ------- + bool + """ + return (isinstance(self.node_data, dict_like) and + 'valType' in self.node_data and + self.plotly_name != 'items') + + @property + def is_array(self) -> bool: + """ + Node has an array datatype + + Returns + ------- + bool + """ + return (isinstance(self.node_data, dict_like) and + self.node_data.get('role', '') == 'object' and + 'items' in self.node_data and + self.name_property != 'transforms') + + @property + def is_array_element(self): + """ + Node has an array-element datatype + + Returns + ------- + bool + """ + if self.parent and self.parent.parent: + return self.parent.parent.is_array + else: + return False + + @property + def is_datatype(self) -> bool: + """ + Node represents any kind of datatype + + Returns + ------- + bool + """ + return self.is_simple or self.is_compound or self.is_array + + # Node path + # --------- + def tidy_path_part(self, p): + """ + Return a tidy version of raw path entry. This allows subclasses to + adjust the raw property names in the plotly_schema + + Parameters + ---------- + p : str + Path element string + + Returns + ------- + str + """ + return p + + @property + def path_parts(self): + """ + Tuple of strings locating this node in the plotly_schema + e.g. ('layout', 'images', 'opacity') + + Returns + ------- + tuple of str + """ + res = [self.root_name] if self.root_name else [] + for i, p in enumerate(self.node_path): + # Handle array datatypes + if (p == 'items' or + (i < len(self.node_path) - 1 and + self.node_path[i+1] == 'items')): + # e.g. [parcoords, dimensions, items, dimension] -> + # [parcoords, dimension] + pass + else: + res.append(self.tidy_path_part(p)) + return tuple(res) + + # Node path strings + # ----------------- + @property + def path_str(self): + """ + String containing path_parts joined on periods + e.g. 'layout.images.opacity' + + Returns + ------- + str + """ + return '.'.join(self.path_parts) + + @property + def dotpath_str(self): + """ + path_str prefixed by a period if path_str is not empty, otherwise empty + + Returns + ------- + str + """ + path_str = '' + for p in self.path_parts: + path_str += '.' + p + return path_str + + @property + def parent_path_parts(self): + """ + Tuple of strings locating this node's parent in the plotly_schema + + Returns + ------- + tuple of str + """ + return self.path_parts[:-1] + + @property + def parent_path_str(self): + """ + String containing parent_path_parts joined on periods + + Returns + ------- + str + """ + return '.'.join(self.path_parts[:-1]) + + @property + def parent_dotpath_str(self): + """ + parent_path_str prefixed by a period if parent_path_str is not empty, + otherwise empty + + Returns + ------- + str + """ + path_str = '' + for p in self.parent_path_parts: + path_str += '.' + p + return path_str + + # Children + # -------- + @property + def parent(self): + """ + Parent node + + Returns + ------- + PlotlyNode + """ + return self._parent + + @property + def children(self): + """ + List of all child nodes + + Returns + ------- + list of PlotlyNode + """ + return self._children + + @property + def simple_attrs(self): + """ + List of simple attribute child nodes + (only valid when is_simple == True) + + Returns + ------- + list of PlotlyNode + """ + if not self.is_simple: + raise ValueError( + f"Cannot get simple attributes of the simple object '{self.path_str}'") + + return [n for n in self.children if n.plotly_name not in ['valType', 'description']] + + @property + def child_datatypes(self): + """ + List of all datatype child nodes + + Returns + ------- + list of PlotlyNode + """ + nodes = [] + for n in self.children: + if n.is_array: + nodes.append(n.children[0].children[0]) + elif n.is_datatype: + nodes.append(n) + + return nodes + + @property + def child_compound_datatypes(self): + """ + List of all compound datatype child nodes + + Returns + ------- + list of PlotlyNode + """ + return [n for n in self.child_datatypes if n.is_compound] + + @property + def child_simple_datatypes(self) -> List['PlotlyNode']: + """ + List of all simple datatype child nodes + + Returns + ------- + list of PlotlyNode + """ + return [n for n in self.child_datatypes if n.is_simple] + + @property + def child_literals(self) -> List['PlotlyNode']: + """ + List of all literal child nodes + + Returns + ------- + list of PlotlyNode + """ + return [n for n in self.children if n.is_literal] + + def get_constructor_params_docstring(self, indent=12): + """ + Return a docstring-style string containing the names and + descriptions of all of the node's child datatypes + + Parameters + ---------- + indent : int + Leading indent of the string + + Returns + ------- + str + """ + assert self.is_compound + + buffer = StringIO() + + subtype_nodes = self.child_datatypes + for subtype_node in subtype_nodes: + raw_description = subtype_node.description + if raw_description: + subtype_description = raw_description + elif subtype_node.is_compound: + class_name = (f'plotly.graph_objs' + f'{subtype_node.parent_dotpath_str}.' + f'{subtype_node.name_datatype_class}') + + subtype_description = (f'{class_name} instance or ' + 'dict with compatible properties') + else: + subtype_description = '' + + subtype_description = '\n'.join( + textwrap.wrap(subtype_description, + initial_indent=' ' * (indent + 4), + subsequent_indent=' ' * (indent + 4), + width=79 - (indent + 4))) + + buffer.write('\n' + ' ' * indent + subtype_node.name_property) + buffer.write('\n' + subtype_description) + + return buffer.getvalue() + + # Static helpers + # -------------- + @staticmethod + def get_all_compound_datatype_nodes(plotly_schema, node_class): + """ + Build a list of the entire hierarchy of compound datatype nodes for + a given PlotlyNode subclass + + Parameters + ---------- + plotly_schema : dict + JSON-parsed version of the default-schema.xml file + node_class + PlotlyNode subclass + + Returns + ------- + list of PlotlyNode + """ + nodes = [] + nodes_to_process = [node_class(plotly_schema)] + + while nodes_to_process: + node = nodes_to_process.pop() + + if node.plotly_name and not node.is_array: + nodes.append(node) + + nodes_to_process.extend(node.child_compound_datatypes) + + return nodes + + @staticmethod + def get_all_datatype_nodes(plotly_schema, node_class): + """ + Build a list of the entire hierarchy of datatype nodes for a given + PlotlyNode subclass + + Parameters + ---------- + plotly_schema : dict + JSON-parsed version of the default-schema.xml file + node_class + PlotlyNode subclass + + Returns + ------- + list of PlotlyNode + """ + nodes = [] + nodes_to_process = [node_class(plotly_schema)] + + while nodes_to_process: + node = nodes_to_process.pop() + + if node.plotly_name and not node.is_array: + nodes.append(node) + + nodes_to_process.extend(node.child_datatypes) + + return nodes + + +class TraceNode(PlotlyNode): + """ + Class representing datatypes in the trace hierarchy + """ + + # Constructor + # ----------- + def __init__(self, plotly_schema, node_path=(), parent=None): + super().__init__(plotly_schema, node_path, parent) + + @property + def name_base_datatype(self): + if len(self.node_path) <= 1: + return 'BaseTraceType' + else: + return 'BaseTraceHierarchyType' + + @property + def root_name(self): + return '' + + # Raw data + # -------- + @property + def node_data(self) -> dict: + if not self.node_path: + node_data = self.plotly_schema['traces'] + else: + trace_name = self.node_path[0] + node_data = self.plotly_schema['traces'][trace_name]['attributes'] + for prop_name in self.node_path[1:]: + node_data = node_data[prop_name] + + return node_data + + # Description + # ----------- + @property + def description(self) -> str: + if len(self.node_path) == 0: + desc = "" + elif len(self.node_path) == 1: + # Get trace descriptions + trace_name = self.node_path[0] + desc = (self.plotly_schema['traces'][trace_name] + ['meta'].get('description', '')) + else: + # Get datatype description + desc = self.node_data.get('description', '') + + if isinstance(desc, list): + desc = ''.join(desc) + + return desc + + +class LayoutNode(PlotlyNode): + """ + Class representing datatypes in the layout hierarchy + """ + + # Constructor + # ----------- + def __init__(self, plotly_schema, node_path=(), parent=None): + # Get main layout properties + layout = plotly_schema['layout']['layoutAttributes'] + + # Get list of additional layout properties for each trace + trace_layouts = [ + plotly_schema['traces'][trace].get('layoutAttributes', {}) + for trace in plotly_schema['traces']] + + # Chain together into layout_data + self.layout_data = ChainMap(layout, *trace_layouts) + + # Call superclass constructor + super().__init__(plotly_schema, node_path, parent) + + @property + def name_base_datatype(self): + if len(self.node_path) == 0: + return 'BaseLayoutType' + else: + return 'BaseLayoutHierarchyType' + + @property + def root_name(self): + return 'layout' + + @property + def plotly_name(self) -> str: + if len(self.node_path) == 0: + return self.root_name + else: + return self.node_path[-1] + + # Description + # ----------- + @property + def description(self) -> str: + desc = self.node_data.get('description', '') + if isinstance(desc, list): + desc = ''.join(desc) + return desc + + # Raw data + # -------- + @property + def node_data(self) -> dict: + node_data = self.layout_data + for prop_name in self.node_path: + node_data = node_data[prop_name] + + return node_data + + +class FrameNode(PlotlyNode): + """ + Class representing datatypes in the frames hierarchy + """ + + # Constructor + # ----------- + def __init__(self, plotly_schema, node_path=(), parent=None): + super().__init__(plotly_schema, node_path, parent) + + @property + def name_base_datatype(self): + return 'BaseFrameHierarchyType' + + @property + def root_name(self): + return '' + + @property + def plotly_name(self) -> str: + if len(self.node_path) < 2: + return self.root_name + elif len(self.node_path) == 2: + return 'frame' # override 'frames_entry' + else: + return self.node_path[-1] + + def tidy_path_part(self, p): + return 'frame' if p == 'frames_entry' else p + + # Description + # ----------- + @property + def description(self) -> str: + desc = self.node_data.get('description', '') + if isinstance(desc, list): + desc = ''.join(desc) + return desc + + # Raw data + # -------- + @property + def node_data(self) -> dict: + node_data = self.plotly_schema['frames'] + for prop_name in self.node_path: + node_data = node_data[prop_name] + + return node_data diff --git a/codegen/validators.py b/codegen/validators.py new file mode 100644 index 0000000000..4bb17442e2 --- /dev/null +++ b/codegen/validators.py @@ -0,0 +1,246 @@ +import os.path as opath +from io import StringIO + +import _plotly_utils.basevalidators +from codegen.utils import (PlotlyNode, TraceNode, + format_and_write_source_py) + + +def build_validator_py(node: PlotlyNode): + """ + Build validator class source code string for a datatype PlotlyNode + + Parameters + ---------- + node : PlotlyNode + The datatype node (node.is_datatype must evaluate to true) for which + to build the validator class + Returns + ------- + str + String containing source code for the validator class definition + """ + + # Validate inputs + # --------------- + assert node.is_datatype + + # Initialize source code buffer + # ----------------------------- + buffer = StringIO() + + # Imports + # ------- + # ### Import package of the validator's superclass ### + import_str = '.'.join( + node.name_base_validator.split('.')[:-1]) + buffer.write(f'import {import_str }\n') + + # Build Validator + # --------------- + # ### Get dict of validator's constructor params ### + params = node.get_validator_params() + + # ### Write class definition ### + class_name = node.name_validator_class + superclass_name = node.name_base_validator + buffer.write(f""" + +class {class_name}({superclass_name}): + def __init__(self, plotly_name={params['plotly_name']}, + parent_name={params['parent_name']}, + **kwargs):""") + + # ### Write constructor ### + buffer.write(f""" + super({class_name}, self).__init__(plotly_name=plotly_name, + parent_name=parent_name""") + + # Write out remaining constructor parameters + for attr_name, attr_val in params.items(): + if attr_name in ['plotly_name', 'parent_name']: + # plotly_name and parent_name are already handled + continue + + buffer.write(f""", + {attr_name}={attr_val}""") + + buffer.write(f""", + **kwargs""") + + + buffer.write(')') + + # ### Return buffer's string ### + return buffer.getvalue() + + +def write_validator_py(outdir, + node: PlotlyNode): + """ + Build validator source code and write to a file + + Parameters + ---------- + outdir : str + Root outdir in which the validators package should reside + node : PlotlyNode + The datatype node (node.is_datatype must evaluate to true) for which + to build a validator class + Returns + ------- + None + """ + # Generate source code + # -------------------- + validator_source = build_validator_py(node) + + # Write file + # ---------- + filepath = opath.join(outdir, 'validators', + *node.parent_path_parts, + '_' + node.name_property + '.py') + + format_and_write_source_py(validator_source, filepath) + + +def build_data_validator_params(base_trace_node: TraceNode): + """ + Build a dict of constructor params for the DataValidator. + (This is the validator that inputs a list of traces) + Parameters + ---------- + base_trace_node : PlotlyNode + PlotlyNode that is the parent of all of the individual trace nodes + Returns + ------- + dict + Mapping from property name to repr-string of property value. + """ + # Get list of trace nodes + # ----------------------- + tracetype_nodes = base_trace_node.child_compound_datatypes + + # Build class_map_repr string + # --------------------------- + # This is the repr-form of a dict from trace propert name string + # to the name of the trace datatype class in the graph_objs package. + buffer = StringIO() + buffer.write('{\n') + for i, tracetype_node in enumerate(tracetype_nodes): + sfx = ',' if i < len(tracetype_nodes) else '' + trace_name = tracetype_node.name_property + trace_datatype_class = tracetype_node.name_datatype_class + buffer.write(f""" + '{trace_name}': '{trace_datatype_class}'{sfx}""") + + buffer.write(""" + }""") + + class_map_repr = buffer.getvalue() + + # Build params dict + # ----------------- + params = {'class_strs_map': class_map_repr, + 'plotly_name': repr('data'), + 'parent_name': repr('')} + + return params + + +def build_data_validator_py(base_trace_node: TraceNode): + """ + Build source code for the DataValidator + (this is the validator that inputs a list of traces) + + Parameters + ---------- + base_trace_node : PlotlyNode + PlotlyNode that is the parent of all of the individual trace nodes + Returns + ------- + str + Source code string for DataValidator class + """ + + # Get constructor params + # ---------------------- + params = build_data_validator_params(base_trace_node) + + # Build source code + # ----------------- + buffer = StringIO() + + buffer.write(f""" +import _plotly_utils.basevalidators + +class DataValidator(_plotly_utils.basevalidators.BaseDataValidator): + + def __init__(self, plotly_name={params['plotly_name']}, + parent_name={params['parent_name']}, + **kwargs): + + super(DataValidator, self).__init__(class_strs_map={params['class_strs_map']}, + plotly_name=plotly_name, + parent_name=parent_name, + **kwargs)""") + + return buffer.getvalue() + + +def get_data_validator_instance(base_trace_node: TraceNode): + """ + Construct an instance of the DataValidator + (this is the validator that inputs a list of traces) + + Parameters + ---------- + base_trace_node : + PlotlyNode that is the parent of all of the individual trace nodes + Returns + ------- + BaseDataValidator + """ + + # Build constructor params + # ------------------------ + # We need to eval the values to convert out of the repr-form of the + # params. e.g. '3' -> 3 + params = build_data_validator_params(base_trace_node) + eval_params = {k: eval(repr_val) for k, repr_val in params.items()} + + # Build and return BaseDataValidator instance + # ------------------------------------------- + return _plotly_utils.basevalidators.BaseDataValidator(**eval_params) + + +def write_data_validator_py(outdir, base_trace_node: TraceNode): + """ + Construct and write out the DataValidator + (this is the validator that inputs a list of traces) + + Parameters + ---------- + outdir : str + Root outdir in which the top-level validators package should reside + base_trace_node : PlotlyNode + PlotlyNode that is the parent of all of the individual trace nodes + Returns + ------- + None + """ + # Validate inputs + # --------------- + if base_trace_node.node_path: + raise ValueError('Expected root trace node.\n' + 'Received node with path "%s"' + % base_trace_node.path_str) + + # Build Source + # ------------ + source = build_data_validator_py(base_trace_node) + + # Write file + # ---------- + filepath = opath.join(outdir, 'validators', '_data.py') + format_and_write_source_py(source, filepath) \ No newline at end of file diff --git a/contributing.md b/contributing.md index 7faae06083..08615d4ecb 100644 --- a/contributing.md +++ b/contributing.md @@ -112,6 +112,25 @@ To install the optional dependencies: pip install -r optional-requirements.txt ``` +## ipywidget development install + $ jupyter nbextension enable --py widgetsnbextension + $ jupyter nbextension install --py --symlink --sys-prefix plotlywidget + $ jupyter nbextension enable --py --sys-prefix plotlywidget + +## Update to a new version of Plotly.js +First update the version of the `plotly.js` dependency in `js/package.json`. + +Then run the `updateplotlyjs` command with: + +```bash +$ python setup.py updateplotlyjs +``` + +This will download new versions of `plot-schema.json` and `plotly.min.js` from +the `plotly/plotly.js` GitHub repository (and place them in +`plotly/package_data`). It will then regenerate all of the `graph_objs` +classes based on the new schema. + ## Testing We take advantage of two tools to run tests: @@ -216,5 +235,12 @@ And ask one of your friends to do it too. Our tests should catch any issues, but <3 Team Plotly +#### Publish widget library to npm + +```bash +cd ./js +npm publish --access public +``` + # Contributing to the Figure Factories If you are interested in contributing to the ever-growing Plotly figure factory library in Python, check out the [documentation](https://github.com/plotly/plotly.py/blob/master/plotly/figure_factory/README.md) to learn how. diff --git a/example_images/simple_scatter.png b/example_images/simple_scatter.png new file mode 100644 index 0000000000..bf6cb5dc9f Binary files /dev/null and b/example_images/simple_scatter.png differ diff --git a/example_images/subplot_methods.png b/example_images/subplot_methods.png new file mode 100644 index 0000000000..278f47dda3 Binary files /dev/null and b/example_images/subplot_methods.png differ diff --git a/js/README.md b/js/README.md new file mode 100644 index 0000000000..21fa647455 --- /dev/null +++ b/js/README.md @@ -0,0 +1,11 @@ +pythonic plotly API for use in Jupyter + +Package Install +--------------- + +**Prerequisites** +- [node](http://nodejs.org/) + +```bash +npm install --save plotlywidget +``` diff --git a/js/package-lock.json b/js/package-lock.json new file mode 100644 index 0000000000..1dcc29e31f --- /dev/null +++ b/js/package-lock.json @@ -0,0 +1,7761 @@ +{ + "name": "plotlywidget", + "version": "0.1.1", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "3d-view": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/3d-view/-/3d-view-2.0.0.tgz", + "integrity": "sha1-gxrpQtdQjFCAHj4G+v4ejFdOF74=", + "requires": { + "matrix-camera-controller": "2.1.3", + "orbit-camera-controller": "4.0.0", + "turntable-camera-controller": "3.0.1" + } + }, + "3d-view-controls": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/3d-view-controls/-/3d-view-controls-2.2.2.tgz", + "integrity": "sha512-WL0u3PN41lEx/4qvKqV6bJlweUYoW18FXMshW/qHb41AVdZxDReLoJNGYsI7x6jf9bYelEF62BJPQmO7yEnG2w==", + "requires": { + "3d-view": "2.0.0", + "has-passive-events": "1.0.0", + "mouse-change": "1.4.0", + "mouse-event-offset": "3.0.2", + "mouse-wheel": "1.2.0", + "right-now": "1.0.0" + } + }, + "@jupyter-widgets/base": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/@jupyter-widgets/base/-/base-1.1.8.tgz", + "integrity": "sha512-IqRyg6tMutHIeV3lzHuQxruwbQCVJ4mOKxqpyLsoMjMK8bqdVZWqYMcFV+TMm+hSLkH1Omkj8heG27Ap+fCY6A==", + "requires": { + "@jupyterlab/services": "1.1.4", + "@phosphor/coreutils": "1.3.0", + "@phosphor/messaging": "1.2.2", + "@phosphor/widgets": "1.5.0", + "@types/backbone": "1.3.42", + "@types/lodash": "4.14.104", + "backbone": "1.2.3", + "base64-js": "1.2.3", + "jquery": "3.3.1", + "lodash": "4.17.5" + } + }, + "@jupyterlab/coreutils": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/@jupyterlab/coreutils/-/coreutils-1.0.9.tgz", + "integrity": "sha512-THsDz68RSo94fowgcZjlgsvMm+c+DUUGHlKcVRDCm/tFOCPNj7g1OtZ4VOe5FzC/wfEzo9mWKoy2hHG3XEWglQ==", + "requires": { + "@phosphor/algorithm": "1.1.2", + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2", + "@phosphor/signaling": "1.2.2", + "ajv": "5.1.6", + "comment-json": "1.1.3", + "minimist": "1.2.0", + "moment": "2.17.1", + "path-posix": "1.0.0", + "url-parse": "1.1.9" + } + }, + "@jupyterlab/observables": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/@jupyterlab/observables/-/observables-1.0.6.tgz", + "integrity": "sha512-oqrZRlQyBEwlNiZkzD6bWLm1zi4SyY8KTSs/gcH7m0UAptwvDeYmRoCumy7alMdRTXR6IUTnYswY13R4TchI/g==", + "requires": { + "@phosphor/algorithm": "1.1.2", + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2", + "@phosphor/messaging": "1.2.2", + "@phosphor/signaling": "1.2.2" + } + }, + "@jupyterlab/services": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/@jupyterlab/services/-/services-1.1.4.tgz", + "integrity": "sha512-1t3UmWU4+ikCVZA7uEfasyof7wMDzY4EWRkaTM0JFJw9DE7sOig4p4q0fD1ra332H/H68aPAoVCyAg+BFnr1Zw==", + "requires": { + "@jupyterlab/coreutils": "1.0.9", + "@jupyterlab/observables": "1.0.6", + "@phosphor/algorithm": "1.1.2", + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2", + "@phosphor/signaling": "1.2.2", + "node-fetch": "1.7.3", + "ws": "1.1.5" + } + }, + "@mapbox/geojson-area": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/@mapbox/geojson-area/-/geojson-area-0.2.2.tgz", + "integrity": "sha1-GNeBSqNr8j+7zDefjiaiKSfevxA=", + "requires": { + "wgs84": "0.0.0" + } + }, + "@mapbox/gl-matrix": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/@mapbox/gl-matrix/-/gl-matrix-0.0.1.tgz", + "integrity": "sha1-5RJqq01kw2uBx6l9CuDd3eV3PSs=" + }, + "@mapbox/mapbox-gl-supported": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@mapbox/mapbox-gl-supported/-/mapbox-gl-supported-1.4.0.tgz", + "integrity": "sha512-ZD0Io4XK+/vU/4zpANjOtdWfVszAgnaMPsGR6LKsWh4kLIEv9qoobTVmJPPuwuM+ZI2b3BlZ6DYw1XHVmv6YTA==" + }, + "@mapbox/point-geometry": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/@mapbox/point-geometry/-/point-geometry-0.1.0.tgz", + "integrity": "sha1-ioP5M1x4YO/6Lu7KJUMyqgru2PI=" + }, + "@mapbox/shelf-pack": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@mapbox/shelf-pack/-/shelf-pack-3.1.0.tgz", + "integrity": "sha1-Ht6pwL9nFbIXFxumBkbCAa9SD2o=" + }, + "@mapbox/tiny-sdf": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@mapbox/tiny-sdf/-/tiny-sdf-1.1.0.tgz", + "integrity": "sha512-dnhyk8X2BkDRWImgHILYAGgo+kuciNYX30CUKj/Qd5eNjh54OWM/mdOS/PWsPeN+3abtN+QDGYM4G220ynVJKA==" + }, + "@mapbox/unitbezier": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/@mapbox/unitbezier/-/unitbezier-0.0.0.tgz", + "integrity": "sha1-FWUb1VOme4WB+zmIEMmK2Go0Uk4=" + }, + "@mapbox/vector-tile": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/@mapbox/vector-tile/-/vector-tile-1.3.1.tgz", + "integrity": "sha512-MCEddb8u44/xfQ3oD+Srl/tNcQoqTw3goGk2oLsrFxOTc3dUp+kAnby3PvAeeBYSMSjSPD1nd1AJA6W49WnoUw==", + "requires": { + "@mapbox/point-geometry": "0.1.0" + } + }, + "@mapbox/whoots-js": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/@mapbox/whoots-js/-/whoots-js-3.0.0.tgz", + "integrity": "sha1-wd5CkwgUJNo6wwwjr6hQrxAZu1Q=" + }, + "@phosphor/algorithm": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/algorithm/-/algorithm-1.1.2.tgz", + "integrity": "sha1-/R3pEEyafzTpKGRYbd8ufy53eeg=" + }, + "@phosphor/collections": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/collections/-/collections-1.1.2.tgz", + "integrity": "sha1-xMC4uREpkF+zap8kPy273kYtq40=", + "requires": { + "@phosphor/algorithm": "1.1.2" + } + }, + "@phosphor/commands": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@phosphor/commands/-/commands-1.4.0.tgz", + "integrity": "sha1-fiNqTAFdrzepWG/eKRiMPawgFi8=", + "requires": { + "@phosphor/algorithm": "1.1.2", + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2", + "@phosphor/domutils": "1.1.2", + "@phosphor/keyboard": "1.1.2", + "@phosphor/signaling": "1.2.2" + } + }, + "@phosphor/coreutils": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@phosphor/coreutils/-/coreutils-1.3.0.tgz", + "integrity": "sha1-YyktOBwBLFqw0Blug87YKbfgSkI=" + }, + "@phosphor/disposable": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/disposable/-/disposable-1.1.2.tgz", + "integrity": "sha1-oZLdai5sadXQnTns8zTauTd4Bg4=", + "requires": { + "@phosphor/algorithm": "1.1.2" + } + }, + "@phosphor/domutils": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/domutils/-/domutils-1.1.2.tgz", + "integrity": "sha1-4u/rBS85jEK5O4npurJq8VzABRQ=" + }, + "@phosphor/dragdrop": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@phosphor/dragdrop/-/dragdrop-1.3.0.tgz", + "integrity": "sha1-fOatOdbKIW1ipW94EE0Cp3rmcwc=", + "requires": { + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2" + } + }, + "@phosphor/keyboard": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/keyboard/-/keyboard-1.1.2.tgz", + "integrity": "sha1-PjIjRFF2QkCpjhSANNWoeXQi3R8=" + }, + "@phosphor/messaging": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@phosphor/messaging/-/messaging-1.2.2.tgz", + "integrity": "sha1-fYlt3TeXuUo0dwje0T2leD23XBQ=", + "requires": { + "@phosphor/algorithm": "1.1.2", + "@phosphor/collections": "1.1.2" + } + }, + "@phosphor/properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/properties/-/properties-1.1.2.tgz", + "integrity": "sha1-eMx37/RSg52gIlXeSOgUlGzAmig=" + }, + "@phosphor/signaling": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/@phosphor/signaling/-/signaling-1.2.2.tgz", + "integrity": "sha1-P8+Xyojji/s1f+j+a/dRM0elFKk=", + "requires": { + "@phosphor/algorithm": "1.1.2" + } + }, + "@phosphor/virtualdom": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/@phosphor/virtualdom/-/virtualdom-1.1.2.tgz", + "integrity": "sha1-zlXIbu8x5dDiax3JbqMr1oRFj0E=", + "requires": { + "@phosphor/algorithm": "1.1.2" + } + }, + "@phosphor/widgets": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/@phosphor/widgets/-/widgets-1.5.0.tgz", + "integrity": "sha1-X5mOhvX9542KpE19wUdobKZhaB4=", + "requires": { + "@phosphor/algorithm": "1.1.2", + "@phosphor/commands": "1.4.0", + "@phosphor/coreutils": "1.3.0", + "@phosphor/disposable": "1.1.2", + "@phosphor/domutils": "1.1.2", + "@phosphor/dragdrop": "1.3.0", + "@phosphor/keyboard": "1.1.2", + "@phosphor/messaging": "1.2.2", + "@phosphor/properties": "1.1.2", + "@phosphor/signaling": "1.2.2", + "@phosphor/virtualdom": "1.1.2" + } + }, + "@plotly/d3-sankey": { + "version": "0.5.0", + "resolved": "https://registry.npmjs.org/@plotly/d3-sankey/-/d3-sankey-0.5.0.tgz", + "integrity": "sha1-si+up0LlglEzXuXZ+6JIdyYHgA8=", + "requires": { + "d3-array": "1.2.1", + "d3-collection": "1.0.4", + "d3-interpolate": "1.2.0" + } + }, + "@types/backbone": { + "version": "1.3.42", + "resolved": "https://registry.npmjs.org/@types/backbone/-/backbone-1.3.42.tgz", + "integrity": "sha512-sg6WhUW1RorO/Yc0yKqVhekBlweLbQqJciHr70FYL4Z8IFhcZngyXaYdfq8MCv/Rf/Nry5Sbsl9jWGzUN+2Zbg==", + "requires": { + "@types/jquery": "3.3.0", + "@types/underscore": "1.8.7" + } + }, + "@types/jquery": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/@types/jquery/-/jquery-3.3.0.tgz", + "integrity": "sha512-szaKV2OQgwxYTGTY6qd9eeBfGGCaP7n2OGit4JdbOcfGgc9VWjfhMhnu5AVNhIAu8WWDIB36q9dfPVba1fGeIQ==" + }, + "@types/lodash": { + "version": "4.14.104", + "resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.14.104.tgz", + "integrity": "sha512-ufQcVg4daO8xQ5kopxRHanqFdL4AI7ondQkV+2f+7mz3gvp0LkBx2zBRC6hfs3T87mzQFmf5Fck7Fi145Ul6NQ==" + }, + "@types/underscore": { + "version": "1.8.7", + "resolved": "https://registry.npmjs.org/@types/underscore/-/underscore-1.8.7.tgz", + "integrity": "sha512-vMSV6VOWFVBcud1bBUKJVVhXmmx136Run3p1xK00XViC2pQnXXrveU79S13h2+Im/TBhtMtTufid+dbysd3m/g==" + }, + "JSV": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/JSV/-/JSV-4.0.2.tgz", + "integrity": "sha1-0Hf2glVx+CEy+d/67Vh7QCn+/1c=" + }, + "a-big-triangle": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/a-big-triangle/-/a-big-triangle-1.0.3.tgz", + "integrity": "sha1-7v0wsCqPUl6LH3K7a7GwwWdRx5Q=", + "requires": { + "gl-buffer": "2.1.2", + "gl-vao": "1.3.0", + "weak-map": "1.0.5" + } + }, + "abs-svg-path": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/abs-svg-path/-/abs-svg-path-0.1.1.tgz", + "integrity": "sha1-32Acjo0roQ1KdtYl4japo5wnI78=" + }, + "acorn": { + "version": "5.4.1", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.4.1.tgz", + "integrity": "sha512-XLmq3H/BVvW6/GbxKryGxWORz1ebilSsUDlyC27bXhWGWAZWkGwS6FLHjOlwFXNFoWFQEO/Df4u0YYd0K3BQgQ==" + }, + "acorn-dynamic-import": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-2.0.2.tgz", + "integrity": "sha1-x1K9IQvvZ5UBtsbLf8hPj0cVjMQ=", + "dev": true, + "requires": { + "acorn": "4.0.13" + }, + "dependencies": { + "acorn": { + "version": "4.0.13", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz", + "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=", + "dev": true + } + } + }, + "acorn-jsx": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-3.0.1.tgz", + "integrity": "sha1-r9+UiPsezvyDSPb7IvRk4ypYs2s=", + "requires": { + "acorn": "3.3.0" + }, + "dependencies": { + "acorn": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz", + "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=" + } + } + }, + "acorn-object-spread": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/acorn-object-spread/-/acorn-object-spread-1.0.0.tgz", + "integrity": "sha1-SOrQ9KjrFplaF6Dbn/xqyq2kumg=", + "requires": { + "acorn": "3.3.0" + }, + "dependencies": { + "acorn": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz", + "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=" + } + } + }, + "add-line-numbers": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/add-line-numbers/-/add-line-numbers-1.0.1.tgz", + "integrity": "sha1-SNu96kfb0jTer+rGyTzqb3C0t+M=", + "requires": { + "pad-left": "1.0.2" + } + }, + "affine-hull": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/affine-hull/-/affine-hull-1.0.0.tgz", + "integrity": "sha1-dj/x040GPOt+Jy8X7k17vK+QXF0=", + "requires": { + "robust-orientation": "1.1.3" + } + }, + "ajv": { + "version": "5.1.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.1.6.tgz", + "integrity": "sha1-Sy8aGd7Ok9V6whYDfj6XkcfdFWQ=", + "requires": { + "co": "4.6.0", + "json-schema-traverse": "0.3.1", + "json-stable-stringify": "1.0.1" + } + }, + "ajv-keywords": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.1.0.tgz", + "integrity": "sha1-rCsnk5xUPpXSwG5/f1wnvkqlQ74=", + "dev": true + }, + "align-text": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/align-text/-/align-text-0.1.4.tgz", + "integrity": "sha1-DNkKVhCT810KmSVsIrcGlDP60Rc=", + "requires": { + "kind-of": "3.2.2", + "longest": "1.0.1", + "repeat-string": "1.6.1" + } + }, + "almost-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/almost-equal/-/almost-equal-1.1.0.tgz", + "integrity": "sha1-+FHGMROHV5lCdqou++jfowZszN0=" + }, + "alpha-complex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/alpha-complex/-/alpha-complex-1.0.0.tgz", + "integrity": "sha1-kIZYcNawVCrnPAwTHU75iWabctI=", + "requires": { + "circumradius": "1.0.0", + "delaunay-triangulate": "1.1.6" + } + }, + "alpha-shape": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/alpha-shape/-/alpha-shape-1.0.0.tgz", + "integrity": "sha1-yDEJkj7P2mZ9IWP+Tyb+JHJvZKk=", + "requires": { + "alpha-complex": "1.0.0", + "simplicial-complex-boundary": "1.0.1" + } + }, + "amdefine": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/amdefine/-/amdefine-1.0.1.tgz", + "integrity": "sha1-SlKCrBZHKek2Gbz9OtFR+BfOkfU=" + }, + "ansi-regex": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-2.1.1.tgz", + "integrity": "sha1-w7M6te42DYbg5ijwRorn7yfWVN8=" + }, + "ansi-styles": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-2.2.1.tgz", + "integrity": "sha1-tDLdM1i2NM914eRmQ2gkBTPB3b4=" + }, + "ansicolors": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/ansicolors/-/ansicolors-0.2.1.tgz", + "integrity": "sha1-vgiVmQl7dKXJxKhKDNvNtivYeu8=" + }, + "anymatch": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/anymatch/-/anymatch-1.3.2.tgz", + "integrity": "sha512-0XNayC8lTHQ2OI8aljNCN3sSx6hsr/1+rlcDAotXJR7C1oZZHCNsfpbKwMjRA3Uqb5tF1Rae2oloTr4xpq+WjA==", + "dev": true, + "requires": { + "micromatch": "2.3.11", + "normalize-path": "2.1.1" + } + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "requires": { + "sprintf-js": "1.0.3" + }, + "dependencies": { + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=" + } + } + }, + "arr-diff": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/arr-diff/-/arr-diff-2.0.0.tgz", + "integrity": "sha1-jzuCf5Vai9ZpaX5KQlasPOrjVs8=", + "dev": true, + "requires": { + "arr-flatten": "1.1.0" + } + }, + "arr-flatten": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/arr-flatten/-/arr-flatten-1.1.0.tgz", + "integrity": "sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==", + "dev": true + }, + "array-bounds": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/array-bounds/-/array-bounds-1.0.1.tgz", + "integrity": "sha512-8wdW3ZGk6UjMPJx/glyEt0sLzzwAE1bhToPsO1W2pbpR2gULyxe3BjSiuJFheP50T/GgODVPz2fuMUmIywt8cQ==" + }, + "array-normalize": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/array-normalize/-/array-normalize-1.1.3.tgz", + "integrity": "sha1-c/uDf0gW7BkVHTxejYU6RZDOAb0=", + "requires": { + "array-bounds": "1.0.1" + } + }, + "array-range": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/array-range/-/array-range-1.0.1.tgz", + "integrity": "sha1-9W5GWRhDYRxqVvd+8C7afFAIm/w=" + }, + "array-rearrange": { + "version": "2.2.2", + "resolved": "https://registry.npmjs.org/array-rearrange/-/array-rearrange-2.2.2.tgz", + "integrity": "sha512-UfobP5N12Qm4Qu4fwLDIi2v6+wZsSf6snYSxAMeKhrh37YGnNWZPRmVEKc/2wfms53TLQnzfpG8wCx2Y/6NG1w==" + }, + "array-unique": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/array-unique/-/array-unique-0.2.1.tgz", + "integrity": "sha1-odl8yvy8JiXMcPrc6zalDFiwGlM=", + "dev": true + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "assert": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz", + "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=", + "dev": true, + "requires": { + "util": "0.10.3" + } + }, + "async": { + "version": "2.6.0", + "resolved": "https://registry.npmjs.org/async/-/async-2.6.0.tgz", + "integrity": "sha512-xAfGg1/NTLBBKlHFmnd7PlmUW9KhVQIUuSrYem9xzFUZy13ScvtyGGejaae9iAVRiRq9+Cx7DPFaAAhCpyxyPw==", + "dev": true, + "requires": { + "lodash": "4.17.5" + } + }, + "async-each": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/async-each/-/async-each-1.0.1.tgz", + "integrity": "sha1-GdOGodntxufByF04iu28xW0zYC0=", + "dev": true + }, + "atob-lite": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/atob-lite/-/atob-lite-1.0.0.tgz", + "integrity": "sha1-uI3KYAaSK5YglPdVaCa6sxxKKWs=" + }, + "babylon": { + "version": "6.18.0", + "resolved": "https://registry.npmjs.org/babylon/-/babylon-6.18.0.tgz", + "integrity": "sha512-q/UEjfGJ2Cm3oKV71DJz9d25TPnq5rhBVL2Q4fA5wcC3jcrdn7+SssEybFIxwAvvP+YCsCYNKughoF33GxgycQ==" + }, + "backbone": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/backbone/-/backbone-1.2.3.tgz", + "integrity": "sha1-wiz9B/yG676uYdGJKe0RXpmdZbk=", + "requires": { + "underscore": "1.8.3" + } + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "barycentric": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/barycentric/-/barycentric-1.0.1.tgz", + "integrity": "sha1-8VYruJGyb0/sRjqC7to2V4AOxog=", + "requires": { + "robust-linear-solve": "1.0.0" + } + }, + "base64-js": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.3.tgz", + "integrity": "sha512-MsAhsUW1GxCdgYSO6tAfZrNapmUKk7mWx/k5mFY/A1gBtkaCaNapTg+FExCw1r9yeaZhqx/xPg43xgTFH6KL5w==" + }, + "big-rat": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/big-rat/-/big-rat-1.0.4.tgz", + "integrity": "sha1-do0JO7V5MN0Y7Vdcf8on3FORreo=", + "requires": { + "bit-twiddle": "1.0.2", + "bn.js": "4.11.8", + "double-bits": "1.1.1" + } + }, + "big.js": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/big.js/-/big.js-3.2.0.tgz", + "integrity": "sha512-+hN/Zh2D08Mx65pZ/4g5bsmNiZUuChDiQfTUQ7qJr4/kuopCr88xZsAXv6mBoZEsUI4OuGHlX59qE94K2mMW8Q==", + "dev": true + }, + "binary-extensions": { + "version": "1.11.0", + "resolved": "https://registry.npmjs.org/binary-extensions/-/binary-extensions-1.11.0.tgz", + "integrity": "sha1-RqoXUftqL5PuXmibsQh9SxTGwgU=", + "dev": true + }, + "binary-search-bounds": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-1.0.0.tgz", + "integrity": "sha1-MjyjF+PypA9CRMclX1OEpbIHu2k=" + }, + "bit-twiddle": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/bit-twiddle/-/bit-twiddle-1.0.2.tgz", + "integrity": "sha1-DGwfq+KyPRcXPZpht7cJPrnhdp4=" + }, + "bitmap-sdf": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/bitmap-sdf/-/bitmap-sdf-1.0.3.tgz", + "integrity": "sha512-ojYySSvWTx21cbgntR942zgEgqj38wHctN64vr4vYRFf3GKVmI23YlA94meWGkFslidwLwGCsMy2laJ3g/94Sg==", + "requires": { + "clamp": "1.0.1" + } + }, + "bl": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/bl/-/bl-1.2.1.tgz", + "integrity": "sha1-ysMo977kVzDUBLaSID/LWQ4XLV4=", + "requires": { + "readable-stream": "2.3.4" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==" + }, + "boundary-cells": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/boundary-cells/-/boundary-cells-2.0.1.tgz", + "integrity": "sha1-6QWo0UGc9Hyza+Pb9SXbXiTeAEI=", + "requires": { + "tape": "4.9.1" + } + }, + "box-intersect": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/box-intersect/-/box-intersect-1.0.1.tgz", + "integrity": "sha1-tyilnj8aPHPCJJM8JmC5J6oTeQI=", + "requires": { + "bit-twiddle": "1.0.2", + "typedarray-pool": "1.1.0" + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "braces": { + "version": "1.8.5", + "resolved": "https://registry.npmjs.org/braces/-/braces-1.8.5.tgz", + "integrity": "sha1-uneWLhLf+WnWt2cR6RS3N4V79qc=", + "dev": true, + "requires": { + "expand-range": "1.8.2", + "preserve": "0.2.0", + "repeat-element": "1.1.2" + } + }, + "brfs": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/brfs/-/brfs-1.6.1.tgz", + "integrity": "sha512-OfZpABRQQf+Xsmju8XE9bDjs+uU4vLREGolP7bDgcpsI17QREyZ4Bl+2KLxxx1kCgA0fAIhKQBaBYh+PEcCqYQ==", + "requires": { + "quote-stream": "1.0.2", + "resolve": "1.4.0", + "static-module": "2.2.5", + "through2": "2.0.3" + }, + "dependencies": { + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "requires": { + "readable-stream": "2.3.6" + } + }, + "escodegen": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", + "integrity": "sha512-6hTjO1NAWkHnDk3OqQ4YrCuwwmGHL9S3nPlzBOUG/R44rda3wLNrfvQ5fkSGjyhHFKM7ALPKcKGrwvCLe0lC7Q==", + "requires": { + "esprima": "3.1.3", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "optionator": "0.8.2", + "source-map": "0.6.1" + } + }, + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=" + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "object-inspect": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.4.1.tgz", + "integrity": "sha512-wqdhLpfCUbEsoEwl3FXwGyv8ief1k/1aUdIPCqVnupM6e8l63BEJdiF/0swtn04/8p05tG/T0FrpTlfwvljOdw==" + }, + "quote-stream": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/quote-stream/-/quote-stream-1.0.2.tgz", + "integrity": "sha1-hJY/jJwmuULhU/7rU6rnRlK34LI=", + "requires": { + "buffer-equal": "0.0.1", + "minimist": "1.2.0", + "through2": "2.0.3" + } + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true + }, + "static-module": { + "version": "2.2.5", + "resolved": "https://registry.npmjs.org/static-module/-/static-module-2.2.5.tgz", + "integrity": "sha512-D8vv82E/Kpmz3TXHKG8PPsCPg+RAX6cbCOyvjM6x04qZtQ47EtJFVwRsdov3n5d6/6ynrOY9XB4JkaZwB2xoRQ==", + "requires": { + "concat-stream": "1.6.2", + "convert-source-map": "1.5.1", + "duplexer2": "0.1.4", + "escodegen": "1.9.1", + "falafel": "2.1.0", + "has": "1.0.3", + "magic-string": "0.22.5", + "merge-source-map": "1.0.4", + "object-inspect": "1.4.1", + "quote-stream": "1.0.2", + "readable-stream": "2.3.6", + "shallow-copy": "0.0.1", + "static-eval": "2.0.0", + "through2": "2.0.3" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "2.3.6", + "xtend": "4.0.1" + } + } + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=", + "dev": true + }, + "browserify-aes": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.1.1.tgz", + "integrity": "sha512-UGnTYAnB2a3YuYKIRy1/4FB2HdM866E0qC46JXvVTYKlBlZlnvfpSfY6OKfXZAkv70eJ2a1SqzpAo5CRhZGDFg==", + "dev": true, + "requires": { + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "browserify-cipher": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.0.tgz", + "integrity": "sha1-mYgkSHS/XtTijalWZtzWasj8Njo=", + "dev": true, + "requires": { + "browserify-aes": "1.1.1", + "browserify-des": "1.0.0", + "evp_bytestokey": "1.0.3" + } + }, + "browserify-des": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.0.tgz", + "integrity": "sha1-2qJ3cXRwki7S/hhZQRihdUOXId0=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "des.js": "1.0.0", + "inherits": "2.0.3" + } + }, + "browserify-package-json": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/browserify-package-json/-/browserify-package-json-1.0.1.tgz", + "integrity": "sha1-mN3oqlxWH9bT/km7qhArdLOW/eo=" + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "randombytes": "2.0.6" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "elliptic": "6.4.0", + "inherits": "2.0.3", + "parse-asn1": "5.1.0" + } + }, + "browserify-zlib": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.2.0.tgz", + "integrity": "sha512-Z942RysHXmJrhqk88FmKBVq/v5tqmSkDz7p54G/MGyjMnCFFnC79XWNbg+Vta8W6Wb2qtSZTSxIGkJrRpCFEiA==", + "dev": true, + "requires": { + "pako": "1.0.6" + } + }, + "buble": { + "version": "0.15.2", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.15.2.tgz", + "integrity": "sha1-VH/EdIP45egXbYKqXrzLGDsC1hM=", + "requires": { + "acorn": "3.3.0", + "acorn-jsx": "3.0.1", + "acorn-object-spread": "1.0.0", + "chalk": "1.1.3", + "magic-string": "0.14.0", + "minimist": "1.2.0", + "os-homedir": "1.0.2" + }, + "dependencies": { + "acorn": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-3.3.0.tgz", + "integrity": "sha1-ReN/s56No/JbruP/U2niu18iAXo=" + }, + "magic-string": { + "version": "0.14.0", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.14.0.tgz", + "integrity": "sha1-VyJK7xcByu7Sc7F6OalW5ysXJGI=", + "requires": { + "vlq": "0.2.3" + } + } + } + }, + "bubleify": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-0.7.0.tgz", + "integrity": "sha1-0I6mQv/Qhf+HEciEP1cHLw1euPY=", + "requires": { + "buble": "0.15.2", + "object-assign": "4.1.1" + } + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "dev": true, + "requires": { + "base64-js": "1.2.3", + "ieee754": "1.1.8", + "isarray": "1.0.0" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + } + } + }, + "buffer-equal": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/buffer-equal/-/buffer-equal-0.0.1.tgz", + "integrity": "sha1-kbx0sR6kBbyRa8aqkI+q+ltKrEs=" + }, + "buffer-from": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.0.tgz", + "integrity": "sha512-c5mRlguI/Pe2dSZmpER62rSCu0ryKmWddzRYsuXc50U2/g8jMOulc31VZMa4mYx31U5xsmSOpDCgH88Vl9cDGQ==" + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=", + "dev": true + }, + "builtin-modules": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/builtin-modules/-/builtin-modules-1.1.1.tgz", + "integrity": "sha1-Jw8HbFpywC9bZaR9+Uxf46J4iS8=", + "dev": true + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=", + "dev": true + }, + "call-matcher": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/call-matcher/-/call-matcher-1.0.1.tgz", + "integrity": "sha1-UTTQd5hPcSpU2tPL9i3ijc5BbKg=", + "requires": { + "core-js": "2.5.7", + "deep-equal": "1.0.1", + "espurify": "1.8.0", + "estraverse": "4.2.0" + } + }, + "camelcase": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-1.2.1.tgz", + "integrity": "sha1-m7UwTS4LVmmLLHWLCKPqqdqlijk=" + }, + "canvas-fit": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/canvas-fit/-/canvas-fit-1.5.0.tgz", + "integrity": "sha1-rhO+Zq3kL1vg5IfjRfzjCl5bXl8=", + "requires": { + "element-size": "1.1.1" + } + }, + "cardinal": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/cardinal/-/cardinal-0.4.4.tgz", + "integrity": "sha1-ylu2iltRG5D+k7ms6km97lwyv+I=", + "requires": { + "ansicolors": "0.2.1", + "redeyed": "0.4.4" + } + }, + "cdt2d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/cdt2d/-/cdt2d-1.0.0.tgz", + "integrity": "sha1-TyEkNLzWe9s9aLj+9KzcLFRBUUE=", + "requires": { + "binary-search-bounds": "2.0.4", + "robust-in-sphere": "1.1.3", + "robust-orientation": "1.1.3" + }, + "dependencies": { + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + } + } + }, + "cell-orientation": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cell-orientation/-/cell-orientation-1.0.1.tgz", + "integrity": "sha1-tQStlqZq0obZ7dmFoiU9A7gNKFA=" + }, + "center-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/center-align/-/center-align-0.1.3.tgz", + "integrity": "sha1-qg0yYptu6XIgBBHL1EYckHvCt60=", + "requires": { + "align-text": "0.1.4", + "lazy-cache": "1.0.4" + } + }, + "chalk": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz", + "integrity": "sha1-qBFcVeSnAv5NFQq9OHKCKn4J/Jg=", + "requires": { + "ansi-styles": "2.2.1", + "escape-string-regexp": "1.0.5", + "has-ansi": "2.0.0", + "strip-ansi": "3.0.1", + "supports-color": "2.0.0" + } + }, + "chokidar": { + "version": "1.7.0", + "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-1.7.0.tgz", + "integrity": "sha1-eY5ol3gVHIB2tLNg5e3SjNortGg=", + "dev": true, + "requires": { + "anymatch": "1.3.2", + "async-each": "1.0.1", + "fsevents": "1.1.3", + "glob-parent": "2.0.0", + "inherits": "2.0.3", + "is-binary-path": "1.0.1", + "is-glob": "2.0.1", + "path-is-absolute": "1.0.1", + "readdirp": "2.1.0" + } + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "circumcenter": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/circumcenter/-/circumcenter-1.0.0.tgz", + "integrity": "sha1-INeqE7F/usUvUtpPVMasi5Bu5Sk=", + "requires": { + "dup": "1.0.0", + "robust-linear-solve": "1.0.0" + } + }, + "circumradius": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/circumradius/-/circumradius-1.0.0.tgz", + "integrity": "sha1-cGxEfj5VzR7T0RvRM+N8JSzDBbU=", + "requires": { + "circumcenter": "1.0.0" + } + }, + "clamp": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/clamp/-/clamp-1.0.1.tgz", + "integrity": "sha1-ZqDmQBGBbjcZaCj9yMjBRzEshjQ=" + }, + "clean-pslg": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/clean-pslg/-/clean-pslg-1.1.2.tgz", + "integrity": "sha1-vTXHRgt+irWp92Gl7VF5aqPIbBE=", + "requires": { + "big-rat": "1.0.4", + "box-intersect": "1.0.1", + "nextafter": "1.0.0", + "rat-vec": "1.1.1", + "robust-segment-intersect": "1.0.1", + "union-find": "1.0.2", + "uniq": "1.0.1" + } + }, + "cliui": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-2.1.0.tgz", + "integrity": "sha1-S0dXYP+AJkx2LDoXGQMukcf+oNE=", + "requires": { + "center-align": "0.1.3", + "right-align": "0.1.3", + "wordwrap": "0.0.2" + }, + "dependencies": { + "wordwrap": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-0.0.2.tgz", + "integrity": "sha1-t5Zpu0LstAn4PVg8rVLKF+qhZD8=" + } + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=" + }, + "code-point-at": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/code-point-at/-/code-point-at-1.1.0.tgz", + "integrity": "sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=", + "dev": true + }, + "color-alpha": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/color-alpha/-/color-alpha-1.0.3.tgz", + "integrity": "sha512-ap5UCPpnpsSQu09ccl/5cNQDJlSFvkuXHMBY1+1vu6iKj6H9zw7Sz852snsETFsrYlPUnvTByCFAnYVynKJb9A==", + "requires": { + "color-parse": "1.3.7" + } + }, + "color-convert": { + "version": "1.9.2", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.2.tgz", + "integrity": "sha512-3NUJZdhMhcdPn8vJ9v2UQJoH0qqoGUkYTgFEPZaPjEtwmmKUfNV46zZmgB2M5M4DCEQHMaCfWHCxiBflLm04Tg==", + "requires": { + "color-name": "1.1.1" + }, + "dependencies": { + "color-name": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.1.tgz", + "integrity": "sha1-SxQVMEz1ACjqgWQ2Q72C6gWANok=" + } + } + }, + "color-id": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/color-id/-/color-id-1.1.0.tgz", + "integrity": "sha512-2iRtAn6dC/6/G7bBIo0uupVrIne1NsQJvJxZOBCzQOfk7jRq97feaDZ3RdzuHakRXXnHGNwglto3pqtRx1sX0g==", + "requires": { + "clamp": "1.0.1" + } + }, + "color-name": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", + "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=" + }, + "color-normalize": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/color-normalize/-/color-normalize-1.1.0.tgz", + "integrity": "sha512-OY+unS2qneabd/72V0VLfwxQHvJ1t3JxM8d7LBPBwaVeda4vbrKuKRgtR1ieuIUdnXN7mWTg8FrrQMmsG7xd3w==", + "requires": { + "clamp": "1.0.1", + "color-rgba": "2.1.0", + "dtype": "2.0.0" + } + }, + "color-parse": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/color-parse/-/color-parse-1.3.7.tgz", + "integrity": "sha512-8G6rPfyTZhWYKU7D2hwywTjA4YlqX/Z7ClqTEzh5ENc5QkLOff0u8EuyNZR6xScEBhWpAyiDrrVGNUE/Btg2LA==", + "requires": { + "color-name": "1.1.3", + "defined": "1.0.0", + "is-plain-obj": "1.1.0" + } + }, + "color-rgba": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/color-rgba/-/color-rgba-2.1.0.tgz", + "integrity": "sha512-yAmMouVOLRAtYJwP52qymiscIMpw2g7VO82pkW+a88BpW1AZ+O6JDxAAojLljGO0pQkkvZLLN9oQNTEgT+RFiw==", + "requires": { + "clamp": "1.0.1", + "color-parse": "1.3.7", + "color-space": "1.16.0" + } + }, + "color-space": { + "version": "1.16.0", + "resolved": "https://registry.npmjs.org/color-space/-/color-space-1.16.0.tgz", + "integrity": "sha512-A6WMiFzunQ8KEPFmj02OnnoUnqhmSaHaZ/0LVFcPTdlvm8+3aMJ5x1HRHy3bDHPkovkf4sS0f4wsVvwk71fKkg==", + "requires": { + "hsluv": "0.0.3", + "mumath": "3.3.4" + } + }, + "colormap": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/colormap/-/colormap-2.3.0.tgz", + "integrity": "sha512-Mkk6mQUMbCleXEeStFm2xLwv5zbRakZMUFB1T1+iNEv58VKBByfPwYIjMQDwSRmXNM1gvo5y3WTYAhmdMn/rbg==", + "requires": { + "lerp": "1.0.3" + } + }, + "colors": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/colors/-/colors-0.6.2.tgz", + "integrity": "sha1-JCP+ZnisDF2uiFLl0OW+CMmXq8w=", + "dev": true + }, + "commander": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.1.0.tgz", + "integrity": "sha1-0SG7roYNmZKj1Re6lvVliOR8Z4E=" + }, + "comment-json": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/comment-json/-/comment-json-1.1.3.tgz", + "integrity": "sha1-aYbDMw/uDEyeAMI5jNYa+l2PI54=", + "requires": { + "json-parser": "1.1.5" + } + }, + "compare-angle": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/compare-angle/-/compare-angle-1.0.1.tgz", + "integrity": "sha1-pOtjQW6jx0f8a9bItjZotN5PoSk=", + "requires": { + "robust-orientation": "1.1.3", + "robust-product": "1.0.0", + "robust-sum": "1.0.0", + "signum": "0.0.0", + "two-sum": "1.0.0" + } + }, + "compare-cell": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/compare-cell/-/compare-cell-1.0.0.tgz", + "integrity": "sha1-qetwj24OQa73qlZrEw8ZaNyeGqo=" + }, + "compare-oriented-cell": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/compare-oriented-cell/-/compare-oriented-cell-1.0.1.tgz", + "integrity": "sha1-ahSf7vnfxPj8YjWOUd1C7/u9w54=", + "requires": { + "cell-orientation": "1.0.1", + "compare-cell": "1.0.0" + } + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.6.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.6.2.tgz", + "integrity": "sha512-27HBghJxjiZtIk3Ycvn/4kbJk/1uZuJFfuPEns6LaEvpvG1f0hTea8lilrouyo9mVc2GWdcEZ8OLoGmSADlrCw==", + "requires": { + "buffer-from": "1.1.0", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "typedarray": "0.0.6" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "console-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz", + "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", + "dev": true, + "requires": { + "date-now": "0.1.4" + } + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=", + "dev": true + }, + "convert-source-map": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.5.1.tgz", + "integrity": "sha1-uCeAl7m8IpNl3lxiz1/K7YtVmeU=" + }, + "convex-hull": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/convex-hull/-/convex-hull-1.0.3.tgz", + "integrity": "sha1-IKOqbOh/St6i/30XlxyfwcZ+H/8=", + "requires": { + "affine-hull": "1.0.0", + "incremental-convex-hull": "1.0.1", + "monotone-convex-hull-2d": "1.0.1" + } + }, + "core-js": { + "version": "2.5.7", + "resolved": "https://registry.npmjs.org/core-js/-/core-js-2.5.7.tgz", + "integrity": "sha512-RszJCAxg/PP6uzXVXL6BsxSXx/B05oJAQ2vkJRjyjrEcNVycaqOmNb5OTxZPE3xa5gwZduqza6L9JOCenh/Ecw==" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "country-regex": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/country-regex/-/country-regex-1.1.0.tgz", + "integrity": "sha1-UcMz3N8Sknt+XuucEKyBEqYSCJY=" + }, + "create-ecdh": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.0.tgz", + "integrity": "sha1-iIxyNZbN92EvZJgjPuvXo1MBc30=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "elliptic": "6.4.0" + } + }, + "create-hash": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.1.3.tgz", + "integrity": "sha1-YGBCrIuSYnUPSDyt2rD1gZFy2P0=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "sha.js": "2.4.10" + } + }, + "create-hmac": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.6.tgz", + "integrity": "sha1-rLniIaThe9sHbpBlfEK5PjcmzwY=", + "dev": true, + "requires": { + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.10" + } + }, + "cross-spawn": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", + "integrity": "sha1-6L0O/uWPz/b4+UUQoKVUu/ojVEk=", + "dev": true, + "requires": { + "lru-cache": "4.1.1", + "shebang-command": "1.2.0", + "which": "1.3.0" + } + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "dev": true, + "requires": { + "browserify-cipher": "1.0.0", + "browserify-sign": "4.0.4", + "create-ecdh": "4.0.0", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "diffie-hellman": "5.0.2", + "inherits": "2.0.3", + "pbkdf2": "3.0.14", + "public-encrypt": "4.0.0", + "randombytes": "2.0.6", + "randomfill": "1.0.4" + } + }, + "csscolorparser": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/csscolorparser/-/csscolorparser-1.0.3.tgz", + "integrity": "sha1-s085HupNqPPpgjHizNjfnAQfFxs=" + }, + "cubic-hermite": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/cubic-hermite/-/cubic-hermite-1.0.0.tgz", + "integrity": "sha1-hOOy8nKzFFToOTuZu2rtRRaMFOU=" + }, + "cwise": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/cwise/-/cwise-1.0.10.tgz", + "integrity": "sha1-JO7mBy69/WuMb12tsXCQtkmxK+8=", + "requires": { + "cwise-compiler": "1.1.3", + "cwise-parser": "1.0.3", + "static-module": "1.5.0", + "uglify-js": "2.8.29" + } + }, + "cwise-compiler": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/cwise-compiler/-/cwise-compiler-1.1.3.tgz", + "integrity": "sha1-9NZnQQ6FDToxOn0tt7HlBbsDTMU=", + "requires": { + "uniq": "1.0.1" + } + }, + "cwise-parser": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cwise-parser/-/cwise-parser-1.0.3.tgz", + "integrity": "sha1-jkk8F9VPl8sDCp6YVLyGyd+zVP4=", + "requires": { + "esprima": "1.2.5", + "uniq": "1.0.1" + }, + "dependencies": { + "esprima": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.2.5.tgz", + "integrity": "sha1-CZNQL+r2aBODJXVvMPmlH+7sEek=" + } + } + }, + "d": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/d/-/d-1.0.0.tgz", + "integrity": "sha1-dUu1v+VUUdpppYuU1F9MWwRi1Y8=", + "requires": { + "es5-ext": "0.10.39" + } + }, + "d3": { + "version": "3.5.17", + "resolved": "https://registry.npmjs.org/d3/-/d3-3.5.17.tgz", + "integrity": "sha1-vEZ0gAQ3iyGjYMn8fPUjF5B2L7g=" + }, + "d3-array": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-1.2.1.tgz", + "integrity": "sha512-CyINJQ0SOUHojDdFDH4JEM0552vCR1utGyLHegJHyYH0JyCpSeTPxi4OBqHMA2jJZq4NH782LtaJWBImqI/HBw==" + }, + "d3-collection": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/d3-collection/-/d3-collection-1.0.4.tgz", + "integrity": "sha1-NC39EoN8kJdPM/HMCnha6lcNzcI=" + }, + "d3-color": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-1.2.0.tgz", + "integrity": "sha512-dmL9Zr/v39aSSMnLOTd58in2RbregCg4UtGyUArvEKTTN6S3HKEy+ziBWVYo9PTzRyVW+pUBHUtRKz0HYX+SQg==" + }, + "d3-dispatch": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-1.0.3.tgz", + "integrity": "sha1-RuFJHqqbWMNY/OW+TovtYm54cfg=" + }, + "d3-force": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-1.1.0.tgz", + "integrity": "sha512-2HVQz3/VCQs0QeRNZTYb7GxoUCeb6bOzMp/cGcLa87awY9ZsPvXOGeZm0iaGBjXic6I1ysKwMn+g+5jSAdzwcg==", + "requires": { + "d3-collection": "1.0.4", + "d3-dispatch": "1.0.3", + "d3-quadtree": "1.0.3", + "d3-timer": "1.0.7" + } + }, + "d3-interpolate": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-1.2.0.tgz", + "integrity": "sha512-zLvTk8CREPFfc/2XglPQriAsXkzoRDAyBzndtKJWrZmHw7kmOWHNS11e40kPTd/oGk8P5mFJW5uBbcFQ+ybxyA==", + "requires": { + "d3-color": "1.2.0" + } + }, + "d3-quadtree": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-1.0.3.tgz", + "integrity": "sha1-rHmH4+I/6AWpkPKOG1DTj8uCJDg=" + }, + "d3-timer": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-1.0.7.tgz", + "integrity": "sha512-vMZXR88XujmG/L5oB96NNKH5lCWwiLM/S2HyyAQLcjWJCloK5shxta4CwOFYLZoY3AWX73v8Lgv4cCAdWtRmOA==" + }, + "date-now": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz", + "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=", + "dev": true + }, + "decamelize": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", + "integrity": "sha1-9lNNFRSCabIDUue+4m9QH5oZEpA=" + }, + "deep-equal": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz", + "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=" + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=" + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "requires": { + "foreach": "2.0.5", + "object-keys": "1.0.12" + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" + }, + "delaunay-triangulate": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/delaunay-triangulate/-/delaunay-triangulate-1.1.6.tgz", + "integrity": "sha1-W7yiGweBmNS8PHV5ajXLuYwllUw=", + "requires": { + "incremental-convex-hull": "1.0.1", + "uniq": "1.0.1" + } + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "diffie-hellman": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.2.tgz", + "integrity": "sha1-tYNXOScM/ias9jIJn97SoH8gnl4=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "miller-rabin": "4.0.1", + "randombytes": "2.0.6" + } + }, + "domain-browser": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.2.0.tgz", + "integrity": "sha512-jnjyiM6eRyZl2H+W8Q/zLMA481hzi0eszAaBUzIVnmYVDBbnLxVNnfu1HgEBvCbL+71FrxMl3E6lpKH7Ge3OXA==", + "dev": true + }, + "double-bits": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/double-bits/-/double-bits-1.1.1.tgz", + "integrity": "sha1-WKu6RUlNpND6Nrc60RoobJGEscY=" + }, + "draw-svg-path": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/draw-svg-path/-/draw-svg-path-1.0.0.tgz", + "integrity": "sha1-bxFtli3TFLmepTTW9Y3WbNvWk3k=", + "requires": { + "abs-svg-path": "0.1.1", + "normalize-svg-path": "0.1.0" + } + }, + "dtype": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/dtype/-/dtype-2.0.0.tgz", + "integrity": "sha1-zQUjI84GFETs0uj1dI9popvihDQ=" + }, + "dup": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/dup/-/dup-1.0.0.tgz", + "integrity": "sha1-UfxaxoX4GWRp3wuQXpNLIK9bQCk=" + }, + "duplexer2": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.0.2.tgz", + "integrity": "sha1-xhTc9n4vsUmVqRcR5aYX6KYKMds=", + "requires": { + "readable-stream": "1.1.14" + }, + "dependencies": { + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + } + } + }, + "duplexify": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/duplexify/-/duplexify-3.6.0.tgz", + "integrity": "sha512-fO3Di4tBKJpYTFHAxTU00BcfWMY9w24r/x21a6rZRbsD/ToUgGxsMbiGRmB7uVAXeGKXD9MwiLZa5E97EVgIRQ==", + "requires": { + "end-of-stream": "1.4.1", + "inherits": "2.0.3", + "readable-stream": "2.3.6", + "stream-shift": "1.0.0" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "earcut": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/earcut/-/earcut-2.1.3.tgz", + "integrity": "sha512-AxdCdWUk1zzK/NuZ7e1ljj6IGC+VAdC3Qb7QQDsXpfNrc5IM8tL9nNXUmEGE6jRHTfZ10zhzRhtDmWVsR5pd3A==" + }, + "edges-to-adjacency-list": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/edges-to-adjacency-list/-/edges-to-adjacency-list-1.0.0.tgz", + "integrity": "sha1-wUbS4ISt37p0pRKTxuAZmkn3V/E=", + "requires": { + "uniq": "1.0.1" + } + }, + "element-size": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/element-size/-/element-size-1.1.1.tgz", + "integrity": "sha1-ZOXxWdlxIWMYRby67K8nnDm1404=" + }, + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0", + "hash.js": "1.1.3", + "hmac-drbg": "1.0.1", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "emojis-list": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/emojis-list/-/emojis-list-2.1.0.tgz", + "integrity": "sha1-TapNnbAPmBmIDHn6RXrlsJof04k=", + "dev": true + }, + "encoding": { + "version": "0.1.12", + "resolved": "https://registry.npmjs.org/encoding/-/encoding-0.1.12.tgz", + "integrity": "sha1-U4tm8+5izRq1HsMjgp0flIDHS+s=", + "requires": { + "iconv-lite": "0.4.19" + } + }, + "end-of-stream": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.1.tgz", + "integrity": "sha512-1MkrZNvWTKCaigbn+W15elq2BB/L22nqrSY5DKlo3X6+vclJm8Bb5djXJBmEX6fS3+zCh/F4VBK5Z2KxJt4s2Q==", + "requires": { + "once": "1.4.0" + } + }, + "enhanced-resolve": { + "version": "3.4.1", + "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-3.4.1.tgz", + "integrity": "sha1-BCHjOf1xQZs9oT0Smzl5BAIwR24=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "memory-fs": "0.4.1", + "object-assign": "4.1.1", + "tapable": "0.2.8" + } + }, + "errno": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/errno/-/errno-0.1.7.tgz", + "integrity": "sha512-MfrRBDWzIWifgq6tJj60gkAwtLNb6sQPlcFrSOflcP1aFmmruKQ2wRnze/8V6kgyz7H3FF8Npzv78mZ7XLLflg==", + "dev": true, + "requires": { + "prr": "1.0.1" + } + }, + "error-ex": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.1.tgz", + "integrity": "sha1-+FWobOYa3E6GIcPNoh56dhLDqNw=", + "dev": true, + "requires": { + "is-arrayish": "0.2.1" + } + }, + "es-abstract": { + "version": "1.12.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.12.0.tgz", + "integrity": "sha512-C8Fx/0jFmV5IPoMOFPA9P9G5NtqW+4cOPit3MIuvR2t7Ag2K15EJTpxnHAYTzL+aYQJIESYeXZmDBfOBE1HcpA==", + "requires": { + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.3", + "is-callable": "1.1.3", + "is-regex": "1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "requires": { + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" + } + }, + "es5-ext": { + "version": "0.10.39", + "resolved": "https://registry.npmjs.org/es5-ext/-/es5-ext-0.10.39.tgz", + "integrity": "sha512-AlaXZhPHl0po/uxMx1tyrlt1O86M6D5iVaDH8UgLfgek4kXTX6vzsRfJQWC2Ku+aG8pkw1XWzh9eTkwfVrsD5g==", + "requires": { + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1" + } + }, + "es6-iterator": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/es6-iterator/-/es6-iterator-2.0.3.tgz", + "integrity": "sha1-p96IkUGgWpSwhUQDstCg+/qY87c=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39", + "es6-symbol": "3.1.1" + } + }, + "es6-map": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/es6-map/-/es6-map-0.1.5.tgz", + "integrity": "sha1-kTbgUD3MBqMBaQ8LsU/042TpSfA=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39", + "es6-iterator": "2.0.3", + "es6-set": "0.1.5", + "es6-symbol": "3.1.1", + "event-emitter": "0.3.5" + } + }, + "es6-promise": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-3.3.1.tgz", + "integrity": "sha1-oIzd6EzNvzTQJ6FFG8kdS80ophM=" + }, + "es6-set": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/es6-set/-/es6-set-0.1.5.tgz", + "integrity": "sha1-0rPsXU2ADO2BjbU40ol02wpzzLE=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39", + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1", + "event-emitter": "0.3.5" + } + }, + "es6-symbol": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/es6-symbol/-/es6-symbol-3.1.1.tgz", + "integrity": "sha1-vwDvT9q2uhtG7Le2KbTH7VcVzHc=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39" + } + }, + "es6-weak-map": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/es6-weak-map/-/es6-weak-map-2.0.2.tgz", + "integrity": "sha1-XjqzIlH/0VOKH45f+hNXdy+S2W8=", + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39", + "es6-iterator": "2.0.3", + "es6-symbol": "3.1.1" + } + }, + "escape-string-regexp": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", + "integrity": "sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=" + }, + "escodegen": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.10.0.tgz", + "integrity": "sha512-fjUOf8johsv23WuIKdNQU4P9t9jhQ4Qzx6pC2uW890OloK3Zs1ZAoCNpg/2larNF501jLl3UNy0kIRcF6VI22g==", + "requires": { + "esprima": "3.1.3", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "optionator": "0.8.2", + "source-map": "0.6.1" + }, + "dependencies": { + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=" + }, + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true + } + } + }, + "escope": { + "version": "3.6.0", + "resolved": "https://registry.npmjs.org/escope/-/escope-3.6.0.tgz", + "integrity": "sha1-4Bl16BJ4GhY6ba392AOY3GTIicM=", + "dev": true, + "requires": { + "es6-map": "0.1.5", + "es6-weak-map": "2.0.2", + "esrecurse": "4.2.0", + "estraverse": "4.2.0" + } + }, + "esprima": { + "version": "2.7.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-2.7.3.tgz", + "integrity": "sha1-luO3DVd59q1JzQMmc9HDEnZ7pYE=" + }, + "espurify": { + "version": "1.8.0", + "resolved": "https://registry.npmjs.org/espurify/-/espurify-1.8.0.tgz", + "integrity": "sha512-jdkJG9jswjKCCDmEridNUuIQei9algr+o66ZZ19610ZoBsiWLRsQGNYS4HGez3Z/DsR0lhANGAqiwBUclPuNag==", + "requires": { + "core-js": "2.5.7" + } + }, + "esrecurse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.2.0.tgz", + "integrity": "sha1-+pVo2Y04I/mkHZHpAtyrnqblsWM=", + "dev": true, + "requires": { + "estraverse": "4.2.0", + "object-assign": "4.1.1" + } + }, + "estraverse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=" + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=" + }, + "event-emitter": { + "version": "0.3.5", + "resolved": "https://registry.npmjs.org/event-emitter/-/event-emitter-0.3.5.tgz", + "integrity": "sha1-34xp7vFkeSPHFXuc6DhAYQsCzDk=", + "dev": true, + "requires": { + "d": "1.0.0", + "es5-ext": "0.10.39" + } + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=" + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "dev": true, + "requires": { + "md5.js": "1.3.4", + "safe-buffer": "5.1.1" + } + }, + "execa": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/execa/-/execa-0.7.0.tgz", + "integrity": "sha1-lEvs00zEHuMqY6n68nrVpl/Fl3c=", + "dev": true, + "requires": { + "cross-spawn": "5.1.0", + "get-stream": "3.0.0", + "is-stream": "1.1.0", + "npm-run-path": "2.0.2", + "p-finally": "1.0.0", + "signal-exit": "3.0.2", + "strip-eof": "1.0.0" + } + }, + "expand-brackets": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/expand-brackets/-/expand-brackets-0.1.5.tgz", + "integrity": "sha1-3wcoTjQqgHzXM6xa9yQR5YHRF3s=", + "dev": true, + "requires": { + "is-posix-bracket": "0.1.1" + } + }, + "expand-range": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/expand-range/-/expand-range-1.8.2.tgz", + "integrity": "sha1-opnv/TNf4nIeuujiV+x5ZE/IUzc=", + "dev": true, + "requires": { + "fill-range": "2.2.3" + } + }, + "expect.js": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/expect.js/-/expect.js-0.2.0.tgz", + "integrity": "sha1-EChTPSwcNj90pnlv9X7AUg3tK+E=" + }, + "extend-shallow": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/extend-shallow/-/extend-shallow-2.0.1.tgz", + "integrity": "sha1-Ua99YUrZqfYQ6huvu5idaxxWiQ8=", + "requires": { + "is-extendable": "0.1.1" + } + }, + "extglob": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/extglob/-/extglob-0.3.2.tgz", + "integrity": "sha1-Lhj/PS9JqydlzskCPwEdqo2DSaE=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + }, + "extract-frustum-planes": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/extract-frustum-planes/-/extract-frustum-planes-1.0.0.tgz", + "integrity": "sha1-l9VwP/BWTIw8aDjKxF+ee8UsnvU=" + }, + "falafel": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/falafel/-/falafel-2.1.0.tgz", + "integrity": "sha1-lrsXdh2rqU9G0AFzizzt86Z/4Gw=", + "requires": { + "acorn": "5.4.1", + "foreach": "2.0.5", + "isarray": "0.0.1", + "object-keys": "1.0.12" + } + }, + "fast-deep-equal": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.0.0.tgz", + "integrity": "sha1-liVqO8l1WV6zbYLpkp0GDYk0Of8=", + "dev": true + }, + "fast-isnumeric": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/fast-isnumeric/-/fast-isnumeric-1.1.1.tgz", + "integrity": "sha1-V7gcB6PAnLnsO++cFhgYmS2JNkM=" + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=", + "dev": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=" + }, + "filename-regex": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/filename-regex/-/filename-regex-2.0.1.tgz", + "integrity": "sha1-wcS5vuPglyXdsQa3XB4wH+LxiyY=", + "dev": true + }, + "fill-range": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-2.2.3.tgz", + "integrity": "sha1-ULd9/X5Gm8dJJHCWNpn+eoSFpyM=", + "dev": true, + "requires": { + "is-number": "2.1.0", + "isobject": "2.1.0", + "randomatic": "1.1.7", + "repeat-element": "1.1.2", + "repeat-string": "1.6.1" + } + }, + "filtered-vector": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/filtered-vector/-/filtered-vector-1.2.4.tgz", + "integrity": "sha1-VkU8A030MC0pPKjs3qw/kKvGeNM=", + "requires": { + "binary-search-bounds": "1.0.0", + "cubic-hermite": "1.0.0" + } + }, + "find-up": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz", + "integrity": "sha1-RdG35QbHF93UgndaK3eSCjwMV6c=", + "dev": true, + "requires": { + "locate-path": "2.0.0" + } + }, + "findup": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/findup/-/findup-0.1.5.tgz", + "integrity": "sha1-itkpozk7rGJ5V6fl3kYjsGsOLOs=", + "dev": true, + "requires": { + "colors": "0.6.2", + "commander": "2.1.0" + } + }, + "flatten-vertex-data": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/flatten-vertex-data/-/flatten-vertex-data-1.0.2.tgz", + "integrity": "sha512-BvCBFK2NZqerFTdMDgqfHBwxYWnxeCkwONsw6PvBMcUXqo8U/KDWwmXhqx1x2kLIg7DqIsJfOaJFOmlua3Lxuw==", + "requires": { + "dtype": "2.0.0" + } + }, + "flow-remove-types": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/flow-remove-types/-/flow-remove-types-1.2.3.tgz", + "integrity": "sha512-ypq/U3V+t9atYiOuSJd40tekCra03EHKoRsiK/wXGrsZimuum0kdwVY7Yv0HTaoXgHW1WiayomYd+Q3kkvPl9Q==", + "requires": { + "babylon": "6.18.0", + "vlq": "0.2.3" + } + }, + "font-atlas-sdf": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/font-atlas-sdf/-/font-atlas-sdf-1.3.3.tgz", + "integrity": "sha512-GxUpcdkdoHgC3UrpMuA7JmG1Ty/MY0BhfmV8r7ZSv3bkqBY5vmRIjcj7Pg8iqj20B03vlU6fUhdpyIgEo/Z35w==", + "requires": { + "optical-properties": "1.0.0", + "tiny-sdf": "1.0.2" + } + }, + "for-each": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.3.tgz", + "integrity": "sha512-jqYfLp7mo9vIyQf8ykW2v7A+2N4QjeCeI5+Dz9XraiO1ign81wjiH7Fb9vSOWvQfNtmSa4H2RoQTrrXivdUZmw==", + "requires": { + "is-callable": "1.1.3" + } + }, + "for-in": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/for-in/-/for-in-1.0.2.tgz", + "integrity": "sha1-gQaNKVqBQuwKxybG4iAMMPttXoA=", + "dev": true + }, + "for-own": { + "version": "0.1.5", + "resolved": "https://registry.npmjs.org/for-own/-/for-own-0.1.5.tgz", + "integrity": "sha1-UmXGgaTylNq78XyVCbZ2OqhFEM4=", + "dev": true, + "requires": { + "for-in": "1.0.2" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=" + }, + "from2": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/from2/-/from2-2.3.0.tgz", + "integrity": "sha1-i/tVAr3kpNNs/e6gB/zKIdfjgq8=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.4" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "from2-array": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/from2-array/-/from2-array-0.0.4.tgz", + "integrity": "sha1-6vwWtl9uJxm81X/cGGkAWsEzLNY=", + "dev": true, + "requires": { + "from2": "2.3.0" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "fsevents": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-1.1.3.tgz", + "integrity": "sha512-WIr7iDkdmdbxu/Gh6eKEZJL6KPE74/5MEsf2whTOFNxbIoIixogroLdKYqB6FDav4Wavh/lZdzzd3b2KxIXC5Q==", + "dev": true, + "optional": true, + "requires": { + "nan": "2.8.0", + "node-pre-gyp": "0.6.39" + }, + "dependencies": { + "abbrev": { + "version": "1.1.0", + "bundled": true, + "dev": true, + "optional": true + }, + "ajv": { + "version": "4.11.8", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "co": "4.6.0", + "json-stable-stringify": "1.0.1" + } + }, + "ansi-regex": { + "version": "2.1.1", + "bundled": true, + "dev": true + }, + "aproba": { + "version": "1.1.1", + "bundled": true, + "dev": true, + "optional": true + }, + "are-we-there-yet": { + "version": "1.1.4", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "delegates": "1.0.0", + "readable-stream": "2.2.9" + } + }, + "asn1": { + "version": "0.2.3", + "bundled": true, + "dev": true, + "optional": true + }, + "assert-plus": { + "version": "0.2.0", + "bundled": true, + "dev": true, + "optional": true + }, + "asynckit": { + "version": "0.4.0", + "bundled": true, + "dev": true, + "optional": true + }, + "aws-sign2": { + "version": "0.6.0", + "bundled": true, + "dev": true, + "optional": true + }, + "aws4": { + "version": "1.6.0", + "bundled": true, + "dev": true, + "optional": true + }, + "balanced-match": { + "version": "0.4.2", + "bundled": true, + "dev": true + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "block-stream": { + "version": "0.0.9", + "bundled": true, + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "boom": { + "version": "2.10.1", + "bundled": true, + "dev": true, + "requires": { + "hoek": "2.16.3" + } + }, + "brace-expansion": { + "version": "1.1.7", + "bundled": true, + "dev": true, + "requires": { + "balanced-match": "0.4.2", + "concat-map": "0.0.1" + } + }, + "buffer-shims": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "caseless": { + "version": "0.12.0", + "bundled": true, + "dev": true, + "optional": true + }, + "co": { + "version": "4.6.0", + "bundled": true, + "dev": true, + "optional": true + }, + "code-point-at": { + "version": "1.1.0", + "bundled": true, + "dev": true + }, + "combined-stream": { + "version": "1.0.5", + "bundled": true, + "dev": true, + "requires": { + "delayed-stream": "1.0.0" + } + }, + "concat-map": { + "version": "0.0.1", + "bundled": true, + "dev": true + }, + "console-control-strings": { + "version": "1.1.0", + "bundled": true, + "dev": true + }, + "core-util-is": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "cryptiles": { + "version": "2.0.5", + "bundled": true, + "dev": true, + "requires": { + "boom": "2.10.1" + } + }, + "dashdash": { + "version": "1.14.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "debug": { + "version": "2.6.8", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "ms": "2.0.0" + } + }, + "deep-extend": { + "version": "0.4.2", + "bundled": true, + "dev": true, + "optional": true + }, + "delayed-stream": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "delegates": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + }, + "detect-libc": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "optional": true + }, + "ecc-jsbn": { + "version": "0.1.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "extend": { + "version": "3.0.1", + "bundled": true, + "dev": true, + "optional": true + }, + "extsprintf": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "forever-agent": { + "version": "0.6.1", + "bundled": true, + "dev": true, + "optional": true + }, + "form-data": { + "version": "2.1.4", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.5", + "mime-types": "2.1.15" + } + }, + "fs.realpath": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "fstream": { + "version": "1.0.11", + "bundled": true, + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "inherits": "2.0.3", + "mkdirp": "0.5.1", + "rimraf": "2.6.1" + } + }, + "fstream-ignore": { + "version": "1.0.5", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "fstream": "1.0.11", + "inherits": "2.0.3", + "minimatch": "3.0.4" + } + }, + "gauge": { + "version": "2.7.4", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "aproba": "1.1.1", + "console-control-strings": "1.1.0", + "has-unicode": "2.0.1", + "object-assign": "4.1.1", + "signal-exit": "3.0.2", + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wide-align": "1.1.2" + } + }, + "getpass": { + "version": "0.1.7", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "glob": { + "version": "7.1.2", + "bundled": true, + "dev": true, + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "graceful-fs": { + "version": "4.1.11", + "bundled": true, + "dev": true + }, + "har-schema": { + "version": "1.0.5", + "bundled": true, + "dev": true, + "optional": true + }, + "har-validator": { + "version": "4.2.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "ajv": "4.11.8", + "har-schema": "1.0.5" + } + }, + "has-unicode": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "optional": true + }, + "hawk": { + "version": "3.1.3", + "bundled": true, + "dev": true, + "requires": { + "boom": "2.10.1", + "cryptiles": "2.0.5", + "hoek": "2.16.3", + "sntp": "1.0.9" + } + }, + "hoek": { + "version": "2.16.3", + "bundled": true, + "dev": true + }, + "http-signature": { + "version": "1.1.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "assert-plus": "0.2.0", + "jsprim": "1.4.0", + "sshpk": "1.13.0" + } + }, + "inflight": { + "version": "1.0.6", + "bundled": true, + "dev": true, + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "bundled": true, + "dev": true + }, + "ini": { + "version": "1.3.4", + "bundled": true, + "dev": true, + "optional": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-typedarray": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + }, + "isarray": { + "version": "1.0.0", + "bundled": true, + "dev": true + }, + "isstream": { + "version": "0.1.2", + "bundled": true, + "dev": true, + "optional": true + }, + "jodid25519": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "jsbn": { + "version": "0.1.1", + "bundled": true, + "dev": true, + "optional": true + }, + "json-schema": { + "version": "0.2.3", + "bundled": true, + "dev": true, + "optional": true + }, + "json-stable-stringify": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "jsonify": "0.0.0" + } + }, + "json-stringify-safe": { + "version": "5.0.1", + "bundled": true, + "dev": true, + "optional": true + }, + "jsonify": { + "version": "0.0.0", + "bundled": true, + "dev": true, + "optional": true + }, + "jsprim": { + "version": "1.4.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.0.2", + "json-schema": "0.2.3", + "verror": "1.3.6" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "mime-db": { + "version": "1.27.0", + "bundled": true, + "dev": true + }, + "mime-types": { + "version": "2.1.15", + "bundled": true, + "dev": true, + "requires": { + "mime-db": "1.27.0" + } + }, + "minimatch": { + "version": "3.0.4", + "bundled": true, + "dev": true, + "requires": { + "brace-expansion": "1.1.7" + } + }, + "minimist": { + "version": "0.0.8", + "bundled": true, + "dev": true + }, + "mkdirp": { + "version": "0.5.1", + "bundled": true, + "dev": true, + "requires": { + "minimist": "0.0.8" + } + }, + "ms": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "optional": true + }, + "node-pre-gyp": { + "version": "0.6.39", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "detect-libc": "1.0.2", + "hawk": "3.1.3", + "mkdirp": "0.5.1", + "nopt": "4.0.1", + "npmlog": "4.1.0", + "rc": "1.2.1", + "request": "2.81.0", + "rimraf": "2.6.1", + "semver": "5.3.0", + "tar": "2.2.1", + "tar-pack": "3.4.0" + } + }, + "nopt": { + "version": "4.0.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "abbrev": "1.1.0", + "osenv": "0.1.4" + } + }, + "npmlog": { + "version": "4.1.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "are-we-there-yet": "1.1.4", + "console-control-strings": "1.1.0", + "gauge": "2.7.4", + "set-blocking": "2.0.0" + } + }, + "number-is-nan": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "oauth-sign": { + "version": "0.8.2", + "bundled": true, + "dev": true, + "optional": true + }, + "object-assign": { + "version": "4.1.1", + "bundled": true, + "dev": true, + "optional": true + }, + "once": { + "version": "1.4.0", + "bundled": true, + "dev": true, + "requires": { + "wrappy": "1.0.2" + } + }, + "os-homedir": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "optional": true + }, + "os-tmpdir": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "optional": true + }, + "osenv": { + "version": "0.1.4", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "os-homedir": "1.0.2", + "os-tmpdir": "1.0.2" + } + }, + "path-is-absolute": { + "version": "1.0.1", + "bundled": true, + "dev": true + }, + "performance-now": { + "version": "0.2.0", + "bundled": true, + "dev": true, + "optional": true + }, + "process-nextick-args": { + "version": "1.0.7", + "bundled": true, + "dev": true + }, + "punycode": { + "version": "1.4.1", + "bundled": true, + "dev": true, + "optional": true + }, + "qs": { + "version": "6.4.0", + "bundled": true, + "dev": true, + "optional": true + }, + "rc": { + "version": "1.2.1", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "deep-extend": "0.4.2", + "ini": "1.3.4", + "minimist": "1.2.0", + "strip-json-comments": "2.0.1" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "readable-stream": { + "version": "2.2.9", + "bundled": true, + "dev": true, + "requires": { + "buffer-shims": "1.0.0", + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "string_decoder": "1.0.1", + "util-deprecate": "1.0.2" + } + }, + "request": { + "version": "2.81.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "aws-sign2": "0.6.0", + "aws4": "1.6.0", + "caseless": "0.12.0", + "combined-stream": "1.0.5", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.1.4", + "har-validator": "4.2.1", + "hawk": "3.1.3", + "http-signature": "1.1.1", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.15", + "oauth-sign": "0.8.2", + "performance-now": "0.2.0", + "qs": "6.4.0", + "safe-buffer": "5.0.1", + "stringstream": "0.0.5", + "tough-cookie": "2.3.2", + "tunnel-agent": "0.6.0", + "uuid": "3.0.1" + } + }, + "rimraf": { + "version": "2.6.1", + "bundled": true, + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "safe-buffer": { + "version": "5.0.1", + "bundled": true, + "dev": true + }, + "semver": { + "version": "5.3.0", + "bundled": true, + "dev": true, + "optional": true + }, + "set-blocking": { + "version": "2.0.0", + "bundled": true, + "dev": true, + "optional": true + }, + "signal-exit": { + "version": "3.0.2", + "bundled": true, + "dev": true, + "optional": true + }, + "sntp": { + "version": "1.0.9", + "bundled": true, + "dev": true, + "requires": { + "hoek": "2.16.3" + } + }, + "sshpk": { + "version": "1.13.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jodid25519": "1.0.2", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + }, + "dependencies": { + "assert-plus": { + "version": "1.0.0", + "bundled": true, + "dev": true, + "optional": true + } + } + }, + "string-width": { + "version": "1.0.2", + "bundled": true, + "dev": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + }, + "string_decoder": { + "version": "1.0.1", + "bundled": true, + "dev": true, + "requires": { + "safe-buffer": "5.0.1" + } + }, + "stringstream": { + "version": "0.0.5", + "bundled": true, + "dev": true, + "optional": true + }, + "strip-ansi": { + "version": "3.0.1", + "bundled": true, + "dev": true, + "requires": { + "ansi-regex": "2.1.1" + } + }, + "strip-json-comments": { + "version": "2.0.1", + "bundled": true, + "dev": true, + "optional": true + }, + "tar": { + "version": "2.2.1", + "bundled": true, + "dev": true, + "requires": { + "block-stream": "0.0.9", + "fstream": "1.0.11", + "inherits": "2.0.3" + } + }, + "tar-pack": { + "version": "3.4.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "debug": "2.6.8", + "fstream": "1.0.11", + "fstream-ignore": "1.0.5", + "once": "1.4.0", + "readable-stream": "2.2.9", + "rimraf": "2.6.1", + "tar": "2.2.1", + "uid-number": "0.0.6" + } + }, + "tough-cookie": { + "version": "2.3.2", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "punycode": "1.4.1" + } + }, + "tunnel-agent": { + "version": "0.6.0", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "safe-buffer": "5.0.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "bundled": true, + "dev": true, + "optional": true + }, + "uid-number": { + "version": "0.0.6", + "bundled": true, + "dev": true, + "optional": true + }, + "util-deprecate": { + "version": "1.0.2", + "bundled": true, + "dev": true + }, + "uuid": { + "version": "3.0.1", + "bundled": true, + "dev": true, + "optional": true + }, + "verror": { + "version": "1.3.6", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "extsprintf": "1.0.2" + } + }, + "wide-align": { + "version": "1.1.2", + "bundled": true, + "dev": true, + "optional": true, + "requires": { + "string-width": "1.0.2" + } + }, + "wrappy": { + "version": "1.0.2", + "bundled": true, + "dev": true + } + } + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "functional-red-black-tree": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/functional-red-black-tree/-/functional-red-black-tree-1.0.1.tgz", + "integrity": "sha1-GwqzvVU7Kg1jmdKcDj6gslIHgyc=" + }, + "gamma": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/gamma/-/gamma-0.1.0.tgz", + "integrity": "sha1-MxVkNAO/J5BsqAqzfDbs6UQO8zA=" + }, + "geojson-rewind": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/geojson-rewind/-/geojson-rewind-0.3.1.tgz", + "integrity": "sha1-IiQHl8hHzC8MHTE+SqDJFa+n8p0=", + "requires": { + "@mapbox/geojson-area": "0.2.2", + "concat-stream": "1.6.2", + "minimist": "1.2.0", + "sharkdown": "0.1.0" + } + }, + "geojson-vt": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/geojson-vt/-/geojson-vt-3.1.3.tgz", + "integrity": "sha512-oWaMsd08gUa1c4B4s2Z3LIX+oUIe8G/i5vp9JLjXlROuveMUpEwT49WDGHp5Gs4RVaJ0B51h1QTcj/dvtT+w9A==" + }, + "get-caller-file": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-1.0.2.tgz", + "integrity": "sha1-9wLmMSfn4jHBYKgMFVSstw1QR+U=", + "dev": true + }, + "get-canvas-context": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/get-canvas-context/-/get-canvas-context-1.0.2.tgz", + "integrity": "sha1-1ue1C8TkyGNXzTnyJkeoS3NgHpM=" + }, + "get-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-3.0.0.tgz", + "integrity": "sha1-jpQ9E1jcN1VQVOy+LtsFqhdO3hQ=", + "dev": true + }, + "gl-axes3d": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/gl-axes3d/-/gl-axes3d-1.2.7.tgz", + "integrity": "sha512-PXyLDQR3+shlvmJg8At0bdsA1FdsotA1fRAz1zktsPhx8dwghE2aGKZ2bLLppYRndbXAgMmBhz+dz+wlZltLsw==", + "requires": { + "bit-twiddle": "1.0.2", + "dup": "1.0.0", + "extract-frustum-planes": "1.0.0", + "gl-buffer": "2.1.2", + "gl-mat4": "1.2.0", + "gl-shader": "4.2.1", + "gl-state": "1.0.0", + "gl-vao": "1.3.0", + "gl-vec4": "1.0.1", + "glslify": "6.1.1", + "robust-orientation": "1.1.3", + "split-polygon": "1.0.0", + "vectorize-text": "3.0.2" + } + }, + "gl-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/gl-buffer/-/gl-buffer-2.1.2.tgz", + "integrity": "sha1-LbjZwaVSf7oM25EonCBuiCuInNs=", + "requires": { + "ndarray": "1.0.18", + "ndarray-ops": "1.2.2", + "typedarray-pool": "1.1.0" + } + }, + "gl-cone3d": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/gl-cone3d/-/gl-cone3d-1.1.0.tgz", + "integrity": "sha512-uru4LHoo5E/F2q6o3JkLsi1DWt8X0rcwMTcG9khI1ed6iTyrREghFdqYOHGeQfJdrXzqC714sz0eGmKOJXtXcA==", + "requires": { + "gl-shader": "4.2.1", + "gl-vec3": "1.1.3", + "glsl-inverse": "1.0.0", + "glslify": "6.1.1" + } + }, + "gl-constants": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gl-constants/-/gl-constants-1.0.0.tgz", + "integrity": "sha1-WXpQTjZHUP9QJTqjX43qevSl0jM=" + }, + "gl-contour2d": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/gl-contour2d/-/gl-contour2d-1.1.4.tgz", + "integrity": "sha512-deoY6k5ZcQfh5brlF3nXKs8FqhMNejlxIqWcK+bKenLcThJF94OR7DtQDwLwNXsYAZlsoDt+G01efXid6Modkg==", + "requires": { + "binary-search-bounds": "2.0.4", + "cdt2d": "1.0.0", + "clean-pslg": "1.1.2", + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "glslify": "6.1.1", + "iota-array": "1.0.0", + "ndarray": "1.0.18", + "surface-nets": "1.0.2" + }, + "dependencies": { + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + } + } + }, + "gl-error3d": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/gl-error3d/-/gl-error3d-1.0.7.tgz", + "integrity": "sha512-otIih1SAh7Fo8DaaGQXOrg307cVpOjtTOwgiJzmmHAglD2EaKVSzNHONI5RVVVP+bBaObZz+wW18Mpeasij9pA==", + "requires": { + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "gl-vao": "1.3.0", + "glslify": "6.1.1" + } + }, + "gl-fbo": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/gl-fbo/-/gl-fbo-2.0.5.tgz", + "integrity": "sha1-D6daSXz3h2lVMGkcjwSrtvtV+iI=", + "requires": { + "gl-texture2d": "2.1.0" + } + }, + "gl-format-compiler-error": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/gl-format-compiler-error/-/gl-format-compiler-error-1.0.3.tgz", + "integrity": "sha1-DHmxdRiZzpcy6GJA8JCqQemEcag=", + "requires": { + "add-line-numbers": "1.0.1", + "gl-constants": "1.0.0", + "glsl-shader-name": "1.0.0", + "sprintf-js": "1.1.1" + } + }, + "gl-heatmap2d": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/gl-heatmap2d/-/gl-heatmap2d-1.0.4.tgz", + "integrity": "sha512-AWJykMTbCM0ZT20jiFaauRVmLv9dxtNNuTS1NQlKD8yBD0iZ62mgWLeYLUMjil6XN8K3P9EpUCBolvcx1Wf0kA==", + "requires": { + "binary-search-bounds": "2.0.4", + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "glslify": "6.1.1", + "iota-array": "1.0.0", + "typedarray-pool": "1.1.0" + }, + "dependencies": { + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + } + } + }, + "gl-line3d": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/gl-line3d/-/gl-line3d-1.1.2.tgz", + "integrity": "sha512-OEkE5dsTunz0JApcx/+T57kOXWY+jNUS4nntnhEy14OcRCb4K6gz53HB+Oi8Cz9nb/95f805QLNgnkhDpdz8uw==", + "requires": { + "binary-search-bounds": "1.0.0", + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "gl-texture2d": "2.1.0", + "gl-vao": "1.3.0", + "glsl-read-float": "1.1.0", + "glslify": "6.1.1", + "ndarray": "1.0.18" + } + }, + "gl-mat2": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gl-mat2/-/gl-mat2-1.0.1.tgz", + "integrity": "sha1-FCUFcwpcL+Hp8l2ezj0NbMJxCjA=" + }, + "gl-mat3": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gl-mat3/-/gl-mat3-1.0.0.tgz", + "integrity": "sha1-iWMyGcpCk3mha5GF2V1BcTRTuRI=" + }, + "gl-mat4": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/gl-mat4/-/gl-mat4-1.2.0.tgz", + "integrity": "sha512-sT5C0pwB1/e9G9AvAoLsoaJtbMGjfd/jfxo8jMCKqYYEnjZuFvqV5rehqar0538EmssjdDeiEWnKyBSTw7quoA==" + }, + "gl-matrix-invert": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gl-matrix-invert/-/gl-matrix-invert-1.0.0.tgz", + "integrity": "sha1-o2173jZUxFkKEn7nxo9uE/6oxj0=", + "requires": { + "gl-mat2": "1.0.1", + "gl-mat3": "1.0.0", + "gl-mat4": "1.2.0" + } + }, + "gl-mesh3d": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/gl-mesh3d/-/gl-mesh3d-2.0.0.tgz", + "integrity": "sha512-cvusWaXEnpH4eXHlN+B3gXj55tOywr5Y2ERI5HrJTdvc5Z77NHEZ6FA66kacdbhqr3r1vM0CMOeeLoteDQumpQ==", + "requires": { + "barycentric": "1.0.1", + "colormap": "2.3.0", + "gl-buffer": "2.1.2", + "gl-mat4": "1.2.0", + "gl-shader": "4.2.1", + "gl-texture2d": "2.1.0", + "gl-vao": "1.3.0", + "glsl-face-normal": "1.0.2", + "glsl-specular-cook-torrance": "2.0.1", + "glslify": "6.1.1", + "ndarray": "1.0.18", + "normals": "1.1.0", + "polytope-closest-point": "1.0.0", + "simplicial-complex-contour": "1.0.2", + "typedarray-pool": "1.1.0" + } + }, + "gl-plot2d": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/gl-plot2d/-/gl-plot2d-1.3.1.tgz", + "integrity": "sha512-wmZC1ztzkWP03J/1W6yenHwu9c3YzBslIoj/qywkrtO8BXsZeXNAQUidJ2Iq9yvphbOWB3dV0IByNVKKUh3CWw==", + "requires": { + "binary-search-bounds": "2.0.4", + "gl-buffer": "2.1.2", + "gl-select-static": "2.0.2", + "gl-shader": "4.2.1", + "glsl-inverse": "1.0.0", + "glslify": "6.1.1", + "text-cache": "4.1.0" + }, + "dependencies": { + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + } + } + }, + "gl-plot3d": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/gl-plot3d/-/gl-plot3d-1.5.5.tgz", + "integrity": "sha512-pmpIVJ/otokKSdUrpT0a0YjT1B0qdrH3qFO7LcuCSV/8YIo0ybYbXAoYacksgbiJehVVxvnN1ZMCkDIl1uFh4w==", + "requires": { + "3d-view-controls": "2.2.2", + "a-big-triangle": "1.0.3", + "gl-axes3d": "1.2.7", + "gl-fbo": "2.0.5", + "gl-mat4": "1.2.0", + "gl-select-static": "2.0.2", + "gl-shader": "4.2.1", + "gl-spikes3d": "1.0.6", + "glslify": "6.1.1", + "is-mobile": "0.2.2", + "mouse-change": "1.4.0", + "ndarray": "1.0.18" + } + }, + "gl-pointcloud2d": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gl-pointcloud2d/-/gl-pointcloud2d-1.0.1.tgz", + "integrity": "sha512-bCNaPSrZjBiKRrlbhHdipnmTc5xteubksevbPrmdlk2R6PTwQlQ38TDxuRYan02j0uDtem9wEp8etYYMjZFMhA==", + "requires": { + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "glslify": "6.1.1", + "typedarray-pool": "1.1.0" + } + }, + "gl-quat": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gl-quat/-/gl-quat-1.0.0.tgz", + "integrity": "sha1-CUXskjOG9FMpvl3DV7HIwtR1hsU=", + "requires": { + "gl-mat3": "1.0.0", + "gl-vec3": "1.1.3", + "gl-vec4": "1.0.1" + } + }, + "gl-scatter3d": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/gl-scatter3d/-/gl-scatter3d-1.0.11.tgz", + "integrity": "sha512-fKpIBm6QHuw3RVzM3fjYgpigQuHIDj5tXbbGx8whWIx7S3ureiZgTxsM2Mtwo+OLsm1lUEryGf2YbFf3NQ9CiQ==", + "requires": { + "gl-buffer": "2.1.2", + "gl-mat4": "1.2.0", + "gl-shader": "4.2.1", + "gl-vao": "1.3.0", + "glslify": "6.1.1", + "typedarray-pool": "1.1.0", + "vectorize-text": "3.0.2" + } + }, + "gl-select-box": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/gl-select-box/-/gl-select-box-1.0.2.tgz", + "integrity": "sha512-QCheTcyHiamTgOQ92P9swHgJoR25T8GGRCANASRtjdMXndlAbQG4qxBP15MRJx7RFWlOVvEeUzCvPn7r116orA==", + "requires": { + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "glslify": "6.1.1" + } + }, + "gl-select-static": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/gl-select-static/-/gl-select-static-2.0.2.tgz", + "integrity": "sha1-8+GQHfAxgdUy55WFMjBnnUr1fuk=", + "requires": { + "bit-twiddle": "1.0.2", + "cwise": "1.0.10", + "gl-fbo": "2.0.5", + "ndarray": "1.0.18", + "typedarray-pool": "1.1.0" + } + }, + "gl-shader": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/gl-shader/-/gl-shader-4.2.1.tgz", + "integrity": "sha1-vJuAjpKTxRtmjojeYVsMETcI3C8=", + "requires": { + "gl-format-compiler-error": "1.0.3", + "weakmap-shim": "1.1.1" + } + }, + "gl-spikes2d": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gl-spikes2d/-/gl-spikes2d-1.0.1.tgz", + "integrity": "sha1-ys2y09vNICuFNFLoUAqLB3lJzAM=" + }, + "gl-spikes3d": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/gl-spikes3d/-/gl-spikes3d-1.0.6.tgz", + "integrity": "sha512-mXRG+3iCs4bDH7if2aOr1G5UpbNqKxfWpy7GR/afOHDSNsrq2ZjnWAwPmIJG7KdClPNPgiK30cVo7XisLt8PCQ==", + "requires": { + "gl-buffer": "2.1.2", + "gl-shader": "4.2.1", + "gl-vao": "1.3.0", + "glslify": "6.1.1" + } + }, + "gl-state": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/gl-state/-/gl-state-1.0.0.tgz", + "integrity": "sha1-Ji+qdYNbC5xTLBLzitxCXR0wzRc=", + "requires": { + "uniq": "1.0.1" + } + }, + "gl-surface3d": { + "version": "1.3.5", + "resolved": "https://registry.npmjs.org/gl-surface3d/-/gl-surface3d-1.3.5.tgz", + "integrity": "sha512-+8/zQKgVvaGee1KYcfM6bnNsfa0UtVwERQymeu4N1il16qK1b+Dgp2y+lzyM97J5Tez0qyDw2BbkOrmve3+8YQ==", + "requires": { + "binary-search-bounds": "1.0.0", + "bit-twiddle": "1.0.2", + "colormap": "2.3.0", + "dup": "1.0.0", + "gl-buffer": "2.1.2", + "gl-mat4": "1.2.0", + "gl-shader": "4.2.1", + "gl-texture2d": "2.1.0", + "gl-vao": "1.3.0", + "glsl-specular-beckmann": "1.1.2", + "glslify": "6.1.1", + "ndarray": "1.0.18", + "ndarray-gradient": "1.0.0", + "ndarray-ops": "1.2.2", + "ndarray-pack": "1.2.1", + "ndarray-scratch": "1.2.0", + "surface-nets": "1.0.2", + "typedarray-pool": "1.1.0" + } + }, + "gl-texture2d": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/gl-texture2d/-/gl-texture2d-2.1.0.tgz", + "integrity": "sha1-/2gk5+fDGoum/c2+nlxpXX4hh8c=", + "requires": { + "ndarray": "1.0.18", + "ndarray-ops": "1.2.2", + "typedarray-pool": "1.1.0" + } + }, + "gl-vao": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/gl-vao/-/gl-vao-1.3.0.tgz", + "integrity": "sha1-6ekqqVWIyrnVwvBLaTRAw99pGSM=" + }, + "gl-vec3": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/gl-vec3/-/gl-vec3-1.1.3.tgz", + "integrity": "sha512-jduKUqT0SGH02l8Yl+mV1yVsDfYgQAJyXGxkJQGyxPLHRiW25DwVIRPt6uvhrEMHftJfqhqKthRcyZqNEl9Xdw==" + }, + "gl-vec4": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/gl-vec4/-/gl-vec4-1.0.1.tgz", + "integrity": "sha1-l9loeCgbFLUyy84QF4Xf0cs0CWQ=" + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "glob-base": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/glob-base/-/glob-base-0.3.0.tgz", + "integrity": "sha1-27Fk9iIbHAscz4Kuoyi0l98Oo8Q=", + "dev": true, + "requires": { + "glob-parent": "2.0.0", + "is-glob": "2.0.1" + } + }, + "glob-parent": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-2.0.0.tgz", + "integrity": "sha1-gTg9ctsFT8zPUzbaqQLxgvbtuyg=", + "dev": true, + "requires": { + "is-glob": "2.0.1" + } + }, + "glsl-face-normal": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/glsl-face-normal/-/glsl-face-normal-1.0.2.tgz", + "integrity": "sha1-fud12Rmk8u6S9Xu2mOh8x12/Eog=" + }, + "glsl-inject-defines": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/glsl-inject-defines/-/glsl-inject-defines-1.0.3.tgz", + "integrity": "sha1-3RqswsF/yyvT/DJBHGYz0Ne2D9Q=", + "requires": { + "glsl-token-inject-block": "1.1.0", + "glsl-token-string": "1.0.1", + "glsl-tokenizer": "2.1.2" + } + }, + "glsl-inverse": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/glsl-inverse/-/glsl-inverse-1.0.0.tgz", + "integrity": "sha1-EsCx0GX1WERNHm/q95td34qRiuY=" + }, + "glsl-read-float": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/glsl-read-float/-/glsl-read-float-1.1.0.tgz", + "integrity": "sha1-37CIsBYtz8xW/E7d0vhuGMrDLyY=" + }, + "glsl-resolve": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/glsl-resolve/-/glsl-resolve-0.0.1.tgz", + "integrity": "sha1-iUvvc5ENeSyBtRQxgANdCnivdtM=", + "requires": { + "resolve": "0.6.3", + "xtend": "2.2.0" + }, + "dependencies": { + "resolve": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-0.6.3.tgz", + "integrity": "sha1-3ZV5gufnNt699TtYpN2RdUV13UY=" + }, + "xtend": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.2.0.tgz", + "integrity": "sha1-7vax8ZjByN6vrYsXZaBNrUoBxak=" + } + } + }, + "glsl-shader-name": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/glsl-shader-name/-/glsl-shader-name-1.0.0.tgz", + "integrity": "sha1-osMLO6c0mb77DMcYTXx3M91LSH0=", + "requires": { + "atob-lite": "1.0.0", + "glsl-tokenizer": "2.1.2" + } + }, + "glsl-specular-beckmann": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/glsl-specular-beckmann/-/glsl-specular-beckmann-1.1.2.tgz", + "integrity": "sha1-/OkFaTPs3yRWJ4N2pU0IKJPndfE=" + }, + "glsl-specular-cook-torrance": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/glsl-specular-cook-torrance/-/glsl-specular-cook-torrance-2.0.1.tgz", + "integrity": "sha1-qJHMBsjHtPRyhwK0gk/ay7ln148=", + "requires": { + "glsl-specular-beckmann": "1.1.2" + } + }, + "glsl-token-assignments": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/glsl-token-assignments/-/glsl-token-assignments-2.0.2.tgz", + "integrity": "sha1-pdgqt4SZwuimuDy2lJXm5mXOAZ8=" + }, + "glsl-token-defines": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/glsl-token-defines/-/glsl-token-defines-1.0.0.tgz", + "integrity": "sha1-y4kqqVmTYjFyhHDU90AySJaX+p0=", + "requires": { + "glsl-tokenizer": "2.1.2" + } + }, + "glsl-token-depth": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/glsl-token-depth/-/glsl-token-depth-1.1.2.tgz", + "integrity": "sha1-I8XjDuK9JViEtKKLyFC495HpXYQ=" + }, + "glsl-token-descope": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/glsl-token-descope/-/glsl-token-descope-1.0.2.tgz", + "integrity": "sha1-D8kKsyYYa4L1l7LnfcniHvzTIHY=", + "requires": { + "glsl-token-assignments": "2.0.2", + "glsl-token-depth": "1.1.2", + "glsl-token-properties": "1.0.1", + "glsl-token-scope": "1.1.2" + } + }, + "glsl-token-inject-block": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/glsl-token-inject-block/-/glsl-token-inject-block-1.1.0.tgz", + "integrity": "sha1-4QFfWYDBCRgkraomJfHf3ovQADQ=" + }, + "glsl-token-properties": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/glsl-token-properties/-/glsl-token-properties-1.0.1.tgz", + "integrity": "sha1-SD3D2Dnw1LXGFx0VkfJJvlPCip4=" + }, + "glsl-token-scope": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/glsl-token-scope/-/glsl-token-scope-1.1.2.tgz", + "integrity": "sha1-oXKOeN8kRE+cuT/RjvD3VQOmQ7E=" + }, + "glsl-token-string": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/glsl-token-string/-/glsl-token-string-1.0.1.tgz", + "integrity": "sha1-WUQdL4V958NEnJRWZgIezjWOSOw=" + }, + "glsl-token-whitespace-trim": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/glsl-token-whitespace-trim/-/glsl-token-whitespace-trim-1.0.0.tgz", + "integrity": "sha1-RtHf6Yx1vX1QTAXX0RsbPpzJOxA=" + }, + "glsl-tokenizer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/glsl-tokenizer/-/glsl-tokenizer-2.1.2.tgz", + "integrity": "sha1-cgMHUi4DxXrzXABVGVDEpw7y37k=", + "requires": { + "through2": "0.6.5" + } + }, + "glslify": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/glslify/-/glslify-6.1.1.tgz", + "integrity": "sha512-FUmL/MFt7rK9RtNqw3xHhdIZncZk8QKdCVonYx73mSlGpRzoGrBhuMVBdFomeQaeGUpaS3InO+qAk6Wx0WUtdw==", + "requires": { + "bl": "1.2.1", + "concat-stream": "1.6.2", + "duplexify": "3.6.0", + "falafel": "2.1.0", + "from2": "2.3.0", + "glsl-resolve": "0.0.1", + "glsl-token-whitespace-trim": "1.0.0", + "glslify-bundle": "5.0.0", + "glslify-deps": "1.3.1", + "minimist": "1.2.0", + "resolve": "1.4.0", + "stack-trace": "0.0.9", + "static-eval": "2.0.0", + "tape": "4.9.1", + "through2": "2.0.3", + "xtend": "4.0.1" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "2.3.6", + "xtend": "4.0.1" + } + } + } + }, + "glslify-bundle": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/glslify-bundle/-/glslify-bundle-5.0.0.tgz", + "integrity": "sha1-AlKtoe+d8wtmAAbguyH9EwtIbkI=", + "requires": { + "glsl-inject-defines": "1.0.3", + "glsl-token-defines": "1.0.0", + "glsl-token-depth": "1.1.2", + "glsl-token-descope": "1.0.2", + "glsl-token-scope": "1.1.2", + "glsl-token-string": "1.0.1", + "glsl-token-whitespace-trim": "1.0.0", + "glsl-tokenizer": "2.1.2", + "murmurhash-js": "1.0.0", + "shallow-copy": "0.0.1" + } + }, + "glslify-deps": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/glslify-deps/-/glslify-deps-1.3.1.tgz", + "integrity": "sha512-Ogm179MCazwIRyEqs3g3EOY4Y3XIAa0yl8J5RE9rJC6QH1w8weVOp2RZu0mvnYy/2xIas1w166YR2eZdDkWQxg==", + "requires": { + "@choojs/findup": "0.2.1", + "events": "1.1.1", + "glsl-resolve": "0.0.1", + "glsl-tokenizer": "2.1.2", + "graceful-fs": "4.1.11", + "inherits": "2.0.3", + "map-limit": "0.0.1", + "resolve": "1.4.0" + }, + "dependencies": { + "@choojs/findup": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/@choojs/findup/-/findup-0.2.1.tgz", + "integrity": "sha512-YstAqNb0MCN8PjdLCDfRsBcGVRN41f3vgLvaI0IrIcBp4AqILRSS0DeWNGkicC+f/zRIPJLc+9RURVSepwvfBw==", + "requires": { + "commander": "2.15.1" + } + }, + "commander": { + "version": "2.15.1", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz", + "integrity": "sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==" + } + } + }, + "graceful-fs": { + "version": "4.1.11", + "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.1.11.tgz", + "integrity": "sha1-Dovf5NHduIVNZOBOp8AOKgJuVlg=" + }, + "gray-matter": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/gray-matter/-/gray-matter-3.1.1.tgz", + "integrity": "sha512-nZ1qjLmayEv0/wt3sHig7I0s3/sJO0dkAaKYQ5YAOApUtYEOonXSFdWvL1khvnZMTvov4UufkqlFsilPnejEXA==", + "requires": { + "extend-shallow": "2.0.1", + "js-yaml": "3.12.0", + "kind-of": "5.1.0", + "strip-bom-string": "1.0.0" + }, + "dependencies": { + "kind-of": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-5.1.0.tgz", + "integrity": "sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==" + } + } + }, + "grid-index": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/grid-index/-/grid-index-1.0.0.tgz", + "integrity": "sha1-rSxdVM5bNUN/r/HXCprrPR0mERA=" + }, + "has": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", + "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", + "requires": { + "function-bind": "1.1.1" + } + }, + "has-ansi": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-ansi/-/has-ansi-2.0.0.tgz", + "integrity": "sha1-NPUEnOHs3ysGSa8+8k5F7TVBbZE=", + "requires": { + "ansi-regex": "2.1.1" + } + }, + "has-color": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/has-color/-/has-color-0.1.7.tgz", + "integrity": "sha1-ZxRKUmDDT8PMpnfQQdr1L+e3iy8=" + }, + "has-flag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", + "integrity": "sha1-tdRU3CGZriJWmfNGfloH87lVuv0=" + }, + "has-hover": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has-hover/-/has-hover-1.0.1.tgz", + "integrity": "sha1-PZdDeusZnGK4rAisvcU9O8UsF/c=", + "requires": { + "is-browser": "2.0.1" + } + }, + "has-passive-events": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/has-passive-events/-/has-passive-events-1.0.0.tgz", + "integrity": "sha512-2vSj6IeIsgvsRMyeQ0JaCX5Q3lX4zMn5HpoVc7MEhQ6pv8Iq9rsXjsp+E5ZwaT7T0xhMT0KmU8gtt1EFVdbJiw==", + "requires": { + "is-browser": "2.0.1" + } + }, + "hash-base": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-2.0.2.tgz", + "integrity": "sha1-ZuodhW206KVHDK32/OI65SRO8uE=", + "dev": true, + "requires": { + "inherits": "2.0.3" + } + }, + "hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "dev": true, + "requires": { + "hash.js": "1.1.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "hosted-git-info": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-2.5.0.tgz", + "integrity": "sha512-pNgbURSuab90KbTqvRPsseaTxOJCZBD0a7t+haSN33piP9cCM4l0CqdzAif2hUqm716UovKB2ROmiabGAKVXyg==", + "dev": true + }, + "hsluv": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/hsluv/-/hsluv-0.0.3.tgz", + "integrity": "sha1-gpEH2vtKn4tSoYCe0C4JHq3mdUw=" + }, + "https-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-1.0.0.tgz", + "integrity": "sha1-7AbBDgo0wPL68Zn3/X/Hj//QPHM=", + "dev": true + }, + "iconv-lite": { + "version": "0.4.19", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.19.tgz", + "integrity": "sha512-oTZqweIP51xaGPI4uPa56/Pri/480R+mo7SeU+YETByQNhDG55ycFyNLIgta9vXhILrxXDmF7ZGhqZIcuN0gJQ==" + }, + "ieee754": { + "version": "1.1.8", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.8.tgz", + "integrity": "sha1-vjPUCsEO8ZJnAfbwii2G+/0a0+Q=" + }, + "ify-loader": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/ify-loader/-/ify-loader-1.1.0.tgz", + "integrity": "sha512-EiyC45FRIs+z4g98+jBzuYCfoM6TKG9p7Ek5YZUeM7rucNucaMZIseRj/5Q3I4ypkZXyC2wnU1RcYrVmshe2xw==", + "dev": true, + "requires": { + "bl": "1.2.1", + "findup": "0.1.5", + "from2-array": "0.0.4", + "map-limit": "0.0.1", + "multipipe": "0.3.1", + "read-package-json": "2.0.13", + "resolve": "1.4.0" + } + }, + "incremental-convex-hull": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/incremental-convex-hull/-/incremental-convex-hull-1.0.1.tgz", + "integrity": "sha1-UUKMFMudmmFEv+abKFH7N3M0vh4=", + "requires": { + "robust-orientation": "1.1.3", + "simplicial-complex": "1.0.0" + } + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=", + "dev": true + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "interpret": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/interpret/-/interpret-1.1.0.tgz", + "integrity": "sha1-ftGxQQxqDg94z5XTuEQMY/eLhhQ=", + "dev": true + }, + "interval-tree-1d": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/interval-tree-1d/-/interval-tree-1d-1.0.3.tgz", + "integrity": "sha1-j9veArayx9verWNry+2OCHENhcE=", + "requires": { + "binary-search-bounds": "1.0.0" + } + }, + "invert-kv": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/invert-kv/-/invert-kv-1.0.0.tgz", + "integrity": "sha1-EEqOSqym09jNFXqO+L+rLXo//bY=", + "dev": true + }, + "invert-permutation": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/invert-permutation/-/invert-permutation-1.0.0.tgz", + "integrity": "sha1-oKeAQurbNrwXVR54fv0UOa3VSTM=" + }, + "iota-array": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/iota-array/-/iota-array-1.0.0.tgz", + "integrity": "sha1-ge9X/l0FgUzVjCSDYyqZwwoOgIc=" + }, + "is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha1-d8mYQFJ6qOyxqLppe4BkWnqSap0=", + "dev": true + }, + "is-binary-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-binary-path/-/is-binary-path-1.0.1.tgz", + "integrity": "sha1-dfFmQrSA8YenEcgUFh/TpKdlWJg=", + "dev": true, + "requires": { + "binary-extensions": "1.11.0" + } + }, + "is-browser": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-browser/-/is-browser-2.0.1.tgz", + "integrity": "sha1-i/C695mpxi/Z3lvO5M8zl8PnUpo=" + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==" + }, + "is-builtin-module": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-builtin-module/-/is-builtin-module-1.0.0.tgz", + "integrity": "sha1-VAVy0096wxGfj3bDDLwbHgN6/74=", + "dev": true, + "requires": { + "builtin-modules": "1.1.1" + } + }, + "is-callable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz", + "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=" + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=" + }, + "is-dotfile": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/is-dotfile/-/is-dotfile-1.0.3.tgz", + "integrity": "sha1-pqLzL/0t+wT1yiXs0Pa4PPeYoeE=", + "dev": true + }, + "is-equal-shallow": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz", + "integrity": "sha1-IjgJj8Ih3gvPpdnqxMRdY4qhxTQ=", + "dev": true, + "requires": { + "is-primitive": "2.0.0" + } + }, + "is-extendable": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-extendable/-/is-extendable-0.1.1.tgz", + "integrity": "sha1-YrEQ4omkcUGOPsNqYX1HLjAd/Ik=" + }, + "is-extglob": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-extglob/-/is-extglob-1.0.0.tgz", + "integrity": "sha1-rEaBd8SUNAWgkvyPKXYMb/xiBsA=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz", + "integrity": "sha1-754xOG8DGn8NZDr4L95QxFfvAMs=", + "dev": true, + "requires": { + "number-is-nan": "1.0.1" + } + }, + "is-glob": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-2.0.1.tgz", + "integrity": "sha1-0Jb5JqPe1WAPP9/ZEZjLCIjC2GM=", + "dev": true, + "requires": { + "is-extglob": "1.0.0" + } + }, + "is-iexplorer": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-iexplorer/-/is-iexplorer-1.0.0.tgz", + "integrity": "sha1-HXK8ZtP+Iur2Fw3ajPEJQySM/HY=" + }, + "is-mobile": { + "version": "0.2.2", + "resolved": "https://registry.npmjs.org/is-mobile/-/is-mobile-0.2.2.tgz", + "integrity": "sha1-Di4AbZntLCFVt2HfgPKjYZrirZ8=" + }, + "is-number": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-2.1.0.tgz", + "integrity": "sha1-Afy7s5NGOlSPL0ZszhbezknbkI8=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + } + }, + "is-obj": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-obj/-/is-obj-1.0.1.tgz", + "integrity": "sha1-PkcprB9f3gJc19g6iW2rn09n2w8=" + }, + "is-plain-obj": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", + "integrity": "sha1-caUMhCnfync8kqOQpKA7OfzVHT4=" + }, + "is-posix-bracket": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz", + "integrity": "sha1-MzTceXdDaOkvAW5vvAqI9c1ua8Q=", + "dev": true + }, + "is-primitive": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-primitive/-/is-primitive-2.0.0.tgz", + "integrity": "sha1-IHurkWOEmcB7Kt8kCkGochADRXU=", + "dev": true + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "requires": { + "has": "1.0.3" + } + }, + "is-stream": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-1.1.0.tgz", + "integrity": "sha1-EtSj3U5o4Lec6428hBc66A2RykQ=" + }, + "is-svg-path": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/is-svg-path/-/is-svg-path-1.0.2.tgz", + "integrity": "sha1-d6tZDBKz0gNI5cehPQBAyHeE3aA=" + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=" + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=", + "dev": true + }, + "isobject": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/isobject/-/isobject-2.1.0.tgz", + "integrity": "sha1-8GVWEJaj8dou9GJy+BXIQNh+DIk=", + "dev": true, + "requires": { + "isarray": "1.0.0" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + } + } + }, + "jquery": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/jquery/-/jquery-3.3.1.tgz", + "integrity": "sha512-Ubldcmxp5np52/ENotGxlLe6aGMvmF4R8S6tZjsP6Knsaxd/xp3Zrh50cG93lR6nPXyUFwzN3ZSOQI0wRJNdGg==" + }, + "js-yaml": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.12.0.tgz", + "integrity": "sha512-PIt2cnwmPfL4hKNwqeiuz4bKfnzHTBv6HyVgjahA6mPLwPDzjDWrplJBMjHUFxku/N3FlmrbyPclad+I+4mJ3A==", + "requires": { + "argparse": "1.0.10", + "esprima": "4.0.0" + }, + "dependencies": { + "esprima": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz", + "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==" + } + } + }, + "json-loader": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/json-loader/-/json-loader-0.5.7.tgz", + "integrity": "sha512-QLPs8Dj7lnf3e3QYS1zkCo+4ZwqOiF9d/nZnYozTISxXWCfNs9yuky5rJw4/W34s7POaNlbZmQGaB5NiXCbP4w==", + "dev": true + }, + "json-parse-better-errors": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/json-parse-better-errors/-/json-parse-better-errors-1.0.2.tgz", + "integrity": "sha512-mrqyZKfX5EhL7hvqcV6WG1yYjnjeuYDzDhhcAAUrq8Po85NBQBJP+ZDUT75qZQ98IkUoBqdkExkukOU7Ts2wrw==", + "dev": true + }, + "json-parser": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/json-parser/-/json-parser-1.1.5.tgz", + "integrity": "sha1-5i7FJh0aal/CDoEqMgdAxtkAVnc=", + "requires": { + "esprima": "2.7.3" + } + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=" + }, + "json-stable-stringify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz", + "integrity": "sha1-mnWdOcXy/1A/1TAGRu1EX4jE+a8=", + "requires": { + "jsonify": "0.0.0" + } + }, + "json5": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/json5/-/json5-0.5.1.tgz", + "integrity": "sha1-Hq3nrMASA0rYTiOWdn6tn6VJWCE=", + "dev": true + }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=" + }, + "jsonlint-lines-primitives": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/jsonlint-lines-primitives/-/jsonlint-lines-primitives-1.6.0.tgz", + "integrity": "sha1-u4n2DIubYS/ZE92qI2ZJuEDYZhE=", + "requires": { + "JSV": "4.0.2", + "nomnom": "1.8.1" + } + }, + "kdbush": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/kdbush/-/kdbush-1.0.1.tgz", + "integrity": "sha1-PL0D6d6tnA9vZszblkUOXOzGQOA=" + }, + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "requires": { + "is-buffer": "1.1.6" + } + }, + "lazy-cache": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/lazy-cache/-/lazy-cache-1.0.4.tgz", + "integrity": "sha1-odePw6UEdMuAhF07O24dpJpEbo4=" + }, + "lcid": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/lcid/-/lcid-1.0.0.tgz", + "integrity": "sha1-MIrMr6C8SDo4Z7S28rlQYlHRuDU=", + "dev": true, + "requires": { + "invert-kv": "1.0.0" + } + }, + "left-pad": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz", + "integrity": "sha512-XI5MPzVNApjAyhQzphX8BkmKsKUxD4LdyK24iZeQGinBN9yTQT3bFlCBy/aVx2HrNcqQGsdot8ghrjyrvMCoEA==" + }, + "lerp": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/lerp/-/lerp-1.0.3.tgz", + "integrity": "sha1-oYyJaPkXiW3hXM/MKNVaa3Med24=" + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "requires": { + "prelude-ls": "1.1.2", + "type-check": "0.3.2" + } + }, + "load-json-file": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/load-json-file/-/load-json-file-2.0.0.tgz", + "integrity": "sha1-eUfkIUmvgNaWy/eXvKq8/h/inKg=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "parse-json": "2.2.0", + "pify": "2.3.0", + "strip-bom": "3.0.0" + } + }, + "loader-runner": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/loader-runner/-/loader-runner-2.3.0.tgz", + "integrity": "sha1-9IKuqC1UPgeSFwDVpG7yb9rGuKI=", + "dev": true + }, + "loader-utils": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/loader-utils/-/loader-utils-1.1.0.tgz", + "integrity": "sha1-yYrvSIvM7aL/teLeZG1qdUQp9c0=", + "dev": true, + "requires": { + "big.js": "3.2.0", + "emojis-list": "2.1.0", + "json5": "0.5.1" + } + }, + "locate-path": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", + "integrity": "sha1-K1aLJl7slExtnA3pw9u7ygNUzY4=", + "dev": true, + "requires": { + "p-locate": "2.0.0", + "path-exists": "3.0.0" + } + }, + "lodash": { + "version": "4.17.5", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.5.tgz", + "integrity": "sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==" + }, + "longest": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/longest/-/longest-1.0.1.tgz", + "integrity": "sha1-MKCy2jj3N3DoKUoNIuZiXtd9AJc=" + }, + "lru-cache": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-4.1.1.tgz", + "integrity": "sha512-q4spe4KTfsAS1SUHLO0wz8Qiyf1+vMIAgpRYioFYDMNqKfHQbg+AVDH3i4fvpl71/P1L0dBl+fQi+P37UYf0ew==", + "dev": true, + "requires": { + "pseudomap": "1.0.2", + "yallist": "2.1.2" + } + }, + "magic-string": { + "version": "0.22.5", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.22.5.tgz", + "integrity": "sha512-oreip9rJZkzvA8Qzk9HFs8fZGF/u7H/gtrE8EN6RjKJ9kh2HlC+yQ2QezifqTZfGyiuAV0dRv5a+y/8gBb1m9w==", + "requires": { + "vlq": "0.2.3" + } + }, + "map-limit": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/map-limit/-/map-limit-0.0.1.tgz", + "integrity": "sha1-63lhAxwPDo0AG/LVb6toXViCLzg=", + "requires": { + "once": "1.3.3" + }, + "dependencies": { + "once": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/once/-/once-1.3.3.tgz", + "integrity": "sha1-suJhVXzkwxTsgwTz+oJmPkKXyiA=", + "requires": { + "wrappy": "1.0.2" + } + } + } + }, + "mapbox-gl": { + "version": "0.44.1", + "resolved": "https://registry.npmjs.org/mapbox-gl/-/mapbox-gl-0.44.1.tgz", + "integrity": "sha512-K6GfXfvumPgiw3NSFGTPYU7VinhWLKFbRmNTx/mPWzxzazfKZsChuyZ9IEhZ6LuFEnV1qzquyg5kLUCledVzvg==", + "requires": { + "@mapbox/gl-matrix": "0.0.1", + "@mapbox/mapbox-gl-supported": "1.4.0", + "@mapbox/point-geometry": "0.1.0", + "@mapbox/shelf-pack": "3.1.0", + "@mapbox/tiny-sdf": "1.1.0", + "@mapbox/unitbezier": "0.0.0", + "@mapbox/vector-tile": "1.3.1", + "@mapbox/whoots-js": "3.0.0", + "brfs": "1.6.1", + "bubleify": "0.7.0", + "csscolorparser": "1.0.3", + "earcut": "2.1.3", + "geojson-rewind": "0.3.1", + "geojson-vt": "3.1.3", + "gray-matter": "3.1.1", + "grid-index": "1.0.0", + "jsonlint-lines-primitives": "1.6.0", + "minimist": "0.0.8", + "package-json-versionify": "1.0.4", + "pbf": "3.1.0", + "quickselect": "1.1.1", + "rw": "1.3.3", + "shuffle-seed": "1.1.6", + "sort-object": "0.3.2", + "supercluster": "2.3.0", + "through2": "2.0.3", + "tinyqueue": "1.2.3", + "unassertify": "2.1.1", + "unflowify": "1.0.1", + "vt-pbf": "3.1.1", + "webworkify": "1.5.0" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "2.3.6", + "xtend": "4.0.1" + } + } + } + }, + "marching-simplex-table": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/marching-simplex-table/-/marching-simplex-table-1.0.0.tgz", + "integrity": "sha1-vBYlbg+Pm1WKqbKHL4gy2UM/Uuo=", + "requires": { + "convex-hull": "1.0.3" + } + }, + "mat4-decompose": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mat4-decompose/-/mat4-decompose-1.0.4.tgz", + "integrity": "sha1-ZetP451wh496RE60Yk1S9+frL68=", + "requires": { + "gl-mat4": "1.2.0", + "gl-vec3": "1.1.3" + } + }, + "mat4-interpolate": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mat4-interpolate/-/mat4-interpolate-1.0.4.tgz", + "integrity": "sha1-Vf/p6zw1KV4sDVqfdyXZBoqJ/3Q=", + "requires": { + "gl-mat4": "1.2.0", + "gl-vec3": "1.1.3", + "mat4-decompose": "1.0.4", + "mat4-recompose": "1.0.4", + "quat-slerp": "1.0.1" + } + }, + "mat4-recompose": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/mat4-recompose/-/mat4-recompose-1.0.4.tgz", + "integrity": "sha1-OVPCMP8kc9x3LuAUpSySXPgbDk0=", + "requires": { + "gl-mat4": "1.2.0" + } + }, + "math-log2": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/math-log2/-/math-log2-1.0.1.tgz", + "integrity": "sha1-+4lBvl9evol55xjmJzsXjlhpRWU=" + }, + "matrix-camera-controller": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/matrix-camera-controller/-/matrix-camera-controller-2.1.3.tgz", + "integrity": "sha1-NeUmDMHNVQliunmfLY1OlLGjk3A=", + "requires": { + "binary-search-bounds": "1.0.0", + "gl-mat4": "1.2.0", + "gl-vec3": "1.1.3", + "mat4-interpolate": "1.0.4" + } + }, + "md5.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz", + "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", + "dev": true, + "requires": { + "hash-base": "3.0.4", + "inherits": "2.0.3" + }, + "dependencies": { + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + } + } + }, + "mem": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/mem/-/mem-1.1.0.tgz", + "integrity": "sha1-Xt1StIXKHZAP5kiVUFOZoN+kX3Y=", + "dev": true, + "requires": { + "mimic-fn": "1.2.0" + } + }, + "memory-fs": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/memory-fs/-/memory-fs-0.4.1.tgz", + "integrity": "sha1-OpoguEYlI+RHz7x+i7gO1me/xVI=", + "dev": true, + "requires": { + "errno": "0.1.7", + "readable-stream": "2.3.4" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "merge-source-map": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/merge-source-map/-/merge-source-map-1.0.4.tgz", + "integrity": "sha1-pd5GU42uhNQRTMXqArR3KmNGcB8=", + "requires": { + "source-map": "0.5.7" + } + }, + "micromatch": { + "version": "2.3.11", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-2.3.11.tgz", + "integrity": "sha1-hmd8l9FyCzY0MdBNDRUpO9OMFWU=", + "dev": true, + "requires": { + "arr-diff": "2.0.0", + "array-unique": "0.2.1", + "braces": "1.8.5", + "expand-brackets": "0.1.5", + "extglob": "0.3.2", + "filename-regex": "2.0.1", + "is-extglob": "1.0.0", + "is-glob": "2.0.1", + "kind-of": "3.2.2", + "normalize-path": "2.1.1", + "object.omit": "2.0.1", + "parse-glob": "3.0.4", + "regex-cache": "0.4.4" + } + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0" + } + }, + "mimic-fn": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-1.2.0.tgz", + "integrity": "sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==", + "dev": true + }, + "minimalistic-assert": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.0.tgz", + "integrity": "sha1-cCvi3aazf0g2vLP121ZkG2Sh09M=", + "dev": true + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=", + "dev": true + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + }, + "mkdirp": { + "version": "0.5.1", + "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.1.tgz", + "integrity": "sha1-MAV0OOrGz3+MR2fzhkjWaX11yQM=", + "dev": true, + "requires": { + "minimist": "0.0.8" + }, + "dependencies": { + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=", + "dev": true + } + } + }, + "moment": { + "version": "2.17.1", + "resolved": "https://registry.npmjs.org/moment/-/moment-2.17.1.tgz", + "integrity": "sha1-/tlQYGPzaxDwZsi1mhRNf66+HYI=" + }, + "monotone-convex-hull-2d": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/monotone-convex-hull-2d/-/monotone-convex-hull-2d-1.0.1.tgz", + "integrity": "sha1-R/Xa6t88Sv03dkuqGqh4ekDu4Iw=", + "requires": { + "robust-orientation": "1.1.3" + } + }, + "mouse-change": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/mouse-change/-/mouse-change-1.4.0.tgz", + "integrity": "sha1-wrd+W/o0pDzhRFyBV6Tk3JiVwU8=", + "requires": { + "mouse-event": "1.0.5" + } + }, + "mouse-event": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/mouse-event/-/mouse-event-1.0.5.tgz", + "integrity": "sha1-s3ie23EJmX1aky0dAdqhVDpQFzI=" + }, + "mouse-event-offset": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/mouse-event-offset/-/mouse-event-offset-3.0.2.tgz", + "integrity": "sha1-39hqbiSMa6jK1TuQXVA3ogY+mYQ=" + }, + "mouse-wheel": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/mouse-wheel/-/mouse-wheel-1.2.0.tgz", + "integrity": "sha1-bSkDseqPtI5h8bU7kDZ3PwQs21w=", + "requires": { + "right-now": "1.0.0", + "signum": "1.0.0", + "to-px": "1.0.1" + }, + "dependencies": { + "signum": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/signum/-/signum-1.0.0.tgz", + "integrity": "sha1-dKfSvyogtA66FqkrFSEk8dVZ+nc=" + } + } + }, + "multi-stage-sourcemap": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/multi-stage-sourcemap/-/multi-stage-sourcemap-0.2.1.tgz", + "integrity": "sha1-sJ/IWG6qF/gdV1xK0C4Pej9rEQU=", + "requires": { + "source-map": "0.1.43" + }, + "dependencies": { + "source-map": { + "version": "0.1.43", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz", + "integrity": "sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=", + "requires": { + "amdefine": "1.0.1" + } + } + } + }, + "multipipe": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/multipipe/-/multipipe-0.3.1.tgz", + "integrity": "sha1-kmJVJXYboE/qoJYFtjgrziyR8R8=", + "dev": true, + "requires": { + "duplexer2": "0.1.4" + }, + "dependencies": { + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "dev": true, + "requires": { + "readable-stream": "2.3.6" + } + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.6.tgz", + "integrity": "sha512-tQtKA9WIAhBF3+VLAseyMqZeBjW0AHJoxOtYqSUZNJxauErmLbVm2FW1y+J/YA9dUrAC39ITejlZWhVIwawkKw==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.1.1", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz", + "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "mumath": { + "version": "3.3.4", + "resolved": "https://registry.npmjs.org/mumath/-/mumath-3.3.4.tgz", + "integrity": "sha1-SNSg8P2MrU57Mglu6JsWGmPTC78=", + "requires": { + "almost-equal": "1.1.0" + } + }, + "murmurhash-js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/murmurhash-js/-/murmurhash-js-1.0.0.tgz", + "integrity": "sha1-sGJ44h/Gw3+lMTcysEEry2rhX1E=" + }, + "nan": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/nan/-/nan-2.8.0.tgz", + "integrity": "sha1-7XFfP+neArV6XmJS2QqWZ14fCFo=", + "dev": true, + "optional": true + }, + "ndarray": { + "version": "1.0.18", + "resolved": "https://registry.npmjs.org/ndarray/-/ndarray-1.0.18.tgz", + "integrity": "sha1-tg06cyJOxVXQ+qeXEeUCRI/T95M=", + "requires": { + "iota-array": "1.0.0", + "is-buffer": "1.1.6" + } + }, + "ndarray-extract-contour": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ndarray-extract-contour/-/ndarray-extract-contour-1.0.1.tgz", + "integrity": "sha1-Cu4ROjozsia5DEiIz4d79HUTBeQ=", + "requires": { + "typedarray-pool": "1.1.0" + } + }, + "ndarray-fill": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/ndarray-fill/-/ndarray-fill-1.0.2.tgz", + "integrity": "sha1-owpg9xiODJWC/N1YiWrNy1IqHtY=", + "requires": { + "cwise": "1.0.10" + } + }, + "ndarray-gradient": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/ndarray-gradient/-/ndarray-gradient-1.0.0.tgz", + "integrity": "sha1-t0kaUVxqZJ8ZpiMk//byf8jCU5M=", + "requires": { + "cwise-compiler": "1.1.3", + "dup": "1.0.0" + } + }, + "ndarray-homography": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/ndarray-homography/-/ndarray-homography-1.0.0.tgz", + "integrity": "sha1-w1UW6oa8KGK06ASiNqJwcwn+KWs=", + "requires": { + "gl-matrix-invert": "1.0.0", + "ndarray-warp": "1.0.1" + } + }, + "ndarray-linear-interpolate": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/ndarray-linear-interpolate/-/ndarray-linear-interpolate-1.0.0.tgz", + "integrity": "sha1-eLySuFuavBW25n7mWCj54hN65ys=" + }, + "ndarray-ops": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/ndarray-ops/-/ndarray-ops-1.2.2.tgz", + "integrity": "sha1-WeiNLDKn7ryxvGkPrhQVeVV6YU4=", + "requires": { + "cwise-compiler": "1.1.3" + } + }, + "ndarray-pack": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ndarray-pack/-/ndarray-pack-1.2.1.tgz", + "integrity": "sha1-jK6+qqJNXs9w/4YCBjeXfajuWFo=", + "requires": { + "cwise-compiler": "1.1.3", + "ndarray": "1.0.18" + } + }, + "ndarray-scratch": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/ndarray-scratch/-/ndarray-scratch-1.2.0.tgz", + "integrity": "sha1-YwRjbWLrqT20cnrBPGkzQdulDgE=", + "requires": { + "ndarray": "1.0.18", + "ndarray-ops": "1.2.2", + "typedarray-pool": "1.1.0" + } + }, + "ndarray-sort": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ndarray-sort/-/ndarray-sort-1.0.1.tgz", + "integrity": "sha1-/qBbTLg0x/TgIWo1TzynUTAN/Wo=", + "requires": { + "typedarray-pool": "1.1.0" + } + }, + "ndarray-warp": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/ndarray-warp/-/ndarray-warp-1.0.1.tgz", + "integrity": "sha1-qKElqqu6C+v5O9bKg+ar1oIqNOA=", + "requires": { + "cwise": "1.0.10", + "ndarray-linear-interpolate": "1.0.0" + } + }, + "nextafter": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/nextafter/-/nextafter-1.0.0.tgz", + "integrity": "sha1-t9d7U1MQ4+CX5gJauwqQNHfsGjo=", + "requires": { + "double-bits": "1.1.1" + } + }, + "node-fetch": { + "version": "1.7.3", + "resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-1.7.3.tgz", + "integrity": "sha512-NhZ4CsKx7cYm2vSrBAr2PvFOe6sWDf0UYLRqA6svUYg7+/TSfVAu49jYC4BvQ4Sms9SZgdqGBgroqfDhJdTyKQ==", + "requires": { + "encoding": "0.1.12", + "is-stream": "1.1.0" + } + }, + "node-libs-browser": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/node-libs-browser/-/node-libs-browser-2.1.0.tgz", + "integrity": "sha512-5AzFzdoIMb89hBGMZglEegffzgRg+ZFoUmisQ8HI4j1KDdpx13J0taNp2y9xPbur6W61gepGDDotGBVQ7mfUCg==", + "dev": true, + "requires": { + "assert": "1.4.1", + "browserify-zlib": "0.2.0", + "buffer": "4.9.1", + "console-browserify": "1.1.0", + "constants-browserify": "1.0.0", + "crypto-browserify": "3.12.0", + "domain-browser": "1.2.0", + "events": "1.1.1", + "https-browserify": "1.0.0", + "os-browserify": "0.3.0", + "path-browserify": "0.0.0", + "process": "0.11.10", + "punycode": "1.4.1", + "querystring-es3": "0.2.1", + "readable-stream": "2.3.4", + "stream-browserify": "2.0.1", + "stream-http": "2.8.0", + "string_decoder": "1.0.3", + "timers-browserify": "2.0.6", + "tty-browserify": "0.0.0", + "url": "0.11.0", + "util": "0.10.3", + "vm-browserify": "0.0.4" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "nomnom": { + "version": "1.8.1", + "resolved": "https://registry.npmjs.org/nomnom/-/nomnom-1.8.1.tgz", + "integrity": "sha1-IVH3Ikcrp55Qp2/BJbuMjy5Nwqc=", + "requires": { + "chalk": "0.4.0", + "underscore": "1.6.0" + }, + "dependencies": { + "ansi-styles": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-1.0.0.tgz", + "integrity": "sha1-yxAt8cVvUSPquLZ817mAJ6AnkXg=" + }, + "chalk": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-0.4.0.tgz", + "integrity": "sha1-UZmj3c0MHv4jvAjBsCewYXbgxk8=", + "requires": { + "ansi-styles": "1.0.0", + "has-color": "0.1.7", + "strip-ansi": "0.1.1" + } + }, + "strip-ansi": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-0.1.1.tgz", + "integrity": "sha1-OeipjQRNFQZgq+SmgIrPcLt7yZE=" + }, + "underscore": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.6.0.tgz", + "integrity": "sha1-izixDKze9jM3uLJOT/htRa6lKag=" + } + } + }, + "normalize-package-data": { + "version": "2.4.0", + "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-2.4.0.tgz", + "integrity": "sha512-9jjUFbTPfEy3R/ad/2oNbKtW9Hgovl5O1FvFWKkKblNXoN/Oou6+9+KKohPK13Yc3/TyunyWhJp6gvRNR/PPAw==", + "dev": true, + "requires": { + "hosted-git-info": "2.5.0", + "is-builtin-module": "1.0.0", + "semver": "5.5.0", + "validate-npm-package-license": "3.0.1" + } + }, + "normalize-path": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-2.1.1.tgz", + "integrity": "sha1-GrKLVW4Zg2Oowab35vogE3/mrtk=", + "dev": true, + "requires": { + "remove-trailing-separator": "1.1.0" + } + }, + "normalize-svg-path": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/normalize-svg-path/-/normalize-svg-path-0.1.0.tgz", + "integrity": "sha1-RWNg5g7Odfvve11+FgSA5//Rb+U=" + }, + "normals": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/normals/-/normals-1.1.0.tgz", + "integrity": "sha1-MltZXtNK/kZ6bFWhT9kIV4f/WcA=" + }, + "npm-run-path": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-2.0.2.tgz", + "integrity": "sha1-NakjLfo11wZ7TLLd8jV7GHFTbF8=", + "dev": true, + "requires": { + "path-key": "2.0.1" + } + }, + "number-is-nan": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/number-is-nan/-/number-is-nan-1.0.1.tgz", + "integrity": "sha1-CXtgK1NCKlIsGvuHkDGDNpQaAR0=", + "dev": true + }, + "numeric": { + "version": "1.2.6", + "resolved": "https://registry.npmjs.org/numeric/-/numeric-1.2.6.tgz", + "integrity": "sha1-dlsCvvl5iPz4gNTrPza4D6MTNao=" + }, + "object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha1-IQmtx5ZYh8/AXLvUQsrIv7s2CGM=" + }, + "object-inspect": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.6.0.tgz", + "integrity": "sha512-GJzfBZ6DgDAmnuaM3104jR4s1Myxr3Y3zfIyN4z3UdqN69oSRacNK8UhnobDdC+7J2AHCjGwxQubNJfE70SXXQ==" + }, + "object-keys": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.12.tgz", + "integrity": "sha512-FTMyFUm2wBcGHnH2eXmz7tC6IwlqQZ6mVZ+6dm6vZ4IQIHjs6FdNsQBuKGPuUUUY6NfJw2PshC08Tn6LzLDOag==" + }, + "object.omit": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/object.omit/-/object.omit-2.0.1.tgz", + "integrity": "sha1-Gpx0SCnznbuFjHbKNXmuKlTr0fo=", + "dev": true, + "requires": { + "for-own": "0.1.5", + "is-extendable": "0.1.1" + } + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } + }, + "optical-properties": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/optical-properties/-/optical-properties-1.0.0.tgz", + "integrity": "sha512-XnBQYbIIzDVr7U3L7d3xyAEqp1W+HTkqmw/G4L/Ae/+dq57bT1jqW2uDwV0wCUzO8gsTDIZhGQsGrMb17VSkEA==" + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "requires": { + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" + } + }, + "options": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz", + "integrity": "sha1-7CLTEoBrtT5zF3Pnza788cZDEo8=" + }, + "orbit-camera-controller": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/orbit-camera-controller/-/orbit-camera-controller-4.0.0.tgz", + "integrity": "sha1-bis28OeHhmPDMPUNqbfOaGwncAU=", + "requires": { + "filtered-vector": "1.2.4", + "gl-mat4": "1.2.0" + } + }, + "os-browserify": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.3.0.tgz", + "integrity": "sha1-hUNzx/XCMVkU/Jv8a9gjj92h7Cc=", + "dev": true + }, + "os-homedir": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/os-homedir/-/os-homedir-1.0.2.tgz", + "integrity": "sha1-/7xJiDNuDoM94MFox+8VISGqf7M=" + }, + "os-locale": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/os-locale/-/os-locale-2.1.0.tgz", + "integrity": "sha512-3sslG3zJbEYcaC4YVAvDorjGxc7tv6KVATnLPZONiljsUncvihe9BQoVCEs0RZ1kmf4Hk9OBqlZfJZWI4GanKA==", + "dev": true, + "requires": { + "execa": "0.7.0", + "lcid": "1.0.0", + "mem": "1.1.0" + } + }, + "p-finally": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-finally/-/p-finally-1.0.0.tgz", + "integrity": "sha1-P7z7FbiZpEEjs0ttzBi3JDNqLK4=", + "dev": true + }, + "p-limit": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.2.0.tgz", + "integrity": "sha512-Y/OtIaXtUPr4/YpMv1pCL5L5ed0rumAaAeBSj12F+bSlMdys7i8oQF/GUJmfpTS/QoaRrS/k6pma29haJpsMng==", + "dev": true, + "requires": { + "p-try": "1.0.0" + } + }, + "p-locate": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz", + "integrity": "sha1-IKAQOyIqcMj9OcwuWAaA893l7EM=", + "dev": true, + "requires": { + "p-limit": "1.2.0" + } + }, + "p-try": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz", + "integrity": "sha1-y8ec26+P1CKOE/Yh8rGiN8GyB7M=", + "dev": true + }, + "package-json-versionify": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/package-json-versionify/-/package-json-versionify-1.0.4.tgz", + "integrity": "sha1-WGBYepRIc6a35tJujlH/siMVvxc=", + "requires": { + "browserify-package-json": "1.0.1" + } + }, + "pad-left": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pad-left/-/pad-left-1.0.2.tgz", + "integrity": "sha1-GeVzXqmDlaJs7carkm6tEPMQDUw=", + "requires": { + "repeat-string": "1.6.1" + } + }, + "pako": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.6.tgz", + "integrity": "sha512-lQe48YPsMJAig+yngZ87Lus+NF+3mtu7DVOBu6b/gHO1YpKwIj5AWjZ/TOS7i46HD/UixzWb1zeWDZfGZ3iYcg==", + "dev": true + }, + "parse-asn1": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.0.tgz", + "integrity": "sha1-N8T5t+06tlx0gXtfJICTf7+XxxI=", + "dev": true, + "requires": { + "asn1.js": "4.10.1", + "browserify-aes": "1.1.1", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "pbkdf2": "3.0.14" + } + }, + "parse-glob": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/parse-glob/-/parse-glob-3.0.4.tgz", + "integrity": "sha1-ssN2z7EfNVE7rdFz7wu246OIORw=", + "dev": true, + "requires": { + "glob-base": "0.3.0", + "is-dotfile": "1.0.3", + "is-extglob": "1.0.0", + "is-glob": "2.0.1" + } + }, + "parse-json": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-2.2.0.tgz", + "integrity": "sha1-9ID0BDTvgHQfhGkJn43qGPVaTck=", + "dev": true, + "requires": { + "error-ex": "1.3.1" + } + }, + "parse-rect": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/parse-rect/-/parse-rect-1.2.0.tgz", + "integrity": "sha512-4QZ6KYbnE6RTwg9E0HpLchUM9EZt6DnDxajFZZDSV4p/12ZJEvPO702DZpGvRYEPo00yKDys7jASi+/w7aO8LA==", + "requires": { + "pick-by-alias": "1.2.0" + } + }, + "parse-svg-path": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/parse-svg-path/-/parse-svg-path-0.1.2.tgz", + "integrity": "sha1-en7A0esG+lMlx9PgCbhZoJtdSes=" + }, + "parse-unit": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parse-unit/-/parse-unit-1.0.1.tgz", + "integrity": "sha1-fhu21b7zh0wo45JSaiVBFwKR7s8=" + }, + "path-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", + "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=", + "dev": true + }, + "path-exists": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz", + "integrity": "sha1-zg6+ql94yxiSXqfYENe1mwEP1RU=", + "dev": true + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-key": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-2.0.1.tgz", + "integrity": "sha1-QRyttXTFoUDTpLGRDUDYDMn0C0A=", + "dev": true + }, + "path-parse": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", + "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=" + }, + "path-posix": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/path-posix/-/path-posix-1.0.0.tgz", + "integrity": "sha1-BrJhE/Vr6rBCVFojv6iAA8ysJg8=" + }, + "path-type": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-2.0.0.tgz", + "integrity": "sha1-8BLMuEFbcJb8LaoQVMPXI4lZTHM=", + "dev": true, + "requires": { + "pify": "2.3.0" + } + }, + "pbf": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/pbf/-/pbf-3.1.0.tgz", + "integrity": "sha512-/hYJmIsTmh7fMkHAWWXJ5b8IKLWdjdlAFb3IHkRBn1XUhIYBChVGfVwmHEAV3UfXTxsP/AKfYTXTS/dCPxJd5w==", + "requires": { + "ieee754": "1.1.8", + "resolve-protobuf-schema": "2.0.0" + } + }, + "pbkdf2": { + "version": "3.0.14", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.14.tgz", + "integrity": "sha512-gjsZW9O34fm0R7PaLHRJmLLVfSoesxztjPjE9o6R+qtVJij90ltg1joIovN9GKrRW3t1PzhDDG3UMEMFfZ+1wA==", + "dev": true, + "requires": { + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.10" + } + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=" + }, + "permutation-parity": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/permutation-parity/-/permutation-parity-1.0.0.tgz", + "integrity": "sha1-AXTVH8pwSxG5pLFSsj1Tf9xrXvQ=", + "requires": { + "typedarray-pool": "1.1.0" + } + }, + "permutation-rank": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/permutation-rank/-/permutation-rank-1.0.0.tgz", + "integrity": "sha1-n9mLvOzwj79ZlLXq3JSmLmeUg7U=", + "requires": { + "invert-permutation": "1.0.0", + "typedarray-pool": "1.1.0" + } + }, + "pick-by-alias": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/pick-by-alias/-/pick-by-alias-1.2.0.tgz", + "integrity": "sha1-X3yysfIabh6ISgyHhVqko3NhEHs=" + }, + "pify": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/pify/-/pify-2.3.0.tgz", + "integrity": "sha1-7RQaasBDqEnqWISY59yosVMw6Qw=", + "dev": true + }, + "planar-dual": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/planar-dual/-/planar-dual-1.0.2.tgz", + "integrity": "sha1-tqQjVSOxsMt55fkm+OozXdmC1WM=", + "requires": { + "compare-angle": "1.0.1", + "dup": "1.0.0" + } + }, + "planar-graph-to-polyline": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/planar-graph-to-polyline/-/planar-graph-to-polyline-1.0.5.tgz", + "integrity": "sha1-iCuGBRmbqIv9RkyVUzA1VsUrmIo=", + "requires": { + "edges-to-adjacency-list": "1.0.0", + "planar-dual": "1.0.2", + "point-in-big-polygon": "2.0.0", + "robust-orientation": "1.1.3", + "robust-sum": "1.0.0", + "two-product": "1.0.2", + "uniq": "1.0.1" + } + }, + "plotly.js": { + "version": "1.38.3", + "resolved": "https://registry.npmjs.org/plotly.js/-/plotly.js-1.38.3.tgz", + "integrity": "sha512-urmbPnsFdG0Cl6aoGI4I+5YCOxaK31X4pVx0Rla0nGeRUqvPf/IoqsPU/FHxovnLdwO2L7pZMzJ+Yh2PX+AArA==", + "requires": { + "3d-view": "2.0.0", + "@plotly/d3-sankey": "0.5.0", + "alpha-shape": "1.0.0", + "array-range": "1.0.1", + "canvas-fit": "1.5.0", + "color-normalize": "1.1.0", + "color-rgba": "2.1.0", + "convex-hull": "1.0.3", + "country-regex": "1.1.0", + "d3": "3.5.17", + "d3-force": "1.1.0", + "delaunay-triangulate": "1.1.6", + "es6-promise": "3.3.1", + "fast-isnumeric": "1.1.1", + "font-atlas-sdf": "1.3.3", + "gl-cone3d": "1.1.0", + "gl-contour2d": "1.1.4", + "gl-error3d": "1.0.7", + "gl-heatmap2d": "1.0.4", + "gl-line3d": "1.1.2", + "gl-mat4": "1.2.0", + "gl-mesh3d": "2.0.0", + "gl-plot2d": "1.3.1", + "gl-plot3d": "1.5.5", + "gl-pointcloud2d": "1.0.1", + "gl-scatter3d": "1.0.11", + "gl-select-box": "1.0.2", + "gl-spikes2d": "1.0.1", + "gl-surface3d": "1.3.5", + "glslify": "6.1.1", + "has-hover": "1.0.1", + "has-passive-events": "1.0.0", + "mapbox-gl": "0.44.1", + "matrix-camera-controller": "2.1.3", + "mouse-change": "1.4.0", + "mouse-event-offset": "3.0.2", + "mouse-wheel": "1.2.0", + "ndarray": "1.0.18", + "ndarray-fill": "1.0.2", + "ndarray-homography": "1.0.0", + "ndarray-ops": "1.2.2", + "point-cluster": "3.1.4", + "polybooljs": "1.2.0", + "regl": "1.3.7", + "regl-error2d": "2.0.5", + "regl-line2d": "3.0.9", + "regl-scatter2d": "3.0.4", + "regl-splom": "1.0.3", + "right-now": "1.0.0", + "robust-orientation": "1.1.3", + "sane-topojson": "2.0.0", + "strongly-connected-components": "1.0.1", + "superscript-text": "1.0.0", + "svg-path-sdf": "1.1.1", + "tinycolor2": "1.4.1", + "topojson-client": "2.1.0", + "webgl-context": "2.2.0", + "world-calendars": "1.0.3" + } + }, + "point-cluster": { + "version": "3.1.4", + "resolved": "https://registry.npmjs.org/point-cluster/-/point-cluster-3.1.4.tgz", + "integrity": "sha512-jVjzC1vYoZlvcLWi170i41he5LhJTncOgFPaZx1uoqNn+8q+24xjLS9yG68XfN6/U1F52kliD6a3oXjJduerTQ==", + "requires": { + "array-bounds": "1.0.1", + "array-normalize": "1.1.3", + "binary-search-bounds": "2.0.4", + "bubleify": "1.2.0", + "clamp": "1.0.1", + "dtype": "2.0.0", + "flatten-vertex-data": "1.0.2", + "is-obj": "1.0.1", + "math-log2": "1.0.1", + "parse-rect": "1.2.0" + }, + "dependencies": { + "acorn-dynamic-import": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz", + "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", + "requires": { + "acorn": "5.4.1" + } + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "requires": { + "acorn": "5.4.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "1.9.2" + } + }, + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + }, + "buble": { + "version": "0.19.3", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.19.3.tgz", + "integrity": "sha512-3B0Lcy2u6x6km0BqTz/FS3UnrOJlnIlBWsyjvtqzdtmWkqiS0+Sg4hc6L9Mmm63hZKTACpYS9vUeIoKSi1vcrQ==", + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "3.0.0", + "acorn-jsx": "4.1.1", + "chalk": "2.4.1", + "magic-string": "0.22.5", + "minimist": "1.2.0", + "os-homedir": "1.0.2", + "vlq": "1.0.0" + } + }, + "bubleify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-1.2.0.tgz", + "integrity": "sha512-SJnUsR+f8WeDw0K2l1S+VuYI33Cu5Gfghe5jTow/fpJueNtnwyoECyfCGsDuFoQt4QGhjpV3LYPpN0hxy90LgA==", + "requires": { + "buble": "0.19.3" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "3.0.0" + } + }, + "vlq": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-1.0.0.tgz", + "integrity": "sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==" + } + } + }, + "point-in-big-polygon": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/point-in-big-polygon/-/point-in-big-polygon-2.0.0.tgz", + "integrity": "sha1-ObYT6mzxfWtD4Yj3fzTETGszulU=", + "requires": { + "binary-search-bounds": "1.0.0", + "interval-tree-1d": "1.0.3", + "robust-orientation": "1.1.3", + "slab-decomposition": "1.0.2" + } + }, + "polybooljs": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/polybooljs/-/polybooljs-1.2.0.tgz", + "integrity": "sha1-tDkMLgedTCYtOyUExiiNlbp6R1g=" + }, + "polytope-closest-point": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/polytope-closest-point/-/polytope-closest-point-1.0.0.tgz", + "integrity": "sha1-5uV/QIGrXox3i4Ee8G4sSK4zjD8=", + "requires": { + "numeric": "1.2.6" + } + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=" + }, + "preserve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/preserve/-/preserve-0.2.0.tgz", + "integrity": "sha1-gV7R9uvGWSb4ZbMQwHE7yzMVzks=", + "dev": true + }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=", + "dev": true + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + }, + "protocol-buffers-schema": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/protocol-buffers-schema/-/protocol-buffers-schema-2.2.0.tgz", + "integrity": "sha1-0pxs1z+2VZePtpiWkRgNuEQRn2E=" + }, + "prr": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/prr/-/prr-1.0.1.tgz", + "integrity": "sha1-0/wRS6BplaRexok/SEzrHXj19HY=", + "dev": true + }, + "pseudomap": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/pseudomap/-/pseudomap-1.0.2.tgz", + "integrity": "sha1-8FKijacOYYkX7wqKw0wa5aaChrM=", + "dev": true + }, + "public-encrypt": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.0.tgz", + "integrity": "sha1-OfaZ86RlYN1eusvKaTyvfGXBjMY=", + "dev": true, + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "parse-asn1": "5.1.0", + "randombytes": "2.0.6" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=", + "dev": true + }, + "quat-slerp": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/quat-slerp/-/quat-slerp-1.0.1.tgz", + "integrity": "sha1-K6oVzjprvcMkHZcusXKDE57Wnyk=", + "requires": { + "gl-quat": "1.0.0" + } + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=", + "dev": true + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=", + "dev": true + }, + "querystringify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-1.0.0.tgz", + "integrity": "sha1-YoYkIRLFtxL6ZU5SZlK/ahP/Bcs=" + }, + "quickselect": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/quickselect/-/quickselect-1.1.1.tgz", + "integrity": "sha512-qN0Gqdw4c4KGPsBOQafj6yj/PA6c/L63f6CaZ/DCF/xF4Esu3jVmKLUDYxghFx8Kb/O7y9tI7x2RjTSXwdK1iQ==" + }, + "quote-stream": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/quote-stream/-/quote-stream-0.0.0.tgz", + "integrity": "sha1-zeKelMQJsW4Z3HCYuJtmWPlyHTs=", + "requires": { + "minimist": "0.0.8", + "through2": "0.4.2" + }, + "dependencies": { + "minimist": { + "version": "0.0.8", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.8.tgz", + "integrity": "sha1-hX/Kv8M5fSYluCKCYuhqp6ARsF0=" + }, + "object-keys": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz", + "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=" + }, + "through2": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.4.2.tgz", + "integrity": "sha1-2/WGYDEVHsg1K7bE22SiKSqEC5s=", + "requires": { + "readable-stream": "1.0.34", + "xtend": "2.1.2" + } + }, + "xtend": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz", + "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=", + "requires": { + "object-keys": "0.4.0" + } + } + } + }, + "raf": { + "version": "3.4.0", + "resolved": "https://registry.npmjs.org/raf/-/raf-3.4.0.tgz", + "integrity": "sha512-pDP/NMRAXoTfrhCfyfSEwJAKLaxBU9eApMeBPB1TkDouZmvPerIClV8lTAd+uF8ZiTaVl69e1FCxQrAd/VTjGw==", + "requires": { + "performance-now": "2.1.0" + } + }, + "randomatic": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/randomatic/-/randomatic-1.1.7.tgz", + "integrity": "sha512-D5JUjPyJbaJDkuAazpVnSfVkLlpeO3wDlPROTMLGKG1zMFNFRgrciKo1ltz/AzNTkqE0HzDx655QOL51N06how==", + "dev": true, + "requires": { + "is-number": "3.0.0", + "kind-of": "4.0.0" + }, + "dependencies": { + "is-number": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-number/-/is-number-3.0.0.tgz", + "integrity": "sha1-JP1iAaR4LPUFYcgQJ2r8fRLXEZU=", + "dev": true, + "requires": { + "kind-of": "3.2.2" + }, + "dependencies": { + "kind-of": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-3.2.2.tgz", + "integrity": "sha1-MeohpzS6ubuw8yRm2JOupR5KPGQ=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "kind-of": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-4.0.0.tgz", + "integrity": "sha1-IIE989cSkosgc3hpGkUGb65y3Vc=", + "dev": true, + "requires": { + "is-buffer": "1.1.6" + } + } + } + }, + "randombytes": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz", + "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "dev": true, + "requires": { + "randombytes": "2.0.6", + "safe-buffer": "5.1.1" + } + }, + "rat-vec": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/rat-vec/-/rat-vec-1.1.1.tgz", + "integrity": "sha1-Dd4rZrezS7G80qI4BerIBth/0X8=", + "requires": { + "big-rat": "1.0.4" + } + }, + "read-package-json": { + "version": "2.0.13", + "resolved": "https://registry.npmjs.org/read-package-json/-/read-package-json-2.0.13.tgz", + "integrity": "sha512-/1dZ7TRZvGrYqE0UAfN6qQb5GYBsNcqS1C0tNK601CFOJmtHI7NIGXwetEPU/OtoFHZL3hDxm4rolFFVE9Bnmg==", + "dev": true, + "requires": { + "glob": "7.1.2", + "graceful-fs": "4.1.11", + "json-parse-better-errors": "1.0.2", + "normalize-package-data": "2.4.0", + "slash": "1.0.0" + } + }, + "read-pkg": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-2.0.0.tgz", + "integrity": "sha1-jvHAYjxqbbDcZxPEv6xGMysjaPg=", + "dev": true, + "requires": { + "load-json-file": "2.0.0", + "normalize-package-data": "2.4.0", + "path-type": "2.0.0" + } + }, + "read-pkg-up": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-2.0.0.tgz", + "integrity": "sha1-a3KoBImE4MQeeVEP1en6mbO1Sb4=", + "dev": true, + "requires": { + "find-up": "2.1.0", + "read-pkg": "2.0.0" + } + }, + "readable-stream": { + "version": "1.0.34", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.34.tgz", + "integrity": "sha1-Elgg40vIQtLyqq+v5MKRbuMsFXw=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + }, + "readdirp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-2.1.0.tgz", + "integrity": "sha1-TtCtBg3zBzMAxIRANz9y0cxkLXg=", + "dev": true, + "requires": { + "graceful-fs": "4.1.11", + "minimatch": "3.0.4", + "readable-stream": "2.3.4", + "set-immediate-shim": "1.0.1" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "redeyed": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/redeyed/-/redeyed-0.4.4.tgz", + "integrity": "sha1-N+mQpvKyGyoRwuakj9QTVpjLqX8=", + "requires": { + "esprima": "1.0.4" + }, + "dependencies": { + "esprima": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz", + "integrity": "sha1-n1V+CPw7TSbs6d00+Pv0drYlha0=" + } + } + }, + "reduce-simplicial-complex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/reduce-simplicial-complex/-/reduce-simplicial-complex-1.0.0.tgz", + "integrity": "sha1-dNaWovg196bc2SBl/YxRgfLt+Lw=", + "requires": { + "cell-orientation": "1.0.1", + "compare-cell": "1.0.0", + "compare-oriented-cell": "1.0.1" + } + }, + "regex-cache": { + "version": "0.4.4", + "resolved": "https://registry.npmjs.org/regex-cache/-/regex-cache-0.4.4.tgz", + "integrity": "sha512-nVIZwtCjkC9YgvWkpM55B5rBhBYRZhAaJbgcFYXXsHnbZ9UZI9nnVWYZpBlCqv9ho2eZryPnWrZGsOdPwVWXWQ==", + "dev": true, + "requires": { + "is-equal-shallow": "0.1.3" + } + }, + "regl": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/regl/-/regl-1.3.7.tgz", + "integrity": "sha512-Uf005fU6C+VsYomGEOtDhpn6aiisljsJEG6CoGTgNnV5W28hDNDR3Xw9scAkx9X1JoZ/otYODztVWZpQNyJWcA==" + }, + "regl-error2d": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/regl-error2d/-/regl-error2d-2.0.5.tgz", + "integrity": "sha512-hBxGSY0F9S3+JsobYiQBKdZ+0oWNpM6k8zeRxVDyv5rbZ2HNclVInrT82em+JPZ+GEh0OLmZdlS4BbPIuYAk2w==", + "requires": { + "array-bounds": "1.0.1", + "bubleify": "1.2.0", + "color-normalize": "1.1.0", + "flatten-vertex-data": "1.0.2", + "object-assign": "4.1.1", + "pick-by-alias": "1.2.0", + "to-float32": "1.0.0", + "update-diff": "1.1.0" + }, + "dependencies": { + "acorn-dynamic-import": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz", + "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", + "requires": { + "acorn": "5.4.1" + } + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "requires": { + "acorn": "5.4.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "1.9.2" + } + }, + "buble": { + "version": "0.19.3", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.19.3.tgz", + "integrity": "sha512-3B0Lcy2u6x6km0BqTz/FS3UnrOJlnIlBWsyjvtqzdtmWkqiS0+Sg4hc6L9Mmm63hZKTACpYS9vUeIoKSi1vcrQ==", + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "3.0.0", + "acorn-jsx": "4.1.1", + "chalk": "2.4.1", + "magic-string": "0.22.5", + "minimist": "1.2.0", + "os-homedir": "1.0.2", + "vlq": "1.0.0" + } + }, + "bubleify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-1.2.0.tgz", + "integrity": "sha512-SJnUsR+f8WeDw0K2l1S+VuYI33Cu5Gfghe5jTow/fpJueNtnwyoECyfCGsDuFoQt4QGhjpV3LYPpN0hxy90LgA==", + "requires": { + "buble": "0.19.3" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "3.0.0" + } + }, + "vlq": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-1.0.0.tgz", + "integrity": "sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==" + } + } + }, + "regl-line2d": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/regl-line2d/-/regl-line2d-3.0.9.tgz", + "integrity": "sha512-D3ASXgofHVcdxi6qfQRJ7YsAVHkK0i7rkKx9qwDLYoZ96eRyyFMDb1zA3ulrmarPnb/U2G7EfsYQDU3V96EP4Q==", + "requires": { + "array-bounds": "1.0.1", + "array-normalize": "1.1.3", + "bubleify": "1.2.0", + "color-normalize": "1.1.0", + "earcut": "2.1.3", + "es6-weak-map": "2.0.2", + "flatten-vertex-data": "1.0.2", + "glslify": "6.1.1", + "object-assign": "4.1.1", + "parse-rect": "1.2.0", + "pick-by-alias": "1.2.0", + "to-float32": "1.0.0" + }, + "dependencies": { + "acorn-dynamic-import": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz", + "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", + "requires": { + "acorn": "5.4.1" + } + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "requires": { + "acorn": "5.4.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "1.9.2" + } + }, + "buble": { + "version": "0.19.3", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.19.3.tgz", + "integrity": "sha512-3B0Lcy2u6x6km0BqTz/FS3UnrOJlnIlBWsyjvtqzdtmWkqiS0+Sg4hc6L9Mmm63hZKTACpYS9vUeIoKSi1vcrQ==", + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "3.0.0", + "acorn-jsx": "4.1.1", + "chalk": "2.4.1", + "magic-string": "0.22.5", + "minimist": "1.2.0", + "os-homedir": "1.0.2", + "vlq": "1.0.0" + } + }, + "bubleify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-1.2.0.tgz", + "integrity": "sha512-SJnUsR+f8WeDw0K2l1S+VuYI33Cu5Gfghe5jTow/fpJueNtnwyoECyfCGsDuFoQt4QGhjpV3LYPpN0hxy90LgA==", + "requires": { + "buble": "0.19.3" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "3.0.0" + } + }, + "vlq": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-1.0.0.tgz", + "integrity": "sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==" + } + } + }, + "regl-scatter2d": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/regl-scatter2d/-/regl-scatter2d-3.0.4.tgz", + "integrity": "sha512-Re9LArRlqIx1yOfvLuv5MH61i4bZ2ZnTNkEC36YacrrijcE2BA+efwQMEI9ZbUNor+pMDPG7DbFatMve44aDXA==", + "requires": { + "array-range": "1.0.1", + "array-rearrange": "2.2.2", + "bubleify": "1.2.0", + "clamp": "1.0.1", + "color-id": "1.1.0", + "color-normalize": "1.1.0", + "flatten-vertex-data": "1.0.2", + "glslify": "6.1.1", + "is-iexplorer": "1.0.0", + "object-assign": "4.1.1", + "parse-rect": "1.2.0", + "pick-by-alias": "1.2.0", + "point-cluster": "3.1.4", + "to-float32": "1.0.0", + "update-diff": "1.1.0" + }, + "dependencies": { + "acorn-dynamic-import": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz", + "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", + "requires": { + "acorn": "5.4.1" + } + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "requires": { + "acorn": "5.4.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "1.9.2" + } + }, + "buble": { + "version": "0.19.3", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.19.3.tgz", + "integrity": "sha512-3B0Lcy2u6x6km0BqTz/FS3UnrOJlnIlBWsyjvtqzdtmWkqiS0+Sg4hc6L9Mmm63hZKTACpYS9vUeIoKSi1vcrQ==", + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "3.0.0", + "acorn-jsx": "4.1.1", + "chalk": "2.4.1", + "magic-string": "0.22.5", + "minimist": "1.2.0", + "os-homedir": "1.0.2", + "vlq": "1.0.0" + } + }, + "bubleify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-1.2.0.tgz", + "integrity": "sha512-SJnUsR+f8WeDw0K2l1S+VuYI33Cu5Gfghe5jTow/fpJueNtnwyoECyfCGsDuFoQt4QGhjpV3LYPpN0hxy90LgA==", + "requires": { + "buble": "0.19.3" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "3.0.0" + } + }, + "vlq": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-1.0.0.tgz", + "integrity": "sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==" + } + } + }, + "regl-splom": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/regl-splom/-/regl-splom-1.0.3.tgz", + "integrity": "sha512-3oJT26xm91p303Jb3jMI7PptHYMSbR2/ZnTLolYGnC42jVp/e+xbbik1pTNFyeS5WiaE0M+Ssl3tUC6zgQ8nOw==", + "requires": { + "array-bounds": "1.0.1", + "array-range": "1.0.1", + "bubleify": "1.2.0", + "color-alpha": "1.0.3", + "defined": "1.0.0", + "flatten-vertex-data": "1.0.2", + "left-pad": "1.3.0", + "parse-rect": "1.2.0", + "pick-by-alias": "1.2.0", + "point-cluster": "1.0.2", + "raf": "3.4.0", + "regl-scatter2d": "3.0.4" + }, + "dependencies": { + "acorn-dynamic-import": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/acorn-dynamic-import/-/acorn-dynamic-import-3.0.0.tgz", + "integrity": "sha512-zVWV8Z8lislJoOKKqdNMOB+s6+XV5WERty8MnKBeFgwA+19XJjJHs2RP5dzM57FftIs+jQnRToLiWazKr6sSWg==", + "requires": { + "acorn": "5.4.1" + } + }, + "acorn-jsx": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/acorn-jsx/-/acorn-jsx-4.1.1.tgz", + "integrity": "sha512-JY+iV6r+cO21KtntVvFkD+iqjtdpRUpGqKWgfkCdZq1R+kbreEl8EcdcJR4SmiIgsIQT33s6QzheQ9a275Q8xw==", + "requires": { + "acorn": "5.4.1" + } + }, + "ansi-styles": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", + "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", + "requires": { + "color-convert": "1.9.2" + } + }, + "binary-search-bounds": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/binary-search-bounds/-/binary-search-bounds-2.0.4.tgz", + "integrity": "sha512-2hg5kgdKql5ClF2ErBcSx0U5bnl5hgS4v7wMnLFodyR47yMtj2w+UAZB+0CiqyHct2q543i7Bi4/aMIegorCCg==" + }, + "buble": { + "version": "0.19.3", + "resolved": "https://registry.npmjs.org/buble/-/buble-0.19.3.tgz", + "integrity": "sha512-3B0Lcy2u6x6km0BqTz/FS3UnrOJlnIlBWsyjvtqzdtmWkqiS0+Sg4hc6L9Mmm63hZKTACpYS9vUeIoKSi1vcrQ==", + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "3.0.0", + "acorn-jsx": "4.1.1", + "chalk": "2.4.1", + "magic-string": "0.22.5", + "minimist": "1.2.0", + "os-homedir": "1.0.2", + "vlq": "1.0.0" + } + }, + "bubleify": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/bubleify/-/bubleify-1.2.0.tgz", + "integrity": "sha512-SJnUsR+f8WeDw0K2l1S+VuYI33Cu5Gfghe5jTow/fpJueNtnwyoECyfCGsDuFoQt4QGhjpV3LYPpN0hxy90LgA==", + "requires": { + "buble": "0.19.3" + } + }, + "chalk": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.1.tgz", + "integrity": "sha512-ObN6h1v2fTJSmUXoS3nMQ92LbDK9be4TV+6G+omQlGJFdcUX5heKi1LZ1YnRMIgwTLEj3E24bT6tYni50rlCfQ==", + "requires": { + "ansi-styles": "3.2.1", + "escape-string-regexp": "1.0.5", + "supports-color": "5.4.0" + } + }, + "point-cluster": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/point-cluster/-/point-cluster-1.0.2.tgz", + "integrity": "sha512-pau5Py38SKgEJZ8pvD/bfXrz2TmQy6BEtMFZZSpjsQ2EmAe4CRO+HLhHw1gmgHVFaY/9KqhrfSeUPIsBOw8tDA==", + "requires": { + "array-bounds": "1.0.1", + "array-normalize": "1.1.3", + "binary-search-bounds": "2.0.4", + "clamp": "1.0.1", + "parse-rect": "1.2.0" + } + }, + "supports-color": { + "version": "5.4.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.4.0.tgz", + "integrity": "sha512-zjaXglF5nnWpsq470jSv6P9DwPvgLkuapYmfDm3JWOm0vkNTVF2tI4UrN2r6jH1qM/uc/WtxYY1hYoA2dOKj5w==", + "requires": { + "has-flag": "3.0.0" + } + }, + "vlq": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-1.0.0.tgz", + "integrity": "sha512-o3WmXySo+oI5thgqr7Qy8uBkT/v9Zr+sRyrh1lr8aWPUkgDWdWt4Nae2WKBrLsocgE8BuWWD0jLc+VW8LeU+2g==" + } + } + }, + "remove-trailing-separator": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/remove-trailing-separator/-/remove-trailing-separator-1.1.0.tgz", + "integrity": "sha1-wkvOKig62tW8P1jg1IJJuSN52O8=", + "dev": true + }, + "repeat-element": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/repeat-element/-/repeat-element-1.1.2.tgz", + "integrity": "sha1-7wiaF40Ug7quTZPrmLT55OEdmQo=", + "dev": true + }, + "repeat-string": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/repeat-string/-/repeat-string-1.6.1.tgz", + "integrity": "sha1-jcrkcOHIirwtYA//Sndihtp15jc=" + }, + "require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha1-jGStX9MNqxyXbiNE/+f3kqam30I=", + "dev": true + }, + "require-main-filename": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/require-main-filename/-/require-main-filename-1.0.1.tgz", + "integrity": "sha1-l/cXtp1IeE9fUmpsWqj/3aBVpNE=", + "dev": true + }, + "requires-port": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz", + "integrity": "sha1-kl0mAdOaxIXgkc8NpcbmlNw9yv8=" + }, + "resolve": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.4.0.tgz", + "integrity": "sha512-aW7sVKPufyHqOmyyLzg/J+8606v5nevBgaliIlV7nUpVMsDnoBGV/cbSLNjZAg9q0Cfd/+easKVKQ8vOu8fn1Q==", + "requires": { + "path-parse": "1.0.5" + } + }, + "resolve-protobuf-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/resolve-protobuf-schema/-/resolve-protobuf-schema-2.0.0.tgz", + "integrity": "sha1-5nsGKmfwLRG9aIbnDv2niEB+D7Q=", + "requires": { + "protocol-buffers-schema": "2.2.0" + } + }, + "resumer": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz", + "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=", + "requires": { + "through": "2.3.8" + } + }, + "right-align": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/right-align/-/right-align-0.1.3.tgz", + "integrity": "sha1-YTObci/mo1FWiSENJOFMlhSGE+8=", + "requires": { + "align-text": "0.1.4" + } + }, + "right-now": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/right-now/-/right-now-1.0.0.tgz", + "integrity": "sha1-bolgne69fc2vja7Mmuo5z1haCRg=" + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "dev": true, + "requires": { + "glob": "7.1.2" + } + }, + "ripemd160": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.1.tgz", + "integrity": "sha1-D0WEKVxTo2KK9+bXmsohzlfRxuc=", + "dev": true, + "requires": { + "hash-base": "2.0.2", + "inherits": "2.0.3" + } + }, + "robust-compress": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-compress/-/robust-compress-1.0.0.tgz", + "integrity": "sha1-TPYsSzGNgwhRYBK7jBF1Lzkymxs=" + }, + "robust-determinant": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/robust-determinant/-/robust-determinant-1.1.0.tgz", + "integrity": "sha1-jsrnm3nKqz509t6+IjflORon6cc=", + "requires": { + "robust-compress": "1.0.0", + "robust-scale": "1.0.2", + "robust-sum": "1.0.0", + "two-product": "1.0.2" + } + }, + "robust-dot-product": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-dot-product/-/robust-dot-product-1.0.0.tgz", + "integrity": "sha1-yboBeL0sMEv9cl9Y6Inx2UYARVM=", + "requires": { + "robust-sum": "1.0.0", + "two-product": "1.0.2" + } + }, + "robust-in-sphere": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/robust-in-sphere/-/robust-in-sphere-1.1.3.tgz", + "integrity": "sha1-HFiD0WpOkjkpR27zSBmFe/Kpz3U=", + "requires": { + "robust-scale": "1.0.2", + "robust-subtract": "1.0.0", + "robust-sum": "1.0.0", + "two-product": "1.0.2" + } + }, + "robust-linear-solve": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-linear-solve/-/robust-linear-solve-1.0.0.tgz", + "integrity": "sha1-DNasUEBpGm8qo81jEdcokFyjofE=", + "requires": { + "robust-determinant": "1.1.0" + } + }, + "robust-orientation": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/robust-orientation/-/robust-orientation-1.1.3.tgz", + "integrity": "sha1-2v9bANO+TmByLw6cAVbvln8cIEk=", + "requires": { + "robust-scale": "1.0.2", + "robust-subtract": "1.0.0", + "robust-sum": "1.0.0", + "two-product": "1.0.2" + } + }, + "robust-product": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-product/-/robust-product-1.0.0.tgz", + "integrity": "sha1-aFJQAHzbunzx3nW/9tKScBEJir4=", + "requires": { + "robust-scale": "1.0.2", + "robust-sum": "1.0.0" + } + }, + "robust-scale": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/robust-scale/-/robust-scale-1.0.2.tgz", + "integrity": "sha1-d1Ey7QlULQKOWLLMecBikLz3jDI=", + "requires": { + "two-product": "1.0.2", + "two-sum": "1.0.0" + } + }, + "robust-segment-intersect": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/robust-segment-intersect/-/robust-segment-intersect-1.0.1.tgz", + "integrity": "sha1-MlK2oPwboUreaRXMvgnLzpqrHBw=", + "requires": { + "robust-orientation": "1.1.3" + } + }, + "robust-subtract": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-subtract/-/robust-subtract-1.0.0.tgz", + "integrity": "sha1-4LFk4e2LpOOl3aRaEgODSNvtPpo=" + }, + "robust-sum": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/robust-sum/-/robust-sum-1.0.0.tgz", + "integrity": "sha1-FmRuUlKStNJdgnV6KGlV4Lv6U9k=" + }, + "rw": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz", + "integrity": "sha1-P4Yt+pGrdmsUiF700BEkv9oHT7Q=" + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "sane-topojson": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/sane-topojson/-/sane-topojson-2.0.0.tgz", + "integrity": "sha1-QOJXNqKMTM6qojP0W7hjc6J4W4Q=" + }, + "seedrandom": { + "version": "2.4.3", + "resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-2.4.3.tgz", + "integrity": "sha1-JDhQTa0zkXMUv/GKxNeU8W1qrsw=" + }, + "semver": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.5.0.tgz", + "integrity": "sha512-4SJ3dm0WAwWy/NVeioZh5AntkdJoWKxHxcmyP622fOkgHa4z3R0TdBJICINyaSDE6uNwVc8gZr+ZinwZAH4xIA==", + "dev": true + }, + "set-blocking": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/set-blocking/-/set-blocking-2.0.0.tgz", + "integrity": "sha1-BF+XgtARrppoA93TgrJDkrPYkPc=", + "dev": true + }, + "set-immediate-shim": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/set-immediate-shim/-/set-immediate-shim-1.0.1.tgz", + "integrity": "sha1-SysbJ+uAip+NzEgaWOXlb1mfP2E=", + "dev": true + }, + "setimmediate": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz", + "integrity": "sha1-KQy7Iy4waULX1+qbg3Mqt4VvgoU=", + "dev": true + }, + "sha.js": { + "version": "2.4.10", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.10.tgz", + "integrity": "sha512-vnwmrFDlOExK4Nm16J2KMWHLrp14lBrjxMxBJpu++EnsuBmpiYaM/MEs46Vxxm/4FvdP5yTwuCTO9it5FSjrqA==", + "dev": true, + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "shallow-copy": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/shallow-copy/-/shallow-copy-0.0.1.tgz", + "integrity": "sha1-QV9CcC1z2BAzApLMXuhurhoRoXA=" + }, + "sharkdown": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/sharkdown/-/sharkdown-0.1.0.tgz", + "integrity": "sha1-YdT+Up510CRCEnzJI0NiJlCZIU8=", + "requires": { + "cardinal": "0.4.4", + "expect.js": "0.2.0", + "minimist": "0.0.5", + "split": "0.2.10", + "stream-spigot": "2.1.2", + "through": "2.3.8" + }, + "dependencies": { + "minimist": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-0.0.5.tgz", + "integrity": "sha1-16oye87PUY+RBqxrjwA/o7zqhWY=" + } + } + }, + "shebang-command": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-1.2.0.tgz", + "integrity": "sha1-RKrGW2lbAzmJaMOfNj/uXer98eo=", + "dev": true, + "requires": { + "shebang-regex": "1.0.0" + } + }, + "shebang-regex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-1.0.0.tgz", + "integrity": "sha1-2kL0l0DAtC2yypcoVxyxkMmO/qM=", + "dev": true + }, + "shuffle-seed": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/shuffle-seed/-/shuffle-seed-1.1.6.tgz", + "integrity": "sha1-UzwSaDurO0+j6HUfxOViFGdEJgs=", + "requires": { + "seedrandom": "2.4.3" + } + }, + "signal-exit": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.2.tgz", + "integrity": "sha1-tf3AjxKH6hF4Yo5BXiUTK3NkbG0=", + "dev": true + }, + "signum": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/signum/-/signum-0.0.0.tgz", + "integrity": "sha1-q1UbEAM1EHCnBHg/GgnF52kfnPY=" + }, + "simplicial-complex": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/simplicial-complex/-/simplicial-complex-1.0.0.tgz", + "integrity": "sha1-bDOk7Wn81Nkbe8rdOzC2NoPq4kE=", + "requires": { + "bit-twiddle": "1.0.2", + "union-find": "1.0.2" + } + }, + "simplicial-complex-boundary": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/simplicial-complex-boundary/-/simplicial-complex-boundary-1.0.1.tgz", + "integrity": "sha1-csn/HiTeqjdMm7L6DL8MCB6++BU=", + "requires": { + "boundary-cells": "2.0.1", + "reduce-simplicial-complex": "1.0.0" + } + }, + "simplicial-complex-contour": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/simplicial-complex-contour/-/simplicial-complex-contour-1.0.2.tgz", + "integrity": "sha1-iQqsrChDZTQBEFRc8mKaJuBL+dE=", + "requires": { + "marching-simplex-table": "1.0.0", + "ndarray": "1.0.18", + "ndarray-sort": "1.0.1", + "typedarray-pool": "1.1.0" + } + }, + "simplify-planar-graph": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/simplify-planar-graph/-/simplify-planar-graph-2.0.1.tgz", + "integrity": "sha1-vIWJNyXzLo+oriVoE5hEbSy892Y=", + "requires": { + "robust-orientation": "1.1.3", + "simplicial-complex": "0.3.3" + }, + "dependencies": { + "bit-twiddle": { + "version": "0.0.2", + "resolved": "https://registry.npmjs.org/bit-twiddle/-/bit-twiddle-0.0.2.tgz", + "integrity": "sha1-wurruVKjuUrMFASX4c3NLxoz9Y4=" + }, + "simplicial-complex": { + "version": "0.3.3", + "resolved": "https://registry.npmjs.org/simplicial-complex/-/simplicial-complex-0.3.3.tgz", + "integrity": "sha1-TDDK1X+eRXKd2PMGyHU1efRr6Z4=", + "requires": { + "bit-twiddle": "0.0.2", + "union-find": "0.0.4" + } + }, + "union-find": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/union-find/-/union-find-0.0.4.tgz", + "integrity": "sha1-uFSzMBYZva0USwAUx4+W6sDS8PY=" + } + } + }, + "slab-decomposition": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/slab-decomposition/-/slab-decomposition-1.0.2.tgz", + "integrity": "sha1-He1WdU1AixBznxRRA9/GGAf2UTQ=", + "requires": { + "binary-search-bounds": "1.0.0", + "functional-red-black-tree": "1.0.1", + "robust-orientation": "1.1.3" + } + }, + "slash": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/slash/-/slash-1.0.0.tgz", + "integrity": "sha1-xB8vbDn8FtHNF61LXYlhFK5HDVU=", + "dev": true + }, + "sort-asc": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/sort-asc/-/sort-asc-0.1.0.tgz", + "integrity": "sha1-q3md9h/HPqCVbHnEtTHtHp53J+k=" + }, + "sort-desc": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/sort-desc/-/sort-desc-0.1.1.tgz", + "integrity": "sha1-GYuMDN6wlcRjNBhh45JdTuNZqe4=" + }, + "sort-object": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/sort-object/-/sort-object-0.3.2.tgz", + "integrity": "sha1-mODRme3kDgfGGoRAPGHWw7KQ+eI=", + "requires": { + "sort-asc": "0.1.0", + "sort-desc": "0.1.1" + } + }, + "source-list-map": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/source-list-map/-/source-list-map-2.0.0.tgz", + "integrity": "sha512-I2UmuJSRr/T8jisiROLU3A3ltr+swpniSmNPI4Ml3ZCX6tVnDsuZzK7F2hl5jTqbZBWCEKlj5HRQiPExXLgE8A==", + "dev": true + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" + }, + "spdx-correct": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-1.0.2.tgz", + "integrity": "sha1-SzBz2TP/UfORLwOsVRlJikFQ20A=", + "dev": true, + "requires": { + "spdx-license-ids": "1.2.2" + } + }, + "spdx-expression-parse": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-1.0.4.tgz", + "integrity": "sha1-m98vIOH0DtRH++JzJmGR/O1RYmw=", + "dev": true + }, + "spdx-license-ids": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-1.2.2.tgz", + "integrity": "sha1-yd96NCRZSt5r0RkA1ZZpbcBrrFc=", + "dev": true + }, + "split": { + "version": "0.2.10", + "resolved": "https://registry.npmjs.org/split/-/split-0.2.10.tgz", + "integrity": "sha1-Zwl8YB1pfOE2j0GPBs0gHPBSGlc=", + "requires": { + "through": "2.3.8" + } + }, + "split-polygon": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/split-polygon/-/split-polygon-1.0.0.tgz", + "integrity": "sha1-DqzIoTanaxKj2VJW6n2kXbDC0kc=", + "requires": { + "robust-dot-product": "1.0.0", + "robust-sum": "1.0.0" + } + }, + "sprintf-js": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.1.tgz", + "integrity": "sha1-Nr54Mgr+WAH2zqPueLblqrlA6gw=" + }, + "stack-trace": { + "version": "0.0.9", + "resolved": "https://registry.npmjs.org/stack-trace/-/stack-trace-0.0.9.tgz", + "integrity": "sha1-qPbq7KkGdMMz58Q5U/J1tFFRBpU=" + }, + "static-eval": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-2.0.0.tgz", + "integrity": "sha512-6flshd3F1Gwm+Ksxq463LtFd1liC77N/PX1FVVc3OzL3hAmo2fwHFbuArkcfi7s9rTNsLEhcRmXGFZhlgy40uw==", + "requires": { + "escodegen": "1.10.0" + } + }, + "static-module": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/static-module/-/static-module-1.5.0.tgz", + "integrity": "sha1-J9qYg8QajNCSNvhC8MHrxu32PYY=", + "requires": { + "concat-stream": "1.6.2", + "duplexer2": "0.0.2", + "escodegen": "1.3.3", + "falafel": "2.1.0", + "has": "1.0.3", + "object-inspect": "0.4.0", + "quote-stream": "0.0.0", + "readable-stream": "1.0.34", + "shallow-copy": "0.0.1", + "static-eval": "0.2.4", + "through2": "0.4.2" + }, + "dependencies": { + "escodegen": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.3.3.tgz", + "integrity": "sha1-8CQBb1qI4Eb9EgBQVek5gC5sXyM=", + "requires": { + "esprima": "1.1.1", + "estraverse": "1.5.1", + "esutils": "1.0.0", + "source-map": "0.1.43" + } + }, + "esprima": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.1.1.tgz", + "integrity": "sha1-W28VR/TRAuZw4UDFCb5ncdautUk=" + }, + "estraverse": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.5.1.tgz", + "integrity": "sha1-hno+jlip+EYYr7bC3bzZFrfLr3E=" + }, + "esutils": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-1.0.0.tgz", + "integrity": "sha1-gVHTWOIMisx/t0XnRywAJf5JZXA=" + }, + "object-inspect": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-0.4.0.tgz", + "integrity": "sha1-9RV8EWwUVbJDsG7pdwM5LFrYn+w=" + }, + "object-keys": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-0.4.0.tgz", + "integrity": "sha1-KKaq50KN0sOpLz2V8hM13SBOAzY=" + }, + "source-map": { + "version": "0.1.43", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.1.43.tgz", + "integrity": "sha1-wkvBRspRfBRx9drL4lcbK3+eM0Y=", + "optional": true, + "requires": { + "amdefine": "1.0.1" + } + }, + "static-eval": { + "version": "0.2.4", + "resolved": "https://registry.npmjs.org/static-eval/-/static-eval-0.2.4.tgz", + "integrity": "sha1-t9NNg4k3uWn5ZBygfUj47eJj6ns=", + "requires": { + "escodegen": "0.0.28" + }, + "dependencies": { + "escodegen": { + "version": "0.0.28", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-0.0.28.tgz", + "integrity": "sha1-Dk/xcV8yh3XWyrUaxEpAbNer/9M=", + "requires": { + "esprima": "1.0.4", + "estraverse": "1.3.2", + "source-map": "0.1.43" + } + }, + "esprima": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-1.0.4.tgz", + "integrity": "sha1-n1V+CPw7TSbs6d00+Pv0drYlha0=" + }, + "estraverse": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-1.3.2.tgz", + "integrity": "sha1-N8K4k+8T1yPydth41g2FNRUqbEI=" + } + } + }, + "through2": { + "version": "0.4.2", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.4.2.tgz", + "integrity": "sha1-2/WGYDEVHsg1K7bE22SiKSqEC5s=", + "requires": { + "readable-stream": "1.0.34", + "xtend": "2.1.2" + } + }, + "xtend": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-2.1.2.tgz", + "integrity": "sha1-bv7MKk2tjmlixJAbM3znuoe10os=", + "requires": { + "object-keys": "0.4.0" + } + } + } + }, + "stream-browserify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz", + "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", + "dev": true, + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.4" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "stream-http": { + "version": "2.8.0", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.8.0.tgz", + "integrity": "sha512-sZOFxI/5xw058XIRHl4dU3dZ+TTOIGJR78Dvo0oEAejIt4ou27k+3ne1zYmCV+v7UucbxIFQuOgnkTVHh8YPnw==", + "dev": true, + "requires": { + "builtin-status-codes": "3.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.4", + "to-arraybuffer": "1.0.1", + "xtend": "4.0.1" + }, + "dependencies": { + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=", + "dev": true + }, + "readable-stream": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.4.tgz", + "integrity": "sha512-vuYxeWYM+fde14+rajzqgeohAI7YoJcHE7kXDAc4Nk0EbuKnJfqtY9YtRkLo/tqkuF7MsBQRhPnPeyjYITp3ZQ==", + "dev": true, + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + } + }, + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "dev": true, + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "stream-shift": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/stream-shift/-/stream-shift-1.0.0.tgz", + "integrity": "sha1-1cdSgl5TZ+eG944Y5EXqIjoVWVI=" + }, + "stream-spigot": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/stream-spigot/-/stream-spigot-2.1.2.tgz", + "integrity": "sha1-feFF6Bn43Q20UJDRPc9zqO08wDU=", + "requires": { + "readable-stream": "1.1.14" + }, + "dependencies": { + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + } + } + }, + "string-width": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-2.1.1.tgz", + "integrity": "sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==", + "dev": true, + "requires": { + "is-fullwidth-code-point": "2.0.0", + "strip-ansi": "4.0.0" + }, + "dependencies": { + "ansi-regex": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-3.0.0.tgz", + "integrity": "sha1-7QMXwyIGT3lGbAKWa922Bas32Zg=", + "dev": true + }, + "is-fullwidth-code-point": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz", + "integrity": "sha1-o7MKXE8ZkYMWeqq5O+764937ZU8=", + "dev": true + }, + "strip-ansi": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-4.0.0.tgz", + "integrity": "sha1-qEeQIusaw2iocTibY1JixQXuNo8=", + "dev": true, + "requires": { + "ansi-regex": "3.0.0" + } + } + } + }, + "string.prototype.trim": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz", + "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=", + "requires": { + "define-properties": "1.1.2", + "es-abstract": "1.12.0", + "function-bind": "1.1.1" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + }, + "strip-ansi": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-3.0.1.tgz", + "integrity": "sha1-ajhfuIU9lS1f8F0Oiq+UJ43GPc8=", + "requires": { + "ansi-regex": "2.1.1" + } + }, + "strip-bom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-bom/-/strip-bom-3.0.0.tgz", + "integrity": "sha1-IzTBjpx1n3vdVv3vfprj1YjmjtM=", + "dev": true + }, + "strip-bom-string": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-bom-string/-/strip-bom-string-1.0.0.tgz", + "integrity": "sha1-5SEekiQ2n7uB1jOi8ABE3IztrZI=" + }, + "strip-eof": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/strip-eof/-/strip-eof-1.0.0.tgz", + "integrity": "sha1-u0P/VZim6wXYm1n80SnJgzE2Br8=", + "dev": true + }, + "strongly-connected-components": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/strongly-connected-components/-/strongly-connected-components-1.0.1.tgz", + "integrity": "sha1-CSDitN9nyOrulsa2I0/inoc9upk=" + }, + "supercluster": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/supercluster/-/supercluster-2.3.0.tgz", + "integrity": "sha1-h6tWCBu+qaHXJN9TUe6ejDry9Is=", + "requires": { + "kdbush": "1.0.1" + } + }, + "superscript-text": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/superscript-text/-/superscript-text-1.0.0.tgz", + "integrity": "sha1-58snUlZzYN9QvrBhDOjfPXHY39g=" + }, + "supports-color": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-2.0.0.tgz", + "integrity": "sha1-U10EXOa2Nj+kARcIRimZXp3zJMc=" + }, + "surface-nets": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/surface-nets/-/surface-nets-1.0.2.tgz", + "integrity": "sha1-5DPIy7qUpydMb0yZVStGG/H8eks=", + "requires": { + "ndarray-extract-contour": "1.0.1", + "triangulate-hypercube": "1.0.1", + "zero-crossings": "1.0.1" + } + }, + "svg-arc-to-cubic-bezier": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/svg-arc-to-cubic-bezier/-/svg-arc-to-cubic-bezier-3.1.0.tgz", + "integrity": "sha1-aYae6gcKilagah8NyQbi7BS6vOw=" + }, + "svg-path-bounds": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/svg-path-bounds/-/svg-path-bounds-1.0.1.tgz", + "integrity": "sha1-v0WLeDcmv1NDG0Yz8nkvYHSNn3Q=", + "requires": { + "abs-svg-path": "0.1.1", + "is-svg-path": "1.0.2", + "normalize-svg-path": "1.0.1", + "parse-svg-path": "0.1.2" + }, + "dependencies": { + "normalize-svg-path": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/normalize-svg-path/-/normalize-svg-path-1.0.1.tgz", + "integrity": "sha1-b3Ka1rcLtMpO/y/ksQdInv4dVv4=", + "requires": { + "svg-arc-to-cubic-bezier": "3.1.0" + } + } + } + }, + "svg-path-sdf": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/svg-path-sdf/-/svg-path-sdf-1.1.1.tgz", + "integrity": "sha1-oqlHJb/mw8Gsn6UmYCc/P18JMuU=", + "requires": { + "bitmap-sdf": "1.0.3", + "draw-svg-path": "1.0.0", + "is-svg-path": "1.0.2", + "parse-svg-path": "0.1.2", + "svg-path-bounds": "1.0.1" + } + }, + "tapable": { + "version": "0.2.8", + "resolved": "https://registry.npmjs.org/tapable/-/tapable-0.2.8.tgz", + "integrity": "sha1-mTcqXJmb8t8WCvwNdL7U9HlIzSI=", + "dev": true + }, + "tape": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.1.tgz", + "integrity": "sha512-6fKIXknLpoe/Jp4rzHKFPpJUHDHDqn8jus99IfPnHIjyz78HYlefTGD3b5EkbQzuLfaEvmfPK3IolLgq2xT3kw==", + "requires": { + "deep-equal": "1.0.1", + "defined": "1.0.0", + "for-each": "0.3.3", + "function-bind": "1.1.1", + "glob": "7.1.2", + "has": "1.0.3", + "inherits": "2.0.3", + "minimist": "1.2.0", + "object-inspect": "1.6.0", + "resolve": "1.7.1", + "resumer": "0.0.0", + "string.prototype.trim": "1.1.2", + "through": "2.3.8" + }, + "dependencies": { + "resolve": { + "version": "1.7.1", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.7.1.tgz", + "integrity": "sha512-c7rwLofp8g1U+h1KNyHL/jicrKg1Ek4q+Lr33AL65uZTinUZHe30D5HlyN5V9NW0JX1D5dXQ4jqW5l7Sy/kGfw==", + "requires": { + "path-parse": "1.0.5" + } + } + } + }, + "text-cache": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/text-cache/-/text-cache-4.1.0.tgz", + "integrity": "sha1-fFgJDoWsCRD5dt9M/Izoqg6lh2Y=", + "requires": { + "vectorize-text": "3.0.2" + } + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "through2": { + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/through2/-/through2-0.6.5.tgz", + "integrity": "sha1-QaucZ7KdVyCQcUEOHXp6lozTrUg=", + "requires": { + "readable-stream": "1.0.34", + "xtend": "4.0.1" + } + }, + "timers-browserify": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-2.0.6.tgz", + "integrity": "sha512-HQ3nbYRAowdVd0ckGFvmJPPCOH/CHleFN/Y0YQCX1DVaB7t+KFvisuyN09fuP8Jtp1CpfSh8O8bMkHbdbPe6Pw==", + "dev": true, + "requires": { + "setimmediate": "1.0.5" + } + }, + "tiny-sdf": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/tiny-sdf/-/tiny-sdf-1.0.2.tgz", + "integrity": "sha1-KOdphcRMTlhMS2fY7N2bM6HKwow=" + }, + "tinycolor2": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/tinycolor2/-/tinycolor2-1.4.1.tgz", + "integrity": "sha1-9PrTM0R7wLB9TcjpIJ2POaisd+g=" + }, + "tinyqueue": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/tinyqueue/-/tinyqueue-1.2.3.tgz", + "integrity": "sha512-Qz9RgWuO9l8lT+Y9xvbzhPT2efIUIFd69N7eF7tJ9lnQl0iLj1M7peK7IoUGZL9DJHw9XftqLreccfxcQgYLxA==" + }, + "to-arraybuffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", + "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=", + "dev": true + }, + "to-float32": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/to-float32/-/to-float32-1.0.0.tgz", + "integrity": "sha512-AtYAqiHS1q+IqVfZOExaRC72mUZuMZP7yU1xsR07y0SLLEvPf68R+xGfya3eY4CR7jxT/zQt3wM8w4mGq/mPXA==" + }, + "to-px": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-px/-/to-px-1.0.1.tgz", + "integrity": "sha1-W7rtXl1PdkRbzJA8KTojB90yRkY=", + "requires": { + "parse-unit": "1.0.1" + } + }, + "topojson-client": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/topojson-client/-/topojson-client-2.1.0.tgz", + "integrity": "sha1-/59784mRGF4LQoTCsGroNPDqxsg=", + "requires": { + "commander": "2.1.0" + } + }, + "triangulate-hypercube": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/triangulate-hypercube/-/triangulate-hypercube-1.0.1.tgz", + "integrity": "sha1-2Acdsuv8/VHzCNC88qXEils20Tc=", + "requires": { + "gamma": "0.1.0", + "permutation-parity": "1.0.0", + "permutation-rank": "1.0.0" + } + }, + "triangulate-polyline": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/triangulate-polyline/-/triangulate-polyline-1.0.3.tgz", + "integrity": "sha1-v4uod6hQVBA/65+lphtOjXAXgU0=", + "requires": { + "cdt2d": "1.0.0" + } + }, + "tty-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.0.tgz", + "integrity": "sha1-oVe6QC2iTpv5V/mqadUk7tQpAaY=", + "dev": true + }, + "turntable-camera-controller": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/turntable-camera-controller/-/turntable-camera-controller-3.0.1.tgz", + "integrity": "sha1-jb0/4AVQGRxlFky4iJcQSVeK/Zk=", + "requires": { + "filtered-vector": "1.2.4", + "gl-mat4": "1.2.0", + "gl-vec3": "1.1.3" + } + }, + "two-product": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/two-product/-/two-product-1.0.2.tgz", + "integrity": "sha1-Z9ldSyV6kh4stL16+VEfkIhSLqo=" + }, + "two-sum": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/two-sum/-/two-sum-1.0.0.tgz", + "integrity": "sha1-MdPzIjnk9zHsqd+RVeKyl/AIq2Q=" + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "requires": { + "prelude-ls": "1.1.2" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + }, + "typedarray-pool": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/typedarray-pool/-/typedarray-pool-1.1.0.tgz", + "integrity": "sha1-0RT0hIAUifU+yrXoCIqiMET0mNk=", + "requires": { + "bit-twiddle": "1.0.2", + "dup": "1.0.0" + } + }, + "uglify-js": { + "version": "2.8.29", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-2.8.29.tgz", + "integrity": "sha1-KcVzMUgFe7Th913zW3qcty5qWd0=", + "requires": { + "source-map": "0.5.7", + "uglify-to-browserify": "1.0.2", + "yargs": "3.10.0" + } + }, + "uglify-to-browserify": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz", + "integrity": "sha1-bgkk1r2mta/jSeOabWMoUKD4grc=", + "optional": true + }, + "uglifyjs-webpack-plugin": { + "version": "0.4.6", + "resolved": "https://registry.npmjs.org/uglifyjs-webpack-plugin/-/uglifyjs-webpack-plugin-0.4.6.tgz", + "integrity": "sha1-uVH0q7a9YX5m9j64kUmOORdj4wk=", + "dev": true, + "requires": { + "source-map": "0.5.7", + "uglify-js": "2.8.29", + "webpack-sources": "1.1.0" + } + }, + "ultron": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.2.tgz", + "integrity": "sha1-rOEWq1V80Zc4ak6I9GhTeMiy5Po=" + }, + "unassert": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/unassert/-/unassert-1.5.1.tgz", + "integrity": "sha1-y8iOw4dBfFpeTALTzQe+mL11/3Y=", + "requires": { + "acorn": "4.0.13", + "call-matcher": "1.0.1", + "deep-equal": "1.0.1", + "espurify": "1.8.0", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "object-assign": "4.1.1" + }, + "dependencies": { + "acorn": { + "version": "4.0.13", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz", + "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=" + } + } + }, + "unassertify": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/unassertify/-/unassertify-2.1.1.tgz", + "integrity": "sha512-YIAaIlc6/KC9Oib8cVZLlpDDhK1UTEuaDyx9BwD97xqxDZC0cJOqwFcs/Y6K3m73B5VzHsRTBLXNO0dxS/GkTw==", + "requires": { + "acorn": "5.4.1", + "convert-source-map": "1.5.1", + "escodegen": "1.10.0", + "multi-stage-sourcemap": "0.2.1", + "through": "2.3.8", + "unassert": "1.5.1" + } + }, + "underscore": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/underscore/-/underscore-1.8.3.tgz", + "integrity": "sha1-Tz+1OxBuYJf8+ctBCfKl6b36UCI=" + }, + "unflowify": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/unflowify/-/unflowify-1.0.1.tgz", + "integrity": "sha1-ouoNJcCv/MRpVeZHNXX3xaH0ppY=", + "requires": { + "flow-remove-types": "1.2.3", + "through": "2.3.8" + } + }, + "union-find": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/union-find/-/union-find-1.0.2.tgz", + "integrity": "sha1-KSusQV5q06iVNdI3AQ20pTYoTlg=" + }, + "uniq": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/uniq/-/uniq-1.0.1.tgz", + "integrity": "sha1-sxxa6CVIRKOoKBVBzisEuGWnNP8=" + }, + "update-diff": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/update-diff/-/update-diff-1.1.0.tgz", + "integrity": "sha1-9RAYLYHugZ+4LDprIrYrve2ngI8=" + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", + "dev": true, + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=", + "dev": true + } + } + }, + "url-parse": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.1.9.tgz", + "integrity": "sha1-xn8dd11R8KGJEd17P/rSe7nlvRk=", + "requires": { + "querystringify": "1.0.0", + "requires-port": "1.0.0" + } + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "dev": true, + "requires": { + "inherits": "2.0.1" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=", + "dev": true + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "validate-npm-package-license": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.1.tgz", + "integrity": "sha1-KAS6vnEq0zeUWaz74kdGqywwP7w=", + "dev": true, + "requires": { + "spdx-correct": "1.0.2", + "spdx-expression-parse": "1.0.4" + } + }, + "vectorize-text": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/vectorize-text/-/vectorize-text-3.0.2.tgz", + "integrity": "sha1-BasWMOQJ83eWTiuSBbLVWakvYNg=", + "requires": { + "cdt2d": "1.0.0", + "clean-pslg": "1.1.2", + "ndarray": "1.0.18", + "planar-graph-to-polyline": "1.0.5", + "simplify-planar-graph": "2.0.1", + "surface-nets": "1.0.2", + "triangulate-polyline": "1.0.3" + } + }, + "vlq": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/vlq/-/vlq-0.2.3.tgz", + "integrity": "sha512-DRibZL6DsNhIgYQ+wNdWDL2SL3bKPlVrRiBqV5yuMm++op8W4kGFtaQfCs4KEJn0wBZcHVHJ3eoywX8983k1ow==" + }, + "vm-browserify": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", + "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=", + "dev": true, + "requires": { + "indexof": "0.0.1" + } + }, + "vt-pbf": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/vt-pbf/-/vt-pbf-3.1.1.tgz", + "integrity": "sha512-pHjWdrIoxurpmTcbfBWXaPwSmtPAHS105253P1qyEfSTV2HJddqjM+kIHquaT/L6lVJIk9ltTGc0IxR/G47hYA==", + "requires": { + "@mapbox/point-geometry": "0.1.0", + "@mapbox/vector-tile": "1.3.1", + "pbf": "3.1.0" + } + }, + "watchpack": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-1.4.0.tgz", + "integrity": "sha1-ShRyvLuVK9Cpu0A2gB+VTfs5+qw=", + "dev": true, + "requires": { + "async": "2.6.0", + "chokidar": "1.7.0", + "graceful-fs": "4.1.11" + } + }, + "weak-map": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/weak-map/-/weak-map-1.0.5.tgz", + "integrity": "sha1-eWkVhNmGB/UHC9O3CkDmuyLkAes=" + }, + "weakmap-shim": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/weakmap-shim/-/weakmap-shim-1.1.1.tgz", + "integrity": "sha1-1lr9eEEJshZuAP9XHDMVDsKkC0k=" + }, + "webgl-context": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/webgl-context/-/webgl-context-2.2.0.tgz", + "integrity": "sha1-jzfXJXz23xzQpJ5qextyG5TMhqA=", + "requires": { + "get-canvas-context": "1.0.2" + } + }, + "webpack": { + "version": "3.11.0", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-3.11.0.tgz", + "integrity": "sha512-3kOFejWqj5ISpJk4Qj/V7w98h9Vl52wak3CLiw/cDOfbVTq7FeoZ0SdoHHY9PYlHr50ZS42OfvzE2vB4nncKQg==", + "dev": true, + "requires": { + "acorn": "5.4.1", + "acorn-dynamic-import": "2.0.2", + "ajv": "6.1.1", + "ajv-keywords": "3.1.0", + "async": "2.6.0", + "enhanced-resolve": "3.4.1", + "escope": "3.6.0", + "interpret": "1.1.0", + "json-loader": "0.5.7", + "json5": "0.5.1", + "loader-runner": "2.3.0", + "loader-utils": "1.1.0", + "memory-fs": "0.4.1", + "mkdirp": "0.5.1", + "node-libs-browser": "2.1.0", + "source-map": "0.5.7", + "supports-color": "4.5.0", + "tapable": "0.2.8", + "uglifyjs-webpack-plugin": "0.4.6", + "watchpack": "1.4.0", + "webpack-sources": "1.1.0", + "yargs": "8.0.2" + }, + "dependencies": { + "ajv": { + "version": "6.1.1", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.1.1.tgz", + "integrity": "sha1-l41Zf7wrfQ5aXD3esUmmgvKr+g4=", + "dev": true, + "requires": { + "fast-deep-equal": "1.0.0", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1" + } + }, + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=", + "dev": true + }, + "cliui": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-3.2.0.tgz", + "integrity": "sha1-EgYBU3qRbSmUD5NNo7SNWFo5IT0=", + "dev": true, + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1", + "wrap-ansi": "2.1.0" + }, + "dependencies": { + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "dev": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + } + } + }, + "has-flag": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-2.0.0.tgz", + "integrity": "sha1-6CB68cx7MNRGzHC3NLXovhj4jVE=", + "dev": true + }, + "supports-color": { + "version": "4.5.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-4.5.0.tgz", + "integrity": "sha1-vnoN5ITexcXN34s9WRJQRJEvY1s=", + "dev": true, + "requires": { + "has-flag": "2.0.0" + } + }, + "yargs": { + "version": "8.0.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-8.0.2.tgz", + "integrity": "sha1-YpmpBVsc78lp/355wdkY3Osiw2A=", + "dev": true, + "requires": { + "camelcase": "4.1.0", + "cliui": "3.2.0", + "decamelize": "1.2.0", + "get-caller-file": "1.0.2", + "os-locale": "2.1.0", + "read-pkg-up": "2.0.0", + "require-directory": "2.1.1", + "require-main-filename": "1.0.1", + "set-blocking": "2.0.0", + "string-width": "2.1.1", + "which-module": "2.0.0", + "y18n": "3.2.1", + "yargs-parser": "7.0.0" + } + } + } + }, + "webpack-sources": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-1.1.0.tgz", + "integrity": "sha512-aqYp18kPphgoO5c/+NaUvEeACtZjMESmDChuD3NBciVpah3XpMEU9VAAtIaB1BsfJWWTSdv8Vv1m3T0aRk2dUw==", + "dev": true, + "requires": { + "source-list-map": "2.0.0", + "source-map": "0.6.1" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "dev": true + } + } + }, + "webworkify": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/webworkify/-/webworkify-1.5.0.tgz", + "integrity": "sha512-AMcUeyXAhbACL8S2hqqdqOLqvJ8ylmIbNwUIqQujRSouf4+eUFaXbG6F1Rbu+srlJMmxQWsiU7mOJi0nMBfM1g==" + }, + "wgs84": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/wgs84/-/wgs84-0.0.0.tgz", + "integrity": "sha1-NP3FVZF7blfPKigu0ENxDASc3HY=" + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", + "dev": true, + "requires": { + "isexe": "2.0.0" + } + }, + "which-module": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/which-module/-/which-module-2.0.0.tgz", + "integrity": "sha1-2e8H3Od7mQK4o6j6SzHD4/fm6Ho=", + "dev": true + }, + "window-size": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/window-size/-/window-size-0.1.0.tgz", + "integrity": "sha1-VDjNLqk7IC76Ohn+iIeu58lPnJ0=" + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=" + }, + "world-calendars": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/world-calendars/-/world-calendars-1.0.3.tgz", + "integrity": "sha1-slxQMrokEo/8QdCfr0pewbnBQzU=", + "requires": { + "object-assign": "4.1.1" + } + }, + "wrap-ansi": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-2.1.0.tgz", + "integrity": "sha1-2Pw9KE3QV5T+hJc8rs3Rz4JP3YU=", + "dev": true, + "requires": { + "string-width": "1.0.2", + "strip-ansi": "3.0.1" + }, + "dependencies": { + "string-width": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-1.0.2.tgz", + "integrity": "sha1-EYvfW4zcUaKn5w0hHgfisLmxB9M=", + "dev": true, + "requires": { + "code-point-at": "1.1.0", + "is-fullwidth-code-point": "1.0.0", + "strip-ansi": "3.0.1" + } + } + } + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "ws": { + "version": "1.1.5", + "resolved": "https://registry.npmjs.org/ws/-/ws-1.1.5.tgz", + "integrity": "sha512-o3KqipXNUdS7wpQzBHSe180lBGO60SoK0yVo3CYJgb2MkobuWuBX6dhkYP5ORCLd55y+SaflMOV5fqAB53ux4w==", + "requires": { + "options": "0.0.6", + "ultron": "1.0.2" + } + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + }, + "y18n": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-3.2.1.tgz", + "integrity": "sha1-bRX7qITAhnnA136I53WegR4H+kE=", + "dev": true + }, + "yallist": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/yallist/-/yallist-2.1.2.tgz", + "integrity": "sha1-HBH5IY8HYImkfdUS+TxmmaaoHVI=", + "dev": true + }, + "yargs": { + "version": "3.10.0", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-3.10.0.tgz", + "integrity": "sha1-9+572FfdfB0tOMDnTvvWgdFDH9E=", + "requires": { + "camelcase": "1.2.1", + "cliui": "2.1.0", + "decamelize": "1.2.0", + "window-size": "0.1.0" + } + }, + "yargs-parser": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-7.0.0.tgz", + "integrity": "sha1-jQrELxbqVd69MyyvTEA4s+P139k=", + "dev": true, + "requires": { + "camelcase": "4.1.0" + }, + "dependencies": { + "camelcase": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-4.1.0.tgz", + "integrity": "sha1-1UVjW+HjPFQmScaRc+Xeas+uNN0=", + "dev": true + } + } + }, + "zero-crossings": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/zero-crossings/-/zero-crossings-1.0.1.tgz", + "integrity": "sha1-xWK9MRNkPzRDokXRJAa4i2m5qf8=", + "requires": { + "cwise-compiler": "1.1.3" + } + } + } +} diff --git a/js/package.json b/js/package.json new file mode 100644 index 0000000000..43fda7b3d8 --- /dev/null +++ b/js/package.json @@ -0,0 +1,41 @@ +{ + "name": "plotlywidget", + "version": "0.1.1", + "description": "The plotly.py ipywidgets library", + "author": "The plotly.py team", + "license": "MIT", + "main": "src/index.js", + "repository": { + "type": "git", + "url": "https://github.com/plotly/plotly.py" + }, + "keywords": [ + "jupyter", + "widgets", + "ipython", + "ipywidgets", + "plotly" + ], + "files": [ + "src/**/*.js", + "dist/*.js" + ], + "scripts": { + "clean": "rimraf dist/ && rimraf ../plotlywidget/static", + "prepublish": "webpack", + "test": "echo \"Error: no test specified\" && exit 1" + }, + "devDependencies": { + "webpack": "^3.10.0", + "rimraf": "^2.6.1", + "ify-loader": "^1.1.0" + }, + "dependencies": { + "plotly.js": "1.38.3", + "@jupyter-widgets/base": "^1.0.0", + "lodash": "^4.17.4" + }, + "jupyterlab": { + "extension": "src/jupyterlab-plugin" + } +} diff --git a/js/src/Figure.js b/js/src/Figure.js new file mode 100644 index 0000000000..c85097c6e6 --- /dev/null +++ b/js/src/Figure.js @@ -0,0 +1,1781 @@ +var widgets = require("@jupyter-widgets/base"); +var _ = require("lodash"); +var Plotly = require("plotly.js/dist/plotly"); +var PlotlyIndex = require("plotly.js/src/lib/index"); +var semver_range = "^" + require("../package.json").version; + +// Model +// ===== +/** + * A FigureModel holds a mirror copy of the state of a FigureWidget on + * the Python side. There is a one-to-one relationship between JavaScript + * FigureModels and Python FigureWidgets. The JavaScript FigureModel is + * initialized as soon as a Python FigureWidget initialized, this happens + * even before the widget is first displayed in the Notebook + * @type {widgets.DOMWidgetModel} + */ +var FigureModel = widgets.DOMWidgetModel.extend({ + + defaults: _.extend(widgets.DOMWidgetModel.prototype.defaults(), { + // Model metadata + // -------------- + _model_name: "FigureModel", + _view_name: "FigureView", + _model_module: "plotlywidget", + _view_module: "plotlywidget", + _view_module_version: semver_range, + _model_module_version: semver_range, + + // Data and Layout + // --------------- + // The _data and _layout properties are synchronized with the + // Python side on initialization only. After initialization, these + // properties are kept in sync through the use of the _py2js_* + // messages + _data: [], + _layout: {}, + + // Python -> JS messages + // --------------------- + // Messages are implemented using trait properties. This is done so + // that we can take advantage of ipywidget's binary serialization + // protocol. + // + // Messages are sent by the Python side by assigning the message + // contents to the appropriate _py2js_* property, and then immediately + // setting it to None. Messages are received by the JavaScript + // side by registering property change callbacks in the initialize + // methods for FigureModel and FigureView. e.g. (where this is a + // FigureModel): + // + // this.on('change:_py2js_addTraces', this.do_addTraces, this); + // + // Message handling methods, do_addTraces, are responsible for + // performing the appropriate action if the message contents are + // not null + + /** + * @typedef {null|Object} Py2JsAddTracesMsg + * @property {Array.} trace_data + * Array of traces to append to the end of the figure's current traces + * @property {Number} trace_edit_id + * Edit ID to use when returning trace deltas using + * the _js2py_traceDeltas message. + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message. + */ + _py2js_addTraces: null, + + /** + * @typedef {null|Object} Py2JsDeleteTracesMsg + * @property {Array.} delete_inds + * Array of indexes of traces to be deleted, in ascending order + * @property {Number} trace_edit_id + * Edit ID to use when returning trace deltas using + * the _js2py_traceDeltas message. + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message. + */ + _py2js_deleteTraces: null, + + /** + * @typedef {null|Object} Py2JsMoveTracesMsg + * @property {Array.} current_trace_inds + * Array of the current indexes of traces to be moved + * @property {Array.} new_trace_inds + * Array of the new indexes that traces should be moved to. + */ + _py2js_moveTraces: null, + + + /** + * @typedef {null|Object} Py2JsRestyleMsg + * @property {Object} restyle_data + * Restyle data as accepted by Plotly.restyle + * @property {null|Array.} restyle_traces + * Array of indexes of the traces that the resytle operation applies + * to, or null to apply the operation to all traces + * @property {Number} trace_edit_id + * Edit ID to use when returning trace deltas using + * the _js2py_traceDeltas message + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message + * @property {null|String} source_view_id + * view_id of the FigureView that triggered the original restyle + * event (e.g. by clicking the legend), or null if the restyle was + * triggered from Python + */ + _py2js_restyle: null, + + /** + * @typedef {null|Object} Py2JsRelayoutMsg + * @property {Object} relayout_data + * Relayout data as accepted by Plotly.relayout + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message + * @property {null|String} source_view_id + * view_id of the FigureView that triggered the original relayout + * event (e.g. by clicking the zoom button), or null if the + * relayout was triggered from Python + */ + _py2js_relayout: null, + + /** + * @typedef {null|Object} Py2JsUpdateMsg + * @property {Object} style_data + * Style data as accepted by Plotly.update + * @property {Object} layout_data + * Layout data as accepted by Plotly.update + * @property {Array.} style_traces + * Array of indexes of the traces that the update operation applies + * to, or null to apply the operation to all traces + * @property {Number} trace_edit_id + * Edit ID to use when returning trace deltas using + * the _js2py_traceDeltas message + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message + * @property {null|String} source_view_id + * view_id of the FigureView that triggered the original update + * event (e.g. by clicking a button), or null if the update was + * triggered from Python + */ + _py2js_update: null, + + /** + * @typedef {null|Object} Py2JsAnimateMsg + * @property {Object} style_data + * Style data as accepted by Plotly.animate + * @property {Object} layout_data + * Layout data as accepted by Plotly.animate + * @property {Array.} style_traces + * Array of indexes of the traces that the animate operation applies + * to, or null to apply the operation to all traces + * @property {Object} animation_opts + * Animation options as accepted by Plotly.animate + * @property {Number} trace_edit_id + * Edit ID to use when returning trace deltas using + * the _js2py_traceDeltas message + * @property {Number} layout_edit_id + * Edit ID to use when returning layout deltas using + * the _js2py_layoutDelta message + * @property {null|String} source_view_id + * view_id of the FigureView that triggered the original animate + * event (e.g. by clicking a button), or null if the update was + * triggered from Python + */ + _py2js_animate: null, + + /** + * @typedef {null|Object} Py2JsRemoveLayoutPropsMsg + * @property {Array.>} remove_props + * Array of property paths to remove. Each propery path is an + * array of property names or array indexes that locate a property + * inside the _layout object + */ + _py2js_removeLayoutProps: null, + + /** + * @typedef {null|Object} Py2JsRemoveTracePropsMsg + * @property {Number} remove_trace + * The index of the trace from which to remove properties + * @property {Array.>} remove_props + * Array of property paths to remove. Each propery path is an + * array of property names or array indexes that locate a property + * inside the _data[remove_trace] object + */ + _py2js_removeTraceProps: null, + + + // JS -> Python messages + // --------------------- + // Messages are sent by the JavaScript side by assigning the + // message contents to the appropriate _js2py_* property and then + // calling the `touch` method on the view that triggered the + // change. e.g. (where this is a FigureView): + // + // this.model.set('_js2py_restyle', data); + // this.touch(); + // + // The Python side is responsible for setting the property to None + // after receiving the message. + // + // Message trigger logic is described in the corresponding + // handle_plotly_* methods of FigureView + + /** + * @typedef {null|Object} Js2PyRestyleMsg + * @property {Object} style_data + * Style data that was passed to Plotly.restyle + * @property {Array.} style_traces + * Array of indexes of the traces that the restyle operation + * was applied to, or null if applied to all traces + * @property {String} source_view_id + * view_id of the FigureView that triggered the original restyle + * event (e.g. by clicking the legend) + */ + _js2py_restyle: null, + + /** + * @typedef {null|Object} Js2PyRelayoutMsg + * @property {Object} relayout_data + * Relayout data that was passed to Plotly.relayout + * @property {String} source_view_id + * view_id of the FigureView that triggered the original relayout + * event (e.g. by clicking the zoom button) + */ + _js2py_relayout: null, + + /** + * @typedef {null|Object} Js2PyUpdateMsg + * @property {Object} style_data + * Style data that was passed to Plotly.update + * @property {Object} layout_data + * Layout data that was passed to Plotly.update + * @property {Array.} style_traces + * Array of indexes of the traces that the update operation applied + * to, or null if applied to all traces + * @property {String} source_view_id + * view_id of the FigureView that triggered the original relayout + * event (e.g. by clicking the zoom button) + */ + _js2py_update: null, + + /** + * @typedef {null|Object} Js2PyLayoutDeltaMsg + * @property {Object} layout_delta + * The layout delta object that contains all of the properties of + * _fullLayout that are not identical to those in the + * FigureModel's _layout property + * @property {Number} layout_edit_id + * Edit ID of message that triggered the creation of layout delta + */ + _js2py_layoutDelta: null, + + /** + * @typedef {null|Object} Js2PyTraceDeltasMsg + * @property {Array.} trace_deltas + * Array of trace delta objects. Each trace delta contains the + * trace's uid along with all of the properties of _fullData that + * are not identical to those in the FigureModel's _data property + * @property {Number} trace_edit_id + * Edit ID of message that triggered the creation of trace deltas + */ + _js2py_traceDeltas: null, + + + /** + * Object representing a collection of points for use in click, hover, + * and selection events + * @typedef {Object} Points + * @property {Array.} trace_indexes + * Array of the trace index for each point + * @property {Array.} point_indexes + * Array of the index of each point in its own trace + * @property {null|Array.} xs + * Array of the x coordinate of each point (for cartesian trace types) + * or null (for non-cartesian trace types) + * @property {null|Array.} ys + * Array of the y coordinate of each point (for cartesian trace types) + * or null (for non-cartesian trace types + * @property {null|Array.} zs + * Array of the z coordinate of each point (for 3D cartesian + * trace types) + * or null (for non-3D-cartesian trace types) + */ + + /** + * Object representing the state of the input devices during a + * plotly event + * @typedef {Object} InputDeviceState + * @property {boolean} alt - true if alt key pressed, + * false otherwise + * @property {boolean} ctrl - true if ctrl key pressed, + * false otherwise + * @property {boolean} meta - true if meta key pressed, + * false otherwise + * @property {boolean} shift - true if shift key pressed, + * false otherwise + * + * @property {boolean} button + * Indicates which button was pressed on the mouse to trigger the + * event. + * 0: Main button pressed, usually the left button or the + * un-initialized state + * 1: Auxiliary button pressed, usually the wheel button or + * the middle button (if present) + * 2: Secondary button pressed, usually the right button + * 3: Fourth button, typically the Browser Back button + * 4: Fifth button, typically the Browser Forward button + * + * @property {boolean} buttons + * Indicates which buttons were pressed on the mouse when the event + * is triggered. + * 0 : No button or un-initialized + * 1 : Primary button (usually left) + * 2 : Secondary button (usually right) + * 4 : Auxilary button (usually middle or mouse wheel button) + * 8 : 4th button (typically the "Browser Back" button) + * 16 : 5th button (typically the "Browser Forward" button) + * + * Combinations of buttons are represented by the sum of the codes + * above. e.g. a value of 7 indicates buttons 1 (primary), + * 2 (secondary), and 4 (auxilary) were pressed during the event + */ + + /** + * @typedef {Object} BoxSelectorState + * @property {Array.} xrange + * Two element array containing the x-range of the box selection + * @property {Array.} yrange + * Two element array containing the y-range of the box selection + */ + + /** + * @typedef {Object} LassoSelectorState + * @property {Array.} xs + * Array of the x-coordinates of the lasso selection region + * @property {Array.} ys + * Array of the y-coordinates of the lasso selection region + */ + + /** + * Object representing the state of the selection tool during a + * plotly_select event + * @typedef {Object} Selector + * @property {String} type + * Selection type. One of: 'box', or 'lasso' + * @property {BoxSelectorState|LassoSelectorState} selector_state + */ + + /** + * @typedef {null|Object} Js2PyPointsCallbackMsg + * @property {string} event_type + * Name of the triggering event. One of 'plotly_click', + * 'plotly_hover', 'plotly_unhover', or 'plotly_selected' + * @property {null|Points} points + * Points object for event + * @property {null|InputDeviceState} device_state + * InputDeviceState object for event + * @property {null|Selector} selector + * State of the selection tool for 'plotly_selected' events, null + * for other event types + */ + _js2py_pointsCallback: null, + + // Message tracking + // ---------------- + /** + * @type {Number} + * layout_edit_id of the last layout modification operation + * requested by the Python side + */ + _last_layout_edit_id: 0, + + /** + * @type {Number} + * trace_edit_id of the last trace modification operation + * requested by the Python side + */ + _last_trace_edit_id: 0 + }), + + /** + * Initialize FigureModel. Called when the Python FigureWidget is first + * constructed + */ + initialize: function() { + FigureModel.__super__.initialize.apply(this, arguments); + console.log(["FigureModel: initialize"]); + + this.on("change:_data", this.do_data, this); + this.on("change:_layout", this.do_layout, this); + this.on("change:_py2js_addTraces", this.do_addTraces, this); + this.on("change:_py2js_deleteTraces", this.do_deleteTraces, this); + this.on("change:_py2js_moveTraces", this.do_moveTraces, this); + this.on("change:_py2js_restyle", this.do_restyle, this); + this.on("change:_py2js_relayout", this.do_relayout, this); + this.on("change:_py2js_update", this.do_update, this); + this.on("change:_py2js_animate", this.do_animate, this); + this.on("change:_py2js_removeLayoutProps", + this.do_removeLayoutProps, this); + this.on("change:_py2js_removeTraceProps", + this.do_removeTraceProps, this); + }, + + /** + * Input a trace index specification and return an Array of trace + * indexes where: + * + * - null|undefined -> Array of all traces + * - Trace index as Number -> Single element array of input index + * - Array of trace indexes -> Input array unchanged + * + * @param {undefined|null|Number|Array.} trace_indexes + * @returns {Array.} + * Array of trace indexes + * @private + */ + _normalize_trace_indexes: function (trace_indexes) { + if (trace_indexes === null || trace_indexes === undefined) { + var numTraces = this.get("_data").length; + trace_indexes = _.range(numTraces); + } + if (!Array.isArray(trace_indexes)) { + // Make sure idx is an array + trace_indexes = [trace_indexes]; + } + return trace_indexes + }, + + /** + * Log changes to the _data trait + * + * This should only happed on FigureModel initialization + */ + do_data: function () { + console.log("Figure Model: do_data"); + var data = this.get("_data"); + + if (data !== null) { + console.log(data); + } + }, + + /** + * Log changes to the _layout trait + * + * This should only happed on FigureModel initialization + */ + do_layout: function () { + console.log("Figure Model: do_layout"); + var layout = this.get("_layout"); + + if (layout !== null) { + console.log(layout); + } + }, + + /** + * Handle addTraces message + */ + do_addTraces: function () { + // add trace to plot + console.log("Figure Model: do_addTraces"); + + /** @type {Py2JsAddTracesMsg} */ + var msgData = this.get("_py2js_addTraces"); + + if (msgData !== null) { + console.log(msgData); + var currentTraces = this.get("_data"); + var newTraces = msgData.trace_data; + _.forEach(newTraces, function (newTrace) { + currentTraces.push(newTrace); + }) + } + }, + + /** + * Handle deleteTraces message + */ + do_deleteTraces: function () { + // remove traces from plot + console.log("Figure Model: do_deleteTraces"); + + /** @type {Py2JsDeleteTracesMsg} */ + var msgData = this.get("_py2js_deleteTraces"); + + if (msgData !== null) { + var delete_inds = msgData.delete_inds; + var tracesData = this.get("_data"); + + // Remove del inds in reverse order so indexes remain valid + // throughout loop + delete_inds.slice().reverse().forEach(function (del_ind) { + tracesData.splice(del_ind, 1); + }); + } + }, + + /** + * Handle moveTraces message + */ + do_moveTraces: function () { + console.log("Figure Model: do_moveTraces"); + + /** @type {Py2JsMoveTracesMsg} */ + var msgData = this.get("_py2js_moveTraces"); + + console.log("do_moveTraces"); + + if (msgData !== null) { + var tracesData = this.get("_data"); + var currentInds = msgData.current_trace_inds; + var newInds = msgData.new_trace_inds; + + performMoveTracesLike(tracesData, currentInds, newInds); + } + }, + + /** + * Handle restyle message + */ + do_restyle: function () { + console.log("FigureModel: do_restyle"); + + /** @type {Py2JsRestyleMsg} */ + var msgData = this.get("_py2js_restyle"); + if (msgData !== null) { + var restyleData = msgData.restyle_data; + var restyleTraces = this._normalize_trace_indexes( + msgData.restyle_traces); + performRestyleLike(this.get("_data"), restyleData, restyleTraces); + } + }, + + /** + * Handle relayout message + */ + do_relayout: function () { + console.log("FigureModel: do_relayout"); + + /** @type {Py2JsRelayoutMsg} */ + var msgData = this.get("_py2js_relayout"); + + if (msgData !== null) { + console.log(msgData); + performRelayoutLike(this.get("_layout"), msgData.relayout_data); + console.log(this.get("_layout")) + } + }, + + /** + * Handle update message + */ + do_update: function() { + console.log("FigureModel: do_update"); + + /** @type {Py2JsUpdateMsg} */ + var msgData = this.get("_py2js_update"); + + if (msgData !== null) { + console.log(msgData); + + var style = msgData.style_data; + var layout = msgData.layout_data; + var styleTraces = this._normalize_trace_indexes( + msgData.style_traces); + performRestyleLike(this.get("_data"), style, styleTraces); + performRelayoutLike(this.get("_layout"), layout); + } + }, + + /** + * Handle animate message + */ + do_animate: function () { + console.log("FigureModel: do_animate"); + + /** @type {Py2JsAnimateMsg} */ + var msgData = this.get("_py2js_animate"); + if (msgData !== null) { + console.log(msgData); + + var styles = msgData.style_data; + var layout = msgData.layout_data; + var trace_indexes = this._normalize_trace_indexes( + msgData.style_traces); + + for (var i = 0; i < styles.length; i++) { + var style = styles[i]; + var trace_index = trace_indexes[i]; + var trace = this.get("_data")[trace_index]; + performRelayoutLike(trace, style); + } + + performRelayoutLike(this.get("_layout"), layout); + } + }, + + /** + * Handle removeLayoutProps message + */ + do_removeLayoutProps: function () { + console.log("FigureModel:do_removeLayoutProps"); + + /** @type {Py2JsRemoveLayoutPropsMsg} */ + var msgData = this.get("_py2js_removeLayoutProps"); + + if (msgData !== null) { + console.log(this.get("_layout")); + + var keyPaths = msgData.remove_props; + var layout = this.get("_layout"); + performRemoveProps(layout, keyPaths); + + console.log(this.get("_layout")); + } + }, + + /** + * Handle removeTraceProps message + */ + do_removeTraceProps: function () { + console.log("FigureModel:do_removeTraceProps"); + + /** @type {Py2JsRemoveTracePropsMsg} */ + var msgData = this.get("_py2js_removeTraceProps"); + if (msgData !== null) { + console.log(msgData); + var keyPaths = msgData.remove_props; + var traceIndex = msgData.remove_trace; + var trace = this.get("_data")[traceIndex]; + + performRemoveProps(trace, keyPaths); + } + } +}, { + serializers: _.extend({ + _data: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _layout: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_addTraces: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_deleteTraces: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_moveTraces: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_restyle: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_relayout: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_update: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_animate: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_removeLayoutProps: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _py2js_removeTraceProps: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_restyle: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_relayout: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_update: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_layoutDelta: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_traceDeltas: { deserialize: py2js_deserializer, + serialize: js2py_serializer}, + _js2py_pointsCallback: { deserialize: py2js_deserializer, + serialize: js2py_serializer} + }, widgets.DOMWidgetModel.serializers) +}); + +// View +// ==== +/** + * A FigureView manages the visual presentation of a single Plotly.js + * figure for a single notebook output cell. Each FigureView has a + * reference to FigureModel. Multiple views may share a single model + * instance, as is the case when a Python FigureWidget is displayed in + * multiple notebook output cells. + * + * @type {widgets.DOMWidgetView} + */ +var FigureView = widgets.DOMWidgetView.extend({ + + /** + * The perform_render method is called by processPhosphorMessage + * after the widget's DOM element has been attached to the notebook + * output cell. This happens after the initialize of the + * FigureModel, and it won't happen at all if the Python FigureWidget + * is never displayed in a notebook output cell + */ + perform_render: function() { + + var that = this; + + // Wire up message property callbacks + // ---------------------------------- + // Python -> JS event properties + this.model.on("change:_py2js_addTraces", + this.do_addTraces, this); + this.model.on("change:_py2js_deleteTraces", + this.do_deleteTraces, this); + this.model.on("change:_py2js_moveTraces", + this.do_moveTraces, this); + this.model.on("change:_py2js_restyle", + this.do_restyle, this); + this.model.on("change:_py2js_relayout", + this.do_relayout, this); + this.model.on("change:_py2js_update", + this.do_update, this); + this.model.on("change:_py2js_animate", + this.do_animate, this); + + // Get message ids + // --------------------- + var layout_edit_id = this.model.get("_last_layout_edit_id"); + var trace_edit_id = this.model.get("_last_trace_edit_id"); + + // Set view UID + // ------------ + this.viewID = PlotlyIndex.randstr(); + console.log("Created view with id: " + this.viewID); + + // Initialize Plotly.js figure + // --------------------------- + console.log("render"); + console.log(this.model.get("_data")); + console.log(this.model.get("_layout")); + + // We must clone the model's data and layout properties so that + // the model is not directly mutated by the Plotly.js library. + var initialTraces = _.cloneDeep(this.model.get("_data")); + var initialLayout = _.cloneDeep(this.model.get("_layout")); + + Plotly.newPlot(that.el, initialTraces, initialLayout).then( + function () { + // Plotly.Plots.resize(that.el); + + // ### Send trace deltas ### + // We create an array of deltas corresponding to the new + // traces. + that._sendTraceDeltas(trace_edit_id); + + // ### Send layout delta ### + that._sendLayoutDelta(layout_edit_id); + + // Wire up plotly event callbacks + that.el.on("plotly_restyle", + function (update) { + that.handle_plotly_restyle(update) + }); + that.el.on("plotly_relayout", + function (update) { + that.handle_plotly_relayout(update) + }); + that.el.on("plotly_update", + function (update) { + that.handle_plotly_update(update) + }); + that.el.on("plotly_click", + function (update) { + that.handle_plotly_click(update) + }); + that.el.on("plotly_hover", + function (update) { + that.handle_plotly_hover(update) + }); + that.el.on("plotly_unhover", + function (update) { + that.handle_plotly_unhover(update) + }); + that.el.on("plotly_selected", + function (update) { + that.handle_plotly_selected(update) + }); + that.el.on("plotly_doubleclick", + function (update) { + that.handle_plotly_doubleclick(update) + }); + }); + }, + + /** + * Respond to phosphorjs events + */ + processPhosphorMessage: function(msg) { + FigureView.__super__.processPhosphorMessage.apply(this, arguments); + var that = this; + switch (msg.type) { + case 'after-attach': + this.perform_render(); + break; + case 'resize': + var layout = this.model.get('_layout'); + if (_.isNil(layout) || + (_.isNil(layout.width) && _.isNil(layout.height))) { + Plotly.Plots.resize(this.el).then(function(){ + var layout_edit_id = that.model.get( + "_last_layout_edit_id"); + that._sendLayoutDelta(layout_edit_id); + }); + } + break + } + }, + + /** + * Purge Plotly.js data structures from the notebook output display + * element when the view is destroyed + */ + destroy: function() { + Plotly.purge(this.el); + }, + + /** + * Return the figure's _fullData array merged with its data array + * + * The merge ensures that for any properties that el._fullData and + * el.data have in common, we return the version from el.data + * + * Named colorscales are one example of why this is needed. The el.data + * array will hold named colorscale strings (e.g. 'Viridis'), while the + * el._fullData array will hold the actual colorscale array. e.g. + * + * el.data[0].marker.colorscale == 'Viridis' but + * el._fullData[0].marker.colorscale = [[..., ...], ...] + * + * Performing the merge allows our FigureModel to retain the 'Viridis' + * string, rather than having it overridded by the colorscale array. + * + */ + getFullData: function () { + return _.mergeWith(this.el._fullData, this.el.data, + fullMergeCustomizer) + }, + + /** + * Return the figure's _fullLayout object merged with its layout object + * + * See getFullData documentation for discussion of why the merge is + * necessary + */ + getFullLayout: function () { + return _.mergeWith(this.el._fullLayout, this.el.layout, + fullMergeCustomizer); + }, + + /** + * Build Points data structure from data supplied by the plotly_click, + * plotly_hover, or plotly_select events + * @param {Object} data + * @returns {null|Points} + */ + buildPointsObject: function (data) { + + var pointsObject; + if (data.hasOwnProperty("points")) { + // Most cartesian plots + var pointObjects = data["points"]; + var numPoints = pointObjects.length; + pointsObject = { + "trace_indexes": new Array(numPoints), + "point_indexes": new Array(numPoints), + "xs": new Array(numPoints), + "ys": new Array(numPoints)}; + + + for (var p = 0; p < numPoints; p++) { + pointsObject["trace_indexes"][p] = + pointObjects[p]["curveNumber"]; + pointsObject["point_indexes"][p] = + pointObjects[p]["pointNumber"]; + pointsObject["xs"][p] = + pointObjects[p]["x"]; + pointsObject["ys"][p] = + pointObjects[p]["y"]; + } + + // Add z if present + var hasZ = pointObjects[0] !== + undefined && pointObjects[0].hasOwnProperty("z"); + if (hasZ) { + pointsObject["zs"] = new Array(numPoints); + for (p = 0; p < numPoints; p++) { + pointsObject["zs"][p] = pointObjects[p]["z"]; + } + } + + return pointsObject + } else { + return null + } + }, + + /** + * Build InputDeviceState data structure from data supplied by the + * plotly_click, plotly_hover, or plotly_select events + * @param {Object} data + * @returns {null|InputDeviceState} + */ + buildInputDeviceStateObject: function (data) { + var event = data["event"]; + if (event === undefined) { + return null; + } else { + /** @type {InputDeviceState} */ + var inputDeviceState = { + // Keyboard modifiers + "alt": event["altKey"], + "ctrl": event["ctrlKey"], + "meta": event["metaKey"], + "shift": event["shiftKey"], + + // Mouse buttons + "button": event["button"], + "buttons": event["buttons"] + }; + return inputDeviceState + } + }, + + /** + * Build Selector data structure from data supplied by the + * plotly_select event + * @param data + * @returns {null|Selector} + */ + buildSelectorObject: function(data) { + + var selectorObject; + + if (data.hasOwnProperty("range")) { + // Box selection + selectorObject = { + type: "box", + selector_state: { + xrange: data["range"]["x"], + yrange: data["range"]["y"] + } + }; + } else if (data.hasOwnProperty("lassoPoints")) { + // Lasso selection + selectorObject = { + type: "lasso", + selector_state: { + xs: data["lassoPoints"]["x"], + ys: data["lassoPoints"]["y"] + } + }; + } else { + selectorObject = null; + } + return selectorObject + }, + + /** + * Handle ploty_restyle events emitted by the Plotly.js library + * @param data + */ + handle_plotly_restyle: function (data) { + + if (data === null || data === undefined) { + // No data to report to the Python side + return + } + + if (data[0] && data[0].hasOwnProperty("_doNotReportToPy")) { + // Restyle originated on the Python side + return + } + + // Unpack data + var styleData = data[0]; + var styleTraces = data[1]; + + // Construct restyle message to send to the Python side + /** @type {Js2PyRestyleMsg} */ + var restyleMsg = { + style_data: styleData, + style_traces: styleTraces, + source_view_id: this.viewID + }; + + // Log message + console.log("plotly_restyle"); + console.log(restyleMsg); + + this.model.set("_js2py_restyle", restyleMsg); + this.touch(); + }, + + /** + * Handle plotly_relayout events emitted by the Plotly.js library + * @param data + */ + handle_plotly_relayout: function (data) { + + if (data === null || data === undefined) { + // No data to report to the Python side + return + } + + if (data.hasOwnProperty("_doNotReportToPy")) { + // Relayout originated on the Python side + return + } + + /** @type {Js2PyRelayoutMsg} */ + var relayoutMsg = { + relayout_data: data, + source_view_id: this.viewID + }; + + // Log message + console.log("plotly_relayout"); + console.log(relayoutMsg); + + this.model.set("_js2py_relayout", relayoutMsg); + this.touch(); + }, + + /** + * Handle plotly_update events emitted by the Plotly.js library + * @param data + */ + handle_plotly_update: function (data) { + + if (data === null || data === undefined) { + // No data to report to the Python side + return + } + + if (data["data"] && + data["data"][0].hasOwnProperty("_doNotReportToPy")) { + // Update originated on the Python side + return + } + + /** @type {Js2PyUpdateMsg} */ + var updateMsg = { + style_data: data["data"][0], + style_traces: data["data"][1], + layout_data: data["layout"], + source_view_id: this.viewID + }; + + // Log message + console.log("plotly_update"); + console.log(updateMsg); + + this.model.set("_js2py_update", updateMsg); + this.touch(); + }, + + /** + * Handle plotly_click events emitted by the Plotly.js library + * @param data + */ + handle_plotly_click: function (data) { + this._send_points_callback_message(data, "plotly_click"); + }, + + /** + * Handle plotly_hover events emitted by the Plotly.js library + * @param data + */ + handle_plotly_hover: function (data) { + this._send_points_callback_message(data, "plotly_hover"); + }, + + /** + * Handle plotly_unhover events emitted by the Plotly.js library + * @param data + */ + handle_plotly_unhover: function (data) { + this._send_points_callback_message(data, "plotly_unhover"); + }, + + /** + * Handle plotly_selected events emitted by the Plotly.js library + * @param data + */ + handle_plotly_selected: function (data) { + this._send_points_callback_message(data, "plotly_selected"); + }, + + /** + * Build and send a points callback message to the Python side + * + * @param {Object} data + * data object as provided by the plotly_click, plotly_hover, + * plotly_unhover, or plotly_selected events + * @param {String} event_type + * Name of the triggering event. One of 'plotly_click', + * 'plotly_hover', 'plotly_unhover', or 'plotly_selected' + * @private + */ + _send_points_callback_message: function (data, event_type) { + if (data === null || data === undefined) { + // No data to report to the Python side + return; + } + + /** @type {Js2PyPointsCallbackMsg} */ + var pointsMsg = { + event_type: event_type, + points: this.buildPointsObject(data), + device_state: this.buildInputDeviceStateObject(data), + selector: this.buildSelectorObject(data) + }; + + if (pointsMsg["points"] !== null && + pointsMsg["points"] !== undefined) { + + this.model.set("_js2py_pointsCallback", pointsMsg); + this.touch(); + } + }, + + /** + * Stub for future handling of plotly_doubleclick + * @param data + */ + handle_plotly_doubleclick: function (data) {}, + + + /** + * Handle Plotly.addTraces request + */ + do_addTraces: function () { + + /** @type {Py2JsAddTracesMsg} */ + var msgData = this.model.get("_py2js_addTraces"); + + console.log("Figure View: do_addTraces"); + + if (msgData !== null) { + console.log(msgData); + + // Save off original number of traces + var prevNumTraces = this.el.data.length; + + var that = this; + Plotly.addTraces(this.el, msgData.trace_data).then(function () { + + // ### Send trace deltas ### + that._sendTraceDeltas(msgData.trace_edit_id); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + that._sendLayoutDelta(layout_edit_id); + }); + } + }, + + /** + * Handle Plotly.deleteTraces request + */ + do_deleteTraces: function () { + + /** @type {Py2JsDeleteTracesMsg} */ + var msgData = this.model.get("_py2js_deleteTraces"); + + console.log(["do_deleteTraces", msgData]); + if (msgData !== null){ + var delete_inds = msgData.delete_inds; + var that = this; + Plotly.deleteTraces(this.el, delete_inds).then(function () { + + // ### Send trace deltas ### + var trace_edit_id = msgData.trace_edit_id; + that._sendTraceDeltas(trace_edit_id); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + that._sendLayoutDelta(layout_edit_id); + }); + } + }, + + /** + * Handle Plotly.moveTraces request + */ + do_moveTraces: function () { + + /** @type {Py2JsMoveTracesMsg} */ + var msgData = this.model.get("_py2js_moveTraces"); + console.log("do_moveTraces"); + + if (msgData !== null){ + // Unpack message + var currentInds = msgData.current_trace_inds; + var newInds = msgData.new_trace_inds; + + // Check if the new trace indexes are actually different than + // the current indexes + var inds_equal = _.isEqual(currentInds, newInds); + + if (!inds_equal) { + Plotly.moveTraces(this.el, currentInds, newInds) + } + } + }, + + /** + * Handle Plotly.restyle request + */ + do_restyle: function () { + console.log("do_restyle"); + + /** @type {Py2JsRestyleMsg} */ + var msgData = this.model.get("_py2js_restyle"); + console.log(msgData); + if (msgData !== null) { + var restyleData = msgData.restyle_data; + var traceIndexes = this.model._normalize_trace_indexes( + msgData.restyle_traces); + + restyleData["_doNotReportToPy"] = true; + Plotly.restyle(this.el, restyleData, traceIndexes); + + // ### Send trace deltas ### + // We create an array of deltas corresponding to the restyled + // traces. + this._sendTraceDeltas(msgData.trace_edit_id); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + this._sendLayoutDelta(layout_edit_id); + } + }, + + /** + * Handle Plotly.relayout request + */ + do_relayout: function () { + console.log("FigureView: do_relayout"); + + /** @type {Py2JsRelayoutMsg} */ + var msgData = this.model.get("_py2js_relayout"); + if (msgData !== null) { + + var relayoutData = msgData.relayout_data; + relayoutData["_doNotReportToPy"] = true; + Plotly.relayout(this.el, msgData.relayout_data); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + this._sendLayoutDelta(layout_edit_id); + } + }, + + /** + * Handle Plotly.update request + */ + do_update: function () { + console.log("FigureView: do_update"); + + /** @type {Py2JsUpdateMsg} */ + var msgData = this.model.get("_py2js_update"); + + if (msgData !== null) { + var style = msgData.style_data || {}; + var layout = msgData.layout_data || {}; + var traceIndexes = this.model._normalize_trace_indexes( + msgData.style_traces); + + style["_doNotReportToPy"] = true; + Plotly.update(this.el, style, layout, traceIndexes); + + // ### Send trace deltas ### + // We create an array of deltas corresponding to the updated + // traces. + this._sendTraceDeltas(msgData.trace_edit_id); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + this._sendLayoutDelta(layout_edit_id); + } + }, + + /** + * Handle Plotly.animate request + */ + do_animate: function() { + console.log("FigureView: do_animate"); + + /** @type {Py2JsAnimateMsg} */ + var msgData = this.model.get("_py2js_animate"); + + if (msgData !== null) { + + // Unpack params + // var animationData = msgData[0]; + var animationOpts = msgData.animation_opts; + + var styles = msgData.style_data; + var layout = msgData.layout_data; + var traceIndexes = this.model._normalize_trace_indexes( + msgData.style_traces); + + var animationData = { + data: styles, + layout: layout, + traces: traceIndexes + }; + + animationData["_doNotReportToPy"] = true; + var that = this; + + Plotly.animate(this.el, animationData, animationOpts).then( + function () { + + // ### Send trace deltas ### + // We create an array of deltas corresponding to the + // animated traces. + that._sendTraceDeltas(msgData.trace_edit_id); + + // ### Send layout delta ### + var layout_edit_id = msgData.layout_edit_id; + that._sendLayoutDelta(layout_edit_id); + }); + + } + }, + + /** + * Construct layout delta object and send layoutDelta message to the + * Python side + * + * @param layout_edit_id + * Edit ID of message that triggered the creation of the layout delta + * @private + */ + _sendLayoutDelta: function(layout_edit_id) { + // ### Handle layout delta ### + var layout_delta = createDeltaObject( + this.getFullLayout(), + this.model.get("_layout")); + + /** @type{Js2PyLayoutDeltaMsg} */ + var layoutDeltaMsg = { + layout_delta: layout_delta, + layout_edit_id: layout_edit_id}; + + this.model.set("_js2py_layoutDelta", layoutDeltaMsg); + this.touch(); + }, + + /** + * Construct trace deltas array for the requested trace indexes and + * send traceDeltas message to the Python side + * Array of indexes of traces for which to compute deltas + * @param trace_edit_id + * Edit ID of message that triggered the creation of trace deltas + * @private + */ + _sendTraceDeltas: function (trace_edit_id) { + + var trace_data = this.model.get("_data"); + var traceIndexes = _.range(trace_data.length); + var trace_deltas = new Array(traceIndexes.length); + + var fullData = this.getFullData(); + for (var i = 0; i < traceIndexes.length; i++) { + var traceInd = traceIndexes[i]; + trace_deltas[i] = createDeltaObject( + fullData[traceInd], trace_data[traceInd]); + } + + /** @type{Js2PyTraceDeltasMsg} */ + var traceDeltasMsg = { + trace_deltas: trace_deltas, + trace_edit_id: trace_edit_id}; + + console.log(["traceDeltasMsg", traceDeltasMsg]); + this.model.set("_js2py_traceDeltas", traceDeltasMsg); + this.touch(); + } +}); + +// Serialization +/** + * Create a mapping from numpy dtype strings to corresponding typed array + * constructors + */ +var numpy_dtype_to_typedarray_type = { + int8: Int8Array, + int16: Int16Array, + int32: Int32Array, + uint8: Uint8Array, + uint16: Uint16Array, + uint32: Uint32Array, + float32: Float32Array, + float64: Float64Array +}; + +/** + * ipywidget JavaScript -> Python serializer + */ +function js2py_serializer(v, widgetManager) { + var res; + + if (Array.isArray(v)) { + // Serialize array elements recursively + res = new Array(v.length); + for (var i = 0; i < v.length; i++) { + res[i] = js2py_serializer(v[i]); + } + } else if (_.isPlainObject(v)) { + // Serialize object properties recursively + res = {}; + for (var p in v) { + if (v.hasOwnProperty(p)) { + res[p] = js2py_serializer(v[p]); + } + } + } else if (v === undefined) { + // Translate undefined into '_undefined_' sentinal string. The + // Python _js_to_py deserializer will convert this into an + // Undefined object + res = "_undefined_"; + } else { + // Primitive value to transfer directly + res = v; + } + return res +} + +/** + * ipywidget Python -> Javascript deserializer + */ +function py2js_deserializer(v, widgetManager) { + var res; + + if (Array.isArray(v)) { + // Deserialize array elements recursively + res = new Array(v.length); + for (var i = 0; i < v.length; i++) { + res[i] = py2js_deserializer(v[i]); + } + } else if (_.isPlainObject(v)) { + if (_.has(v, "buffer") && _.has(v, "dtype") && _.has(v, "shape")) { + // Deserialize special buffer/dtype/shape objects into typed arrays + // These objects correspond to numpy arrays on the Python side + var typedarray_type = numpy_dtype_to_typedarray_type[v.dtype]; + res = new typedarray_type(v.buffer.buffer); + } else { + // Deserialize object properties recursively + res = {}; + for (var p in v) { + if (v.hasOwnProperty(p)) { + res[p] = py2js_deserializer(v[p]); + } + } + } + } else if (v === "_undefined_") { + // Convert the _undefined_ sentinal into undefined + res = undefined; + } else { + // Accept primitive value directly + res = v; + } + return res +} + +/** + * Return whether the input value is a typed array + * @param potentialTypedArray + * Value to examine + * @returns {boolean} + */ +function isTypedArray(potentialTypedArray) { + return ArrayBuffer.isView(potentialTypedArray) && + !(potentialTypedArray instanceof DataView); +} + +/** + * Customizer for use with lodash's mergeWith function + * + * The customizer ensures that typed arrays are not converted into standard + * arrays during the recursive merge + * + * See: https://lodash.com/docs/latest#mergeWith + */ +function fullMergeCustomizer(objValue, srcValue) { + if (isTypedArray(srcValue)) { + // Return typed arrays directly, don't recurse inside + return srcValue + } +} + +/** + * Reform a Plotly.relayout like operation on an input object + * + * @param {Object} parentObj + * The object that the relayout operation should be applied to + * @param {Object} relayoutData + * An relayout object as accepted by Plotly.relayout + * + * Examples: + * var d = {foo {bar [5, 10]}}; + * performRelayoutLike(d, {'foo.bar': [0, 1]}); + * d -> {foo: {bar: [0, 1]}} + * + * var d = {foo {bar [5, 10]}}; + * performRelayoutLike(d, {'baz': 34}); + * d -> {foo: {bar: [5, 10]}, baz: 34} + * + * var d = {foo: {bar: [5, 10]}; + * performRelayoutLike(d, {'foo.baz[1]': 17}); + * d -> {foo: {bar: [5, 17]}} + * + */ +function performRelayoutLike(parentObj, relayoutData) { + // Perform a relayout style operation on a given parent object + for (var rawKey in relayoutData) { + if (!relayoutData.hasOwnProperty(rawKey)) { + continue + } + + // Extract value for this key + var relayoutVal = relayoutData[rawKey]; + + // Set property value + if (relayoutVal === null) { + _.unset(parentObj, rawKey); + } else { + _.set(parentObj, rawKey, relayoutVal); + } + } +} + +/** + * Perform a Plotly.restyle like operation on an input object array + * + * @param {Array.} parentArray + * The object that the restyle operation should be applied to + * @param {Object} restyleData + * A restyle object as accepted by Plotly.restyle + * @param {Array.} restyleTraces + * Array of indexes of the traces that the resytle operation applies to + * + * Examples: + * var d = [{foo: {bar: 1}}, {}, {}] + * performRestyleLike(d, {'foo.bar': 2}, [0]) + * d -> [{foo: {bar: 2}}, {}, {}] + * + * var d = [{foo: {bar: 1}}, {}, {}] + * performRestyleLike(d, {'foo.bar': 2}, [0, 1, 2]) + * d -> [{foo: {bar: 2}}, {foo: {bar: 2}}, {foo: {bar: 2}}] + * + * var d = [{foo: {bar: 1}}, {}, {}] + * performRestyleLike(d, {'foo.bar': [2, 3, 4]}, [0, 1, 2]) + * d -> [{foo: {bar: 2}}, {foo: {bar: 3}}, {foo: {bar: 4}}] + * + */ +function performRestyleLike(parentArray, restyleData, restyleTraces) { + // Loop over the properties of restyleData + for (var rawKey in restyleData) { + if (!restyleData.hasOwnProperty(rawKey)) { continue } + + // Extract value for property and normalize into a value list + var valArray = restyleData[rawKey]; + if (!Array.isArray(valArray)) { + valArray = [valArray] + } + + // Loop over the indexes of the traces being restyled + for (var i = 0; i < restyleTraces.length; i++) { + + // Get trace object + var traceInd = restyleTraces[i]; + var trace = parentArray[traceInd]; + + // Extract value for this trace + var singleVal = valArray[i % valArray.length]; + + // Set property value + if (singleVal === null) { + _.unset(trace, rawKey); + } else if (singleVal !== undefined){ + _.set(trace, rawKey, singleVal); + } + } + } +} + +/** + * Perform a Plotly.moveTraces like operation on an input object array + * @param parentArray + * The object that the moveTraces operation should be applied to + * @param currentInds + * Array of the current indexes of traces to be moved + * @param newInds + * Array of the new indexes that traces selected by currentInds should be + * moved to. + * + * Examples: + * var d = [{foo: 0}, {foo: 1}, {foo: 2}] + * performMoveTracesLike(d, [0, 1], [2, 0]) + * d -> [{foo: 1}, {foo: 2}, {foo: 0}] + * + * var d = [{foo: 0}, {foo: 1}, {foo: 2}] + * performMoveTracesLike(d, [0, 2], [1, 2]) + * d -> [{foo: 1}, {foo: 0}, {foo: 2}] + */ +function performMoveTracesLike(parentArray, currentInds, newInds) { + + // ### Remove by currentInds in reverse order ### + var movingTracesData = []; + for (var ci = currentInds.length - 1; ci >= 0; ci--) { + // Insert moving parentArray at beginning of the list + movingTracesData.splice(0, 0, parentArray[currentInds[ci]]); + parentArray.splice(currentInds[ci], 1); + } + + // ### Sort newInds and movingTracesData by newInds ### + var newIndexSortedArrays = _(newInds).zip(movingTracesData) + .sortBy(0) + .unzip() + .value(); + + newInds = newIndexSortedArrays[0]; + movingTracesData = newIndexSortedArrays[1]; + + // ### Insert by newInds in forward order ### + for (var ni = 0; ni < newInds.length; ni++) { + parentArray.splice(newInds[ni], 0, movingTracesData[ni]); + } +} + +/** + * Remove nested properties from a parent object + * @param {Object} parentObj + * Parent object from which properties or nested properties should be removed + * @param {Array.>} keyPaths + * Array of key paths for properties that should be removed. Each key path + * is an array of properties names or array indexes that reference a + * property to be removed + * + * Examples: + * var d = {foo: [{bar: 0}, {bar: 1}], baz: 32} + * performRemoveProps(d, ['baz']) + * d -> {foo: [{bar: 0}, {bar: 1}]} + * + * var d = {foo: [{bar: 0}, {bar: 1}], baz: 32} + * performRemoveProps(d, ['foo[1].bar', 'baz']) + * d -> {foo: [{bar: 0}, {}]} + * + */ +function performRemoveProps(parentObj, keyPaths) { + + for(var i=0; i < keyPaths.length; i++) { + var keyPath = keyPaths[i]; + _.unset(parentObj, keyPath); + } +} + + +/** + * Return object that contains all properties in fullObj that are not + * identical to the corresponding properties in removeObj + * + * Properties of fullObj and removeObj may be objects or arrays of objects + * + * Returned object is a deep clone of the properties of the input objects + * + * @param {Object} fullObj + * @param {Object} removeObj + * + * Examples: + * var fullD = {foo: [{bar: 0}, {bar: 1}], baz: 32} + * var removeD = {baz: 32} + * createDeltaObject(fullD, removeD) + * -> {foo: [{bar: 0}, {bar: 1}]} + * + * var fullD = {foo: [{bar: 0}, {bar: 1}], baz: 32} + * var removeD = {baz: 45} + * createDeltaObject(fullD, removeD) + * -> {foo: [{bar: 0}, {bar: 1}], baz: 32} + * + * var fullD = {foo: [{bar: 0}, {bar: 1}], baz: 32} + * var removeD = {foo: [{bar: 0}, {bar: 1}]} + * createDeltaObject(fullD, removeD) + * -> {baz: 32} + * + */ +function createDeltaObject(fullObj, removeObj) { + + // Initialize result as object or array + var res; + if(Array.isArray(fullObj)) { + res = new Array(fullObj.length); + } else { + res = {}; + } + + // Initialize removeObj to empty object if not specified + if (removeObj === null || removeObj === undefined) { + removeObj = {}; + } + + // Iterate over object properties or array indices + for (var p in fullObj) { + if (p[0] !== "_" && // Don't consider private properties + fullObj.hasOwnProperty(p) && // Exclude parent properties + fullObj[p] !== null // Exclude cases where fullObj doesn't + // have the property + ) { + // Compute object equality + var props_equal; + props_equal = _.isEqual(fullObj[p], removeObj[p]); + + // Perform recursive comparison if props are not equal + if (!props_equal || p === "uid") { // Let uids through + + // property has non-null value in fullObj that doesn't + // match the value in removeObj + var fullVal = fullObj[p]; + if (removeObj.hasOwnProperty(p) && + typeof fullVal === "object") { + // Recurse over object properties + if(Array.isArray(fullVal)) { + + if (fullVal.length > 0 && + typeof(fullVal[0]) === "object") { + // We have an object array + res[p] = new Array(fullVal.length); + for (var i = 0; i < fullVal.length; i++) { + if (!Array.isArray(removeObj[p]) || + removeObj[p].length <= i) { + + res[p][i] = fullVal[i] + } else { + res[p][i] = createDeltaObject(fullVal[i], + removeObj[p][i]); + } + } + } else { + // We have a primitive array or typed array + res[p] = fullVal; + } + } else { // object + var full_obj = createDeltaObject(fullVal, + removeObj[p]); + if (Object.keys(full_obj).length > 0) { + // new object is not empty + res[p] = full_obj; + } + } + } else if (typeof fullVal === "object" && + !Array.isArray(fullVal)) { + // Return 'clone' of fullVal + // We don't use a standard clone method so that we keep + // the special case handling of this method + res[p] = createDeltaObject(fullVal, {}); + + } else if (fullVal !== undefined) { + // No recursion necessary, Just keep value from fullObj + res[p] = fullVal; + } + } + } + } + return res +} + +module.exports = { + FigureView : FigureView, + FigureModel: FigureModel +}; diff --git a/js/src/embed.js b/js/src/embed.js new file mode 100644 index 0000000000..85bc6308ad --- /dev/null +++ b/js/src/embed.js @@ -0,0 +1,9 @@ +// Entry point for the unpkg bundle containing custom model definitions. +// +// It differs from the notebook bundle in that it does not need to define a +// dynamic baseURL for the static assets and may load some css that would +// already be loaded by the notebook otherwise. + +// Export widget models and views, and the npm package version number. +module.exports = require('./Figure.js'); +module.exports['version'] = require('../package.json').version; diff --git a/js/src/extension.js b/js/src/extension.js new file mode 100644 index 0000000000..93114e153c --- /dev/null +++ b/js/src/extension.js @@ -0,0 +1,19 @@ +// This file contains the javascript that is run when the notebook is loaded. +// It contains some requirejs configuration and the `load_ipython_extension` +// which is required for any notebook extension. + +// Configure requirejs +if (window.require) { + window.require.config({ + map: { + "*" : { + "plotlywidget": "nbextensions/plotlywidget/index" + } + } + }); +} + +// Export the required load_ipython_extention +module.exports = { + load_ipython_extension: function() {} +}; diff --git a/js/src/index.js b/js/src/index.js new file mode 100644 index 0000000000..fd81a0c733 --- /dev/null +++ b/js/src/index.js @@ -0,0 +1,3 @@ +// Export widget models and views, and the npm package version number. +module.exports = require('./Figure.js'); +module.exports['version'] = require('../package.json').version; diff --git a/js/src/jupyterlab-plugin.js b/js/src/jupyterlab-plugin.js new file mode 100644 index 0000000000..aff2ce752d --- /dev/null +++ b/js/src/jupyterlab-plugin.js @@ -0,0 +1,18 @@ +var plotly = require('./index'); +var base = require('@jupyter-widgets/base'); + +/** + * The widget manager provider. + */ +module.exports = { + id: 'plotlywidget', + requires: [base.IJupyterWidgetRegistry], + activate: function(app, widgets) { + widgets.registerWidget({ + name: 'plotlywidget', + version: plotly.version, + exports: plotly + }); + }, + autoStart: true +}; diff --git a/js/webpack.config.js b/js/webpack.config.js new file mode 100644 index 0000000000..167ed1335a --- /dev/null +++ b/js/webpack.config.js @@ -0,0 +1,79 @@ +var path = require('path'); +var version = require('./package.json').version; + +// Custom webpack loaders are generally the same for all webpack bundles, hence +// stored in a separate local variable. +var rules = [ + { test: /\.css$/, use: ['style-loader', 'css-loader']}, + { test: /\.js$/, use: ['ify-loader']} +]; + + +module.exports = [ + {// Notebook extension + // + // This bundle only contains the part of the JavaScript that is run on + // load of the notebook. This section generally only performs + // some configuration for requirejs, and provides the legacy + // "load_ipython_extension" function which is required for any notebook + // extension. + // + entry: './src/extension.js', + output: { + filename: 'extension.js', + path: path.resolve(__dirname, '..', 'plotlywidget', 'static'), + libraryTarget: 'amd' + } + }, + {// Bundle for the notebook containing the custom widget views and models + // + // This bundle contains the implementation for the custom widget views and + // custom widget. + // It must be an amd module + // + entry: './src/index.js', + output: { + filename: 'index.js', + path: path.resolve(__dirname, '..', 'plotlywidget', 'static'), + libraryTarget: 'amd' + }, + devtool: 'source-map', + node: { + fs: 'empty' + }, + module: { + rules: rules + }, + externals: ['@jupyter-widgets/base'] + }, + {// Embeddable plotlywidget bundle + // + // This bundle is generally almost identical to the notebook bundle + // containing the custom widget views and models. + // + // The only difference is in the configuration of the webpack public path + // for the static assets. + // + // It will be automatically distributed by unpkg to work with the static + // widget embedder. + // + // The target bundle is always `dist/index.js`, which is the path required + // by the custom widget embedder. + // + entry: './src/embed.js', + output: { + filename: 'index.js', + path: path.resolve(__dirname, 'dist'), + libraryTarget: 'amd', + publicPath: 'https://unpkg.com/plotlywidget@' + version + '/dist/' + }, + devtool: 'source-map', + node: { + fs: 'empty' + }, + module: { + rules: rules + }, + externals: ['@jupyter-widgets/base'] + } +]; diff --git a/makefile b/makefile index ca75f11480..355c05a1e4 100644 --- a/makefile +++ b/makefile @@ -17,16 +17,10 @@ setup_subs : make sync_subs update_default_schema : - @echo "Making sure the default-schema.json file is up to date" - python -c "import requests;\ - from requests.compat import json as _json;\ - response = requests.get('https://api.plot.ly/v2/plot-schema?sha1');\ - f = open('plotly/package_data/default-schema.json', 'w');\ - _json.dump(response.json()['schema'], f, indent=4,\ - sort_keys=True, separators=(',', ': '));\ - f.close()" - @echo "Auto-generating graph objects based on updated default-schema." - python update_graph_objs.py + @echo "Updating plotly-schema" + python setup.py updateschema + @echo "Auto-generating graph objects based on updated schema." + python setup.py codegen install : sync_subs @echo "" @@ -62,14 +56,8 @@ pull_chunked : submodules/chunked_requests cd submodules/chunked_requests; git pull origin master update_plotlyjs_for_offline : - @echo "Updating plotly.js for Offline Mode" + @echo "Updating plotly.js" @echo "------------------" - python -c "import urllib2;\ - cdn_url = 'https://cdn.plot.ly/plotly-latest.min.js';\ - response = urllib2.urlopen(cdn_url);\ - html = response.read();\ - f = open('./plotly/package_data/plotly.min.js', 'w');\ - f.write(html);\ - f.close()" + python setup.py updateplotlyjs @echo "---------------------------------" @echo "Remember to update the CHANGELOG!" diff --git a/meta.yaml b/meta.yaml index ebbde7aefe..bead5de9c4 100644 --- a/meta.yaml +++ b/meta.yaml @@ -56,6 +56,7 @@ test: - plotly.offline - plotly.plotly - plotly.plotly.chunked_requests + - plotly.validators - plotly.widgets # commands: diff --git a/migration-guide.md b/migration-guide.md new file mode 100644 index 0000000000..71ea8e9d67 --- /dev/null +++ b/migration-guide.md @@ -0,0 +1,152 @@ +# Migration to Version 3 +There are many new and great features in Plotly 3.0 including deeper Jupyter integration, deeper figure validation, improved performance, and more. This guide contains the a summary of the breaking changes that you need to be aware of when migrating code from version 2 to version 3. + +## Simple FigureWidget Example +We now have seamless integration with the Jupyter widget ecosystem. We've introduced a new graph object called `go.FigureWidget` that acts like a regular plotly `go.Figure` that can be directly displayed in the notebook. + +Simple Example: Make a Scatter Plot +```python +import plotly +import plotly.graph_objs as go + +f = go.FigureWidget() +``` + +## Tab Completion +Entering ``f.add_`` displays add methods for all of the supported trace types. Try it! +``` +f.add_ +``` + +Entering `f.add_scatter()` displays the names of all of the top-level properties for the scatter trace type + +Entering `f.add_scatter()` displays the signature pop-up. Expanding this pop-up reveals the method doc string which contains the descriptions of all of the top level properties. Let's finish add a scatter trace to `f`: + +```python +f.add_scatter(x=[1,2,3], y=[3,4,2]) +f +``` + +![Simple Scatter](example_images/simple_scatter.png) + +Notice that you don't need to use one of the legacy `iplot` methods to display a `FigureWidget`. Its visual representation is the plot itself! + +## New Plotly Object Representation +Plotly figures and graph objects have an updated `__repr__` method that displays objects in a pretty printed form that can be copied, pasted, and evaluated to recreate the object. + +Eg. `print(f)` returns + +``` +FigureWidget({ + 'data': [{'type': 'scatter', 'uid': '07968b11-7b0a-11e8-ba67-c869cda04ed6', 'x': [1, 2, 3], 'y': [4, 3, 2]}], + 'layout': {} +}) +``` + +## New add trace methods that handle subplots +The legacy `append_trace` method for adding traces to subplots has been deprecated in favor of the new `add_trace`, `add_traces`, and `add_*` methods. Each of these new methods accepts optional row/column information that may be used to add traces to subplots for figures initialized by the `plotly.tools.make_subplots` function. + +Let's create a subplot then turn it into a FigureWidget to display in the notebook. + +```python +import plotly +import plotly.graph_objs as go +import plotly.tools as tls + +import pandas as pd +dataset = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/diabetes.csv') + +subplot = tls.make_subplots(2, 2, print_grid=False) +f2 = go.FigureWidget(subplot) + +# Use add_trace method with optional row/col parameters +f2.add_trace(go.Scatter(x=dataset['Age'], y=dataset['Pregnancies'], mode='markers'), row=1, col=1) + +# Use add_traces with optional rows/cols parameters +f2.add_traces([ + go.Scatter(x=dataset['Age'], y=dataset['BMI'], mode='markers'), + go.Scatter(x=dataset['Age'], y=dataset['SkinThickness'], mode='markers')], + rows=[1, 2], cols=[2, 1] +) + +# Use add_scatter with optional row/col parameters +f2.add_scatter(x=dataset['Age'], y=dataset['BloodPressure'], mode='markers', row=2, col=2) + +f2.layout.title = 'Age and Diabetes Factors' +f2 +``` + +![Simple Subplots](example_images/subplot_methods.png) + +## Breaking Changes + +## Graph Objects Superclass +Graph objects are no longer `dict` subclasses, though they still provide many `dict`-like magic methods. + +## Graph Objects Hierarchy +All graph objects are now placed in a package hierarchy that matches their position in the object hierarchy. For example, `go.Marker` is now accessible as `go.scatter.Marker` or `go.bar.Marker` or whatever trace it is nested within. By providing unique objects under the parent-trace namespace, we can provide better validation (the properties for a marker object within a scatter trace may be different than the properties of a marker object within a bar trace). Although deprecated, the previous objects are still supported, they just won’t provide the same level of validation as our new objects. + +For example, the following approach to creating a `Marker` object for a `Scatter` trace is now deprecated. +``` +import plotly.graph_objs as go +go.Scatter( + x=[0], + y=[0], + marker=go.Marker( + color='rgb(255,45,15)' + ) +) +``` + +Instead, use the `Marker` object in the `go.scatter` package. + +``` +import plotly.graph_objs as go +go.Scatter( + x=[0], + y=[0], + marker=go.scatter.Marker( + color='rgb(255,45,15)' + ) +) +``` + +### Property Immutability +In order to support the automatic synchronization a `FigureWidget` object and the front-end view in a notebook, it is necessary for the `FigureWidget` to be aware of all changes to its properties. This is accomplished by presenting the individual properties to the user as immutable objects. For example, the `layout.xaxis.range` property may be assigned using a list, but it will be returned as a tuple. Similarly, object arrays (`Figure.data`, `Layout.images`, `Parcoords.dimensions`, etc.) are now represented as tuples of graph objects, not lists. + +### Object Array Classes Deprecated +Since graph object arrays are now represented as tuple of graph objects, the following object array classes are deprecated: `go.Data`, `go.Annotations`, and `go.Frames` + +### New Figure.data Assignment +There are new restriction on the assignment of traces to the `data` property of a figure. The assigned value must be a list or a tuple of a subset of the traces already present in the figure. Assignment to `data` may be used to reorder and remove existing traces, but it may not currently be used to add new traces. New traces must be added using the `add_trace`, `add_traces`, or `add_*` methods. + +For example, suppose a figure, `fig`, has 3 traces. The following command is valid and it will move the third trace to be the first, the first trace to be the second, and it will remove the second trace. + +``` +fig.data = [fig.data[2], fig.data[0]] +``` + +However this is not valid: +``` +fig.data = [fig.data[0], go.Scatter(y=[2, 3, 1])] +``` + +It's not valid because it's introducing a new trace during assignment. This trace would need to be added using `add_trace` instead. + +### Data array properties may not be specified as scalars +For example, the following is now invalid: +``` +import plotly.graph_objs as go +go.Bar(x=1) +``` + +This should be replaced by: +``` +import plotly.graph_objs as go +go.Bar(x=[1]) +``` + +### Removal of undocumented methods and properties + - Several undocumented `Figure` methods have been removed. These include: `.to_string`, `.strip_style`, `.get_data`, `.validate` and `.to_dataframe`. + + - Graph objects no longer support the undocumented `_raise` parameter. They are always validated and always raise an exception on validation failures. It is still possible to pass a dict to `plot`/`iplot` with `validate=False` to bypass validation. diff --git a/optional-requirements.txt b/optional-requirements.txt index 3d4083f6bf..a270815120 100644 --- a/optional-requirements.txt +++ b/optional-requirements.txt @@ -8,14 +8,17 @@ ## numpy (technically, this is covered by matplotlib's deps) ## numpy -## matplotlylib dependencies ## -# matplotlib==1.3.1 +## matplotlylib dependencies - moving away from 1.3.1 ## +# matplotlib==2.2.2 ## testing dependencies ## coverage==4.3.1 mock==2.0.0 nose==1.3.3 +## codegen dependencies ## +yapf + ## ipython ## ipython @@ -32,4 +35,7 @@ ipykernel ## deps for _county_choropleth.py figure factory pyshp geopandas -shapely \ No newline at end of file +shapely + +# ipyplotly integration +pil diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000000..48e341a095 --- /dev/null +++ b/package-lock.json @@ -0,0 +1,3 @@ +{ + "lockfileVersion": 1 +} diff --git a/plotly/animation.py b/plotly/animation.py new file mode 100644 index 0000000000..dabbc387a8 --- /dev/null +++ b/plotly/animation.py @@ -0,0 +1,54 @@ +from _plotly_utils.basevalidators import EnumeratedValidator, NumberValidator + + +class EasingValidator(EnumeratedValidator): + + def __init__(self, plotly_name='easing'): + super(EasingValidator, self).__init__(plotly_name=plotly_name, + parent_name='batch_animate', + values=[ + "linear", + "quad", + "cubic", + "sin", + "exp", + "circle", + "elastic", + "back", + "bounce", + "linear-in", + "quad-in", + "cubic-in", + "sin-in", + "exp-in", + "circle-in", + "elastic-in", + "back-in", + "bounce-in", + "linear-out", + "quad-out", + "cubic-out", + "sin-out", + "exp-out", + "circle-out", + "elastic-out", + "back-out", + "bounce-out", + "linear-in-out", + "quad-in-out", + "cubic-in-out", + "sin-in-out", + "exp-in-out", + "circle-in-out", + "elastic-in-out", + "back-in-out", + "bounce-in-out" + ]) + + +class DurationValidator(NumberValidator): + + def __init__(self, plotly_name='duration'): + super(DurationValidator, self).__init__(plotly_name=plotly_name, + parent_name='batch_animate', + min=0) diff --git a/plotly/api/v1/clientresp.py b/plotly/api/v1/clientresp.py index c3af66c6b1..d27fc5e812 100644 --- a/plotly/api/v1/clientresp.py +++ b/plotly/api/v1/clientresp.py @@ -25,7 +25,7 @@ def clientresp(data, **kwargs): dumps_kwargs = {'sort_keys': True, 'cls': utils.PlotlyJSONEncoder} payload = { - 'platform': 'python', 'version': version.__version__, + 'platform': 'python', 'version': version.stable_semver(), 'args': _json.dumps(data, **dumps_kwargs), 'un': creds['username'], 'key': creds['api_key'], 'origin': 'plot', 'kwargs': _json.dumps(kwargs, **dumps_kwargs) diff --git a/plotly/api/v2/utils.py b/plotly/api/v2/utils.py index 21bd0ddd01..a8222929ab 100644 --- a/plotly/api/v2/utils.py +++ b/plotly/api/v2/utils.py @@ -3,7 +3,7 @@ import requests from requests.compat import json as _json from requests.exceptions import RequestException - +from retrying import retry from plotly import config, exceptions, version, utils from plotly.api.utils import basic_auth @@ -93,7 +93,7 @@ def get_headers(): creds = config.get_credentials() headers = { - 'plotly-client-platform': 'python {}'.format(version.__version__), + 'plotly-client-platform': 'python {}'.format(version.stable_semver()), 'content-type': 'application/json' } @@ -111,6 +111,8 @@ def get_headers(): return headers +@retry(wait_random_min=100, wait_random_max=1000, wait_exponential_max=10000, + stop_max_delay=90000) def request(method, url, **kwargs): """ Central place to make any api v2 api request. diff --git a/plotly/basedatatypes.py b/plotly/basedatatypes.py new file mode 100644 index 0000000000..2b1830fe70 --- /dev/null +++ b/plotly/basedatatypes.py @@ -0,0 +1,3947 @@ +import collections +import re +import six +from six import string_types +import warnings +from contextlib import contextmanager +from copy import deepcopy, copy +from pprint import PrettyPrinter + +from .optional_imports import get_module + +from . import offline as pyo +from _plotly_utils.basevalidators import ( + CompoundValidator, CompoundArrayValidator, BaseDataValidator, + BaseValidator, LiteralValidator +) +from . import animation +from .callbacks import (Points, BoxSelector, LassoSelector, + InputDeviceState) +from .utils import ElidedPrettyPrinter +from .validators import (DataValidator, LayoutValidator, FramesValidator) + + +# Optional imports +# ---------------- +np = get_module('numpy') + +# Create Undefined sentinel value +# - Setting a property to None removes any existing value +# - Setting a property to Undefined leaves existing value unmodified +Undefined = object() + + +# back-port of fullmatch from Py3.4+ +def fullmatch(regex, string, flags=0): + """Emulate python-3.4 re.fullmatch().""" + if 'pattern' in dir(regex): + regex_string = regex.pattern + else: + regex_string = regex + return re.match("(?:" + regex_string + r")\Z", string, flags=flags) + + +class BaseFigure(object): + """ + Base class for all figure types (both widget and non-widget) + """ + + # Constructor + # ----------- + def __init__(self, data=None, layout_plotly=None, frames=None): + """ + Construct a BaseFigure object + + Parameters + ---------- + data + One of: + - A list or tuple of trace objects (or dicts that can be coerced + into trace objects) + + - If `data` is a dict that contains a 'data', + 'layout', or 'frames' key then these values are used to + construct the figure. + + - If `data` is a `BaseFigure` instance then the `data`, `layout`, + and `frames` properties are extracted from the input figure + layout_plotly + The plotly layout dict. + + Note: this property is named `layout_plotly` rather than `layout` + to deconflict it with the `layout` constructor parameter of the + `widgets.DOMWidget` ipywidgets class, as the `BaseFigureWidget` + class is a subclass of both BaseFigure and widgets.DOMWidget. + + If the `data` property is a BaseFigure instance, or a dict that + contains a 'layout' key, then this property is ignored. + frames + A list or tuple of `plotly.graph_objs.Frame` objects (or dicts + that can be coerced into Frame objects) + + If the `data` property is a BaseFigure instance, or a dict that + contains a 'frames' key, then this property is ignored. + """ + super(BaseFigure, self).__init__() + + # Assign layout_plotly to layout + # ------------------------------ + # See docstring note for explanation + layout = layout_plotly + + # Subplot properties + # ------------------ + # These properties are used by the tools.make_subplots logic. + # We initialize them to None here, before checking if the input data + # object is a BaseFigure, in which case we bring over the _grid* + # properties of the input BaseFigure + self._grid_str = None + self._grid_ref = None + + # Handle case where data is a Figure or Figure-like dict + # ------------------------------------------------------ + if isinstance(data, BaseFigure): + # Bring over subplot fields + self._grid_str = data._grid_str + self._grid_ref = data._grid_ref + + # Extract data, layout, and frames + data, layout, frames = data.data, data.layout, data.frames + + elif (isinstance(data, dict) + and ('data' in data or 'layout' in data or 'frames' in data)): + data, layout, frames = (data.get('data', None), + data.get('layout', None), + data.get('frames', None)) + + # Handle data (traces) + # -------------------- + # ### Construct data validator ### + # This is the validator that handles importing sequences of trace + # objects + self._data_validator = DataValidator(set_uid=True) + + # ### Import traces ### + data = self._data_validator.validate_coerce(data) + + # ### Save tuple of trace objects ### + self._data_objs = data + + # ### Import clone of trace properties ### + # The _data property is a list of dicts containing the properties + # explicitly set by the user for each trace. + self._data = [deepcopy(trace._props) for trace in data] + + # ### Create data defaults ### + # _data_defaults is a tuple of dicts, one for each trace. When + # running in a widget context, these defaults are populated with + # all property values chosen by the Plotly.js library that + # aren't explicitly specified by the user. + # + # Note: No property should exist in both the _data and + # _data_defaults for the same trace. + self._data_defaults = [{} for _ in data] + + # ### Reparent trace objects ### + for trace in data: + # By setting the trace's parent to be this figure, we tell the + # trace object to use the figure's _data and _data_defaults + # dicts to get/set it's properties, rather than using the trace + # object's internal _orphan_props dict. + trace._parent = self + + # We clear the orphan props since the trace no longer needs then + trace._orphan_props.clear() + + # Layout + # ------ + # ### Construct layout validator ### + # This is the validator that handles importing Layout objects + self._layout_validator = LayoutValidator() + + # ### Import Layout ### + self._layout_obj = self._layout_validator.validate_coerce(layout) + + # ### Import clone of layout properties ### + self._layout = deepcopy(self._layout_obj._props) + + # ### Initialize layout defaults dict ### + self._layout_defaults = {} + + # ### Reparent layout object ### + self._layout_obj._orphan_props.clear() + self._layout_obj._parent = self + + # Frames + # ------ + + # ### Construct frames validator ### + # This is the validator that handles importing sequences of frame + # objects + self._frames_validator = FramesValidator() + + # ### Import frames ### + self._frame_objs = self._frames_validator.validate_coerce(frames) + + # Note: Because frames are not currently supported in the widget + # context, we don't need to follow the pattern above and create + # _frames and _frame_defaults properties and then reparent the + # frames. The figure doesn't need to be notified of + # changes to the properties in the frames object hierarchy. + + # Context manager + # --------------- + + # ### batch mode indicator ### + # Flag that indicates whether we're currently inside a batch_*() + # context + self._in_batch_mode = False + + # ### Batch trace edits ### + # Dict from trace indexes to trace edit dicts. These trace edit dicts + # are suitable as `data` elements of Plotly.animate, but not + # the Plotly.update (See `_build_update_params_from_batch`) + # + # type: typ.Dict[int, typ.Dict[str, typ.Any]] + self._batch_trace_edits = {} + + # ### Batch layout edits ### + # Dict from layout properties to new layout values. This dict is + # directly suitable for use in Plotly.animate and Plotly.update + # type: typ.Dict[str, typ.Any] + self._batch_layout_edits = {} + + # Animation property validators + # ----------------------------- + self._animation_duration_validator = animation.DurationValidator() + self._animation_easing_validator = animation.EasingValidator() + + # Magic Methods + # ------------- + def __setitem__(self, prop, value): + + # Normalize prop + # -------------- + # Convert into a property tuple + orig_prop = prop + prop = BaseFigure._str_to_dict_path(prop) + + # Handle empty case + # ----------------- + if len(prop) == 0: + raise KeyError(orig_prop) + + # Handle scalar case + # ------------------ + # e.g. ('foo',) + elif len(prop) == 1: + # ### Unwrap scalar tuple ### + prop = prop[0] + + if prop == 'data': + self.data = value + elif prop == 'layout': + self.layout = value + elif prop == 'frames': + self.frames = value + else: + raise KeyError(prop) + + # Handle non-scalar case + # ---------------------- + # e.g. ('foo', 1) + else: + res = self + for p in prop[:-1]: + res = res[p] + + res[prop[-1]] = value + + def __setattr__(self, prop, value): + """ + Parameters + ---------- + prop : str + The name of a direct child of this object + value + New property value + Returns + ------- + None + """ + if prop.startswith('_') or hasattr(self, prop): + # Let known properties and private properties through + super(BaseFigure, self).__setattr__(prop, value) + else: + # Raise error on unknown public properties + raise AttributeError(prop) + + def __getitem__(self, prop): + + # Normalize prop + # -------------- + # Convert into a property tuple + orig_prop = prop + prop = BaseFigure._str_to_dict_path(prop) + + # Handle scalar case + # ------------------ + # e.g. ('foo',) + if len(prop) == 1: + # Unwrap scalar tuple + prop = prop[0] + + if prop == 'data': + return self._data_validator.present(self._data_objs) + elif prop == 'layout': + return self._layout_validator.present(self._layout_obj) + elif prop == 'frames': + return self._frames_validator.present(self._frame_objs) + else: + raise KeyError(orig_prop) + + # Handle non-scalar case + # ---------------------- + # e.g. ('foo', 1) + else: + res = self + for p in prop: + res = res[p] + + return res + + def __iter__(self): + return iter(('data', 'layout', 'frames')) + + def __contains__(self, prop): + return prop in ('data', 'layout', 'frames') + + def __eq__(self, other): + if not isinstance(other, BaseFigure): + # Require objects to both be BaseFigure instances + return False + else: + # Compare plotly_json representations + + # Use _vals_equal instead of `==` to handle cases where + # underlying dicts contain numpy arrays + return BasePlotlyType._vals_equal(self.to_plotly_json(), + other.to_plotly_json()) + + def __repr__(self): + """ + Customize Figure representation when displayed in the + terminal/notebook + """ + repr_str = BasePlotlyType._build_repr_for_class( + props=self.to_plotly_json(), + class_name=self.__class__.__name__) + + return repr_str + + def update(self, dict1=None, **kwargs): + """ + Update the properties of the figure with a dict and/or with + keyword arguments. + + This recursively updates the structure of the figure + object with the values in the input dict / keyword arguments. + + Parameters + ---------- + dict1 : dict + Dictionary of properties to be updated + kwargs : + Keyword/value pair of properties to be updated + + Examples + -------- + >>> import plotly.graph_objs as go + >>> fig = go.Figure(data=[{'y': [1, 2, 3]}]) + >>> fig.update(data=[{'y': [4, 5, 6]}]) + >>> fig.to_plotly_json() + {'data': [{'type': 'scatter', + 'uid': 'e86a7c7a-346a-11e8-8aa8-a0999b0c017b', + 'y': array([4, 5, 6], dtype=int32)}], + 'layout': {}} + + >>> fig = go.Figure(layout={'xaxis': + ... {'color': 'green', + ... 'range': [0, 1]}}) + >>> fig.update({'layout': {'xaxis': {'color': 'pink'}}}) + >>> fig.to_plotly_json() + {'data': [], + 'layout': {'xaxis': + {'color': 'pink', + 'range': [0, 1]}}} + + Returns + ------- + BaseFigure + Updated figure + """ + with self.batch_update(): + for d in [dict1, kwargs]: + if d: + for k, v in d.items(): + BaseFigure._perform_update(self[k], v) + + return self + + # Data + # ---- + @property + def data(self): + """ + The `data` property is a tuple of the figure's trace objects + + Returns + ------- + tuple[BaseTraceType] + """ + return self['data'] + + @data.setter + def data(self, new_data): + + # Validate new_data + # ----------------- + err_header = ('The data property of a figure may only be assigned ' + 'a list or tuple that contains a permutation of a ' + 'subset of itself\n') + + # ### Check valid input type ### + if not isinstance(new_data, (list, tuple)): + err_msg = (err_header + ' Received value with type {typ}' + .format(typ=type(new_data))) + raise ValueError(err_msg) + + # ### Check valid element types ### + for trace in new_data: + if not isinstance(trace, BaseTraceType): + err_msg = ( + err_header + ' Received element value of type {typ}' + .format(typ=type(trace))) + raise ValueError(err_msg) + + # ### Check UIDs ### + # Require that no new uids are introduced + orig_uids = [_trace['uid'] for _trace in self._data] + new_uids = [trace.uid for trace in new_data] + + invalid_uids = set(new_uids).difference(set(orig_uids)) + if invalid_uids: + err_msg = ( + err_header + ' Invalid trace(s) with uid(s): {invalid_uids}' + .format(invalid_uids=invalid_uids)) + + raise ValueError(err_msg) + + # ### Check for duplicates in assignment ### + uid_counter = collections.Counter(new_uids) + duplicate_uids = [ + uid for uid, count in uid_counter.items() if count > 1 + ] + if duplicate_uids: + err_msg = ( + err_header + ' Received duplicated traces with uid(s): ' + + '{duplicate_uids}'.format(duplicate_uids=duplicate_uids)) + + raise ValueError(err_msg) + + # Remove traces + # ------------- + remove_uids = set(orig_uids).difference(set(new_uids)) + delete_inds = [] + + # ### Unparent removed traces ### + for i, _trace in enumerate(self._data): + if _trace['uid'] in remove_uids: + delete_inds.append(i) + + # Unparent trace object to be removed + old_trace = self.data[i] + old_trace._orphan_props.update(deepcopy(old_trace._props)) + old_trace._parent = None + + # ### Compute trace props / defaults after removal ### + traces_props_post_removal = [t for t in self._data] + traces_prop_defaults_post_removal = [t for t in self._data_defaults] + uids_post_removal = [trace_data['uid'] for trace_data in self._data] + + for i in reversed(delete_inds): + del traces_props_post_removal[i] + del traces_prop_defaults_post_removal[i] + del uids_post_removal[i] + + # Modify in-place so we don't trigger serialization + del self._data[i] + + if delete_inds: + # Update widget, if any + self._send_deleteTraces_msg(delete_inds) + + # Move traces + # ----------- + + # ### Compute new index for each remaining trace ### + new_inds = [] + for uid in uids_post_removal: + new_inds.append(new_uids.index(uid)) + + # ### Compute current index for each remaining trace ### + current_inds = list(range(len(traces_props_post_removal))) + + # ### Check whether a move is needed ### + if not all([i1 == i2 for i1, i2 in zip(new_inds, current_inds)]): + + # #### Update widget, if any #### + self._send_moveTraces_msg(current_inds, new_inds) + + # #### Reorder trace elements #### + # We do so in-place so we don't trigger traitlet property + # serialization for the FigureWidget case + # ##### Remove by curr_inds in reverse order ##### + moving_traces_data = [] + for ci in reversed(current_inds): + # Push moving traces data to front of list + moving_traces_data.insert(0, self._data[ci]) + del self._data[ci] + + # #### Sort new_inds and moving_traces_data by new_inds #### + new_inds, moving_traces_data = zip( + *sorted(zip(new_inds, moving_traces_data))) + + # #### Insert by new_inds in forward order #### + for ni, trace_data in zip(new_inds, moving_traces_data): + self._data.insert(ni, trace_data) + + # ### Update data defaults ### + # There is to front-end syncronization to worry about so this + # operations doesn't need to be in-place + self._data_defaults = [ + _trace for i, _trace in sorted( + zip(new_inds, traces_prop_defaults_post_removal)) + ] + + # Update trace objects tuple + self._data_objs = list(new_data) + + # Restyle + # ------- + def plotly_restyle(self, restyle_data, trace_indexes=None, **kwargs): + """ + Perform a Plotly restyle operation on the figure's traces + + Parameters + ---------- + restyle_data : dict + Dict of trace style updates. + + Keys are strings that specify the properties to be updated. + Nested properties are expressed by joining successive keys on + '.' characters (e.g. 'marker.color'). + + Values may be scalars or lists. When values are scalars, + that scalar value is applied to all traces specified by the + `trace_indexes` parameter. When values are lists, + the restyle operation will cycle through the elements + of the list as it cycles through the traces specified by the + `trace_indexes` parameter. + + Caution: To use plotly_restyle to update a list property (e.g. + the `x` property of the scatter trace), the property value + should be a scalar list containing the list to update with. For + example, the following command would be used to update the 'x' + property of the first trace to the list [1, 2, 3] + + >>> fig.plotly_restyle({'x': [[1, 2, 3]]}, 0) + + trace_indexes : int or list of int + Trace index, or list of trace indexes, that the restyle operation + applies to. Defaults to all trace indexes. + + Returns + ------- + None + """ + + # Normalize trace indexes + # ----------------------- + trace_indexes = self._normalize_trace_indexes(trace_indexes) + + # Handle source_view_id + # --------------------- + # If not None, the source_view_id is the UID of the frontend + # Plotly.js view that initially triggered this restyle operation + # (e.g. the user clicked on the legend to hide a trace). We pass + # this UID along so that the frontend views can determine whether + # they need to apply the restyle operation on themselves. + source_view_id = kwargs.get('source_view_id', None) + + # Perform restyle on trace dicts + # ------------------------------ + restyle_changes = self._perform_plotly_restyle(restyle_data, + trace_indexes) + if restyle_changes: + # The restyle operation resulted in a change to some trace + # properties, so we dispatch change callbacks and send the + # restyle message to the frontend (if any) + msg_kwargs = ({'source_view_id': source_view_id} + if source_view_id is not None + else {}) + + self._send_restyle_msg( + restyle_changes, + trace_indexes=trace_indexes, + **msg_kwargs) + + self._dispatch_trace_change_callbacks( + restyle_changes, trace_indexes) + + def _perform_plotly_restyle(self, restyle_data, trace_indexes): + """ + Perform a restyle operation on the figure's traces data and return + the changes that were applied + + Parameters + ---------- + restyle_data : dict[str, any] + See docstring for plotly_restyle + trace_indexes : list[int] + List of trace indexes that restyle operation applies to + Returns + ------- + restyle_changes: dict[str, any] + Subset of restyle_data including only the keys / values that + resulted in a change to the figure's traces data + """ + # Initialize restyle changes + # -------------------------- + # This will be a subset of the restyle_data including only the + # keys / values that are changed in the figure's trace data + restyle_changes = {} + + # Process each key + # ---------------- + for key_path_str, v in restyle_data.items(): + + # Track whether any of the new values are cause a change in + # self._data + any_vals_changed = False + for i, trace_ind in enumerate(trace_indexes): + if trace_ind >= len(self._data): + raise ValueError( + 'Trace index {trace_ind} out of range'.format( + trace_ind=trace_ind)) + + # Get new value for this particular trace + trace_v = v[i % len(v)] if isinstance(v, list) else v + + if trace_v is not Undefined: + + # Get trace being updated + trace_obj = self.data[trace_ind] + + # Validate key_path_str + if not BaseFigure._is_key_path_compatible( + key_path_str, trace_obj): + + trace_class = trace_obj.__class__.__name__ + raise ValueError(""" +Invalid property path '{key_path_str}' for trace class {trace_class} +""".format(key_path_str=key_path_str, trace_class=trace_class)) + + # Apply set operation for this trace and thist value + val_changed = BaseFigure._set_in(self._data[trace_ind], + key_path_str, + trace_v) + + # Update any_vals_changed status + any_vals_changed = (any_vals_changed or val_changed) + + if any_vals_changed: + restyle_changes[key_path_str] = v + + return restyle_changes + + def _restyle_child(self, child, key_path_str, val): + """ + Process restyle operation on a child trace object + + Note: This method name/signature must match the one in + BasePlotlyType. BasePlotlyType objects call their parent's + _restyle_child method without knowing whether their parent is a + BasePlotlyType or a BaseFigure. + + Parameters + ---------- + child : BaseTraceType + Child being restyled + key_path_str : str + A key path string (e.g. 'foo.bar[0]') + val + Restyle value + + Returns + ------- + None + """ + + # Compute trace index + # ------------------- + trace_index = BaseFigure._index_is(self.data, child) + + # Not in batch mode + # ----------------- + # Dispatch change callbacks and send restyle message + if not self._in_batch_mode: + send_val = [val] + restyle = {key_path_str: send_val} + self._send_restyle_msg(restyle, trace_indexes=trace_index) + self._dispatch_trace_change_callbacks(restyle, [trace_index]) + + # In batch mode + # ------------- + # Add key_path_str/val to saved batch edits + else: + if trace_index not in self._batch_trace_edits: + self._batch_trace_edits[trace_index] = {} + self._batch_trace_edits[trace_index][key_path_str] = val + + def _normalize_trace_indexes(self, trace_indexes): + """ + Input trace index specification and return list of the specified trace + indexes + + Parameters + ---------- + trace_indexes : None or int or list[int] + + Returns + ------- + list[int] + """ + if trace_indexes is None: + trace_indexes = list(range(len(self.data))) + if not isinstance(trace_indexes, (list, tuple)): + trace_indexes = [trace_indexes] + return list(trace_indexes) + + @staticmethod + def _str_to_dict_path(key_path_str): + """ + Convert a key path string into a tuple of key path elements + + Parameters + ---------- + key_path_str : str + Key path string, where nested keys are joined on '.' characters + and array indexes are specified using brackets + (e.g. 'foo.bar[1]') + Returns + ------- + tuple[str | int] + """ + if isinstance(key_path_str, tuple): + # Nothing to do + return key_path_str + else: + # Split string on periods. e.g. 'foo.bar[1]' -> ['foo', 'bar[1]'] + key_path = key_path_str.split('.') + + # Split out bracket indexes. + # e.g. ['foo', 'bar[1]'] -> ['foo', 'bar', '1'] + bracket_re = re.compile('(.*)\[(\d+)\]') + key_path2 = [] + for key in key_path: + match = fullmatch(bracket_re, key) + #match = bracket_re.fullmatch(key) + if match: + key_path2.extend(match.groups()) + else: + key_path2.append(key) + + # Convert elements to ints if possible. + # e.g. ['foo', 'bar', '0'] -> ['foo', 'bar', 0] + for i in range(len(key_path2)): + try: + key_path2[i] = int(key_path2[i]) + except ValueError as _: + pass + + return tuple(key_path2) + + @staticmethod + def _set_in(d, key_path_str, v): + """ + Set a value in a nested dict using a key path string + (e.g. 'foo.bar[0]') + + Parameters + ---------- + d : dict + Input dict to set property in + key_path_str : str + Key path string, where nested keys are joined on '.' characters + and array indexes are specified using brackets + (e.g. 'foo.bar[1]') + v + New value + Returns + ------- + bool + True if set resulted in modification of dict (i.e. v was not + already present at the specified location), False otherwise. + """ + + # Validate inputs + # --------------- + assert isinstance(d, dict) + + # Compute key path + # ---------------- + # Convert the key_path_str into a tuple of key paths + # e.g. 'foo.bar[0]' -> ('foo', 'bar', 0) + key_path = BaseFigure._str_to_dict_path(key_path_str) + + # Initialize val_parent + # --------------------- + # This variable will be assigned to the parent of the next key path + # element currently being processed + val_parent = d + + # Initialize parent dict or list of value to be assigned + # ----------------------------------------------------- + for kp, key_path_el in enumerate(key_path[:-1]): + + # Extend val_parent list if needed + if (isinstance(val_parent, list) and + isinstance(key_path_el, int)): + while len(val_parent) <= key_path_el: + val_parent.append(None) + + elif (isinstance(val_parent, dict) and + key_path_el not in val_parent): + if isinstance(key_path[kp + 1], int): + val_parent[key_path_el] = [] + else: + val_parent[key_path_el] = {} + + val_parent = val_parent[key_path_el] + + # Assign value to to final parent dict or list + # -------------------------------------------- + # ### Get reference to final key path element ### + last_key = key_path[-1] + + # ### Track whether assignment alters parent ### + val_changed = False + + # v is Undefined + # -------------- + # Don't alter val_parent + if v is Undefined: + pass + + # v is None + # --------- + # Check whether we can remove key from parent + elif v is None: + if isinstance(val_parent, dict): + if last_key in val_parent: + # Parent is a dict and has last_key as a current key so + # we can pop the key, which alters parent + val_parent.pop(last_key) + val_changed = True + elif isinstance(val_parent, list): + if (isinstance(last_key, int) and + 0 <= last_key < len(val_parent)): + # Parent is a list and last_key is a valid index so we + # can set the element value to None + val_parent[last_key] = None + val_changed = True + else: + # Unsupported parent type (numpy array for example) + raise ValueError(""" + Cannot remove element of type {typ} at location {raw_key}""" + .format(typ=type(val_parent), + raw_key=key_path_str)) + # v is a valid value + # ------------------ + # Check whether parent should be updated + else: + if isinstance(val_parent, dict): + if (last_key not in val_parent + or not BasePlotlyType._vals_equal( + val_parent[last_key], v)): + # Parent is a dict and does not already contain the + # value v at key last_key + val_parent[last_key] = v + val_changed = True + elif isinstance(val_parent, list): + if isinstance(last_key, int): + # Extend list with Nones if needed so that last_key is + # in bounds + while len(val_parent) <= last_key: + val_parent.append(None) + + if not BasePlotlyType._vals_equal( + val_parent[last_key], v): + # Parent is a list and does not already contain the + # value v at index last_key + val_parent[last_key] = v + val_changed = True + else: + # Unsupported parent type (numpy array for example) + raise ValueError(""" + Cannot set element of type {typ} at location {raw_key}""" + .format(typ=type(val_parent), + raw_key=key_path_str)) + return val_changed + + # Add traces + # ---------- + @staticmethod + def _raise_invalid_rows_cols(name, n, invalid): + rows_err_msg = """ + If specified, the {name} parameter must be a list or tuple of integers + of length {n} (The number of traces being added) + + Received: {invalid} + """.format(name=name, n=n, invalid=invalid) + + raise ValueError(rows_err_msg) + + @staticmethod + def _validate_rows_cols(name, n, vals): + if vals is None: + pass + elif isinstance(vals, (list, tuple)): + if len(vals) != n: + BaseFigure._raise_invalid_rows_cols( + name=name, n=n, invalid=vals) + + if [r for r in vals if not isinstance(r, int)]: + BaseFigure._raise_invalid_rows_cols( + name=name, n=n, invalid=vals) + else: + BaseFigure._raise_invalid_rows_cols(name=name, n=n, invalid=vals) + + def add_trace(self, trace, row=None, col=None): + """ + Add a trace to the figure + + Parameters + ---------- + trace : BaseTraceType or dict + Either: + - An instances of a trace classe from the plotly.graph_objs + package (e.g plotly.graph_objs.Scatter, plotly.graph_objs.Bar) + - or a dicts where: + + - The 'type' property specifies the trace type (e.g. + 'scatter', 'bar', 'area', etc.). If the dict has no 'type' + property then 'scatter' is assumed. + - All remaining properties are passed to the constructor + of the specified trace type. + + row : int or None (default) + Subplot row index (starting from 1) for the trace to be added. + Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be added. + Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + BaseTraceType + The newly added trace + + Examples + -------- + >>> from plotly import tools + >>> import plotly.graph_objs as go + + Add two Scatter traces to a figure + >>> fig = go.Figure() + >>> fig.add_trace(go.Scatter(x=[1,2,3], y=[2,1,2])) + >>> fig.add_trace(go.Scatter(x=[1,2,3], y=[2,1,2])) + + + Add two Scatter traces to vertically stacked subplots + >>> fig = tools.make_subplots(rows=2) + This is the format of your plot grid: + [ (1,1) x1,y1 ] + [ (2,1) x2,y2 ] + + >>> fig.add_trace(go.Scatter(x=[1,2,3], y=[2,1,2]), row=1, col=1) + >>> fig.add_trace(go.Scatter(x=[1,2,3], y=[2,1,2]), row=2, col=1) + """ + # Validate row/col + if row is not None and not isinstance(row, int): + pass + + if col is not None and not isinstance(col, int): + pass + + # Make sure we have both row and col or neither + if row is not None and col is None: + raise ValueError( + 'Received row parameter but not col.\n' + 'row and col must be specified together') + elif col is not None and row is None: + raise ValueError( + 'Received col parameter but not row.\n' + 'row and col must be specified together') + + return self.add_traces(data=[trace], + rows=[row] if row is not None else None, + cols=[col] if col is not None else None + )[0] + + def add_traces(self, data, rows=None, cols=None): + """ + Add traces to the figure + + Parameters + ---------- + data : list[BaseTraceType or dict] + A list of trace specifications to be added. + Trace specifications may be either: + + - Instances of trace classes from the plotly.graph_objs + package (e.g plotly.graph_objs.Scatter, plotly.graph_objs.Bar) + - Dicts where: + + - The 'type' property specifies the trace type (e.g. + 'scatter', 'bar', 'area', etc.). If the dict has no 'type' + property then 'scatter' is assumed. + - All remaining properties are passed to the constructor + of the specified trace type. + + rows : None or list[int] (default None) + List of subplot row indexes (starting from 1) for the traces to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + cols : None or list[int] (default None) + List of subplot column indexes (starting from 1) for the traces + to be added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + tuple[BaseTraceType] + Tuple of the newly added traces + + Examples + -------- + >>> from plotly import tools + >>> import plotly.graph_objs as go + + Add two Scatter traces to a figure + >>> fig = go.Figure() + >>> fig.add_traces([go.Scatter(x=[1,2,3], y=[2,1,2]), + ... go.Scatter(x=[1,2,3], y=[2,1,2])]) + + Add two Scatter traces to vertically stacked subplots + >>> fig = tools.make_subplots(rows=2) + This is the format of your plot grid: + [ (1,1) x1,y1 ] + [ (2,1) x2,y2 ] + + >>> fig.add_traces([go.Scatter(x=[1,2,3], y=[2,1,2]), + ... go.Scatter(x=[1,2,3], y=[2,1,2])], + ... rows=[1, 2], cols=[1, 1]) + """ + + if self._in_batch_mode: + self._batch_layout_edits.clear() + self._batch_trace_edits.clear() + raise ValueError('Traces may not be added in a batch context') + + # Validate traces + data = self._data_validator.validate_coerce(data) + + # Validate rows / cols + n = len(data) + BaseFigure._validate_rows_cols('rows', n, rows) + BaseFigure._validate_rows_cols('cols', n, cols) + + # Make sure we have both rows and cols or neither + if rows is not None and cols is None: + raise ValueError( + 'Received rows parameter but not cols.\n' + 'rows and cols must be specified together') + elif cols is not None and rows is None: + raise ValueError( + 'Received cols parameter but not rows.\n' + 'rows and cols must be specified together') + + # Apply rows / cols + if rows is not None: + for trace, row, col in zip(data, rows, cols): + self._set_trace_grid_position(trace, row, col) + + # Make deep copy of trace data (Optimize later if needed) + new_traces_data = [deepcopy(trace._props) for trace in data] + + # Update trace parent + for trace in data: + trace._parent = self + trace._orphan_props.clear() + + # Update python side + # Use extend instead of assignment so we don't trigger serialization + self._data.extend(new_traces_data) + self._data_defaults = self._data_defaults + [{} for _ in data] + self._data_objs = self._data_objs + data + + # Update messages + self._send_addTraces_msg(new_traces_data) + + return data + + # Subplots + # -------- + def print_grid(self): + """ + Print a visual layout of the figure's axes arrangement. + This is only valid for figures that are created + with plotly.tools.make_subplots. + """ + if self._grid_str is None: + raise Exception("Use plotly.tools.make_subplots " + "to create a subplot grid.") + print(self._grid_str) + + def append_trace(self, trace, row, col): + """ + Add a trace to the figure bound to axes at the specified row, + col index. + + A row, col index grid is generated for figures created with + plotly.tools.make_subplots, and can be viewed with the `print_grid` + method + + Parameters + ---------- + trace + The data trace to be bound + row: int + Subplot row index (see Figure.print_grid) + col: int + Subplot column index (see Figure.print_grid) + + Examples + -------- + >>> from plotly import tools + >>> import plotly.graph_objs as go + # stack two subplots vertically + >>> fig = tools.make_subplots(rows=2) + This is the format of your plot grid: + [ (1,1) x1,y1 ] + [ (2,1) x2,y2 ] + + >>> fig.append_trace(go.Scatter(x=[1,2,3], y=[2,1,2]), row=1, col=1) + >>> fig.append_trace(go.Scatter(x=[1,2,3], y=[2,1,2]), row=2, col=1) + """ + warnings.warn("""\ +The append_trace method is deprecated and will be removed in a future version. +Please use the add_trace method with the row and col parameters. +""", DeprecationWarning) + + self.add_trace(trace=trace, row=row, col=col) + + def _set_trace_grid_position(self, trace, row, col): + try: + grid_ref = self._grid_ref + except AttributeError: + raise Exception("In order to use Figure.append_trace, " + "you must first use " + "plotly.tools.make_subplots " + "to create a subplot grid.") + if row <= 0: + raise Exception("Row value is out of range. " + "Note: the starting cell is (1, 1)") + if col <= 0: + raise Exception("Col value is out of range. " + "Note: the starting cell is (1, 1)") + try: + ref = grid_ref[row - 1][col - 1] + except IndexError: + raise Exception("The (row, col) pair sent is out of " + "range. Use Figure.print_grid to view the " + "subplot grid. ") + if 'scene' in ref[0]: + trace['scene'] = ref[0] + if ref[0] not in self['layout']: + raise Exception("Something went wrong. " + "The scene object for ({r},{c}) " + "subplot cell " + "got deleted.".format(r=row, c=col)) + else: + xaxis_key = "xaxis{ref}".format(ref=ref[0][1:]) + yaxis_key = "yaxis{ref}".format(ref=ref[1][1:]) + if (xaxis_key not in self['layout'] + or yaxis_key not in self['layout']): + raise Exception("Something went wrong. " + "An axis object for ({r},{c}) subplot " + "cell got deleted.".format(r=row, c=col)) + trace['xaxis'] = ref[0] + trace['yaxis'] = ref[1] + + # Child property operations + # ------------------------- + def _get_child_props(self, child): + """ + Return the properties dict for a child trace or child layout + + Note: this method must match the name/signature of one on + BasePlotlyType + + Parameters + ---------- + child : BaseTraceType | BaseLayoutType + + Returns + ------- + dict + """ + # Try to find index of child as a trace + # ------------------------------------- + try: + trace_index = BaseFigure._index_is(self.data, child) + except ValueError as _: + trace_index = None + + # Child is a trace + # ---------------- + if trace_index is not None: + return self._data[trace_index] + + # Child is the layout + # ------------------- + elif child is self.layout: + return self._layout + + # Unknown child + # ------------- + else: + raise ValueError('Unrecognized child: %s' % child) + + def _get_child_prop_defaults(self, child): + """ + Return the default properties dict for a child trace or child layout + + Note: this method must match the name/signature of one on + BasePlotlyType + + Parameters + ---------- + child : BaseTraceType | BaseLayoutType + + Returns + ------- + dict + """ + # Try to find index of child as a trace + # ------------------------------------- + try: + trace_index = BaseFigure._index_is(self.data, child) + except ValueError as _: + trace_index = None + + # Child is a trace + # ---------------- + if trace_index is not None: + return self._data_defaults[trace_index] + + # Child is the layout + # ------------------- + elif child is self.layout: + return self._layout_defaults + + # Unknown child + # ------------- + else: + raise ValueError('Unrecognized child: %s' % child) + + def _init_child_props(self, child): + """ + Initialize the properites dict for a child trace or layout + + Note: this method must match the name/signature of one on + BasePlotlyType + + Parameters + ---------- + child : BaseTraceType | BaseLayoutType + + Returns + ------- + None + """ + # layout and traces dict are initialize when figure is constructed + # and when new traces are added to the figure + pass + + # Layout + # ------ + @property + def layout(self): + """ + The `layout` property of the figure + + Returns + ------- + plotly.graph_objs.Layout + """ + return self['layout'] + + @layout.setter + def layout(self, new_layout): + + # Validate new layout + # ------------------- + new_layout = self._layout_validator.validate_coerce(new_layout) + new_layout_data = deepcopy(new_layout._props) + + # Unparent current layout + # ----------------------- + if self._layout_obj: + old_layout_data = deepcopy(self._layout_obj._props) + self._layout_obj._orphan_props.update(old_layout_data) + self._layout_obj._parent = None + + # Parent new layout + # ----------------- + self._layout = new_layout_data + new_layout._parent = self + new_layout._orphan_props.clear() + self._layout_obj = new_layout + + # Notify JS side + self._send_relayout_msg(new_layout_data) + + def plotly_relayout(self, relayout_data, **kwargs): + """ + Perform a Plotly relayout operation on the figure's layout + + Parameters + ---------- + relayout_data : dict + Dict of layout updates + + dict keys are strings that specify the properties to be updated. + Nested properties are expressed by joining successive keys on + '.' characters (e.g. 'xaxis.range') + + dict values are the values to use to update the layout. + + Returns + ------- + None + """ + + # Handle source_view_id + # --------------------- + # If not None, the source_view_id is the UID of the frontend + # Plotly.js view that initially triggered this relayout operation + # (e.g. the user clicked on the toolbar to change the drag mode + # from zoom to pan). We pass this UID along so that the frontend + # views can determine whether they need to apply the relayout + # operation on themselves. + if 'source_view_id' in kwargs: + msg_kwargs = {'source_view_id': kwargs['source_view_id']} + else: + msg_kwargs = {} + + # Perform relayout operation on layout dict + # ----------------------------------------- + relayout_changes = self._perform_plotly_relayout(relayout_data) + if relayout_changes: + # The relayout operation resulted in a change to some layout + # properties, so we dispatch change callbacks and send the + # relayout message to the frontend (if any) + self._send_relayout_msg( + relayout_changes, **msg_kwargs) + + self._dispatch_layout_change_callbacks(relayout_changes) + + def _perform_plotly_relayout(self, relayout_data): + """ + Perform a relayout operation on the figure's layout data and return + the changes that were applied + + Parameters + ---------- + relayout_data : dict[str, any] + See the docstring for plotly_relayout + Returns + ------- + relayout_changes: dict[str, any] + Subset of relayout_data including only the keys / values that + resulted in a change to the figure's layout data + """ + # Initialize relayout changes + # --------------------------- + # This will be a subset of the relayout_data including only the + # keys / values that are changed in the figure's layout data + relayout_changes = {} + + # Process each key + # ---------------- + for key_path_str, v in relayout_data.items(): + + if not BaseFigure._is_key_path_compatible( + key_path_str, self.layout): + + raise ValueError(""" +Invalid property path '{key_path_str}' for layout +""".format(key_path_str=key_path_str)) + + # Apply set operation on the layout dict + val_changed = BaseFigure._set_in(self._layout, key_path_str, v) + + if val_changed: + relayout_changes[key_path_str] = v + + return relayout_changes + + @staticmethod + def _is_key_path_compatible(key_path_str, plotly_obj): + """ + Return whether the specifieid key path string is compatible with + the specified plotly object for the purpose of relayout/restyle + operation + """ + + # Convert string to tuple of path components + # e.g. 'foo[0].bar[1]' -> ('foo', 0, 'bar', 1) + key_path_tuple = BaseFigure._str_to_dict_path(key_path_str) + + # Remove trailing integer component + # e.g. ('foo', 0, 'bar', 1) -> ('foo', 0, 'bar') + # We do this because it's fine for relayout/restyle to create new + # elements in the final array in the path. + if isinstance(key_path_tuple[-1], int): + key_path_tuple = key_path_tuple[:-1] + + # Test whether modified key path tuple is in plotly_obj + return key_path_tuple in plotly_obj + + def _relayout_child(self, child, key_path_str, val): + """ + Process relayout operation on child layout object + + Parameters + ---------- + child : BaseLayoutType + The figure's layout + key_path_str : + A key path string (e.g. 'foo.bar[0]') + val + Relayout value + + Returns + ------- + None + """ + + # Validate input + # -------------- + assert child is self.layout + + # Not in batch mode + # ------------- + # Dispatch change callbacks and send relayout message + if not self._in_batch_mode: + relayout_msg = {key_path_str: val} + self._send_relayout_msg(relayout_msg) + self._dispatch_layout_change_callbacks(relayout_msg) + + # In batch mode + # ------------- + # Add key_path_str/val to saved batch edits + else: + self._batch_layout_edits[key_path_str] = val + + # Dispatch change callbacks + # ------------------------- + @staticmethod + def _build_dispatch_plan(key_path_strs): + """ + Build a dispatch plan for a list of key path strings + + A dispatch plan is a dict: + - *from* path tuples that reference an object that has descendants + that are referenced in `key_path_strs`. + - *to* sets of tuples that correspond to descendants of the object + above. + + Parameters + ---------- + key_path_strs : list[str] + List of key path strings. For example: + + ['xaxis.rangeselector.font.color', 'xaxis.rangeselector.bgcolor'] + + Returns + ------- + dispatch_plan: dict[tuple[str|int], set[tuple[str|int]]] + + Examples + -------- + >>> key_path_strs = ['xaxis.rangeselector.font.color', + ... 'xaxis.rangeselector.bgcolor'] + + >>> BaseFigure._build_dispatch_plan(key_path_strs) + {(): {('xaxis',), + ('xaxis', 'rangeselector'), + ('xaxis', 'rangeselector', 'bgcolor'), + ('xaxis', 'rangeselector', 'font'), + ('xaxis', 'rangeselector', 'font', 'color')}, + ('xaxis',): {('rangeselector',), + ('rangeselector', 'bgcolor'), + ('rangeselector', 'font'), + ('rangeselector', 'font', 'color')}, + ('xaxis', 'rangeselector'): {('bgcolor',), + ('font',), + ('font', 'color')}, + ('xaxis', 'rangeselector', 'font'): {('color',)}} + """ + dispatch_plan = {} + + for key_path_str in key_path_strs: + + key_path = BaseFigure._str_to_dict_path(key_path_str) + key_path_so_far = () + keys_left = key_path + + # Iterate down the key path + for next_key in key_path: + if key_path_so_far not in dispatch_plan: + dispatch_plan[key_path_so_far] = set() + + to_add = [keys_left[:i+1] for i in range(len(keys_left))] + dispatch_plan[key_path_so_far].update(to_add) + + key_path_so_far = key_path_so_far + (next_key, ) + keys_left = keys_left[1:] + + return dispatch_plan + + def _dispatch_layout_change_callbacks(self, relayout_data): + """ + Dispatch property change callbacks given relayout_data + + Parameters + ---------- + relayout_data : dict[str, any] + See docstring for plotly_relayout. + + Returns + ------- + None + """ + # Build dispatch plan + # ------------------- + key_path_strs = list(relayout_data.keys()) + dispatch_plan = BaseFigure._build_dispatch_plan(key_path_strs) + + # Dispatch changes to each layout objects + # --------------------------------------- + for path_tuple, changed_paths in dispatch_plan.items(): + if path_tuple in self.layout: + dispatch_obj = self.layout[path_tuple] + if isinstance(dispatch_obj, BasePlotlyType): + dispatch_obj._dispatch_change_callbacks(changed_paths) + + def _dispatch_trace_change_callbacks(self, restyle_data, trace_indexes): + """ + Dispatch property change callbacks given restyle_data + + Parameters + ---------- + restyle_data : dict[str, any] + See docstring for plotly_restyle. + + trace_indexes : list[int] + List of trace indexes that restyle operation applied to + + Returns + ------- + None + """ + + # Build dispatch plan + # ------------------- + key_path_strs = list(restyle_data.keys()) + dispatch_plan = BaseFigure._build_dispatch_plan(key_path_strs) + + # Dispatch changes to each object in each trace + # --------------------------------------------- + for path_tuple, changed_paths in dispatch_plan.items(): + for trace_ind in trace_indexes: + trace = self.data[trace_ind] + if path_tuple in trace: + dispatch_obj = trace[path_tuple] + if isinstance(dispatch_obj, BasePlotlyType): + dispatch_obj._dispatch_change_callbacks(changed_paths) + + # Frames + # ------ + @property + def frames(self): + """ + The `frames` property is a tuple of the figure's frame objects + + Returns + ------- + tuple[plotly.graph_objs.Frame] + """ + return self['frames'] + + @frames.setter + def frames(self, new_frames): + # Note: Frames are not supported by the FigureWidget subclass so we + # only validate coerce the frames. We don't emit any events on frame + # changes, and we don't reparent the frames. + + # Validate frames + self._frame_objs = self._frames_validator.validate_coerce(new_frames) + + # Update + # ------ + def plotly_update(self, + restyle_data=None, + relayout_data=None, + trace_indexes=None, + **kwargs): + """ + Perform a Plotly update operation on the figure. + + Note: This operation both mutates and returns the figure + + Parameters + ---------- + restyle_data : dict + Traces update specification. See the docstring for the + `plotly_restyle` method for details + relayout_data : dict + Layout update specification. See the docstring for the + `plotly_relayout` method for details + trace_indexes : + Trace index, or list of trace indexes, that the update operation + applies to. Defaults to all trace indexes. + + Returns + ------- + BaseFigure + None + """ + + # Handle source_view_id + # --------------------- + # If not None, the source_view_id is the UID of the frontend + # Plotly.js view that initially triggered this update operation + # (e.g. the user clicked a button that triggered an update + # operation). We pass this UID along so that the frontend views can + # determine whether they need to apply the update operation on + # themselves. + if 'source_view_id' in kwargs: + msg_kwargs = {'source_view_id': kwargs['source_view_id']} + else: + msg_kwargs = {} + + # Perform update operation + # ------------------------ + # This updates the _data and _layout dicts, and returns the changes + # to the traces (restyle_changes) and layout (relayout_changes) + (restyle_changes, + relayout_changes, + trace_indexes) = self._perform_plotly_update( + restyle_data=restyle_data, + relayout_data=relayout_data, + trace_indexes=trace_indexes) + + # Send update message + # ------------------- + # Send a plotly_update message to the frontend (if any) + if restyle_changes or relayout_changes: + self._send_update_msg( + restyle_data=restyle_changes, + relayout_data=relayout_changes, + trace_indexes=trace_indexes, + **msg_kwargs) + + # Dispatch changes + # ---------------- + # ### Dispatch restyle changes ### + if restyle_changes: + self._dispatch_trace_change_callbacks( + restyle_changes, trace_indexes) + + # ### Dispatch relayout changes ### + if relayout_changes: + self._dispatch_layout_change_callbacks(relayout_changes) + + def _perform_plotly_update(self, restyle_data=None, relayout_data=None, + trace_indexes=None): + + # Check for early exist + # --------------------- + if not restyle_data and not relayout_data: + # Nothing to do + return None, None, None + + # Normalize input + # --------------- + if restyle_data is None: + restyle_data = {} + if relayout_data is None: + relayout_data = {} + + trace_indexes = self._normalize_trace_indexes(trace_indexes) + + # Perform relayout + # ---------------- + relayout_changes = self._perform_plotly_relayout(relayout_data) + + # Perform restyle + # --------------- + restyle_changes = self._perform_plotly_restyle( + restyle_data, trace_indexes) + + # Return changes + # -------------- + return restyle_changes, relayout_changes, trace_indexes + + # Plotly message stubs + # -------------------- + # send-message stubs that may be overridden by the widget subclass + def _send_addTraces_msg(self, new_traces_data): + pass + + def _send_moveTraces_msg(self, current_inds, new_inds): + pass + + def _send_deleteTraces_msg(self, delete_inds): + pass + + def _send_restyle_msg(self, style, trace_indexes=None, + source_view_id=None): + pass + + def _send_relayout_msg(self, layout, source_view_id=None): + pass + + def _send_update_msg(self, + restyle_data, + relayout_data, + trace_indexes=None, + source_view_id=None): + pass + + def _send_animate_msg(self, + styles_data, + relayout_data, + trace_indexes, + animation_opts): + pass + + # Context managers + # ---------------- + @contextmanager + def batch_update(self): + """ + A context manager that batches up trace and layout assignment + operations into a singe plotly_update message that is executed when + the context exits. + + Examples + -------- + For example, suppose we have a figure widget, `fig`, with a single + trace. + >>> import plotly.graph_objs as go + >>> fig = go.FigureWidget(data=[{'y': [3, 4, 2]}]) + + If we want to update the xaxis range, the yaxis range, and the + marker color, we could do so using a series of three property + assignments as follows: + + >>> fig.layout.xaxis.range = [0, 5] + >>> fig.layout.yaxis.range = [0, 10] + >>> fig.data[0].marker.color = 'green' + + This will work, however it will result in three messages being + sent to the front end (two relayout messages for the axis range + updates followed by one restyle message for the marker color + update). This can cause the plot to appear to stutter as the + three updates are applied incrementally. + + We can avoid this problem by performing these three assignments in a + `batch_update` context as follows: + + >>> with fig.batch_update(): + ... fig.layout.xaxis.range = [0, 5] + ... fig.layout.yaxis.range = [0, 10] + ... fig.data[0].marker.color = 'green' + + Now, these three property updates will be sent to the frontend in a + single update message, and they will be applied by the front end + simultaneously. + """ + if self._in_batch_mode is True: + yield + else: + try: + self._in_batch_mode = True + yield + finally: + # ### Disable batch mode ### + self._in_batch_mode = False + + # ### Build plotly_update params ### + (restyle_data, + relayout_data, + trace_indexes) = self._build_update_params_from_batch() + + # ### Call plotly_update ### + self.plotly_update( + restyle_data=restyle_data, + relayout_data=relayout_data, + trace_indexes=trace_indexes) + + # ### Clear out saved batch edits ### + self._batch_layout_edits.clear() + self._batch_trace_edits.clear() + + def _build_update_params_from_batch(self): + """ + Convert `_batch_trace_edits` and `_batch_layout_edits` into the + `restyle_data`, `relayout_data`, and `trace_indexes` params accepted + by the `plotly_update` method. + + Returns + ------- + (dict, dict, list[int]) + """ + + # Handle Style / Trace Indexes + # ---------------------------- + batch_style_commands = self._batch_trace_edits + trace_indexes = sorted( + set([trace_ind for trace_ind in batch_style_commands])) + + all_props = sorted( + set([ + prop for trace_style in self._batch_trace_edits.values() + for prop in trace_style + ])) + + # Initialize restyle_data dict with all values undefined + restyle_data = { + prop: [Undefined for _ in range(len(trace_indexes))] + for prop in all_props + } + + # Fill in values + for trace_ind, trace_style in batch_style_commands.items(): + for trace_prop, trace_val in trace_style.items(): + restyle_trace_index = trace_indexes.index(trace_ind) + restyle_data[trace_prop][restyle_trace_index] = trace_val + + # Handle Layout + # ------------- + relayout_data = self._batch_layout_edits + + # Return plotly_update params + # --------------------------- + return restyle_data, relayout_data, trace_indexes + + @contextmanager + def batch_animate(self, duration=500, easing="cubic-in-out"): + """ + Context manager to animate trace / layout updates + + Parameters + ---------- + duration : number + The duration of the transition, in milliseconds. + If equal to zero, updates are synchronous. + easing : string + The easing function used for the transition. + One of: + - linear + - quad + - cubic + - sin + - exp + - circle + - elastic + - back + - bounce + - linear-in + - quad-in + - cubic-in + - sin-in + - exp-in + - circle-in + - elastic-in + - back-in + - bounce-in + - linear-out + - quad-out + - cubic-out + - sin-out + - exp-out + - circle-out + - elastic-out + - back-out + - bounce-out + - linear-in-out + - quad-in-out + - cubic-in-out + - sin-in-out + - exp-in-out + - circle-in-out + - elastic-in-out + - back-in-out + - bounce-in-out + + Examples + -------- + Suppose we have a figure widget, `fig`, with a single trace. + + >>> import plotly.graph_objs as go + >>> fig = go.FigureWidget(data=[{'y': [3, 4, 2]}]) + + 1) Animate a change in the xaxis and yaxis ranges using default + duration and easing parameters. + + >>> with fig.batch_animate(): + ... fig.layout.xaxis.range = [0, 5] + ... fig.layout.yaxis.range = [0, 10] + + 2) Animate a change in the size and color of the trace's markers + over 2 seconds using the elastic-in-out easing method + >>> with fig.batch_update(duration=2000, easing='elastic-in-out'): + ... fig.data[0].marker.color = 'green' + ... fig.data[0].marker.size = 20 + """ + + # Validate inputs + # --------------- + duration = self._animation_duration_validator.validate_coerce(duration) + easing = self._animation_easing_validator.validate_coerce(easing) + + if self._in_batch_mode is True: + yield + else: + try: + self._in_batch_mode = True + yield + finally: + # Exit batch mode + # --------------- + self._in_batch_mode = False + + # Apply batch animate + # ------------------- + self._perform_batch_animate({ + 'transition': { + 'duration': duration, + 'easing': easing + }, + 'frame': { + 'duration': duration + } + }) + + def _perform_batch_animate(self, animation_opts): + """ + Perform the batch animate operation + + This method should be called with the batch_animate() context + manager exits. + + Parameters + ---------- + animation_opts : dict + Animation options as accepted by frontend Plotly.animation command + + Returns + ------- + None + """ + # Apply commands to internal dictionaries as an update + # ---------------------------------------------------- + (restyle_data, + relayout_data, + trace_indexes) = self._build_update_params_from_batch() + + (restyle_changes, + relayout_changes, + trace_indexes) = self._perform_plotly_update(restyle_data, + relayout_data, + trace_indexes) + + # Convert style / trace_indexes into animate form + # ----------------------------------------------- + if self._batch_trace_edits: + animate_styles, animate_trace_indexes = zip( + *[(trace_style, trace_index) for trace_index, trace_style in + self._batch_trace_edits.items()]) + else: + animate_styles, animate_trace_indexes = {}, [] + + animate_layout = copy(self._batch_layout_edits) + + # Send animate message + # -------------------- + # Sends animate message to the front end (if any) + self._send_animate_msg( + styles_data=list(animate_styles), + relayout_data=animate_layout, + trace_indexes=list(animate_trace_indexes), + animation_opts=animation_opts) + + # Clear batched commands + # ---------------------- + self._batch_layout_edits.clear() + self._batch_trace_edits.clear() + + # Dispatch callbacks + # ------------------ + # ### Dispatch restyle changes ### + if restyle_changes: + self._dispatch_trace_change_callbacks(restyle_changes, + trace_indexes) + + # ### Dispatch relayout changes ### + if relayout_changes: + self._dispatch_layout_change_callbacks(relayout_changes) + + # Exports + # ------- + def to_dict(self): + """ + Convert figure to a dictionary + + Note: the dictionary includes the properties explicitly set by the + user, it does not include default values of unspecified properties + + Returns + ------- + dict + """ + # Handle data + # ----------- + data = deepcopy(self._data) + + # Handle layout + # ------------- + layout = deepcopy(self._layout) + + # Handle frames + # ------------- + # Frame key is only added if there are any frames + res = {'data': data, 'layout': layout} + frames = deepcopy([frame._props for frame in self._frame_objs]) + if frames: + res['frames'] = frames + + return res + + def to_plotly_json(self): + """ + Convert figure to a JSON representation as a Python dict + + Returns + ------- + dict + """ + return self.to_dict() + + # Static helpers + # -------------- + @staticmethod + def _is_dict_list(v): + """ + Return true of the input object is a list of dicts + """ + return isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict) + + @staticmethod + def _perform_update(plotly_obj, update_obj): + """ + Helper to support the update() methods on :class:`BaseFigure` and + :class:`BasePlotlyType` + + Parameters + ---------- + plotly_obj : BasePlotlyType|tuple[BasePlotlyType] + Object to up updated + update_obj : dict|list[dict]|tuple[dict] + When ``plotly_obj`` is an instance of :class:`BaseFigure`, + ``update_obj`` should be a dict + + When ``plotly_obj`` is a tuple of instances of + :class:`BasePlotlyType`, ``update_obj`` should be a tuple or list + of dicts + """ + + if update_obj is None: + # Nothing to do + return + elif isinstance(plotly_obj, BasePlotlyType): + + # Handle invalid properties + # ------------------------- + invalid_props = [ + k for k in update_obj if k not in plotly_obj._validators + ] + + plotly_obj._raise_on_invalid_property_error(*invalid_props) + + # Process valid properties + # ------------------------ + for key in update_obj: + val = update_obj[key] + validator = plotly_obj._validators[key] + + if isinstance(validator, CompoundValidator): + + # Update compound objects recursively + # plotly_obj[key].update(val) + BaseFigure._perform_update( + plotly_obj[key], val) + elif isinstance(validator, CompoundArrayValidator): + BaseFigure._perform_update( + plotly_obj[key], val) + else: + # Assign non-compound value + plotly_obj[key] = val + + elif isinstance(plotly_obj, tuple): + + if len(update_obj) == 0: + # Nothing to do + return + else: + for i, plotly_element in enumerate(plotly_obj): + if isinstance(update_obj, dict): + if i in update_obj: + update_element = update_obj[i] + else: + continue + else: + update_element = update_obj[i % len(update_obj)] + BaseFigure._perform_update(plotly_element, update_element) + else: + raise ValueError('Unexpected plotly object with type {typ}' + .format(typ=type(plotly_obj))) + + @staticmethod + def _index_is(iterable, val): + """ + Return the index of a value in an iterable using object identity + (not object equality as is the case for list.index) + + """ + index_list = [ + i for i, curr_val in enumerate(iterable) if curr_val is val + ] + if not index_list: + raise ValueError('Invalid value') + + return index_list[0] + + +class BasePlotlyType(object): + """ + BasePlotlyType is the base class for all objects in the trace, layout, + and frame object hierarchies + """ + + def __init__(self, plotly_name, **kwargs): + """ + Construct a new BasePlotlyType + + Parameters + ---------- + plotly_name : str + The lowercase name of the plotly object + kwargs : dict + Invalid props/values to raise on + """ + # Validate inputs + # --------------- + self._process_kwargs(**kwargs) + + # Store params + # ------------ + self._plotly_name = plotly_name + + # Initialize properties + # --------------------- + # ### _validators ### + # A dict from property names to property validators + # type: Dict[str, BaseValidator] + self._validators = {} + + # ### _compound_props ### + # A dict from compound property names to compound objects + # type: Dict[str, BasePlotlyType] + self._compound_props = {} + + # ### _compound_array_props ### + # A dict from compound array property names to tuples of compound + # objects + # type: Dict[str, Tuple[BasePlotlyType]] + self._compound_array_props = {} + + # ### _orphan_props ### + # A dict of properties for use while object has no parent. When + # object has a parent, it requests its properties dict from its + # parent and doesn't use this. + # type: Dict + self._orphan_props = {} + + # ### _parent ### + # The parent of the object. May be another BasePlotlyType or it may + # be a BaseFigure (as is the case for the Layout and Trace objects) + # type: Union[BasePlotlyType, BaseFigure] + self._parent = None + + # ### _change_callbacks ### + # A dict from tuples of child property path tuples to lists + # of callbacks that should be executed whenever any of these + # properties is modified + # type: Dict[Tuple[Tuple[Union[str, int]]], List[Callable]] + self._change_callbacks = {} + + def _process_kwargs(self, **kwargs): + """ + Process any extra kwargs that are not predefined as constructor params + """ + self._raise_on_invalid_property_error(*kwargs.keys()) + + @property + def plotly_name(self): + """ + The plotly name of the object + + Returns + ------- + str + """ + return self._plotly_name + + @property + def _parent_path_str(self): + """ + dot-separated path string to this object's parent. + + Returns + ------- + str + + Examples + -------- + >>> import plotly.graph_objs as go + >>> go.Layout()._parent_path_str + '' + + >>> go.layout.XAxis()._parent_path_str + 'layout' + + >>> go.layout.xaxis.rangeselector.Button()._parent_path_str + 'layout.xaxis.rangeselector' + """ + raise NotImplementedError + + @property + def _prop_descriptions(self): + """ + Formatted string containing all of this obejcts child properties + and their descriptions + + Returns + ------- + str + """ + raise NotImplementedError + + @property + def _props(self): + """ + Dictionary used to store this object properties. When the object + has a parent, this dict is retreived from the parent. When the + object does not have a parent, this dict is the object's + `_orphan_props` property + + Note: Property will return None if the object has a parent and the + object's properties have not been initialized using the + `_init_props` method. + + Returns + ------- + dict|None + """ + if self.parent is None: + # Use orphan data + return self._orphan_props + else: + # Get data from parent's dict + return self.parent._get_child_props(self) + + def _get_child_props(self, child): + """ + Return properties dict for child + + Parameters + ---------- + child : BasePlotlyType + + Returns + ------- + dict + """ + if self._props is None: + # If this node's properties are uninitialized then so are its + # child's + return None + else: + # ### Child a compound property ### + if child.plotly_name in self._compound_props: + return self._props.get(child.plotly_name, None) + + # ### Child an element of a compound array property ### + elif child.plotly_name in self._compound_array_props: + children = self._compound_array_props[child.plotly_name] + child_ind = BaseFigure._index_is(children, child) + assert child_ind is not None + + children_props = self._props.get(child.plotly_name, None) + return (children_props[child_ind] + if children_props is not None and + len(children_props) > child_ind + else None) + + # ### Invalid child ### + else: + raise ValueError('Invalid child with name: %s' + % child.plotly_name) + + def _init_props(self): + """ + Ensure that this object's properties dict has been initialized. When + the object has a parent, this ensures that the parent has an + initialized properties dict with this object's plotly_name as a key. + + Returns + ------- + None + """ + # Ensure that _data is initialized. + if self._props is not None: + pass + else: + self._parent._init_child_props(self) + + def _init_child_props(self, child): + """ + Ensure that a properties dict has been initialized for a child object + + Parameters + ---------- + child : BasePlotlyType + + Returns + ------- + None + """ + # Init our own properties + # ----------------------- + self._init_props() + + # Child a compound property + # ------------------------- + if child.plotly_name in self._compound_props: + if child.plotly_name not in self._props: + self._props[child.plotly_name] = {} + + # Child an element of a compound array property + # --------------------------------------------- + elif child.plotly_name in self._compound_array_props: + children = self._compound_array_props[child.plotly_name] + child_ind = BaseFigure._index_is(children, child) + assert child_ind is not None + + if child.plotly_name not in self._props: + # Initialize list + self._props[child.plotly_name] = [] + + # Make sure list is long enough for child + children_list = self._props[child.plotly_name] + while len(children_list) <= child_ind: + children_list.append({}) + + # Invalid child + # ------------- + else: + raise ValueError('Invalid child with name: %s' + % child.plotly_name) + + def _get_child_prop_defaults(self, child): + """ + Return default properties dict for child + + Parameters + ---------- + child : BasePlotlyType + + Returns + ------- + dict + """ + if self._prop_defaults is None: + # If this node's default properties are uninitialized then so are + # its child's + return None + else: + # ### Child a compound property ### + if child.plotly_name in self._compound_props: + return self._prop_defaults.get(child.plotly_name, None) + + # ### Child an element of a compound array property ### + elif child.plotly_name in self._compound_array_props: + children = self._compound_array_props[child.plotly_name] + child_ind = BaseFigure._index_is(children, child) + + assert child_ind is not None + + children_props = self._prop_defaults.get( + child.plotly_name, None) + + return (children_props[child_ind] + if children_props is not None and + len(children_props) > child_ind + else None) + + # ### Invalid child ### + else: + raise ValueError('Invalid child with name: %s' + % child.plotly_name) + + @property + def _prop_defaults(self): + """ + Return default properties dict + + Returns + ------- + dict + """ + if self.parent is None: + return None + else: + return self.parent._get_child_prop_defaults(self) + + @property + def parent(self): + """ + Return the object's parent, or None if the object has no parent + Returns + ------- + BasePlotlyType|BaseFigure + """ + return self._parent + + @property + def figure(self): + """ + Reference to the top-level Figure or FigureWidget that this object + belongs to. None if the object does not belong to a Figure + + Returns + ------- + Union[BaseFigure, None] + """ + top_parent = self + while top_parent is not None: + if isinstance(top_parent, BaseFigure): + break + else: + top_parent = top_parent.parent + + return top_parent + + # Magic Methods + # ------------- + def __getitem__(self, prop): + """ + Get item or nested item from object + + Parameters + ---------- + prop : str|tuple + + If prop is the name of a property of this object, then the + property is returned. + + If prop is a nested property path string (e.g. 'foo[1].bar'), + then a nested property is returned (e.g. obj['foo'][1]['bar']) + + If prop is a path tuple (e.g. ('foo', 1, 'bar')), then a nested + property is returned (e.g. obj['foo'][1]['bar']). + + Returns + ------- + Any + """ + + # Normalize prop + # -------------- + # Convert into a property tuple + prop = BaseFigure._str_to_dict_path(prop) + + # Handle scalar case + # ------------------ + # e.g. ('foo',) + if len(prop) == 1: + # Unwrap scalar tuple + prop = prop[0] + if prop not in self._validators: + raise KeyError(prop) + + validator = self._validators[prop] + if prop in self._compound_props: + return validator.present(self._compound_props[prop]) + elif prop in self._compound_array_props: + return validator.present(self._compound_array_props[prop]) + elif self._props is not None and prop in self._props: + return validator.present(self._props[prop]) + elif self._prop_defaults is not None: + return validator.present(self._prop_defaults.get(prop, None)) + else: + return None + + # Handle non-scalar case + # ---------------------- + # e.g. ('foo', 1), () + else: + res = self + for p in prop: + res = res[p] + + return res + + def __contains__(self, prop): + """ + Determine whether object contains a property or nested property + + Parameters + ---------- + prop : str|tuple + If prop is a simple string (e.g. 'foo'), then return true of the + object contains an element named 'foo' + + If prop is a property path string (e.g. 'foo[0].bar'), + then return true if the obejct contains the nested elements for + each entry in the path string (e.g. 'bar' in obj['foo'][0]) + + If prop is a property path tuple (e.g. ('foo', 0, 'bar')), + then return true if the object contains the nested elements for + each entry in the path string (e.g. 'bar' in obj['foo'][0]) + + Returns + ------- + bool + """ + prop_tuple = BaseFigure._str_to_dict_path(prop) + + obj = self + for p in prop_tuple: + if isinstance(p, int): + if isinstance(obj, tuple) and 0 <= p < len(obj): + obj = obj[p] + else: + return False + else: + if p in obj._validators: + obj = obj[p] + else: + return False + + return True + + def __setitem__(self, prop, value): + """ + Parameters + ---------- + prop : str + The name of a direct child of this object + + Note: Setting nested properties using property path string or + property path tuples is not supported. + value + New property value + + Returns + ------- + None + """ + + # Normalize prop + # -------------- + # Convert into a property tuple + orig_prop = prop + prop = BaseFigure._str_to_dict_path(prop) + + # Handle empty case + # ----------------- + if len(prop) == 0: + raise KeyError(orig_prop) + + # Handle scalar case + # ------------------ + # e.g. ('foo',) + if len(prop) == 1: + + # ### Unwrap scalar tuple ### + prop = prop[0] + + # ### Validate prop ### + if prop not in self._validators: + self._raise_on_invalid_property_error(prop) + + # ### Get validator for this property ### + validator = self._validators[prop] + + # ### Handle compound property ### + if isinstance(validator, CompoundValidator): + self._set_compound_prop(prop, value) + + # ### Handle compound array property ### + elif isinstance(validator, + (CompoundArrayValidator, BaseDataValidator)): + self._set_array_prop(prop, value) + + # ### Handle simple property ### + else: + self._set_prop(prop, value) + + # Handle non-scalar case + # ---------------------- + # e.g. ('foo', 1), () + else: + res = self + for p in prop[:-1]: + res = res[p] + + res[prop[-1]] = value + + def __setattr__(self, prop, value): + """ + Parameters + ---------- + prop : str + The name of a direct child of this object + value + New property value + Returns + ------- + None + """ + if (prop.startswith('_') or + hasattr(self, prop) or + prop in self._validators): + # Let known properties and private properties through + super(BasePlotlyType, self).__setattr__(prop, value) + else: + # Raise error on unknown public properties + self._raise_on_invalid_property_error(prop) + + def __iter__(self): + """ + Return an iterator over the object's properties + """ + return iter(self._validators.keys()) + + def __eq__(self, other): + """ + Test for equality + + To be considered equal, `other` must have the same type as this object + and their `to_plotly_json` representaitons must be identical. + + Parameters + ---------- + other + The object to compare against + + Returns + ------- + bool + """ + if not isinstance(other, self.__class__): + # Require objects to be of the same plotly type + return False + else: + # Compare plotly_json representations + + # Use _vals_equal instead of `==` to handle cases where + # underlying dicts contain numpy arrays + return BasePlotlyType._vals_equal( + self._props if self._props is not None else {}, + other._props if other._props is not None else {}) + + @staticmethod + def _build_repr_for_class(props, class_name, parent_path_str=None): + """ + Helper to build representation string for a class + + Parameters + ---------- + class_name : str + Name of the class being represented + parent_path_str : str of None (default) + Name of the class's parent package to display + props : dict + Properties to unpack into the constructor + + Returns + ------- + str + The representation string + """ + if parent_path_str: + class_name = parent_path_str + '.' + class_name + + if len(props) == 0: + repr_str = class_name + '()' + else: + pprinter = ElidedPrettyPrinter(threshold=200, width=120) + pprint_res = pprinter.pformat(props) + + # pprint_res is indented by 1 space. Add extra 3 spaces for PEP8 + # complaint indent + body = ' ' + pprint_res[1:-1].replace('\n', '\n ') + + repr_str = class_name + '({\n ' + body + '\n})' + + return repr_str + + def __repr__(self): + """ + Customize object representation when displayed in the + terminal/notebook + """ + + # Get all properties + props = self._props if self._props is not None else {} + + # Remove literals (These can't be specified in the constructor) + props = {p: v for p, v in props.items() + if p in self._validators and + not isinstance(self._validators[p], LiteralValidator)} + + # Build repr string + repr_str = BasePlotlyType._build_repr_for_class( + props=props, + class_name=self.__class__.__name__, + parent_path_str=self._parent_path_str) + + return repr_str + + def _raise_on_invalid_property_error(self, *args): + """ + Raise informative exception when invalid property names are + encountered + + Parameters + ---------- + args : list[str] + List of property names that have already been determined to be + invalid + + Raises + ------ + ValueError + Always + """ + invalid_props = args + if invalid_props: + if len(invalid_props) == 1: + prop_str = 'property' + invalid_str = repr(invalid_props[0]) + else: + prop_str = 'properties' + invalid_str = repr(invalid_props) + + module_root = 'plotly.graph_objs.' + if self._parent_path_str: + full_obj_name = (module_root + self._parent_path_str + '.' + + self.__class__.__name__) + else: + full_obj_name = module_root + self.__class__.__name__ + + raise ValueError("Invalid {prop_str} specified for object of type " + "{full_obj_name}: {invalid_str}\n\n" + " Valid properties:\n" + "{prop_descriptions}".format( + prop_str=prop_str, + full_obj_name=full_obj_name, + invalid_str=invalid_str, + prop_descriptions=self._prop_descriptions)) + + def update(self, dict1=None, **kwargs): + """ + Update the properties of an object with a dict and/or with + keyword arguments. + + This recursively updates the structure of the original + object with the values in the input dict / keyword arguments. + + Parameters + ---------- + dict1 : dict + Dictionary of properties to be updated + kwargs : + Keyword/value pair of properties to be updated + + Returns + ------- + BasePlotlyType + Updated plotly object + """ + if self.figure: + with self.figure.batch_update(): + BaseFigure._perform_update(self, dict1) + BaseFigure._perform_update(self, kwargs) + else: + BaseFigure._perform_update(self, dict1) + BaseFigure._perform_update(self, kwargs) + + @property + def _in_batch_mode(self): + """ + True if the object belongs to a figure that is currently in batch mode + Returns + ------- + bool + """ + return self.parent and self.parent._in_batch_mode + + def _set_prop(self, prop, val): + """ + Set the value of a simple property + + Parameters + ---------- + prop : str + Name of a simple (non-compound, non-array) property + val + The new property value + + Returns + ------- + Any + The coerced assigned value + """ + + # val is Undefined + # ---------------- + if val is Undefined: + # Do nothing + return + + # Import value + # ------------ + validator = self._validators.get(prop) + val = validator.validate_coerce(val) + + # val is None + # ----------- + if val is None: + # Check if we should send null update + if self._props and prop in self._props: + # Remove property if not in batch mode + if not self._in_batch_mode: + self._props.pop(prop) + + # Send property update message + self._send_prop_set(prop, val) + + # val is valid value + # ------------------ + else: + # Make sure properties dict is initialized + self._init_props() + + # Check whether the value is a change + if (prop not in self._props or + not BasePlotlyType._vals_equal(self._props[prop], val)): + # Set property value if not in batch mode + if not self._in_batch_mode: + self._props[prop] = val + + # Send property update message + self._send_prop_set(prop, val) + + return val + + def _set_compound_prop(self, prop, val): + """ + Set the value of a compound property + + Parameters + ---------- + prop : str + Name of a compound property + val + The new property value + + Returns + ------- + BasePlotlyType + The coerced assigned object + """ + + # val is Undefined + # ---------------- + if val is Undefined: + # Do nothing + return + + # Import value + # ------------ + validator = self._validators.get(prop) + # type: BasePlotlyType + val = validator.validate_coerce(val) + + # Save deep copies of current and new states + # ------------------------------------------ + curr_val = self._compound_props.get(prop, None) + if curr_val is not None: + curr_dict_val = deepcopy(curr_val._props) + else: + curr_dict_val = None + + if val is not None: + new_dict_val = deepcopy(val._props) + else: + new_dict_val = None + + # Update _props dict + # ------------------ + if not self._in_batch_mode: + if not new_dict_val: + if prop in self._props: + self._props.pop(prop) + else: + self._init_props() + self._props[prop] = new_dict_val + + # Send update if there was a change in value + # ------------------------------------------ + if not BasePlotlyType._vals_equal(curr_dict_val, new_dict_val): + self._send_prop_set(prop, new_dict_val) + + # Reparent + # -------- + # ### Reparent new value and clear orphan data ### + val._parent = self + val._orphan_props.clear() + + # ### Unparent old value and update orphan data ### + if curr_val is not None: + if curr_dict_val is not None: + curr_val._orphan_props.update(curr_dict_val) + curr_val._parent = None + + # Update _compound_props + # ---------------------- + self._compound_props[prop] = val + return val + + def _set_array_prop(self, prop, val): + """ + Set the value of a compound property + + Parameters + ---------- + prop : str + Name of a compound property + val + The new property value + + Returns + ------- + tuple[BasePlotlyType] + The coerced assigned object + """ + + # val is Undefined + # ---------------- + if val is Undefined: + # Do nothing + return + + # Import value + # ------------ + validator = self._validators.get(prop) + # type: Tuple[BasePlotlyType] + val = validator.validate_coerce(val) + + # Save deep copies of current and new states + # ------------------------------------------ + curr_val = self._compound_array_props.get(prop, None) + if curr_val is not None: + curr_dict_vals = [deepcopy(cv._props) for cv in curr_val] + else: + curr_dict_vals = None + + if val is not None: + new_dict_vals = [deepcopy(nv._props) for nv in val] + else: + new_dict_vals = None + + # Update _props dict + # ------------------ + if not self._in_batch_mode: + if not new_dict_vals: + if prop in self._props: + self._props.pop(prop) + else: + self._init_props() + self._props[prop] = new_dict_vals + + # Send update if there was a change in value + # ------------------------------------------ + if not BasePlotlyType._vals_equal(curr_dict_vals, new_dict_vals): + self._send_prop_set(prop, new_dict_vals) + + # Reparent + # -------- + # ### Reparent new values and clear orphan data ### + if val is not None: + for v in val: + v._orphan_props.clear() + v._parent = self + + # ### Unparent old value and update orphan data ### + if curr_val is not None: + for cv, cv_dict in zip(curr_val, curr_dict_vals): + if cv_dict is not None: + cv._orphan_props.update(cv_dict) + cv._parent = None + + # Update _compound_array_props + # ---------------------------- + self._compound_array_props[prop] = val + return val + + def _send_prop_set(self, prop_path_str, val): + """ + Notify parent that a property has been set to a new value + + Parameters + ---------- + prop_path_str : str + Property path string (e.g. 'foo[0].bar') of property that + was set, relative to this object + val + New value for property. Either a simple value, a dict, + or a tuple of dicts. This should *not* be a BasePlotlyType object. + + Returns + ------- + None + """ + raise NotImplementedError() + + def _prop_set_child(self, child, prop_path_str, val): + """ + Propagate property setting notification from child to parent + + Parameters + ---------- + child : BasePlotlyType + Child object + prop_path_str : str + Property path string (e.g. 'foo[0].bar') of property that + was set, relative to `child` + val + New value for property. Either a simple value, a dict, + or a tuple of dicts. This should *not* be a BasePlotlyType object. + + Returns + ------- + None + """ + + # Child is compound array property + # -------------------------------- + child_prop_val = getattr(self, child.plotly_name) + if isinstance(child_prop_val, (list, tuple)): + child_ind = BaseFigure._index_is(child_prop_val, child) + obj_path = '{child_name}.{child_ind}.{prop}'.format( + child_name=child.plotly_name, + child_ind=child_ind, + prop=prop_path_str) + + # Child is compound property + # -------------------------- + else: + obj_path = '{child_name}.{prop}'.format( + child_name=child.plotly_name, + prop=prop_path_str) + + # Propagate to parent + # ------------------- + self._send_prop_set(obj_path, val) + + def _restyle_child(self, child, prop, val): + """ + Propagate _restyle_child to parent + + Note: This method must match the name and signature of the + corresponding method on BaseFigure + """ + self._prop_set_child(child, prop, val) + + def _relayout_child(self, child, prop, val): + """ + Propagate _relayout_child to parent + + Note: This method must match the name and signature of the + corresponding method on BaseFigure + """ + self._prop_set_child(child, prop, val) + + # Callbacks + # --------- + def _dispatch_change_callbacks(self, changed_paths): + """ + Execute the appropriate change callback functions given a set of + changed property path tuples + + Parameters + ---------- + changed_paths : set[tuple[int|str]] + + Returns + ------- + None + """ + # Loop over registered callbacks + # ------------------------------ + for prop_path_tuples, callbacks in self._change_callbacks.items(): + # ### Compute callback paths that changed ### + common_paths = changed_paths.intersection(set(prop_path_tuples)) + if common_paths: + + # #### Invoke callback #### + callback_args = [self[cb_path] + for cb_path in prop_path_tuples] + + for callback in callbacks: + callback(self, *callback_args) + + def on_change(self, callback, *args, **kwargs): + """ + Register callback function to be called when certain properties or + subproperties of this object are modified. + + Callback will be invoked whenever ANY of these properties is + modified. Furthermore, the callback will only be invoked once even + if multiple properties are modified during the same restyle / + relayout / update operation. + + Parameters + ---------- + callback : function + Function that accepts 1 + len(`args`) parameters. First parameter + is this object. Second through last parameters are the + property / subpropery values referenced by args. + args : list[str|tuple[int|str]] + List of property references where each reference may be one of: + + 1) A property name string (e.g. 'foo') for direct properties + 2) A property path string (e.g. 'foo[0].bar') for + subproperties + 3) A property path tuple (e.g. ('foo', 0, 'bar')) for + subproperties + + append : bool + True if callback should be appended to previously registered + callback on the same properties, False if callback should replace + previously registered callbacks on the same properties. Defaults + to False. + + Examples + -------- + + Register callback that prints out the range extents of the xaxis and + yaxis whenever either either of them changes. + + >>> fig.layout.on_change( + ... lambda obj, xrange, yrange: print("%s-%s" % (xrange, yrange)), + ... ('xaxis', 'range'), ('yaxis', 'range')) + + + Returns + ------- + None + """ + + # Warn if object not descendent of a figure + # ----------------------------------------- + if not self.figure: + class_name = self.__class__.__name__ + msg = """ +{class_name} object is not a descendant of a Figure. +on_change callbacks are not supported in this case. +""".format(class_name=class_name) + raise ValueError(msg) + + # Validate args not empty + # ----------------------- + if len(args) == 0: + raise ValueError( + 'At least one change property must be specified') + + # Validate args + # ------------- + invalid_args = [arg for arg in args if arg not in self] + if invalid_args: + raise ValueError( + 'Invalid property specification(s): %s' % invalid_args) + + # Process append option + # --------------------- + append = kwargs.get('append', False) + + # Normalize args to path tuples + # ----------------------------- + arg_tuples = tuple([BaseFigure._str_to_dict_path(a) for a in args]) + + # Initialize callbacks list + # ------------------------- + # Initialize an empty callbacks list if there are no previously + # defined callbacks for this collection of args, or if append is False + if arg_tuples not in self._change_callbacks or not append: + self._change_callbacks[arg_tuples] = [] + + # Register callback + # ----------------- + self._change_callbacks[arg_tuples].append(callback) + + def to_plotly_json(self): + """ + Return plotly JSON representation of object as a Python dict + + Returns + ------- + dict + """ + return deepcopy(self._props if self._props is not None else {}) + + @staticmethod + def _vals_equal(v1, v2): + """ + Recursive equality function that handles nested dicts / tuples / lists + that contain numpy arrays. + + v1 + First value to compare + v2 + Second value to compare + + Returns + ------- + bool + True if v1 and v2 are equal, False otherwise + """ + if (np is not None and + (isinstance(v1, np.ndarray) or isinstance(v2, np.ndarray))): + return np.array_equal(v1, v2) + elif isinstance(v1, (list, tuple)): + # Handle recursive equality on lists and tuples + return (isinstance(v2, (list, tuple)) and + len(v1) == len(v2) and + all(BasePlotlyType._vals_equal(e1, e2) + for e1, e2 in zip(v1, v2))) + elif isinstance(v1, dict): + # Handle recursive equality on dicts + return (isinstance(v2, dict) and + set(v1.keys()) == set(v2.keys()) and + all(BasePlotlyType._vals_equal(v1[k], v2[k]) for k in v1)) + else: + return v1 == v2 + + +class BaseLayoutHierarchyType(BasePlotlyType): + """ + Base class for all types in the layout hierarchy + """ + + @property + def _parent_path_str(self): + pass + + def __init__(self, plotly_name, **kwargs): + super(BaseLayoutHierarchyType, self).__init__(plotly_name, **kwargs) + + def _send_prop_set(self, prop_path_str, val): + if self.parent: + # ### Inform parent of relayout operation ### + self.parent._relayout_child(self, prop_path_str, val) + + +class BaseLayoutType(BaseLayoutHierarchyType): + """ + Base class for the layout type. The Layout class itself is a + code-generated subclass. + """ + + # Dynamic properties + # ------------------ + # Unlike all other plotly types, BaseLayoutType has dynamic properties. + # These are used when a layout has multiple instances of subplot types + # (xaxis2, yaxis3, geo4, etc.) + # + # The base version of each suplot type is defined in the schema and code + # generated. So the Layout subclass has statically defined properties + # for xaxis, yaxis, geo, ternary, and scene. But, we need to dynamically + # generated properties/validators as needed for xaxis2, yaxis3, etc. + + # # ### Create subplot property regular expression ### + _subplotid_prop_names = ['xaxis', 'yaxis', 'geo', 'ternary', 'scene'] + _subplotid_prop_re = re.compile( + '(' + '|'.join(_subplotid_prop_names) + ')(\d+)') + + @property + def _subplotid_validators(self): + """ + dict of validator classes for each subplot type + + Returns + ------- + dict + """ + from .validators.layout import (XAxisValidator, YAxisValidator, + GeoValidator, TernaryValidator, + SceneValidator) + + return { + 'xaxis': XAxisValidator, + 'yaxis': YAxisValidator, + 'geo': GeoValidator, + 'ternary': TernaryValidator, + 'scene': SceneValidator + } + + def __init__(self, plotly_name, **kwargs): + """ + Construct a new BaseLayoutType object + + Parameters + ---------- + plotly_name : str + Name of the object (should always be 'layout') + kwargs : dict[str, any] + Properties that were not recognized by the Layout subclass. + These are subplot identifiers (xaxis2, geo4, etc.) or they are + invalid properties. + """ + # Validate inputs + # --------------- + assert plotly_name == 'layout' + + # Call superclass constructor + # --------------------------- + super(BaseLayoutHierarchyType, self).__init__(plotly_name) + + # Initialize _subplotid_props + # --------------------------- + # This is a set storing the names of the layout's dynamic subplot + # properties + self._subplotid_props = set() + + # Process kwargs + # -------------- + self._process_kwargs(**kwargs) + + def _process_kwargs(self, **kwargs): + """ + Process any extra kwargs that are not predefined as constructor params + """ + unknown_kwargs = { + k: v + for k, v in kwargs.items() + if not fullmatch(self._subplotid_prop_re, k) + # if not self._subplotid_prop_re.fullmatch(k) + } + super(BaseLayoutHierarchyType, self)._process_kwargs(**unknown_kwargs) + + subplot_kwargs = { + k: v + for k, v in kwargs.items() + if fullmatch(self._subplotid_prop_re, k) + #if self._subplotid_prop_re.fullmatch(k) + } + + for prop, value in subplot_kwargs.items(): + self._set_subplotid_prop(prop, value) + + def _set_subplotid_prop(self, prop, value): + """ + Set a subplot property on the layout + + Parameters + ---------- + prop : str + A valid subplot property + value + Subplot value + """ + # Get regular expression match + # ---------------------------- + # Note: we already tested that match exists in the constructor + # match = self._subplotid_prop_re.fullmatch(prop) + match = fullmatch(self._subplotid_prop_re, prop) + subplot_prop = match.group(1) + suffix_digit = int(match.group(2)) + + # Validate suffix digit + # --------------------- + if suffix_digit == 0: + raise TypeError('Subplot properties may only be suffixed by an ' + 'integer >= 1\n' + 'Received {k}'.format(k=prop)) + + # Handle suffix_digit == 1 + # ------------------------ + # In this case we remove suffix digit (e.g. xaxis1 -> xaxis) + if suffix_digit == 1: + prop = subplot_prop + + # Construct and add validator + # --------------------------- + if prop not in self._validators: + validator_class = self._subplotid_validators[subplot_prop] + validator = validator_class(plotly_name=prop) + self._validators[prop] = validator + + # Import value + # ------------ + # Use the standard _set_compound_prop method to + # validate/coerce/import subplot value. This must be called AFTER + # the validator instance is added to self._validators above. + self._set_compound_prop(prop, value) + self._subplotid_props.add(prop) + + def _strip_subplot_suffix_of_1(self, prop): + """ + Strip the suffix for subplot property names that have a suffix of 1. + All other properties are returned unchanged + + e.g. 'xaxis1' -> 'xaxis' + + Parameters + ---------- + prop : str|tuple + + Returns + ------- + str|tuple + """ + # Let parent handle non-scalar cases + # ---------------------------------- + # e.g. ('xaxis', 'range') or 'xaxis.range' + prop_tuple = BaseFigure._str_to_dict_path(prop) + if (len(prop_tuple) != 1 or + not isinstance(prop_tuple[0], string_types)): + return prop + else: + # Unwrap to scalar string + prop = prop_tuple[0] + + # Handle subplot suffix digit of 1 + # -------------------------------- + # Remove digit of 1 from subplot id (e.g.. xaxis1 -> xaxis) + match = fullmatch(self._subplotid_prop_re, prop) + + if match: + subplot_prop = match.group(1) + suffix_digit = int(match.group(2)) + if subplot_prop and suffix_digit == 1: + prop = subplot_prop + + return prop + + def __getattr__(self, prop): + """ + Custom __getattr__ that handles dynamic subplot properties + """ + prop = self._strip_subplot_suffix_of_1(prop) + if prop in self._subplotid_props: + validator = self._validators[prop] + return validator.present(self._compound_props[prop]) + else: + return super(BaseLayoutHierarchyType, self).__getattribute__(prop) + + def __getitem__(self, prop): + """ + Custom __getitem__ that handles dynamic subplot properties + """ + prop = self._strip_subplot_suffix_of_1(prop) + return super(BaseLayoutHierarchyType, self).__getitem__(prop) + + def __contains__(self, prop): + """ + Custom __contains__ that handles dynamic subplot properties + """ + prop = self._strip_subplot_suffix_of_1(prop) + return super(BaseLayoutHierarchyType, self).__contains__(prop) + + def __setitem__(self, prop, value): + """ + Custom __setitem__ that handles dynamic subplot properties + """ + # Convert prop to prop tuple + # -------------------------- + prop_tuple = BaseFigure._str_to_dict_path(prop) + if len(prop_tuple) != 1 or not isinstance(prop_tuple[0], + string_types): + # Let parent handle non-scalar non-string cases + super(BaseLayoutHierarchyType, self).__setitem__(prop, value) + return + else: + # Unwrap prop tuple + prop = prop_tuple[0] + + # Check for subplot assignment + # ---------------------------- + match = fullmatch(self._subplotid_prop_re, prop) + if match is None: + # Set as ordinary property + super(BaseLayoutHierarchyType, self).__setitem__(prop, value) + else: + # Set as subplotid property + self._set_subplotid_prop(prop, value) + + def __setattr__(self, prop, value): + """ + Custom __setattr__ that handles dynamic subplot properties + """ + # Check for subplot assignment + # ---------------------------- + # match = self._subplotid_prop_re.fullmatch(prop) + match = fullmatch(self._subplotid_prop_re, prop) + if match is None: + # Set as ordinary property + super(BaseLayoutHierarchyType, self).__setattr__(prop, value) + else: + # Set as subplotid property + self._set_subplotid_prop(prop, value) + + def __dir__(self): + """ + Custom __dir__ that handles dynamic subplot properties + """ + # Include any active subplot values + if six.PY3: + return list(super(BaseLayoutHierarchyType, self).__dir__()) + sorted(self._subplotid_props) + else: + def get_attrs(obj): + import types + if not hasattr(obj, '__dict__'): + return [] + if not isinstance(obj.__dict__, (dict, types.DictProxyType)): + raise TypeError("%s.__dict__ is not a dictionary" + "" % obj.__name__) + return obj.__dict__.keys() + + def dir2(obj): + attrs = set() + if not hasattr(obj, '__bases__'): + # obj is an instance + if not hasattr(obj, '__class__'): + # slots + return sorted(get_attrs(obj)) + klass = obj.__class__ + attrs.update(get_attrs(klass)) + else: + # obj is a class + klass = obj + + for cls in klass.__bases__: + attrs.update(get_attrs(cls)) + attrs.update(dir2(cls)) + attrs.update(get_attrs(obj)) + return list(attrs) + + return dir2(self) + sorted(self._subplotid_props) + + +class BaseTraceHierarchyType(BasePlotlyType): + """ + Base class for all types in the trace hierarchy + """ + + def __init__(self, plotly_name, **kwargs): + super(BaseTraceHierarchyType, self).__init__(plotly_name, **kwargs) + def _send_prop_set(self, prop_path_str, val): + if self.parent: + # ### Inform parent of restyle operation ### + self.parent._restyle_child(self, prop_path_str, val) + + +class BaseTraceType(BaseTraceHierarchyType): + """ + Base class for the all trace types. + + Specific trace type classes (Scatter, Bar, etc.) are code generated as + subclasses of this class. + """ + + def __init__(self, plotly_name, **kwargs): + super(BaseTraceHierarchyType, self).__init__(plotly_name, **kwargs) + + # Initialize callback function lists + # ---------------------------------- + # ### Callbacks to be called on hover ### + self._hover_callbacks = [] + + # ### Callbacks to be called on unhover ### + self._unhover_callbacks = [] + + # ### Callbacks to be called on click ### + self._click_callbacks = [] + + # ### Callbacks to be called on selection ### + self._select_callbacks = [] + + # uid + # --- + # All trace types must have a top-level UID + @property + def uid(self): + raise NotImplementedError + + @uid.setter + def uid(self, val): + raise NotImplementedError + + # Hover + # ----- + def on_hover(self, + callback, + append=False): + """ + Register function to be called when the user hovers over one or more + points in this trace + + Note: Callbacks will only be triggered when the trace belongs to a + instance of plotly.graph_objs.FigureWidget and it is displayed in an + ipywidget context. Callbacks will not be triggered on figures + that are displayed using plot/iplot. + + Parameters + ---------- + callback + Callable function that accepts 3 arguments + + - this trace + - plotly.callbacks.Points object + - plotly.callbacks.InputDeviceState object + + append : bool + If False (the default), this callback replaces any previously + defined on_hover callbacks for this trace. If True, + this callback is appended to the list of any previously defined + callbacks. + + Returns + ------- + None + + Examples + -------- + >>> from plotly.callbacks import Points, InputDeviceState + >>> points, state = Points(), InputDeviceState() + + >>> def hover_fn(trace, points, state): + ... inds = points.point_inds + ... # Do something + + >>> trace.on_hover(hover_fn) + + Note: The creation of the `points` and `state` objects is optional, + it's simply a convenience to help the text editor perform completion + on the arguments inside `hover_fn` + """ + if not append: + del self._hover_callbacks[:] + + if callback: + self._hover_callbacks.append(callback) + + def _dispatch_on_hover(self, points, state): + """ + Dispatch points and device state all all hover callbacks + """ + for callback in self._hover_callbacks: + callback(self, points, state) + + # Unhover + # ------- + def on_unhover(self, + callback, + append=False): + """ + Register function to be called when the user unhovers away from one + or more points in this trace. + + Note: Callbacks will only be triggered when the trace belongs to a + instance of plotly.graph_objs.FigureWidget and it is displayed in an + ipywidget context. Callbacks will not be triggered on figures + that are displayed using plot/iplot. + + Parameters + ---------- + callback + Callable function that accepts 3 arguments + + - this trace + - plotly.callbacks.Points object + - plotly.callbacks.InputDeviceState object + + append : bool + If False (the default), this callback replaces any previously + defined on_unhover callbacks for this trace. If True, + this callback is appended to the list of any previously defined + callbacks. + + Returns + ------- + None + + Examples + -------- + >>> from plotly.callbacks import Points, InputDeviceState + >>> points, state = Points(), InputDeviceState() + + >>> def unhover_fn(trace, points, state): + ... inds = points.point_inds + ... # Do something + + >>> trace.on_unhover(unhover_fn) + + Note: The creation of the `points` and `state` objects is optional, + it's simply a convenience to help the text editor perform completion + on the arguments inside `unhover_fn` + """ + if not append: + del self._unhover_callbacks[:] + + if callback: + self._unhover_callbacks.append(callback) + + def _dispatch_on_unhover(self, points, state): + """ + Dispatch points and device state all all hover callbacks + """ + for callback in self._unhover_callbacks: + callback(self, points, state) + + # Click + # ----- + def on_click(self, + callback, + append=False): + """ + Register function to be called when the user clicks on one or more + points in this trace. + + Note: Callbacks will only be triggered when the trace belongs to a + instance of plotly.graph_objs.FigureWidget and it is displayed in an + ipywidget context. Callbacks will not be triggered on figures + that are displayed using plot/iplot. + + Parameters + ---------- + callback + Callable function that accepts 3 arguments + + - this trace + - plotly.callbacks.Points object + - plotly.callbacks.InputDeviceState object + + append : bool + If False (the default), this callback replaces any previously + defined on_click callbacks for this trace. If True, + this callback is appended to the list of any previously defined + callbacks. + + Returns + ------- + None + + Examples + -------- + >>> from plotly.callbacks import Points, InputDeviceState + >>> points, state = Points(), InputDeviceState() + + >>> def click_fn(trace, points, state): + ... inds = points.point_inds + ... # Do something + + >>> trace.on_click(click_fn) + + Note: The creation of the `points` and `state` objects is optional, + it's simply a convenience to help the text editor perform completion + on the arguments inside `click_fn` + """ + if not append: + del self._click_callbacks[:] + if callback: + self._click_callbacks.append(callback) + + def _dispatch_on_click(self, points, state): + """ + Dispatch points and device state all all hover callbacks + """ + for callback in self._click_callbacks: + callback(self, points, state) + + # Select + # ------ + def on_selection( + self, + callback, + append=False): + """ + Register function to be called when the user selects one or more + points in this trace. + + Note: Callbacks will only be triggered when the trace belongs to a + instance of plotly.graph_objs.FigureWidget and it is displayed in an + ipywidget context. Callbacks will not be triggered on figures + that are displayed using plot/iplot. + + Parameters + ---------- + callback + Callable function that accepts 4 arguments + + - this trace + - plotly.callbacks.Points object + - plotly.callbacks.BoxSelector or plotly.callbacks.LassoSelector + + append : bool + If False (the default), this callback replaces any previously + defined on_selection callbacks for this trace. If True, + this callback is appended to the list of any previously defined + callbacks. + + Returns + ------- + None + + Examples + -------- + >>> from plotly.callbacks import Points + >>> points = Points() + + >>> def selection_fn(trace, points, selector): + ... inds = points.point_inds + ... # Do something + + >>> trace.on_selection(selection_fn) + + Note: The creation of the `points` object is optional, + it's simply a convenience to help the text editor perform completion + on the `points` arguments inside `selection_fn` + """ + if not append: + del self._select_callbacks[:] + + if callback: + self._select_callbacks.append(callback) + + def _dispatch_on_selection(self, + points, + selector): + """ + Dispatch points and selector info to selection callbacks + """ + for callback in self._select_callbacks: + callback(self, points, selector) + + +class BaseFrameHierarchyType(BasePlotlyType): + """ + Base class for all types in the trace hierarchy + """ + + def __init__(self, plotly_name, **kwargs): + super(BaseFrameHierarchyType, self).__init__(plotly_name, **kwargs) + + def _send_prop_set(self, prop_path_str, val): + # Note: Frames are not supported by FigureWidget, and updates are not + # propagated to parents + pass + + def on_change(self, callback, *args): + raise NotImplementedError( + 'Change callbacks are not supported on Frames') + + def _get_child_props(self, child): + """ + Return the properties dict for a child trace or child layout + + Note: this method must match the name/signature of one on + BasePlotlyType + + Parameters + ---------- + child : BaseTraceType | BaseLayoutType + + Returns + ------- + dict + """ + # Try to find index of child as a trace + # ------------------------------------- + try: + trace_index = BaseFigure._index_is(self.data, child) + except ValueError as _: + trace_index = None + + # Child is a trace + # ---------------- + if trace_index is not None: + if 'data' in self._props: + return self._props['data'][trace_index] + else: + return None + + # Child is the layout + # ------------------- + elif child is self.layout: + return self._props.get('layout', None) + + # Unknown child + # ------------- + else: + raise ValueError('Unrecognized child: %s' % child) diff --git a/plotly/basewidget.py b/plotly/basewidget.py new file mode 100644 index 0000000000..af404b6923 --- /dev/null +++ b/plotly/basewidget.py @@ -0,0 +1,956 @@ +import uuid +from importlib import import_module +import os +import numbers +try: + from urllib import parse +except ImportError: + from urlparse import urlparse as parse + +import ipywidgets as widgets +from traitlets import List, Unicode, Dict, observe, Integer +from .basedatatypes import BaseFigure, BasePlotlyType, fullmatch +from .callbacks import (BoxSelector, LassoSelector, + InputDeviceState, Points) +from .serializers import custom_serializers +from .version import __frontend_version__ + +@widgets.register() +class BaseFigureWidget(BaseFigure, widgets.DOMWidget): + """ + Base class for FigureWidget. The FigureWidget class is code-generated as a + subclass + """ + + # Widget Traits + # ------------- + # Widget traitlets are automatically synchronized with the FigureModel + # JavaScript object + _view_name = Unicode('FigureView').tag(sync=True) + _view_module = Unicode('plotlywidget').tag(sync=True) + _view_module_version = Unicode(__frontend_version__).tag(sync=True) + + _model_name = Unicode('FigureModel').tag(sync=True) + _model_module = Unicode('plotlywidget').tag(sync=True) + _model_module_version = Unicode(__frontend_version__).tag(sync=True) + + # ### _data and _layout ### + # These properties store the current state of the traces and + # layout as JSON-style dicts. These dicts do not store any subclasses of + # `BasePlotlyType` + # + # Note: These are only automatically synced with the frontend on full + # assignment, not on mutation. We use this fact to only directly sync + # them to the front-end on FigureWidget construction. All other updates + # are made using mutation, and they are manually synced to the frontend + # using the relayout/restyle/update/etc. messages. + _layout = Dict().tag(sync=True, **custom_serializers) + _data = List().tag(sync=True, **custom_serializers) + + # ### Python -> JS message properties ### + # These properties are used to send messages from Python to the + # frontend. Messages are sent by assigning the message contents to the + # appropriate _py2js_* property and then immediatly assigning None to the + # property. + # + # See JSDoc comments in the FigureModel class in js/src/Figure.js for + # detailed descriptions of the messages. + _py2js_addTraces = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_restyle = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_relayout = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_update = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_animate = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + + _py2js_deleteTraces = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_moveTraces = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + + _py2js_removeLayoutProps = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _py2js_removeTraceProps = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + + # ### JS -> Python message properties ### + # These properties are used to receive messages from the frontend. + # Messages are received by defining methods that observe changes to these + # properties. Receive methods are named `_handler_js2py_*` where '*' is + # the name of the corresponding message property. Receive methods are + # responsible for setting the message property to None after retreiving + # the message data. + # + # See JSDoc comments in the FigureModel class in js/src/Figure.js for + # detailed descriptions of the messages. + _js2py_traceDeltas = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _js2py_layoutDelta = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _js2py_restyle = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _js2py_relayout = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _js2py_update = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + _js2py_pointsCallback = Dict(allow_none=True).tag(sync=True, + **custom_serializers) + + # ### Message tracking properties ### + # The _last_layout_edit_id and _last_trace_edit_id properties are used + # to keep track of the edit id of the message that most recently + # requested an update to the Figures layout or traces respectively. + # + # We track this information because we don't want to update the Figure's + # default layout/trace properties (_layout_defaults, _data_defaults) + # while edits are in process. This can lead to inconsistent property + # states. + _last_layout_edit_id = Integer(0).tag(sync=True) + _last_trace_edit_id = Integer(0).tag(sync=True) + + # Constructor + # ----------- + def __init__(self, + data=None, + layout=None, + frames=None): + + # Call superclass constructors + # ---------------------------- + # Note: We rename layout to layout_plotly because to deconflict it + # with the `layout` constructor parameter of the `widgets.DOMWidget` + # ipywidgets class + super(BaseFigureWidget, self).__init__(data=data, + layout_plotly=layout, + frames=frames) + + # Validate Frames + # --------------- + # Frames are not supported by figure widget + if self._frame_objs: + BaseFigureWidget._display_frames_error() + + # Message States + # -------------- + # ### Layout ### + + # _last_layout_edit_id is described above + self._last_layout_edit_id = 0 + + # _layout_edit_in_process is set to True if there are layout edit + # operations that have been sent to the frontend that haven't + # completed yet. + self._layout_edit_in_process = False + + # _waiting_edit_callbacks is a list of callback functions that + # should be executed as soon as all pending edit operations are + # completed + self._waiting_edit_callbacks = [] + + # ### Trace ### + # _last_trace_edit_id: described above + self._last_trace_edit_id = 0 + + # _trace_edit_in_process is set to True if there are trace edit + # operations that have been sent to the frontend that haven't + # completed yet. + self._trace_edit_in_process = False + + # View count + # ---------- + # ipywidget property that stores the number of active frontend + # views of this widget + self._view_count = 0 + + # Python -> JavaScript Messages + # ----------------------------- + def _send_relayout_msg(self, layout_data, source_view_id=None): + """ + Send Plotly.relayout message to the frontend + + Parameters + ---------- + layout_data : dict + Plotly.relayout layout data + source_view_id : str + UID of view that triggered this relayout operation + (e.g. By the user clicking 'zoom' in the toolbar). None if the + operation was not triggered by a frontend view + """ + # Increment layout edit messages IDs + # ---------------------------------- + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + # Build message + # ------------- + msg_data = { + 'relayout_data': layout_data, + 'layout_edit_id': layout_edit_id, + 'source_view_id': source_view_id + } + + # Send message + # ------------ + self._py2js_relayout = msg_data + self._py2js_relayout = None + + def _send_restyle_msg(self, restyle_data, trace_indexes=None, + source_view_id=None): + """ + Send Plotly.restyle message to the frontend + + Parameters + ---------- + restyle_data : dict + Plotly.restyle restyle data + trace_indexes : list[int] + List of trace indexes that the restyle operation + applies to + source_view_id : str + UID of view that triggered this restyle operation + (e.g. By the user clicking the legend to hide a trace). + None if the operation was not triggered by a frontend view + """ + + # Validate / normalize inputs + # --------------------------- + trace_indexes = self._normalize_trace_indexes(trace_indexes) + + # Increment layout/trace edit message IDs + # --------------------------------------- + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + trace_edit_id = self._last_trace_edit_id + 1 + self._last_trace_edit_id = trace_edit_id + self._trace_edit_in_process = True + + # Build message + # ------------- + restyle_msg = { + 'restyle_data': restyle_data, + 'restyle_traces': trace_indexes, + 'trace_edit_id': trace_edit_id, + 'layout_edit_id': layout_edit_id, + 'source_view_id': source_view_id, + } + + # Send message + # ------------ + self._py2js_restyle = restyle_msg + self._py2js_restyle = None + + def _send_addTraces_msg(self, new_traces_data): + """ + Send Plotly.addTraces message to the frontend + + Parameters + ---------- + new_traces_data : list[dict] + List of trace data for new traces as accepted by Plotly.addTraces + """ + + # Increment layout/trace edit message IDs + # --------------------------------------- + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + trace_edit_id = self._last_trace_edit_id + 1 + self._last_trace_edit_id = trace_edit_id + self._trace_edit_in_process = True + + # Build message + # ------------- + add_traces_msg = { + 'trace_data': new_traces_data, + 'trace_edit_id': trace_edit_id, + 'layout_edit_id': layout_edit_id + } + + # Send message + # ------------ + self._py2js_addTraces = add_traces_msg + self._py2js_addTraces = None + + def _send_moveTraces_msg(self, current_inds, new_inds): + """ + Send Plotly.moveTraces message to the frontend + + Parameters + ---------- + current_inds : list[int] + List of current trace indexes + new_inds : list[int] + List of new trace indexes + """ + + # Build message + # ------------- + move_msg = { + 'current_trace_inds': current_inds, + 'new_trace_inds': new_inds + } + + # Send message + # ------------ + self._py2js_moveTraces = move_msg + self._py2js_moveTraces = None + + def _send_update_msg(self, + restyle_data, + relayout_data, + trace_indexes=None, + source_view_id=None): + """ + Send Plotly.update message to the frontend + + Parameters + ---------- + restyle_data : dict + Plotly.update restyle data + relayout_data : dict + Plotly.update relayout data + trace_indexes : list[int] + List of trace indexes that the update operation applies to + source_view_id : str + UID of view that triggered this update operation + (e.g. By the user clicking a button). + None if the operation was not triggered by a frontend view + """ + + # Validate / normalize inputs + # --------------------------- + trace_indexes = self._normalize_trace_indexes(trace_indexes) + + # Increment layout/trace edit message IDs + # --------------------------------------- + trace_edit_id = self._last_trace_edit_id + 1 + self._last_trace_edit_id = trace_edit_id + self._trace_edit_in_process = True + + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + # Build message + # ------------- + update_msg = { + 'style_data': restyle_data, + 'layout_data': relayout_data, + 'style_traces': trace_indexes, + 'trace_edit_id': trace_edit_id, + 'layout_edit_id': layout_edit_id, + 'source_view_id': source_view_id + } + + # Send message + # ------------ + self._py2js_update = update_msg + self._py2js_update = None + + def _send_animate_msg(self, + styles_data, + relayout_data, + trace_indexes, + animation_opts): + """ + Send Plotly.update message to the frontend + + Note: there is no source_view_id parameter because animations + triggered by the fontend are not currently supported + + Parameters + ---------- + styles_data : list[dict] + Plotly.animate styles data + relayout_data : dict + Plotly.animate relayout data + trace_indexes : list[int] + List of trace indexes that the animate operation applies to + """ + + # Validate / normalize inputs + # --------------------------- + trace_indexes = self._normalize_trace_indexes(trace_indexes) + + # Increment layout/trace edit message IDs + # --------------------------------------- + trace_edit_id = self._last_trace_edit_id + 1 + self._last_trace_edit_id = trace_edit_id + self._trace_edit_in_process = True + + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + # Build message + # ------------- + animate_msg = { + 'style_data': styles_data, + 'layout_data': relayout_data, + 'style_traces': trace_indexes, + 'animation_opts': animation_opts, + 'trace_edit_id': trace_edit_id, + 'layout_edit_id': layout_edit_id, + 'source_view_id': None + } + + # Send message + # ------------ + self._py2js_animate = animate_msg + self._py2js_animate = None + + def _send_deleteTraces_msg(self, delete_inds): + """ + Send Plotly.deleteTraces message to the frontend + + Parameters + ---------- + delete_inds : list[int] + List of trace indexes of traces to delete + """ + + # Increment layout/trace edit message IDs + # --------------------------------------- + trace_edit_id = self._last_trace_edit_id + 1 + self._last_trace_edit_id = trace_edit_id + self._trace_edit_in_process = True + + layout_edit_id = self._last_layout_edit_id + 1 + self._last_layout_edit_id = layout_edit_id + self._layout_edit_in_process = True + + # Build message + # ------------- + delete_msg = { + 'delete_inds': delete_inds, + 'layout_edit_id': layout_edit_id, + 'trace_edit_id': trace_edit_id + } + + # Send message + # ------------ + self._py2js_deleteTraces = delete_msg + self._py2js_deleteTraces = None + + # JavaScript -> Python Messages + # ----------------------------- + @observe('_js2py_traceDeltas') + def _handler_js2py_traceDeltas(self, change): + """ + Process trace deltas message from the frontend + """ + + # Receive message + # --------------- + msg_data = change['new'] + self._js2py_traceDeltas = None + if not msg_data: + return + + trace_deltas = msg_data['trace_deltas'] + trace_edit_id = msg_data['trace_edit_id'] + + # Apply deltas + # ------------ + # We only apply the deltas if this message corresponds to the most + # recent trace edit operation + if trace_edit_id == self._last_trace_edit_id: + + # ### Loop over deltas ### + for delta in trace_deltas: + + # #### Find existing trace for uid ### + trace_uid = delta['uid'] + trace_uids = [trace.uid for trace in self.data] + trace_index = trace_uids.index(trace_uid) + uid_trace = self.data[trace_index] + + # #### Transform defaults to delta #### + delta_transform = BaseFigureWidget._transform_data( + uid_trace._prop_defaults, delta) + + # #### Remove overlapping properties #### + # If a property is present in both _props and _prop_defaults + # then we remove the copy from _props + remove_props = self._remove_overlapping_props( + uid_trace._props, uid_trace._prop_defaults) + + # #### Notify frontend model of property removal #### + if remove_props: + remove_trace_props_msg = { + 'remove_trace': trace_index, + 'remove_props': remove_props + } + self._py2js_removeTraceProps = remove_trace_props_msg + self._py2js_removeTraceProps = None + + # #### Dispatch change callbacks #### + self._dispatch_trace_change_callbacks(delta_transform, + [trace_index]) + + # ### Trace edits no longer in process ### + self._trace_edit_in_process = False + + # ### Call any waiting trace edit callbacks ### + if not self._layout_edit_in_process: + while self._waiting_edit_callbacks: + self._waiting_edit_callbacks.pop()() + + @observe('_js2py_layoutDelta') + def _handler_js2py_layoutDelta(self, change): + """ + Process layout delta message from the frontend + """ + + # Receive message + # --------------- + msg_data = change['new'] + self._js2py_layoutDelta = None + if not msg_data: + return + + layout_delta = msg_data['layout_delta'] + layout_edit_id = msg_data['layout_edit_id'] + + # Apply delta + # ----------- + # We only apply the delta if this message corresponds to the most + # recent layout edit operation + if layout_edit_id == self._last_layout_edit_id: + + # ### Transform defaults to delta ### + delta_transform = BaseFigureWidget._transform_data( + self._layout_defaults, layout_delta) + + # ### Remove overlapping properties ### + # If a property is present in both _layout and _layout_defaults + # then we remove the copy from _layout + removed_props = self._remove_overlapping_props( + self._layout, self._layout_defaults) + + # ### Notify frontend model of property removal ### + if removed_props: + remove_props_msg = { + 'remove_props': removed_props + } + + self._py2js_removeLayoutProps = remove_props_msg + self._py2js_removeLayoutProps = None + + # ### Create axis objects ### + # For example, when a SPLOM trace is created the layout defaults + # may include axes that weren't explicitly defined by the user. + for proppath in delta_transform: + prop = proppath[0] + match = fullmatch(self.layout._subplotid_prop_re, prop) + if match and prop not in self.layout: + # We need to create a subplotid object + self.layout[prop] = {} + + # ### Dispatch change callbacks ### + self._dispatch_layout_change_callbacks(delta_transform) + + # ### Layout edits no longer in process ### + self._layout_edit_in_process = False + + # ### Call any waiting layout edit callbacks ### + if not self._trace_edit_in_process: + while self._waiting_edit_callbacks: + self._waiting_edit_callbacks.pop()() + + @observe('_js2py_restyle') + def _handler_js2py_restyle(self, change): + """ + Process Plotly.restyle message from the frontend + """ + + # Receive message + # --------------- + restyle_msg = change['new'] + self._js2py_restyle = None + if not restyle_msg: + return + + style_data = restyle_msg['style_data'] + style_traces = restyle_msg['style_traces'] + source_view_id = restyle_msg['source_view_id'] + + # Perform restyle + # --------------- + self.plotly_restyle(restyle_data=style_data, + trace_indexes=style_traces, + source_view_id=source_view_id) + + @observe('_js2py_update') + def _handler_js2py_update(self, change): + """ + Process Plotly.update message from the frontend + """ + + # Receive message + # --------------- + update_msg = change['new'] + self._js2py_update = None + if not update_msg: + return + + style = update_msg['style_data'] + trace_indexes = update_msg['style_traces'] + layout = update_msg['layout_data'] + source_view_id = update_msg['source_view_id'] + + # Perform update + # -------------- + self.plotly_update(restyle_data=style, relayout_data=layout, + trace_indexes=trace_indexes, + source_view_id=source_view_id) + + @observe('_js2py_relayout') + def _handler_js2py_relayout(self, change): + """ + Process Plotly.relayout message from the frontend + """ + + # Receive message + # --------------- + relayout_msg = change['new'] + self._js2py_relayout = None + if not relayout_msg: + return + + relayout_data = relayout_msg['relayout_data'] + source_view_id = relayout_msg['source_view_id'] + + if 'lastInputTime' in relayout_data: + # Remove 'lastInputTime'. Seems to be an internal plotly + # property that is introduced for some plot types, but it is not + # actually a property in the schema + relayout_data.pop('lastInputTime') + + # Perform relayout + # ---------------- + self.plotly_relayout(relayout_data=relayout_data, + source_view_id=source_view_id) + + @observe('_js2py_pointsCallback') + def _handler_js2py_pointsCallback(self, change): + """ + Process points callback message from the frontend + """ + + # Receive message + # --------------- + callback_data = change['new'] + self._js2py_pointsCallback = None + if not callback_data: + return + + # Get event type + # -------------- + event_type = callback_data['event_type'] + + # Build Selector Object + # --------------------- + if callback_data.get('selector', None): + selector_data = callback_data['selector'] + selector_type = selector_data['type'] + selector_state = selector_data['selector_state'] + if selector_type == 'box': + selector = BoxSelector(**selector_state) + elif selector_type == 'lasso': + selector = LassoSelector(**selector_state) + else: + raise ValueError('Unsupported selector type: %s' + % selector_type) + else: + selector = None + + # Build Input Device State Object + # ------------------------------- + if callback_data.get('device_state', None): + device_state_data = callback_data['device_state'] + state = InputDeviceState(**device_state_data) + else: + state = None + + # Build Trace Points Dictionary + # ----------------------------- + points_data = callback_data['points'] + trace_points = { + trace_ind: + {'point_inds': [], + 'xs': [], + 'ys': [], + 'trace_name': self._data_objs[trace_ind].name, + 'trace_index': trace_ind} + for trace_ind in range(len(self._data_objs))} + + for x, y, point_ind, trace_ind in zip(points_data['xs'], + points_data['ys'], + points_data['point_indexes'], + points_data['trace_indexes']): + + trace_dict = trace_points[trace_ind] + trace_dict['xs'].append(x) + trace_dict['ys'].append(y) + trace_dict['point_inds'].append(point_ind) + + # Dispatch callbacks + # ------------------ + for trace_ind, trace_points_data in trace_points.items(): + points = Points(**trace_points_data) + trace = self.data[trace_ind] + + if event_type == 'plotly_click': + trace._dispatch_on_click(points, state) + elif event_type == 'plotly_hover': + trace._dispatch_on_hover(points, state) + elif event_type == 'plotly_unhover': + trace._dispatch_on_unhover(points, state) + elif event_type == 'plotly_selected': + trace._dispatch_on_selection(points, selector) + + # Callbacks + # --------- + def on_edits_completed(self, fn): + """ + Register a function to be called after all pending trace and layout + edit operations have completed + + If there are no pending edit operations then function is called + immediately + + Parameters + ---------- + fn : callable + Function of zero arguments to be called when all pending edit + operations have completed + """ + if self._layout_edit_in_process or self._trace_edit_in_process: + self._waiting_edit_callbacks.append(fn) + else: + fn() + + # Validate No Frames + # ------------------ + @property + def frames(self): + # Note: This property getter is identical to that of the superclass, + # but it must be included here because we're overriding the setter + # below. + return self._frame_objs + + @frames.setter + def frames(self, new_frames): + if new_frames: + BaseFigureWidget._display_frames_error() + + @staticmethod + def _display_frames_error(): + """ + Display an informative error when user attempts to set frames on a + FigureWidget + + Raises + ------ + ValueError + always + """ + msg = """ +Frames are not supported by the plotly.graph_objs.FigureWidget class. +Note: Frames are supported by the plotly.graph_objs.Figure class""" + raise ValueError(msg) + + # Static Helpers + # -------------- + @staticmethod + def _remove_overlapping_props(input_data, delta_data, prop_path=()): + """ + Remove properties in input_data that are also in delta_data, and do so + recursively. + + Exception: Never remove 'uid' from input_data, this property is used + to align traces + + Parameters + ---------- + input_data : dict|list + delta_data : dict|list + + Returns + ------- + list[tuple[str|int]] + List of removed property path tuples + """ + + # Initialize removed + # ------------------ + # This is the list of path tuples to the properties that were + # removed from input_data + removed = [] + + # Handle dict + # ----------- + if isinstance(input_data, dict): + assert isinstance(delta_data, dict) + + for p, delta_val in delta_data.items(): + if (isinstance(delta_val, dict) or + BaseFigure._is_dict_list(delta_val)): + if p in input_data: + # ### Recurse ### + input_val = input_data[p] + recur_prop_path = prop_path + (p,) + recur_removed = ( + BaseFigureWidget._remove_overlapping_props( + input_val, delta_val, recur_prop_path)) + removed.extend(recur_removed) + + elif p in input_data and p != 'uid': + # ### Remove property ### + input_data.pop(p) + removed.append(prop_path + (p,)) + + # Handle list + # ----------- + elif isinstance(input_data, list): + assert isinstance(delta_data, list) + + for i, delta_val in enumerate(delta_data): + if i >= len(input_data): + break + + input_val = input_data[i] + if (input_val is not None and + isinstance(delta_val, dict) or + BaseFigure._is_dict_list(delta_val)): + + # ### Recurse ### + recur_prop_path = prop_path + (i,) + recur_removed = ( + BaseFigureWidget._remove_overlapping_props( + input_val, delta_val, recur_prop_path)) + + removed.extend(recur_removed) + + return removed + + @staticmethod + def _transform_data(to_data, + from_data, + should_remove=True, + relayout_path=()): + """ + Transform to_data into from_data and return relayout-style + description of the transformation + + Parameters + ---------- + to_data : dict|list + from_data : dict|list + + Returns + ------- + dict + relayout-style description of the transformation + """ + + # Initialize relayout data + # ------------------------ + relayout_data = {} + + # Handle dict + # ----------- + if isinstance(to_data, dict): + + # ### Validate from_data ### + if not isinstance(from_data, dict): + raise ValueError( + 'Mismatched data types: {to_dict} {from_data}'. + format(to_dict=to_data, from_data=from_data)) + + # ### Add/modify properties ### + # Loop over props/vals + for from_prop, from_val in from_data.items(): + + # #### Handle compound vals recursively #### + if (isinstance(from_val, dict) or + BaseFigure._is_dict_list(from_val)): + + # ##### Init property value if needed ##### + if from_prop not in to_data: + to_data[from_prop] = ({} + if isinstance(from_val, dict) + else []) + + # ##### Transform property val recursively ##### + input_val = to_data[from_prop] + relayout_data.update( + BaseFigureWidget._transform_data( + input_val, + from_val, + should_remove=should_remove, + relayout_path=relayout_path + (from_prop,))) + + # #### Handle simple vals directly #### + else: + if (from_prop not in to_data or + not BasePlotlyType._vals_equal( + to_data[from_prop], from_val)): + + to_data[from_prop] = from_val + relayout_path_prop = relayout_path + (from_prop,) + relayout_data[relayout_path_prop] = from_val + + # ### Remove properties ### + if should_remove: + for remove_prop in set(to_data.keys()).difference( + set(from_data.keys())): + to_data.pop(remove_prop) + + # Handle list + # ----------- + elif isinstance(to_data, list): + + # ### Validate from_data ### + if not isinstance(from_data, list): + raise ValueError( + 'Mismatched data types: to_data: {to_data} {from_data}'. + format(to_data=to_data, from_data=from_data)) + + # ### Add/modify properties ### + # Loop over indexes / elements + for i, from_val in enumerate(from_data): + + # #### Initialize element if needed #### + if i >= len(to_data): + to_data.append(None) + input_val = to_data[i] + + # #### Handle compound element recursively #### + if (input_val is not None and + (isinstance(from_val, dict) or + BaseFigure._is_dict_list(from_val))): + + relayout_data.update( + BaseFigureWidget._transform_data( + input_val, + from_val, + should_remove=should_remove, + relayout_path=relayout_path + (i, ))) + + # #### Handle simple elements directly #### + else: + if not BasePlotlyType._vals_equal(to_data[i], from_val): + to_data[i] = from_val + relayout_data[relayout_path + (i, )] = from_val + + return relayout_data diff --git a/plotly/callbacks.py b/plotly/callbacks.py new file mode 100644 index 0000000000..bd99e68cc2 --- /dev/null +++ b/plotly/callbacks.py @@ -0,0 +1,309 @@ +from .utils import _list_repr_elided + + +class InputDeviceState: + def __init__(self, + ctrl=None, + alt=None, + shift=None, + meta=None, + button=None, + buttons=None, + **_): + + self._ctrl = ctrl + self._alt = alt + self._meta = meta + self._shift = shift + self._button = button + self._buttons = buttons + + def __repr__(self): + return """\ +InputDeviceState( + ctrl={ctrl}, + alt={alt}, + shift={shift}, + meta={meta}, + button={button}, + buttons={buttons})""".format( + ctrl=repr(self.ctrl), + alt=repr(self.alt), + meta=repr(self.meta), + shift=repr(self.shift), + button=repr(self.button), + buttons=repr(self.buttons)) + + @property + def alt(self): + """ + Whether alt key pressed + + Returns + ------- + bool + """ + return self._alt + + @property + def ctrl(self): + """ + Whether ctrl key pressed + + Returns + ------- + bool + """ + return self._ctrl + + @property + def shift(self): + """ + Whether shift key pressed + + Returns + ------- + bool + """ + return self._shift + + @property + def meta(self): + """ + Whether meta key pressed + + Returns + ------- + bool + """ + return self._meta + + @property + def button(self): + """ + Integer code for the button that was pressed on the mouse to trigger + the event + + - 0: Main button pressed, usually the left button or the + un-initialized state + - 1: Auxiliary button pressed, usually the wheel button or the middle + button (if present) + - 2: Secondary button pressed, usually the right button + - 3: Fourth button, typically the Browser Back button + - 4: Fifth button, typically the Browser Forward button + + Returns + ------- + int + """ + return self._button + + @property + def buttons(self): + """ + Integer code for which combination of buttons are pressed on the + mouse when the event is triggered. + + - 0: No button or un-initialized + - 1: Primary button (usually left) + - 2: Secondary button (usually right) + - 4: Auxilary button (usually middle or mouse wheel button) + - 8: 4th button (typically the "Browser Back" button) + - 16: 5th button (typically the "Browser Forward" button) + + Combinations of buttons are represented as the decimal form of the + bitmask of the values above. + + For example, pressing both the primary (1) and auxilary (4) buttons + will result in a code of 5 + + Returns + ------- + int + """ + return self._buttons + + +class Points: + + def __init__(self, + point_inds=[], + xs=[], + ys=[], + trace_name=None, + trace_index=None): + + self._point_inds = point_inds + self._xs = xs + self._ys = ys + self._trace_name = trace_name + self._trace_index = trace_index + + def __repr__(self): + return """\ +Points(point_inds={point_inds}, + xs={xs}, + ys={ys}, + trace_name={trace_name}, + trace_index={trace_index})""".format( + point_inds=_list_repr_elided(self.point_inds, + indent=len('Points(point_inds=')), + xs=_list_repr_elided(self.xs, + indent=len(' xs=')), + ys=_list_repr_elided(self.ys, + indent=len(' ys=')), + trace_name=repr(self.trace_name), + trace_index=repr(self.trace_index)) + + @property + def point_inds(self): + """ + List of selected indexes into the trace's points + + Returns + ------- + list[int] + """ + return self._point_inds + + @property + def xs(self): + """ + List of x-coordinates of selected points + + Returns + ------- + list[float] + """ + return self._xs + + @property + def ys(self): + """ + List of y-coordinates of selected points + + Returns + ------- + list[float] + """ + return self._ys + + @property + def trace_name(self): + """ + Name of the trace + + Returns + ------- + str + """ + return self._trace_name + + @property + def trace_index(self): + """ + Index of the trace in the figure + + Returns + ------- + int + """ + return self._trace_index + + +class BoxSelector: + def __init__(self, xrange=None, yrange=None, **_): + self._type = 'box' + self._xrange = xrange + self._yrange = yrange + + def __repr__(self): + return """\ +BoxSelector(xrange={xrange}, + yrange={yrange})""".format( + xrange=self.xrange, + yrange=self.yrange) + + @property + def type(self): + """ + The selector's type + + Returns + ------- + str + """ + return self._type + + @property + def xrange(self): + """ + x-axis range extents of the box selection + + Returns + ------- + (float, float) + """ + return self._xrange + + @property + def yrange(self): + """ + y-axis range extents of the box selection + + Returns + ------- + (float, float) + """ + return self._yrange + + +class LassoSelector: + def __init__(self, xs=None, ys=None, **_): + self._type = 'lasso' + self._xs = xs + self._ys = ys + + def __repr__(self): + return """\ +LassoSelector(xs={xs}, + ys={ys})""".format( + xs=_list_repr_elided(self.xs, + indent=len('LassoSelector(xs=')), + ys=_list_repr_elided(self.ys, + indent=len(' ys='))) + + @property + def type(self): + """ + The selector's type + + Returns + ------- + str + """ + return self._type + + @property + def xs(self): + """ + list of x-axis coordinates of each point in the lasso selection + boundary + + Returns + ------- + list[float] + """ + return self._xs + + @property + def ys(self): + """ + list of y-axis coordinates of each point in the lasso selection + boundary + + Returns + ------- + list[float] + """ + return self._ys diff --git a/plotly/figure_factory/_2d_density.py b/plotly/figure_factory/_2d_density.py index 3be0bb06af..8d004bff14 100644 --- a/plotly/figure_factory/_2d_density.py +++ b/plotly/figure_factory/_2d_density.py @@ -115,7 +115,7 @@ def create_2d_density(x, y, colorscale='Earth', ncontours=20, opacity=0.4 ) ) - trace2 = graph_objs.Histogram2dcontour( + trace2 = graph_objs.Histogram2dContour( x=x, y=y, name='density', ncontours=ncontours, colorscale=colorscale, reversescale=True, showscale=False ) diff --git a/plotly/figure_factory/_annotated_heatmap.py b/plotly/figure_factory/_annotated_heatmap.py index ba1985fd70..5b2a8eaec9 100644 --- a/plotly/figure_factory/_annotated_heatmap.py +++ b/plotly/figure_factory/_annotated_heatmap.py @@ -228,7 +228,7 @@ def make_annotations(self): for m, val in enumerate(row): font_color = min_text_color if val < z_mid else max_text_color annotations.append( - graph_objs.Annotation( + graph_objs.layout.Annotation( text=str(self.annotation_text[n][m]), x=self.x[m], y=self.y[n], diff --git a/plotly/figure_factory/_bullet.py b/plotly/figure_factory/_bullet.py index c23eaeb0e0..bcb5b2541d 100644 --- a/plotly/figure_factory/_bullet.py +++ b/plotly/figure_factory/_bullet.py @@ -56,8 +56,8 @@ def _bullet(df, markers, measures, ranges, subtitles, titles, orientation, width_axis = 'xaxis' length_axis = 'yaxis' - for key in fig['layout'].keys(): - if 'axis' in key: + for key in fig['layout']: + if 'xaxis' in key or 'yaxis' in key: fig['layout'][key]['showgrid'] = False fig['layout'][key]['zeroline'] = False if length_axis in key: @@ -100,7 +100,7 @@ def _bullet(df, markers, measures, ranges, subtitles, titles, orientation, xaxis='x{}'.format(row + 1), yaxis='y{}'.format(row + 1) ) - fig['data'].append(bar) + fig.add_trace(bar) # measures bars for idx in range(len(df.iloc[row]['measures'])): @@ -126,7 +126,7 @@ def _bullet(df, markers, measures, ranges, subtitles, titles, orientation, xaxis='x{}'.format(row + 1), yaxis='y{}'.format(row + 1) ) - fig['data'].append(bar) + fig.add_trace(bar) # markers x = df.iloc[row]['markers'] if orientation == 'h' else [0.5] @@ -141,7 +141,7 @@ def _bullet(df, markers, measures, ranges, subtitles, titles, orientation, **scatter_options ) - fig['data'].append(markers) + fig.add_trace(markers) # titles and subtitles title = df.iloc[row]['titles'] @@ -159,7 +159,7 @@ def _bullet(df, markers, measures, ranges, subtitles, titles, orientation, True if orientation == 'h' else False, False ) - fig['layout']['annotations'].append(annot) + fig['layout']['annotations'] += (annot,) return fig diff --git a/plotly/figure_factory/_dendrogram.py b/plotly/figure_factory/_dendrogram.py index 700ab35be4..c51bf55531 100644 --- a/plotly/figure_factory/_dendrogram.py +++ b/plotly/figure_factory/_dendrogram.py @@ -90,14 +90,15 @@ def create_dendrogram(X, orientation="bottom", labels=None, distfun=distfun, linkagefun=linkagefun, hovertext=hovertext) - return graph_objs.Figure(data=dendrogram.data, layout=dendrogram.layout) + return graph_objs.Figure(data=dendrogram.data, + layout=dendrogram.layout) class _Dendrogram(object): """Refer to FigureFactory.create_dendrogram() for docstring.""" def __init__(self, X, orientation='bottom', labels=None, colorscale=None, - width="100%", height="100%", xaxis='xaxis', yaxis='yaxis', + width=np.inf, height=np.inf, xaxis='xaxis', yaxis='yaxis', distfun=None, linkagefun=lambda x: sch.linkage(x, 'complete'), hovertext=None): @@ -126,7 +127,7 @@ def __init__(self, X, orientation='bottom', labels=None, colorscale=None, (dd_traces, xvals, yvals, ordered_labels, leaves) = self.get_dendrogram_traces(X, colorscale, distfun, - linkagefun, + linkagefun, hovertext) self.labels = ordered_labels @@ -143,7 +144,7 @@ def __init__(self, X, orientation='bottom', labels=None, colorscale=None, self.zero_vals.sort() self.layout = self.set_figure_layout(width, height) - self.data = graph_objs.Data(dd_traces) + self.data = dd_traces def get_color_dict(self, colorscale): """ @@ -291,7 +292,7 @@ def get_dendrogram_traces(self, X, colorscale, distfun, linkagefun, hovertext): x=np.multiply(self.sign[self.xaxis], xs), y=np.multiply(self.sign[self.yaxis], ys), mode='lines', - marker=graph_objs.Marker(color=colors[color_key]), + marker=graph_objs.scatter.Marker(color=colors[color_key]), text=hovertext_label, hoverinfo='text' ) diff --git a/plotly/figure_factory/_facet_grid.py b/plotly/figure_factory/_facet_grid.py index 6d5fe33eed..a202599d74 100644 --- a/plotly/figure_factory/_facet_grid.py +++ b/plotly/figure_factory/_facet_grid.py @@ -2,11 +2,9 @@ from plotly import colors, exceptions, optional_imports from plotly.figure_factory import utils -from plotly.graph_objs import graph_objs from plotly.tools import make_subplots import math -import copy from numbers import Number pd = optional_imports.get_module('pandas') @@ -108,7 +106,7 @@ def _annotation_dict(text, lane, num_of_lanes, SUBPLOT_SPACING, row_col='col', showarrow=False, xref='paper', yref='paper', - text=text, + text=str(text), font=dict( size=13, color=AXIS_TITLE_COLOR @@ -145,8 +143,8 @@ def _axis_title_annotation(text, x_or_y_axis): def _add_shapes_to_fig(fig, annot_rect_color, flipped_rows=False, flipped_cols=False): - fig['layout']['shapes'] = [] - for key in fig['layout'].keys(): + shapes_list = [] + for key in fig['layout'].to_plotly_json().keys(): if 'axis' in key and fig['layout'][key]['domain'] != [0.0, 1.0]: shape = { 'fillcolor': annot_rect_color, @@ -165,7 +163,7 @@ def _add_shapes_to_fig(fig, annot_rect_color, flipped_rows=False, if flipped_cols: shape['y1'] += 0.5 - fig['layout']['shapes'].append(shape) + shapes_list.append(shape) elif 'yaxis' in key: shape['x0'] = 1.005 @@ -175,7 +173,9 @@ def _add_shapes_to_fig(fig, annot_rect_color, flipped_rows=False, if flipped_rows: shape['x1'] += 1 - fig['layout']['shapes'].append(shape) + shapes_list.append(shape) + + fig['layout']['shapes'] = shapes_list def _make_trace_for_scatter(trace, trace_type, color, **kwargs_marker): @@ -331,10 +331,7 @@ def _facet_grid_color_categorical(df, x, y, facet_row, facet_col, color_name, row_col='row', flipped=flipped_rows) ) - # add annotations - fig['layout']['annotations'] = annotations - - return fig + return fig, annotations def _facet_grid_color_numerical(df, x, y, facet_row, facet_col, color_name, @@ -474,10 +471,7 @@ def _facet_grid_color_numerical(df, x, y, facet_row, facet_col, color_name, row_col='row', flipped=flipped_rows) ) - # add annotations - fig['layout']['annotations'] = annotations - - return fig + return fig, annotations def _facet_grid(df, x, y, facet_row, facet_col, num_of_rows, @@ -600,10 +594,7 @@ def _facet_grid(df, x, y, facet_row, facet_col, num_of_rows, row_col='row', flipped=flipped_rows) ) - # add annotations - fig['layout']['annotations'] = annotations - - return fig + return fig, annotations def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, @@ -905,7 +896,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, j = 0 colormap[val] = default_colors[j] j += 1 - fig = _facet_grid_color_categorical( + fig, annotations = _facet_grid_color_categorical( df, x, y, facet_row, facet_col, color_name, colormap, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, flipped_rows, flipped_cols, show_boxes, @@ -924,7 +915,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, "all the values of the colormap column are in " "the keys of your dictionary." ) - fig = _facet_grid_color_categorical( + fig, annotations = _facet_grid_color_categorical( df, x, y, facet_row, facet_col, color_name, colormap, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, flipped_rows, @@ -936,7 +927,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, colorscale_list = colormap utils.validate_colorscale(colorscale_list) - fig = _facet_grid_color_numerical( + fig, annotations = _facet_grid_color_numerical( df, x, y, facet_row, facet_col, color_name, colorscale_list, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, @@ -952,7 +943,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, "of a Plotly Colorscale. The available colorscale " "names are {}".format(colors.PLOTLY_SCALES.keys()) ) - fig = _facet_grid_color_numerical( + fig, annotations = _facet_grid_color_numerical( df, x, y, facet_row, facet_col, color_name, colorscale_list, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, @@ -961,7 +952,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, ) else: colorscale_list = colors.PLOTLY_SCALES['Reds'] - fig = _facet_grid_color_numerical( + fig, annotations = _facet_grid_color_numerical( df, x, y, facet_row, facet_col, color_name, colorscale_list, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, @@ -970,7 +961,7 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, ) else: - fig = _facet_grid( + fig, annotations = _facet_grid( df, x, y, facet_row, facet_col, num_of_rows, num_of_cols, facet_row_labels, facet_col_labels, trace_type, flipped_rows, flipped_cols, show_boxes, SUBPLOT_SPACING, marker_color, @@ -992,8 +983,10 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, # axis titles x_title_annot = _axis_title_annotation(x, 'x') y_title_annot = _axis_title_annotation(y, 'y') - fig['layout']['annotations'].append(x_title_annot) - fig['layout']['annotations'].append(y_title_annot) + + # annotations + annotations.append(x_title_annot) + annotations.append(y_title_annot) # legend fig['layout']['showlegend'] = show_legend @@ -1008,9 +1001,12 @@ def create_facet_grid(df, x=None, y=None, facet_row=None, facet_col=None, if ggplot2: if color_name: legend_annot = _legend_annotation(color_name) - fig['layout']['annotations'].append(legend_annot) + annotations.append(legend_annot) fig['layout']['margin']['r'] = 150 + # assign annotations to figure + fig['layout']['annotations'] = annotations + # add shaded boxes behind axis titles if show_boxes and ggplot2: _add_shapes_to_fig(fig, ANNOT_RECT_COLOR, flipped_rows, flipped_cols) diff --git a/plotly/figure_factory/_table.py b/plotly/figure_factory/_table.py index 001dc9ea0e..3bd48db905 100644 --- a/plotly/figure_factory/_table.py +++ b/plotly/figure_factory/_table.py @@ -219,7 +219,7 @@ def make_table_annotations(self): font_color = (self.font_colors[0] if self.index and m == 0 else all_font_colors[n]) annotations.append( - graph_objs.Annotation( + graph_objs.layout.Annotation( text=format_text, x=self.x[m] - self.annotation_offset, y=self.y[n], @@ -228,5 +228,6 @@ def make_table_annotations(self): align="left", xanchor="left", font=dict(color=font_color), - showarrow=False)) + showarrow=False) + ) return annotations diff --git a/plotly/figure_factory/_trisurf.py b/plotly/figure_factory/_trisurf.py index d2b5842047..06e9cc04fe 100644 --- a/plotly/figure_factory/_trisurf.py +++ b/plotly/figure_factory/_trisurf.py @@ -160,16 +160,16 @@ def trisurf(x, y, z, simplices, show_colorbar, edges_color, scale, color=[min_mean_dists, max_mean_dists], colorscale=colorscale, showscale=True), - hoverinfo='None', + hoverinfo='none', showlegend=False ) # the triangle sides are not plotted if plot_edges is False: if mean_dists_are_numbers and show_colorbar is True: - return graph_objs.Data([triangles, colorbar]) + return [triangles, colorbar] else: - return graph_objs.Data([triangles]) + return [triangles] # define the lists x_edge, y_edge and z_edge, of x, y, resp z # coordinates of edge end points for each triangle @@ -206,7 +206,7 @@ def trisurf(x, y, z, simplices, show_colorbar, edges_color, scale, # define the lines for plotting lines = graph_objs.Scatter3d( x=x_edge, y=y_edge, z=z_edge, mode='lines', - line=graph_objs.Line( + line=graph_objs.scatter3d.Line( color=edges_color, width=1.5 ), @@ -214,9 +214,9 @@ def trisurf(x, y, z, simplices, show_colorbar, edges_color, scale, ) if mean_dists_are_numbers and show_colorbar is True: - return graph_objs.Data([triangles, lines, colorbar]) + return [triangles, lines, colorbar] else: - return graph_objs.Data([triangles, lines]) + return [triangles, lines] def create_trisurf(x, y, z, simplices, colormap=None, show_colorbar=True, @@ -474,10 +474,10 @@ def dist_origin(x, y, z): title=title, width=width, height=height, - scene=graph_objs.Scene( - xaxis=graph_objs.XAxis(axis), - yaxis=graph_objs.YAxis(axis), - zaxis=graph_objs.ZAxis(axis), + scene=graph_objs.layout.Scene( + xaxis=graph_objs.layout.scene.XAxis(**axis), + yaxis=graph_objs.layout.scene.YAxis(**axis), + zaxis=graph_objs.layout.scene.ZAxis(**axis), aspectratio=dict( x=aspectratio['x'], y=aspectratio['y'], diff --git a/plotly/figure_factory/_violin.py b/plotly/figure_factory/_violin.py index e0bba56d95..384f3497a1 100644 --- a/plotly/figure_factory/_violin.py +++ b/plotly/figure_factory/_violin.py @@ -56,7 +56,7 @@ def make_half_violin(x, y, fillcolor='#1f77b4', linecolor='rgb(0, 0, 0)'): text=text, fill='tonextx', fillcolor=fillcolor, - line=graph_objs.Line(width=0.5, color=linecolor, shape='spline'), + line=graph_objs.scatter.Line(width=0.5, color=linecolor, shape='spline'), hoverinfo='text', opacity=0.5 ) @@ -69,7 +69,7 @@ def make_violin_rugplot(vals, pdf_max, distance, color='#1f77b4'): return graph_objs.Scatter( y=vals, x=[-pdf_max-distance]*len(vals), - marker=graph_objs.Marker( + marker=graph_objs.scatter.Marker( color=color, symbol='line-ew-open' ), @@ -89,8 +89,8 @@ def make_non_outlier_interval(d1, d2): y=[d1, d2], name='', mode='lines', - line=graph_objs.Line(width=1.5, - color='rgb(0,0,0)') + line=graph_objs.scatter.Line(width=1.5, + color='rgb(0,0,0)') ) @@ -104,7 +104,7 @@ def make_quartiles(q1, q3): text=['lower-quartile: ' + '{:0.2f}'.format(q1), 'upper-quartile: ' + '{:0.2f}'.format(q3)], mode='lines', - line=graph_objs.Line( + line=graph_objs.scatter.Line( width=4, color='rgb(0,0,0)' ), @@ -131,7 +131,7 @@ def make_XAxis(xaxis_title, xaxis_range): """ Makes the x-axis for a violin plot. """ - xaxis = graph_objs.XAxis(title=xaxis_title, + xaxis = graph_objs.layout.XAxis(title=xaxis_title, range=xaxis_range, showgrid=False, zeroline=False, @@ -146,7 +146,7 @@ def make_YAxis(yaxis_title): """ Makes the y-axis for a violin plot. """ - yaxis = graph_objs.YAxis(title=yaxis_title, + yaxis = graph_objs.layout.YAxis(title=yaxis_title, showticklabels=True, autorange=True, ticklen=4, @@ -577,7 +577,7 @@ def create_violin(data, data_header=None, group_header=None, colors=None, layout = graph_objs.Layout( title=title, autosize=False, - font=graph_objs.Font(size=11), + font=graph_objs.layout.Font(size=11), height=height, showlegend=False, width=width, @@ -589,7 +589,7 @@ def create_violin(data, data_header=None, group_header=None, colors=None, showticklabels=False, ticks='')) - fig = graph_objs.Figure(data=graph_objs.Data(plot_data), + fig = graph_objs.Figure(data=plot_data, layout=layout) return fig diff --git a/plotly/graph_objs/__init__.py b/plotly/graph_objs/__init__.py index cfc295feb7..439815b189 100644 --- a/plotly/graph_objs/__init__.py +++ b/plotly/graph_objs/__init__.py @@ -1,14 +1,82 @@ -""" -graph_objs -========== +from ._violin import Violin +from plotly.graph_objs import violin +from ._table import Table +from plotly.graph_objs import table +from ._surface import Surface +from plotly.graph_objs import surface +from ._splom import Splom +from plotly.graph_objs import splom +from ._scatterternary import Scatterternary +from plotly.graph_objs import scatterternary +from ._scatterpolargl import Scatterpolargl +from plotly.graph_objs import scatterpolargl +from ._scatterpolar import Scatterpolar +from plotly.graph_objs import scatterpolar +from ._scattermapbox import Scattermapbox +from plotly.graph_objs import scattermapbox +from ._scattergl import Scattergl +from plotly.graph_objs import scattergl +from ._scattergeo import Scattergeo +from plotly.graph_objs import scattergeo +from ._scattercarpet import Scattercarpet +from plotly.graph_objs import scattercarpet +from ._scatter3d import Scatter3d +from plotly.graph_objs import scatter3d +from ._scatter import Scatter +from plotly.graph_objs import scatter +from ._sankey import Sankey +from plotly.graph_objs import sankey +from ._pointcloud import Pointcloud +from plotly.graph_objs import pointcloud +from ._pie import Pie +from plotly.graph_objs import pie +from ._parcoords import Parcoords +from plotly.graph_objs import parcoords +from ._ohlc import Ohlc +from plotly.graph_objs import ohlc +from ._mesh3d import Mesh3d +from plotly.graph_objs import mesh3d +from ._histogram2dcontour import Histogram2dContour +from plotly.graph_objs import histogram2dcontour +from ._histogram2d import Histogram2d +from plotly.graph_objs import histogram2d +from ._histogram import Histogram +from plotly.graph_objs import histogram +from ._heatmapgl import Heatmapgl +from plotly.graph_objs import heatmapgl +from ._heatmap import Heatmap +from plotly.graph_objs import heatmap +from ._contourcarpet import Contourcarpet +from plotly.graph_objs import contourcarpet +from ._contour import Contour +from plotly.graph_objs import contour +from ._cone import Cone +from plotly.graph_objs import cone +from ._choropleth import Choropleth +from plotly.graph_objs import choropleth +from ._carpet import Carpet +from plotly.graph_objs import carpet +from ._candlestick import Candlestick +from plotly.graph_objs import candlestick +from ._box import Box +from plotly.graph_objs import box +from ._bar import Bar +from plotly.graph_objs import bar +from ._area import Area +from plotly.graph_objs import area +from ._layout import Layout +from plotly.graph_objs import layout +from ._frame import Frame +from ._figure import Figure -This package imports definitions for all of Plotly's graph objects. For more -information, run help(Obj) on any of the following objects defined here. +try: + import ipywidgets + from ._figurewidget import FigureWidget +except ImportError: + pass -The reason for the package graph_objs and the module graph_objs is to provide -a clearer API for users. - -""" -from __future__ import absolute_import - -from plotly.graph_objs.graph_objs import * # this is protected with __all__ +from ._deprecations import ( + Data, Annotations, Frames, AngularAxis, Annotation, ColorBar, Contours, + ErrorX, ErrorY, ErrorZ, Font, Legend, Line, Margin, Marker, RadialAxis, + Scene, Stream, XAxis, YAxis, ZAxis, XBins, YBins, Trace, Histogram2dcontour +) diff --git a/plotly/graph_objs/_area.py b/plotly/graph_objs/_area.py new file mode 100644 index 0000000000..ccfadac1ea --- /dev/null +++ b/plotly/graph_objs/_area.py @@ -0,0 +1,793 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Area(BaseTraceType): + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.area.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.area.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.area.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color + . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + size + Sets the marker size (in px). + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.area.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # r + # - + @property + def r(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the radial coordinates. + + The 'r' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # rsrc + # ---- + @property + def rsrc(self): + """ + Sets the source reference on plot.ly for r . + + The 'rsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['rsrc'] + + @rsrc.setter + def rsrc(self, val): + self['rsrc'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.area.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.area.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # t + # - + @property + def t(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the angular coordinates. + + The 't' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # tsrc + # ---- + @property + def tsrc(self): + """ + Sets the source reference on plot.ly for t . + + The 'tsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tsrc'] + + @tsrc.setter + def tsrc(self, val): + self['tsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.area.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.area.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.area.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + tsrc + Sets the source reference on plot.ly for t . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + tsrc=None, + uid=None, + visible=None, + **kwargs + ): + """ + Construct a new Area object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Area + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.area.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.area.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.area.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + tsrc + Sets the source reference on plot.ly for t . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Area + """ + super(Area, self).__init__('area') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Area +constructor must be a dict or +an instance of plotly.graph_objs.Area""" + ) + + # Import validators + # ----------------- + from plotly.validators import (area as v_area) + + # Initialize validators + # --------------------- + self._validators['customdata'] = v_area.CustomdataValidator() + self._validators['customdatasrc'] = v_area.CustomdatasrcValidator() + self._validators['hoverinfo'] = v_area.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_area.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_area.HoverlabelValidator() + self._validators['ids'] = v_area.IdsValidator() + self._validators['idssrc'] = v_area.IdssrcValidator() + self._validators['legendgroup'] = v_area.LegendgroupValidator() + self._validators['marker'] = v_area.MarkerValidator() + self._validators['name'] = v_area.NameValidator() + self._validators['opacity'] = v_area.OpacityValidator() + self._validators['r'] = v_area.RValidator() + self._validators['rsrc'] = v_area.RsrcValidator() + self._validators['selectedpoints'] = v_area.SelectedpointsValidator() + self._validators['showlegend'] = v_area.ShowlegendValidator() + self._validators['stream'] = v_area.StreamValidator() + self._validators['t'] = v_area.TValidator() + self._validators['tsrc'] = v_area.TsrcValidator() + self._validators['uid'] = v_area.UidValidator() + self._validators['visible'] = v_area.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('rsrc', None) + self.rsrc = rsrc if rsrc is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + v = arg.pop('tsrc', None) + self.tsrc = tsrc if tsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'area' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='area' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_bar.py b/plotly/graph_objs/_bar.py new file mode 100644 index 0000000000..bfbb9561dd --- /dev/null +++ b/plotly/graph_objs/_bar.py @@ -0,0 +1,2180 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Bar(BaseTraceType): + + # base + # ---- + @property + def base(self): + """ + Sets where the bar base is drawn (in position axis units). In + *stack* or *relative* barmode, traces that set *base* will be + excluded and drawn in *overlay* mode instead. + + The 'base' property accepts values of any type + + Returns + ------- + Any|numpy.ndarray + """ + return self['base'] + + @base.setter + def base(self, val): + self['base'] = val + + # basesrc + # ------- + @property + def basesrc(self): + """ + Sets the source reference on plot.ly for base . + + The 'basesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['basesrc'] + + @basesrc.setter + def basesrc(self, val): + self['basesrc'] = val + + # cliponaxis + # ---------- + @property + def cliponaxis(self): + """ + Determines whether the text nodes are clipped about the subplot + axes. To show the text nodes above axis lines and tick labels, + make sure to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + + The 'cliponaxis' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cliponaxis'] + + @cliponaxis.setter + def cliponaxis(self, val): + self['cliponaxis'] = val + + # constraintext + # ------------- + @property + def constraintext(self): + """ + Constrain the size of text inside or outside a bar to be no + larger than the bar itself. + + The 'constraintext' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['inside', 'outside', 'both', 'none'] + + Returns + ------- + Any + """ + return self['constraintext'] + + @constraintext.setter + def constraintext(self, val): + self['constraintext'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # error_x + # ------- + @property + def error_x(self): + """ + The 'error_x' property is an instance of ErrorX + that may be specified as: + - An instance of plotly.graph_objs.bar.ErrorX + - A dict of string/value properties that will be passed + to the ErrorX constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.bar.ErrorX + """ + return self['error_x'] + + @error_x.setter + def error_x(self, val): + self['error_x'] = val + + # error_y + # ------- + @property + def error_y(self): + """ + The 'error_y' property is an instance of ErrorY + that may be specified as: + - An instance of plotly.graph_objs.bar.ErrorY + - A dict of string/value properties that will be passed + to the ErrorY constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.bar.ErrorY + """ + return self['error_y'] + + @error_y.setter + def error_y(self, val): + self['error_y'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.bar.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.bar.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (x,y) pair. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # insidetextfont + # -------------- + @property + def insidetextfont(self): + """ + Sets the font used for `text` lying inside the bar. + + The 'insidetextfont' property is an instance of Insidetextfont + that may be specified as: + - An instance of plotly.graph_objs.bar.Insidetextfont + - A dict of string/value properties that will be passed + to the Insidetextfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.bar.Insidetextfont + """ + return self['insidetextfont'] + + @insidetextfont.setter + def insidetextfont(self, val): + self['insidetextfont'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.bar.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.bar.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.bar.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + + Returns + ------- + plotly.graph_objs.bar.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # offset + # ------ + @property + def offset(self): + """ + Shifts the position where the bar is drawn (in position axis + units). In *group* barmode, traces that set *offset* will be + excluded and drawn in *overlay* mode instead. + + The 'offset' property is a number and may be specified as: + - An int or float + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['offset'] + + @offset.setter + def offset(self, val): + self['offset'] = val + + # offsetsrc + # --------- + @property + def offsetsrc(self): + """ + Sets the source reference on plot.ly for offset . + + The 'offsetsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['offsetsrc'] + + @offsetsrc.setter + def offsetsrc(self, val): + self['offsetsrc'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the bars. With *v* (*h*), the value of + the each bar spans along the vertical (horizontal). + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # outsidetextfont + # --------------- + @property + def outsidetextfont(self): + """ + Sets the font used for `text` lying outside the bar. + + The 'outsidetextfont' property is an instance of Outsidetextfont + that may be specified as: + - An instance of plotly.graph_objs.bar.Outsidetextfont + - A dict of string/value properties that will be passed + to the Outsidetextfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.bar.Outsidetextfont + """ + return self['outsidetextfont'] + + @outsidetextfont.setter + def outsidetextfont(self, val): + self['outsidetextfont'] = val + + # r + # - + @property + def r(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the radial coordinates. + + The 'r' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # rsrc + # ---- + @property + def rsrc(self): + """ + Sets the source reference on plot.ly for r . + + The 'rsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['rsrc'] + + @rsrc.setter + def rsrc(self, val): + self['rsrc'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.bar.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.bar.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.bar.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.bar.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.bar.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.bar.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # t + # - + @property + def t(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the angular coordinates. + + The 't' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the font used for `text`. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.bar.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.bar.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Specifies the location of the `text`. *inside* positions `text` + inside, next to the bar end (rotated and scaled if needed). + *outside* positions `text` outside, next to the bar end (scaled + if needed). *auto* positions `text` inside or outside so that + `text` size is maximized. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['inside', 'outside', 'auto', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # tsrc + # ---- + @property + def tsrc(self): + """ + Sets the source reference on plot.ly for t . + + The 'tsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tsrc'] + + @tsrc.setter + def tsrc(self, val): + self['tsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.bar.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.bar.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.bar.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.bar.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the bar width (in position axis units). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + base + Sets where the bar base is drawn (in position axis + units). In *stack* or *relative* barmode, traces that + set *base* will be excluded and drawn in *overlay* mode + instead. + basesrc + Sets the source reference on plot.ly for base . + cliponaxis + Determines whether the text nodes are clipped about the + subplot axes. To show the text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + constraintext + Constrain the size of text inside or outside a bar to + be no larger than the bar itself. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.bar.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.bar.ErrorY instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.bar.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `text` lying inside the bar. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.bar.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + offset + Shifts the position where the bar is drawn (in position + axis units). In *group* barmode, traces that set + *offset* will be excluded and drawn in *overlay* mode + instead. + offsetsrc + Sets the source reference on plot.ly for offset . + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + outsidetextfont + Sets the font used for `text` lying outside the bar. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.bar.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.bar.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the font used for `text`. + textposition + Specifies the location of the `text`. *inside* + positions `text` inside, next to the bar end (rotated + and scaled if needed). *outside* positions `text` + outside, next to the bar end (scaled if needed). *auto* + positions `text` inside or outside so that `text` size + is maximized. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.bar.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + width + Sets the bar width (in position axis units). + widthsrc + Sets the source reference on plot.ly for width . + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + base=None, + basesrc=None, + cliponaxis=None, + constraintext=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + legendgroup=None, + marker=None, + name=None, + offset=None, + offsetsrc=None, + opacity=None, + orientation=None, + outsidetextfont=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + width=None, + widthsrc=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Bar object + + The data visualized by the span of the bars is set in `y` if + `orientation` is set th *v* (the default) and the labels are + set in `x`. By setting `orientation` to *h*, the roles are + interchanged. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Bar + base + Sets where the bar base is drawn (in position axis + units). In *stack* or *relative* barmode, traces that + set *base* will be excluded and drawn in *overlay* mode + instead. + basesrc + Sets the source reference on plot.ly for base . + cliponaxis + Determines whether the text nodes are clipped about the + subplot axes. To show the text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + constraintext + Constrain the size of text inside or outside a bar to + be no larger than the bar itself. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.bar.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.bar.ErrorY instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.bar.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `text` lying inside the bar. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.bar.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + offset + Shifts the position where the bar is drawn (in position + axis units). In *group* barmode, traces that set + *offset* will be excluded and drawn in *overlay* mode + instead. + offsetsrc + Sets the source reference on plot.ly for offset . + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + outsidetextfont + Sets the font used for `text` lying outside the bar. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.bar.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.bar.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the font used for `text`. + textposition + Specifies the location of the `text`. *inside* + positions `text` inside, next to the bar end (rotated + and scaled if needed). *outside* positions `text` + outside, next to the bar end (scaled if needed). *auto* + positions `text` inside or outside so that `text` size + is maximized. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.bar.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + width + Sets the bar width (in position axis units). + widthsrc + Sets the source reference on plot.ly for width . + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Bar + """ + super(Bar, self).__init__('bar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Bar +constructor must be a dict or +an instance of plotly.graph_objs.Bar""" + ) + + # Import validators + # ----------------- + from plotly.validators import (bar as v_bar) + + # Initialize validators + # --------------------- + self._validators['base'] = v_bar.BaseValidator() + self._validators['basesrc'] = v_bar.BasesrcValidator() + self._validators['cliponaxis'] = v_bar.CliponaxisValidator() + self._validators['constraintext'] = v_bar.ConstraintextValidator() + self._validators['customdata'] = v_bar.CustomdataValidator() + self._validators['customdatasrc'] = v_bar.CustomdatasrcValidator() + self._validators['dx'] = v_bar.DxValidator() + self._validators['dy'] = v_bar.DyValidator() + self._validators['error_x'] = v_bar.ErrorXValidator() + self._validators['error_y'] = v_bar.ErrorYValidator() + self._validators['hoverinfo'] = v_bar.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_bar.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_bar.HoverlabelValidator() + self._validators['hovertext'] = v_bar.HovertextValidator() + self._validators['hovertextsrc'] = v_bar.HovertextsrcValidator() + self._validators['ids'] = v_bar.IdsValidator() + self._validators['idssrc'] = v_bar.IdssrcValidator() + self._validators['insidetextfont'] = v_bar.InsidetextfontValidator() + self._validators['legendgroup'] = v_bar.LegendgroupValidator() + self._validators['marker'] = v_bar.MarkerValidator() + self._validators['name'] = v_bar.NameValidator() + self._validators['offset'] = v_bar.OffsetValidator() + self._validators['offsetsrc'] = v_bar.OffsetsrcValidator() + self._validators['opacity'] = v_bar.OpacityValidator() + self._validators['orientation'] = v_bar.OrientationValidator() + self._validators['outsidetextfont'] = v_bar.OutsidetextfontValidator() + self._validators['r'] = v_bar.RValidator() + self._validators['rsrc'] = v_bar.RsrcValidator() + self._validators['selected'] = v_bar.SelectedValidator() + self._validators['selectedpoints'] = v_bar.SelectedpointsValidator() + self._validators['showlegend'] = v_bar.ShowlegendValidator() + self._validators['stream'] = v_bar.StreamValidator() + self._validators['t'] = v_bar.TValidator() + self._validators['text'] = v_bar.TextValidator() + self._validators['textfont'] = v_bar.TextfontValidator() + self._validators['textposition'] = v_bar.TextpositionValidator() + self._validators['textpositionsrc'] = v_bar.TextpositionsrcValidator() + self._validators['textsrc'] = v_bar.TextsrcValidator() + self._validators['tsrc'] = v_bar.TsrcValidator() + self._validators['uid'] = v_bar.UidValidator() + self._validators['unselected'] = v_bar.UnselectedValidator() + self._validators['visible'] = v_bar.VisibleValidator() + self._validators['width'] = v_bar.WidthValidator() + self._validators['widthsrc'] = v_bar.WidthsrcValidator() + self._validators['x'] = v_bar.XValidator() + self._validators['x0'] = v_bar.X0Validator() + self._validators['xaxis'] = v_bar.XAxisValidator() + self._validators['xcalendar'] = v_bar.XcalendarValidator() + self._validators['xsrc'] = v_bar.XsrcValidator() + self._validators['y'] = v_bar.YValidator() + self._validators['y0'] = v_bar.Y0Validator() + self._validators['yaxis'] = v_bar.YAxisValidator() + self._validators['ycalendar'] = v_bar.YcalendarValidator() + self._validators['ysrc'] = v_bar.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('base', None) + self.base = base if base is not None else v + v = arg.pop('basesrc', None) + self.basesrc = basesrc if basesrc is not None else v + v = arg.pop('cliponaxis', None) + self.cliponaxis = cliponaxis if cliponaxis is not None else v + v = arg.pop('constraintext', None) + self.constraintext = constraintext if constraintext is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('error_x', None) + self.error_x = error_x if error_x is not None else v + v = arg.pop('error_y', None) + self.error_y = error_y if error_y is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('insidetextfont', None) + self.insidetextfont = insidetextfont if insidetextfont is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('offset', None) + self.offset = offset if offset is not None else v + v = arg.pop('offsetsrc', None) + self.offsetsrc = offsetsrc if offsetsrc is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('outsidetextfont', None) + self.outsidetextfont = outsidetextfont if outsidetextfont is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('rsrc', None) + self.rsrc = rsrc if rsrc is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('tsrc', None) + self.tsrc = tsrc if tsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'bar' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='bar' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_box.py b/plotly/graph_objs/_box.py new file mode 100644 index 0000000000..0044f8b3a4 --- /dev/null +++ b/plotly/graph_objs/_box.py @@ -0,0 +1,1582 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Box(BaseTraceType): + + # boxmean + # ------- + @property + def boxmean(self): + """ + If *true*, the mean of the box(es)' underlying distribution is + drawn as a dashed line inside the box(es). If *sd* the standard + deviation is also drawn. + + The 'boxmean' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'sd', False] + + Returns + ------- + Any + """ + return self['boxmean'] + + @boxmean.setter + def boxmean(self, val): + self['boxmean'] = val + + # boxpoints + # --------- + @property + def boxpoints(self): + """ + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier points + are shown and points either less than 4*Q1-3*Q3 or greater than + 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all + sample points are shown If *false*, only the box(es) are shown + with no sample points + + The 'boxpoints' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'outliers', 'suspectedoutliers', False] + + Returns + ------- + Any + """ + return self['boxpoints'] + + @boxpoints.setter + def boxpoints(self, val): + self['boxpoints'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.box.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.box.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual boxes or sample + points or both? + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['boxes', 'points'] joined with '+' characters + (e.g. 'boxes+points') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # jitter + # ------ + @property + def jitter(self): + """ + Sets the amount of jitter in the sample points drawn. If *0*, + the sample points align along the distribution axis. If *1*, + the sample points are drawn in a random jitter of width equal + to the width of the box(es). + + The 'jitter' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['jitter'] + + @jitter.setter + def jitter(self, val): + self['jitter'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.box.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es). + + Returns + ------- + plotly.graph_objs.box.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.box.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + line + plotly.graph_objs.box.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + + Returns + ------- + plotly.graph_objs.box.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. For box traces, the name will also be used for + the position coordinate, if `x` and `x0` (`y` and `y0` if + horizontal) are missing and the position axis is categorical + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # notched + # ------- + @property + def notched(self): + """ + Determines whether or not notches should be drawn. + + The 'notched' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['notched'] + + @notched.setter + def notched(self, val): + self['notched'] = val + + # notchwidth + # ---------- + @property + def notchwidth(self): + """ + Sets the width of the notches relative to the box' width. For + example, with 0, the notches are as wide as the box(es). + + The 'notchwidth' property is a number and may be specified as: + - An int or float in the interval [0, 0.5] + + Returns + ------- + int|float + """ + return self['notchwidth'] + + @notchwidth.setter + def notchwidth(self, val): + self['notchwidth'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the box(es). If *v* (*h*), the + distribution is visualized along the vertical (horizontal). + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # pointpos + # -------- + @property + def pointpos(self): + """ + Sets the position of the sample points in relation to the + box(es). If *0*, the sample points are places over the center + of the box(es). Positive (negative) values correspond to + positions to the right (left) for vertical boxes and above + (below) for horizontal boxes + + The 'pointpos' property is a number and may be specified as: + - An int or float in the interval [-2, 2] + + Returns + ------- + int|float + """ + return self['pointpos'] + + @pointpos.setter + def pointpos(self, val): + self['pointpos'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.box.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.box.selected.Marker instance + or dict with compatible properties + + Returns + ------- + plotly.graph_objs.box.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.box.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.box.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each sample value. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.box.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.box.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.box.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # whiskerwidth + # ------------ + @property + def whiskerwidth(self): + """ + Sets the width of the whiskers relative to the box' width. For + example, with 1, the whiskers are as wide as the box(es). + + The 'whiskerwidth' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['whiskerwidth'] + + @whiskerwidth.setter + def whiskerwidth(self, val): + self['whiskerwidth'] = val + + # x + # - + @property + def x(self): + """ + Sets the x sample data or coordinates. See overview for more + info. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Sets the x coordinate of the box. See overview for more info. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y sample data or coordinates. See overview for more + info. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Sets the y coordinate of the box. See overview for more info. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + boxmean + If *true*, the mean of the box(es)' underlying + distribution is drawn as a dashed line inside the + box(es). If *sd* the standard deviation is also drawn. + boxpoints + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the box(es) are shown with no sample + points + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.box.Hoverlabel instance or dict with + compatible properties + hoveron + Do the hover effects highlight individual boxes or + sample points or both? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the box(es). + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.box.Line instance or dict with + compatible properties + marker + plotly.graph_objs.box.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + notched + Determines whether or not notches should be drawn. + notchwidth + Sets the width of the notches relative to the box' + width. For example, with 0, the notches are as wide as + the box(es). + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the box(es). If *v* (*h*), the + distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the box(es). If *0*, the sample points are places over + the center of the box(es). Positive (negative) values + correspond to positions to the right (left) for + vertical boxes and above (below) for horizontal boxes + selected + plotly.graph_objs.box.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.box.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.box.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + boxmean=None, + boxpoints=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + name=None, + notched=None, + notchwidth=None, + opacity=None, + orientation=None, + pointpos=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + whiskerwidth=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Box object + + In vertical (horizontal) box plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + box per distinct x (y) value is drawn If no `x` (`y`) {array} + is provided, a single box is drawn. That box position is then + positioned with with `name` or with `x0` (`y0`) if provided. + Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The + second quartile (Q2) is marked by a line inside the box. By + default, the whiskers correspond to the box' edges +/- 1.5 + times the interquartile range (IQR = Q3-Q1), see *boxpoints* + for other options. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Box + boxmean + If *true*, the mean of the box(es)' underlying + distribution is drawn as a dashed line inside the + box(es). If *sd* the standard deviation is also drawn. + boxpoints + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the box(es) are shown with no sample + points + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.box.Hoverlabel instance or dict with + compatible properties + hoveron + Do the hover effects highlight individual boxes or + sample points or both? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the box(es). + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.box.Line instance or dict with + compatible properties + marker + plotly.graph_objs.box.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + notched + Determines whether or not notches should be drawn. + notchwidth + Sets the width of the notches relative to the box' + width. For example, with 0, the notches are as wide as + the box(es). + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the box(es). If *v* (*h*), the + distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the box(es). If *0*, the sample points are places over + the center of the box(es). Positive (negative) values + correspond to positions to the right (left) for + vertical boxes and above (below) for horizontal boxes + selected + plotly.graph_objs.box.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.box.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.box.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Box + """ + super(Box, self).__init__('box') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Box +constructor must be a dict or +an instance of plotly.graph_objs.Box""" + ) + + # Import validators + # ----------------- + from plotly.validators import (box as v_box) + + # Initialize validators + # --------------------- + self._validators['boxmean'] = v_box.BoxmeanValidator() + self._validators['boxpoints'] = v_box.BoxpointsValidator() + self._validators['customdata'] = v_box.CustomdataValidator() + self._validators['customdatasrc'] = v_box.CustomdatasrcValidator() + self._validators['fillcolor'] = v_box.FillcolorValidator() + self._validators['hoverinfo'] = v_box.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_box.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_box.HoverlabelValidator() + self._validators['hoveron'] = v_box.HoveronValidator() + self._validators['ids'] = v_box.IdsValidator() + self._validators['idssrc'] = v_box.IdssrcValidator() + self._validators['jitter'] = v_box.JitterValidator() + self._validators['legendgroup'] = v_box.LegendgroupValidator() + self._validators['line'] = v_box.LineValidator() + self._validators['marker'] = v_box.MarkerValidator() + self._validators['name'] = v_box.NameValidator() + self._validators['notched'] = v_box.NotchedValidator() + self._validators['notchwidth'] = v_box.NotchwidthValidator() + self._validators['opacity'] = v_box.OpacityValidator() + self._validators['orientation'] = v_box.OrientationValidator() + self._validators['pointpos'] = v_box.PointposValidator() + self._validators['selected'] = v_box.SelectedValidator() + self._validators['selectedpoints'] = v_box.SelectedpointsValidator() + self._validators['showlegend'] = v_box.ShowlegendValidator() + self._validators['stream'] = v_box.StreamValidator() + self._validators['text'] = v_box.TextValidator() + self._validators['textsrc'] = v_box.TextsrcValidator() + self._validators['uid'] = v_box.UidValidator() + self._validators['unselected'] = v_box.UnselectedValidator() + self._validators['visible'] = v_box.VisibleValidator() + self._validators['whiskerwidth'] = v_box.WhiskerwidthValidator() + self._validators['x'] = v_box.XValidator() + self._validators['x0'] = v_box.X0Validator() + self._validators['xaxis'] = v_box.XAxisValidator() + self._validators['xcalendar'] = v_box.XcalendarValidator() + self._validators['xsrc'] = v_box.XsrcValidator() + self._validators['y'] = v_box.YValidator() + self._validators['y0'] = v_box.Y0Validator() + self._validators['yaxis'] = v_box.YAxisValidator() + self._validators['ycalendar'] = v_box.YcalendarValidator() + self._validators['ysrc'] = v_box.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('boxmean', None) + self.boxmean = boxmean if boxmean is not None else v + v = arg.pop('boxpoints', None) + self.boxpoints = boxpoints if boxpoints is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('jitter', None) + self.jitter = jitter if jitter is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('notched', None) + self.notched = notched if notched is not None else v + v = arg.pop('notchwidth', None) + self.notchwidth = notchwidth if notchwidth is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('pointpos', None) + self.pointpos = pointpos if pointpos is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('whiskerwidth', None) + self.whiskerwidth = whiskerwidth if whiskerwidth is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'box' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='box' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_candlestick.py b/plotly/graph_objs/_candlestick.py new file mode 100644 index 0000000000..04a4a4a851 --- /dev/null +++ b/plotly/graph_objs/_candlestick.py @@ -0,0 +1,1242 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Candlestick(BaseTraceType): + + # close + # ----- + @property + def close(self): + """ + Sets the close values. + + The 'close' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['close'] + + @close.setter + def close(self, val): + self['close'] = val + + # closesrc + # -------- + @property + def closesrc(self): + """ + Sets the source reference on plot.ly for close . + + The 'closesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['closesrc'] + + @closesrc.setter + def closesrc(self, val): + self['closesrc'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # decreasing + # ---------- + @property + def decreasing(self): + """ + The 'decreasing' property is an instance of Decreasing + that may be specified as: + - An instance of plotly.graph_objs.candlestick.Decreasing + - A dict of string/value properties that will be passed + to the Decreasing constructor + + Supported dict properties: + + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + line + plotly.graph_objs.candlestick.decreasing.Line + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.candlestick.Decreasing + """ + return self['decreasing'] + + @decreasing.setter + def decreasing(self, val): + self['decreasing'] = val + + # high + # ---- + @property + def high(self): + """ + Sets the high values. + + The 'high' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['high'] + + @high.setter + def high(self, val): + self['high'] = val + + # highsrc + # ------- + @property + def highsrc(self): + """ + Sets the source reference on plot.ly for high . + + The 'highsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['highsrc'] + + @highsrc.setter + def highsrc(self, val): + self['highsrc'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.candlestick.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.candlestick.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # increasing + # ---------- + @property + def increasing(self): + """ + The 'increasing' property is an instance of Increasing + that may be specified as: + - An instance of plotly.graph_objs.candlestick.Increasing + - A dict of string/value properties that will be passed + to the Increasing constructor + + Supported dict properties: + + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + line + plotly.graph_objs.candlestick.increasing.Line + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.candlestick.Increasing + """ + return self['increasing'] + + @increasing.setter + def increasing(self, val): + self['increasing'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.candlestick.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + width + Sets the width (in px) of line bounding the + box(es). Note that this style setting can also + be set per direction via + `increasing.line.width` and + `decreasing.line.width`. + + Returns + ------- + plotly.graph_objs.candlestick.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # low + # --- + @property + def low(self): + """ + Sets the low values. + + The 'low' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['low'] + + @low.setter + def low(self, val): + self['low'] = val + + # lowsrc + # ------ + @property + def lowsrc(self): + """ + Sets the source reference on plot.ly for low . + + The 'lowsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['lowsrc'] + + @lowsrc.setter + def lowsrc(self, val): + self['lowsrc'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # open + # ---- + @property + def open(self): + """ + Sets the open values. + + The 'open' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['open'] + + @open.setter + def open(self, val): + self['open'] = val + + # opensrc + # ------- + @property + def opensrc(self): + """ + Sets the source reference on plot.ly for open . + + The 'opensrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opensrc'] + + @opensrc.setter + def opensrc(self, val): + self['opensrc'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.candlestick.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.candlestick.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets hover text elements associated with each sample point. If + a single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + this trace's sample points. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # whiskerwidth + # ------------ + @property + def whiskerwidth(self): + """ + Sets the width of the whiskers relative to the box' width. For + example, with 1, the whiskers are as wide as the box(es). + + The 'whiskerwidth' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['whiskerwidth'] + + @whiskerwidth.setter + def whiskerwidth(self, val): + self['whiskerwidth'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. If absent, linear coordinate will be + generated. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.candlestick.Decreasing instance or + dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.candlestick.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.candlestick.Increasing instance or + dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.candlestick.Line instance or dict + with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.candlestick.Stream instance or dict + with compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + """ + + def __init__( + self, + arg=None, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + whiskerwidth=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + **kwargs + ): + """ + Construct a new Candlestick object + + The candlestick is a style of financial chart describing open, + high, low and close for a given `x` coordinate (most likely + time). The boxes represent the spread between the `open` and + `close` values and the lines represent the spread between the + `low` and `high` values Sample points where the close value is + higher (lower) then the open value are called increasing + (decreasing). By default, increasing candles are drawn in green + whereas decreasing are drawn in red. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Candlestick + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.candlestick.Decreasing instance or + dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.candlestick.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.candlestick.Increasing instance or + dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.candlestick.Line instance or dict + with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.candlestick.Stream instance or dict + with compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + + Returns + ------- + Candlestick + """ + super(Candlestick, self).__init__('candlestick') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Candlestick +constructor must be a dict or +an instance of plotly.graph_objs.Candlestick""" + ) + + # Import validators + # ----------------- + from plotly.validators import (candlestick as v_candlestick) + + # Initialize validators + # --------------------- + self._validators['close'] = v_candlestick.CloseValidator() + self._validators['closesrc'] = v_candlestick.ClosesrcValidator() + self._validators['customdata'] = v_candlestick.CustomdataValidator() + self._validators['customdatasrc' + ] = v_candlestick.CustomdatasrcValidator() + self._validators['decreasing'] = v_candlestick.DecreasingValidator() + self._validators['high'] = v_candlestick.HighValidator() + self._validators['highsrc'] = v_candlestick.HighsrcValidator() + self._validators['hoverinfo'] = v_candlestick.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_candlestick.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_candlestick.HoverlabelValidator() + self._validators['ids'] = v_candlestick.IdsValidator() + self._validators['idssrc'] = v_candlestick.IdssrcValidator() + self._validators['increasing'] = v_candlestick.IncreasingValidator() + self._validators['legendgroup'] = v_candlestick.LegendgroupValidator() + self._validators['line'] = v_candlestick.LineValidator() + self._validators['low'] = v_candlestick.LowValidator() + self._validators['lowsrc'] = v_candlestick.LowsrcValidator() + self._validators['name'] = v_candlestick.NameValidator() + self._validators['opacity'] = v_candlestick.OpacityValidator() + self._validators['open'] = v_candlestick.OpenValidator() + self._validators['opensrc'] = v_candlestick.OpensrcValidator() + self._validators['selectedpoints' + ] = v_candlestick.SelectedpointsValidator() + self._validators['showlegend'] = v_candlestick.ShowlegendValidator() + self._validators['stream'] = v_candlestick.StreamValidator() + self._validators['text'] = v_candlestick.TextValidator() + self._validators['textsrc'] = v_candlestick.TextsrcValidator() + self._validators['uid'] = v_candlestick.UidValidator() + self._validators['visible'] = v_candlestick.VisibleValidator() + self._validators['whiskerwidth' + ] = v_candlestick.WhiskerwidthValidator() + self._validators['x'] = v_candlestick.XValidator() + self._validators['xaxis'] = v_candlestick.XAxisValidator() + self._validators['xcalendar'] = v_candlestick.XcalendarValidator() + self._validators['xsrc'] = v_candlestick.XsrcValidator() + self._validators['yaxis'] = v_candlestick.YAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('close', None) + self.close = close if close is not None else v + v = arg.pop('closesrc', None) + self.closesrc = closesrc if closesrc is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('decreasing', None) + self.decreasing = decreasing if decreasing is not None else v + v = arg.pop('high', None) + self.high = high if high is not None else v + v = arg.pop('highsrc', None) + self.highsrc = highsrc if highsrc is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('increasing', None) + self.increasing = increasing if increasing is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('low', None) + self.low = low if low is not None else v + v = arg.pop('lowsrc', None) + self.lowsrc = lowsrc if lowsrc is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('open', None) + self.open = open if open is not None else v + v = arg.pop('opensrc', None) + self.opensrc = opensrc if opensrc is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('whiskerwidth', None) + self.whiskerwidth = whiskerwidth if whiskerwidth is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'candlestick' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='candlestick' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_carpet.py b/plotly/graph_objs/_carpet.py new file mode 100644 index 0000000000..add21b903a --- /dev/null +++ b/plotly/graph_objs/_carpet.py @@ -0,0 +1,1720 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Carpet(BaseTraceType): + + # a + # - + @property + def a(self): + """ + An array containing values of the first parameter value + + The 'a' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['a'] + + @a.setter + def a(self, val): + self['a'] = val + + # a0 + # -- + @property + def a0(self): + """ + Alternate to `a`. Builds a linear space of a coordinates. Use + with `da` where `a0` is the starting coordinate and `da` the + step. + + The 'a0' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['a0'] + + @a0.setter + def a0(self, val): + self['a0'] = val + + # aaxis + # ----- + @property + def aaxis(self): + """ + The 'aaxis' property is an instance of Aaxis + that may be specified as: + - An instance of plotly.graph_objs.carpet.Aaxis + - A dict of string/value properties that will be passed + to the Aaxis constructor + + Supported dict properties: + + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at + along the final value of this axis. If *true*, + the end line is drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major + grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether axis labels are drawn on the + low side, the high side, both, or neither side + of the axis. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at + along the starting value of this axis. If + *true*, the start line is drawn on top of the + grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.aaxis.Tickformatstop + instance or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the + title from the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + + Returns + ------- + plotly.graph_objs.carpet.Aaxis + """ + return self['aaxis'] + + @aaxis.setter + def aaxis(self, val): + self['aaxis'] = val + + # asrc + # ---- + @property + def asrc(self): + """ + Sets the source reference on plot.ly for a . + + The 'asrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['asrc'] + + @asrc.setter + def asrc(self, val): + self['asrc'] = val + + # b + # - + @property + def b(self): + """ + A two dimensional array of y coordinates at each carpet point. + + The 'b' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # b0 + # -- + @property + def b0(self): + """ + Alternate to `b`. Builds a linear space of a coordinates. Use + with `db` where `b0` is the starting coordinate and `db` the + step. + + The 'b0' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['b0'] + + @b0.setter + def b0(self, val): + self['b0'] = val + + # baxis + # ----- + @property + def baxis(self): + """ + The 'baxis' property is an instance of Baxis + that may be specified as: + - An instance of plotly.graph_objs.carpet.Baxis + - A dict of string/value properties that will be passed + to the Baxis constructor + + Supported dict properties: + + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at + along the final value of this axis. If *true*, + the end line is drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major + grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether axis labels are drawn on the + low side, the high side, both, or neither side + of the axis. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at + along the starting value of this axis. If + *true*, the start line is drawn on top of the + grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.baxis.Tickformatstop + instance or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the + title from the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + + Returns + ------- + plotly.graph_objs.carpet.Baxis + """ + return self['baxis'] + + @baxis.setter + def baxis(self, val): + self['baxis'] = val + + # bsrc + # ---- + @property + def bsrc(self): + """ + Sets the source reference on plot.ly for b . + + The 'bsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bsrc'] + + @bsrc.setter + def bsrc(self, val): + self['bsrc'] = val + + # carpet + # ------ + @property + def carpet(self): + """ + An identifier for this carpet, so that `scattercarpet` and + `scattercontour` traces can specify a carpet plot on which they + lie + + The 'carpet' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['carpet'] + + @carpet.setter + def carpet(self, val): + self['carpet'] = val + + # cheaterslope + # ------------ + @property + def cheaterslope(self): + """ + The shift applied to each successive row of data in creating a + cheater plot. Only used if `x` is been ommitted. + + The 'cheaterslope' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cheaterslope'] + + @cheaterslope.setter + def cheaterslope(self, val): + self['cheaterslope'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # da + # -- + @property + def da(self): + """ + Sets the a coordinate step. See `a0` for more info. + + The 'da' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['da'] + + @da.setter + def da(self, val): + self['da'] = val + + # db + # -- + @property + def db(self): + """ + Sets the b coordinate step. See `b0` for more info. + + The 'db' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['db'] + + @db.setter + def db(self, val): + self['db'] = val + + # font + # ---- + @property + def font(self): + """ + The default font used for axis & tick labels on this carpet + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.carpet.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.carpet.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.carpet.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.carpet.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.carpet.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.carpet.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + A two dimensional array of x coordinates at each carpet point. + If ommitted, the plot is a cheater plot and the xaxis is hidden + by default. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + A two dimensional array of y coordinates at each carpet point. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + a + An array containing values of the first parameter value + a0 + Alternate to `a`. Builds a linear space of a + coordinates. Use with `da` where `a0` is the starting + coordinate and `da` the step. + aaxis + plotly.graph_objs.carpet.Aaxis instance or dict with + compatible properties + asrc + Sets the source reference on plot.ly for a . + b + A two dimensional array of y coordinates at each carpet + point. + b0 + Alternate to `b`. Builds a linear space of a + coordinates. Use with `db` where `b0` is the starting + coordinate and `db` the step. + baxis + plotly.graph_objs.carpet.Baxis instance or dict with + compatible properties + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + cheaterslope + The shift applied to each successive row of data in + creating a cheater plot. Only used if `x` is been + ommitted. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the a coordinate step. See `a0` for more info. + db + Sets the b coordinate step. See `b0` for more info. + font + The default font used for axis & tick labels on this + carpet + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.carpet.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.carpet.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + A two dimensional array of x coordinates at each carpet + point. If ommitted, the plot is a cheater plot and the + xaxis is hidden by default. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + A two dimensional array of y coordinates at each carpet + point. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + a=None, + a0=None, + aaxis=None, + asrc=None, + b=None, + b0=None, + baxis=None, + bsrc=None, + carpet=None, + cheaterslope=None, + color=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + font=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xsrc=None, + y=None, + yaxis=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Carpet object + + The data describing carpet axis layout is set in `y` and + (optionally) also `x`. If only `y` is present, `x` the plot is + interpreted as a cheater plot and is filled in using the `y` + values. `x` and `y` may either be 2D arrays matching with each + dimension matching that of `a` and `b`, or they may be 1D + arrays with total length equal to that of `a` and `b`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Carpet + a + An array containing values of the first parameter value + a0 + Alternate to `a`. Builds a linear space of a + coordinates. Use with `da` where `a0` is the starting + coordinate and `da` the step. + aaxis + plotly.graph_objs.carpet.Aaxis instance or dict with + compatible properties + asrc + Sets the source reference on plot.ly for a . + b + A two dimensional array of y coordinates at each carpet + point. + b0 + Alternate to `b`. Builds a linear space of a + coordinates. Use with `db` where `b0` is the starting + coordinate and `db` the step. + baxis + plotly.graph_objs.carpet.Baxis instance or dict with + compatible properties + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + cheaterslope + The shift applied to each successive row of data in + creating a cheater plot. Only used if `x` is been + ommitted. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the a coordinate step. See `a0` for more info. + db + Sets the b coordinate step. See `b0` for more info. + font + The default font used for axis & tick labels on this + carpet + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.carpet.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.carpet.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + A two dimensional array of x coordinates at each carpet + point. If ommitted, the plot is a cheater plot and the + xaxis is hidden by default. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + A two dimensional array of y coordinates at each carpet + point. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Carpet + """ + super(Carpet, self).__init__('carpet') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Carpet +constructor must be a dict or +an instance of plotly.graph_objs.Carpet""" + ) + + # Import validators + # ----------------- + from plotly.validators import (carpet as v_carpet) + + # Initialize validators + # --------------------- + self._validators['a'] = v_carpet.AValidator() + self._validators['a0'] = v_carpet.A0Validator() + self._validators['aaxis'] = v_carpet.AaxisValidator() + self._validators['asrc'] = v_carpet.AsrcValidator() + self._validators['b'] = v_carpet.BValidator() + self._validators['b0'] = v_carpet.B0Validator() + self._validators['baxis'] = v_carpet.BaxisValidator() + self._validators['bsrc'] = v_carpet.BsrcValidator() + self._validators['carpet'] = v_carpet.CarpetValidator() + self._validators['cheaterslope'] = v_carpet.CheaterslopeValidator() + self._validators['color'] = v_carpet.ColorValidator() + self._validators['customdata'] = v_carpet.CustomdataValidator() + self._validators['customdatasrc'] = v_carpet.CustomdatasrcValidator() + self._validators['da'] = v_carpet.DaValidator() + self._validators['db'] = v_carpet.DbValidator() + self._validators['font'] = v_carpet.FontValidator() + self._validators['hoverinfo'] = v_carpet.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_carpet.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_carpet.HoverlabelValidator() + self._validators['ids'] = v_carpet.IdsValidator() + self._validators['idssrc'] = v_carpet.IdssrcValidator() + self._validators['legendgroup'] = v_carpet.LegendgroupValidator() + self._validators['name'] = v_carpet.NameValidator() + self._validators['opacity'] = v_carpet.OpacityValidator() + self._validators['selectedpoints'] = v_carpet.SelectedpointsValidator() + self._validators['showlegend'] = v_carpet.ShowlegendValidator() + self._validators['stream'] = v_carpet.StreamValidator() + self._validators['uid'] = v_carpet.UidValidator() + self._validators['visible'] = v_carpet.VisibleValidator() + self._validators['x'] = v_carpet.XValidator() + self._validators['xaxis'] = v_carpet.XAxisValidator() + self._validators['xsrc'] = v_carpet.XsrcValidator() + self._validators['y'] = v_carpet.YValidator() + self._validators['yaxis'] = v_carpet.YAxisValidator() + self._validators['ysrc'] = v_carpet.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('a', None) + self.a = a if a is not None else v + v = arg.pop('a0', None) + self.a0 = a0 if a0 is not None else v + v = arg.pop('aaxis', None) + self.aaxis = aaxis if aaxis is not None else v + v = arg.pop('asrc', None) + self.asrc = asrc if asrc is not None else v + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('b0', None) + self.b0 = b0 if b0 is not None else v + v = arg.pop('baxis', None) + self.baxis = baxis if baxis is not None else v + v = arg.pop('bsrc', None) + self.bsrc = bsrc if bsrc is not None else v + v = arg.pop('carpet', None) + self.carpet = carpet if carpet is not None else v + v = arg.pop('cheaterslope', None) + self.cheaterslope = cheaterslope if cheaterslope is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('da', None) + self.da = da if da is not None else v + v = arg.pop('db', None) + self.db = db if db is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'carpet' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='carpet' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_choropleth.py b/plotly/graph_objs/_choropleth.py new file mode 100644 index 0000000000..34c1603802 --- /dev/null +++ b/plotly/graph_objs/_choropleth.py @@ -0,0 +1,1440 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Choropleth(BaseTraceType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.choropleth.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.choropleth.colorbar.Tickforma + tstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.choropleth.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # geo + # --- + @property + def geo(self): + """ + Sets a reference between this trace's geospatial coordinates + and a geographic map. If *geo* (the default value), the + geospatial coordinates refer to `layout.geo`. If *geo2*, the + geospatial coordinates refer to `layout.geo2`, and so on. + + The 'geo' property is an identifier of a particular + subplot, of type 'geo', that may be specified as the string 'geo' + optionally followed by an integer >= 1 + (e.g. 'geo', 'geo1', 'geo2', 'geo3', etc.) + + Returns + ------- + str + """ + return self['geo'] + + @geo.setter + def geo(self, val): + self['geo'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['location', 'z', 'text', 'name', 'name'] joined with '+' characters + (e.g. 'location+z') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.choropleth.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.choropleth.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # locationmode + # ------------ + @property + def locationmode(self): + """ + Determines the set of locations used to match entries in + `locations` to regions on the map. + + The 'locationmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['ISO-3', 'USA-states', 'country names'] + + Returns + ------- + Any + """ + return self['locationmode'] + + @locationmode.setter + def locationmode(self, val): + self['locationmode'] = val + + # locations + # --------- + @property + def locations(self): + """ + Sets the coordinates via location IDs or names. See + `locationmode` for more info. + + The 'locations' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['locations'] + + @locations.setter + def locations(self, val): + self['locations'] = val + + # locationssrc + # ------------ + @property + def locationssrc(self): + """ + Sets the source reference on plot.ly for locations . + + The 'locationssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['locationssrc'] + + @locationssrc.setter + def locationssrc(self, val): + self['locationssrc'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.choropleth.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + line + plotly.graph_objs.choropleth.marker.Line + instance or dict with compatible properties + opacity + Sets the opacity of the locations. + opacitysrc + Sets the source reference on plot.ly for + opacity . + + Returns + ------- + plotly.graph_objs.choropleth.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.choropleth.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.choropleth.selected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.choropleth.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.choropleth.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.choropleth.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each location. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.choropleth.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.choropleth.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.choropleth.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # z + # - + @property + def z(self): + """ + Sets the color values. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.choropleth.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.choropleth.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. See + `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + marker + plotly.graph_objs.choropleth.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selected + plotly.graph_objs.choropleth.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.choropleth.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each location. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.choropleth.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + z + Sets the color values. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + locationmode=None, + locations=None, + locationssrc=None, + marker=None, + name=None, + opacity=None, + reversescale=None, + selected=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Choropleth object + + The data that describes the choropleth value-to-color mapping + is set in `z`. The geographic locations corresponding to each + value in `z` are set in `locations`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Choropleth + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.choropleth.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.choropleth.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. See + `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + marker + plotly.graph_objs.choropleth.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selected + plotly.graph_objs.choropleth.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.choropleth.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each location. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.choropleth.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + z + Sets the color values. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Choropleth + """ + super(Choropleth, self).__init__('choropleth') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Choropleth +constructor must be a dict or +an instance of plotly.graph_objs.Choropleth""" + ) + + # Import validators + # ----------------- + from plotly.validators import (choropleth as v_choropleth) + + # Initialize validators + # --------------------- + self._validators['autocolorscale' + ] = v_choropleth.AutocolorscaleValidator() + self._validators['colorbar'] = v_choropleth.ColorBarValidator() + self._validators['colorscale'] = v_choropleth.ColorscaleValidator() + self._validators['customdata'] = v_choropleth.CustomdataValidator() + self._validators['customdatasrc' + ] = v_choropleth.CustomdatasrcValidator() + self._validators['geo'] = v_choropleth.GeoValidator() + self._validators['hoverinfo'] = v_choropleth.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_choropleth.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_choropleth.HoverlabelValidator() + self._validators['ids'] = v_choropleth.IdsValidator() + self._validators['idssrc'] = v_choropleth.IdssrcValidator() + self._validators['legendgroup'] = v_choropleth.LegendgroupValidator() + self._validators['locationmode'] = v_choropleth.LocationmodeValidator() + self._validators['locations'] = v_choropleth.LocationsValidator() + self._validators['locationssrc'] = v_choropleth.LocationssrcValidator() + self._validators['marker'] = v_choropleth.MarkerValidator() + self._validators['name'] = v_choropleth.NameValidator() + self._validators['opacity'] = v_choropleth.OpacityValidator() + self._validators['reversescale'] = v_choropleth.ReversescaleValidator() + self._validators['selected'] = v_choropleth.SelectedValidator() + self._validators['selectedpoints' + ] = v_choropleth.SelectedpointsValidator() + self._validators['showlegend'] = v_choropleth.ShowlegendValidator() + self._validators['showscale'] = v_choropleth.ShowscaleValidator() + self._validators['stream'] = v_choropleth.StreamValidator() + self._validators['text'] = v_choropleth.TextValidator() + self._validators['textsrc'] = v_choropleth.TextsrcValidator() + self._validators['uid'] = v_choropleth.UidValidator() + self._validators['unselected'] = v_choropleth.UnselectedValidator() + self._validators['visible'] = v_choropleth.VisibleValidator() + self._validators['z'] = v_choropleth.ZValidator() + self._validators['zauto'] = v_choropleth.ZautoValidator() + self._validators['zmax'] = v_choropleth.ZmaxValidator() + self._validators['zmin'] = v_choropleth.ZminValidator() + self._validators['zsrc'] = v_choropleth.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('geo', None) + self.geo = geo if geo is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('locationmode', None) + self.locationmode = locationmode if locationmode is not None else v + v = arg.pop('locations', None) + self.locations = locations if locations is not None else v + v = arg.pop('locationssrc', None) + self.locationssrc = locationssrc if locationssrc is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'choropleth' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='choropleth' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_cone.py b/plotly/graph_objs/_cone.py new file mode 100644 index 0000000000..7d295d22a2 --- /dev/null +++ b/plotly/graph_objs/_cone.py @@ -0,0 +1,1833 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Cone(BaseTraceType): + + # anchor + # ------ + @property + def anchor(self): + """ + Sets the cones' anchor with respect to their x/y/z positions. + Note that *cm* denote the cone's center of mass which + corresponds to 1/4 from the tail to tip. + + The 'anchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['tip', 'tail', 'cm', 'center'] + + Returns + ------- + Any + """ + return self['anchor'] + + @anchor.setter + def anchor(self, val): + self['anchor'] = val + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `color` is set to a numerical array. + Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `color` is set to a numerical array and + `cmin`, `cmax` are set by the user. In this case, it controls + whether the range of colors in `colorscale` is mapped to the + range of values in the `color` array (`cauto: true`), or the + `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the upper bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmin` must be set as + well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the lower bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmax` must be set as + well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.cone.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.cone.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.cone.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `color` is set to + a numerical array. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'u', 'v', 'w', 'norm', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.cone.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.cone.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # lighting + # -------- + @property + def lighting(self): + """ + The 'lighting' property is an instance of Lighting + that may be specified as: + - An instance of plotly.graph_objs.cone.Lighting + - A dict of string/value properties that will be passed + to the Lighting constructor + + Supported dict properties: + + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids + math issues arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids + math issues arising from degenerate geometry. + + Returns + ------- + plotly.graph_objs.cone.Lighting + """ + return self['lighting'] + + @lighting.setter + def lighting(self, val): + self['lighting'] = val + + # lightposition + # ------------- + @property + def lightposition(self): + """ + The 'lightposition' property is an instance of Lightposition + that may be specified as: + - An instance of plotly.graph_objs.cone.Lightposition + - A dict of string/value properties that will be passed + to the Lightposition constructor + + Supported dict properties: + + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex. + + Returns + ------- + plotly.graph_objs.cone.Lightposition + """ + return self['lightposition'] + + @lightposition.setter + def lightposition(self, val): + self['lightposition'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the surface. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `color` is set to a numerical array. + Reverses the color mapping if true (`cmin` will correspond to + the last color in the array and `cmax` will correspond to the + first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # scene + # ----- + @property + def scene(self): + """ + Sets a reference between this trace's 3D coordinate system and + a 3D scene. If *scene* (the default value), the (x,y,z) + coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) + coordinates refer to `layout.scene2`, and so on. + + The 'scene' property is an identifier of a particular + subplot, of type 'scene', that may be specified as the string 'scene' + optionally followed by an integer >= 1 + (e.g. 'scene', 'scene1', 'scene2', 'scene3', etc.) + + Returns + ------- + str + """ + return self['scene'] + + @scene.setter + def scene(self, val): + self['scene'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Determines whether `sizeref` is set as a *scaled* (i.e + unitless) scalar (normalized by the max u/v/w norm in the + vector field) or as *absolute* value (in the same units as the + vector field). + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['scaled', 'absolute'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Adjusts the cone size scaling. The size of the cones is + determined by their u/v/w norm multiplied a factor and + `sizeref`. This factor (computed internally) corresponds to the + minimum "time" to travel across two successive x/y/z positions + at the average velocity of those two successive positions. All + cones in a given trace use the same factor. With `sizemode` set + to *scaled*, `sizeref` is unitless, its default value is *0.5* + With `sizemode` set to *absolute*, `sizeref` has the same units + as the u/v/w vector field, its the default value is half the + sample's maximum vector norm. + + The 'sizeref' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.cone.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.cone.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with the cones. If trace + `hoverinfo` contains a *text* flag and *hovertext* is not set, + these elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # u + # - + @property + def u(self): + """ + Sets the x components of the vector field. + + The 'u' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['u'] + + @u.setter + def u(self, val): + self['u'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # usrc + # ---- + @property + def usrc(self): + """ + Sets the source reference on plot.ly for u . + + The 'usrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['usrc'] + + @usrc.setter + def usrc(self, val): + self['usrc'] = val + + # v + # - + @property + def v(self): + """ + Sets the y components of the vector field. + + The 'v' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['v'] + + @v.setter + def v(self, val): + self['v'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # vsrc + # ---- + @property + def vsrc(self): + """ + Sets the source reference on plot.ly for v . + + The 'vsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['vsrc'] + + @vsrc.setter + def vsrc(self, val): + self['vsrc'] = val + + # w + # - + @property + def w(self): + """ + Sets the z components of the vector field. + + The 'w' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['w'] + + @w.setter + def w(self, val): + self['w'] = val + + # wsrc + # ---- + @property + def wsrc(self): + """ + Sets the source reference on plot.ly for w . + + The 'wsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['wsrc'] + + @wsrc.setter + def wsrc(self, val): + self['wsrc'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates of the vector field and of the displayed + cones. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates of the vector field and of the displayed + cones. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the z coordinates of the vector field and of the displayed + cones. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + anchor + Sets the cones' anchor with respect to their x/y/z + positions. Note that *cm* denote the cone's center of + mass which corresponds to 1/4 from the tail to tip. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + colorbar + plotly.graph_objs.cone.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.cone.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.cone.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.cone.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + sizemode + Determines whether `sizeref` is set as a *scaled* (i.e + unitless) scalar (normalized by the max u/v/w norm in + the vector field) or as *absolute* value (in the same + units as the vector field). + sizeref + Adjusts the cone size scaling. The size of the cones is + determined by their u/v/w norm multiplied a factor and + `sizeref`. This factor (computed internally) + corresponds to the minimum "time" to travel across two + successive x/y/z positions at the average velocity of + those two successive positions. All cones in a given + trace use the same factor. With `sizemode` set to + *scaled*, `sizeref` is unitless, its default value is + *0.5* With `sizemode` set to *absolute*, `sizeref` has + the same units as the u/v/w vector field, its the + default value is half the sample's maximum vector norm. + stream + plotly.graph_objs.cone.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the cones. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + u + Sets the x components of the vector field. + uid + + usrc + Sets the source reference on plot.ly for u . + v + Sets the y components of the vector field. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + vsrc + Sets the source reference on plot.ly for v . + w + Sets the z components of the vector field. + wsrc + Sets the source reference on plot.ly for w . + x + Sets the x coordinates of the vector field and of the + displayed cones. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates of the vector field and of the + displayed cones. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates of the vector field and of the + displayed cones. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + anchor=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + sizemode=None, + sizeref=None, + stream=None, + text=None, + textsrc=None, + u=None, + uid=None, + usrc=None, + v=None, + visible=None, + vsrc=None, + w=None, + wsrc=None, + x=None, + xsrc=None, + y=None, + ysrc=None, + z=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Cone object + + Use cone traces to visualize vector fields. Specify a vector + field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and + 3 vector component arrays `u`, `v`, `w`. The cones are drawn + exactly at the positions given by `x`, `y` and `z`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Cone + anchor + Sets the cones' anchor with respect to their x/y/z + positions. Note that *cm* denote the cone's center of + mass which corresponds to 1/4 from the tail to tip. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + colorbar + plotly.graph_objs.cone.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.cone.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.cone.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.cone.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + sizemode + Determines whether `sizeref` is set as a *scaled* (i.e + unitless) scalar (normalized by the max u/v/w norm in + the vector field) or as *absolute* value (in the same + units as the vector field). + sizeref + Adjusts the cone size scaling. The size of the cones is + determined by their u/v/w norm multiplied a factor and + `sizeref`. This factor (computed internally) + corresponds to the minimum "time" to travel across two + successive x/y/z positions at the average velocity of + those two successive positions. All cones in a given + trace use the same factor. With `sizemode` set to + *scaled*, `sizeref` is unitless, its default value is + *0.5* With `sizemode` set to *absolute*, `sizeref` has + the same units as the u/v/w vector field, its the + default value is half the sample's maximum vector norm. + stream + plotly.graph_objs.cone.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the cones. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + u + Sets the x components of the vector field. + uid + + usrc + Sets the source reference on plot.ly for u . + v + Sets the y components of the vector field. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + vsrc + Sets the source reference on plot.ly for v . + w + Sets the z components of the vector field. + wsrc + Sets the source reference on plot.ly for w . + x + Sets the x coordinates of the vector field and of the + displayed cones. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates of the vector field and of the + displayed cones. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates of the vector field and of the + displayed cones. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Cone + """ + super(Cone, self).__init__('cone') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Cone +constructor must be a dict or +an instance of plotly.graph_objs.Cone""" + ) + + # Import validators + # ----------------- + from plotly.validators import (cone as v_cone) + + # Initialize validators + # --------------------- + self._validators['anchor'] = v_cone.AnchorValidator() + self._validators['autocolorscale'] = v_cone.AutocolorscaleValidator() + self._validators['cauto'] = v_cone.CautoValidator() + self._validators['cmax'] = v_cone.CmaxValidator() + self._validators['cmin'] = v_cone.CminValidator() + self._validators['colorbar'] = v_cone.ColorBarValidator() + self._validators['colorscale'] = v_cone.ColorscaleValidator() + self._validators['customdata'] = v_cone.CustomdataValidator() + self._validators['customdatasrc'] = v_cone.CustomdatasrcValidator() + self._validators['hoverinfo'] = v_cone.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_cone.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_cone.HoverlabelValidator() + self._validators['ids'] = v_cone.IdsValidator() + self._validators['idssrc'] = v_cone.IdssrcValidator() + self._validators['legendgroup'] = v_cone.LegendgroupValidator() + self._validators['lighting'] = v_cone.LightingValidator() + self._validators['lightposition'] = v_cone.LightpositionValidator() + self._validators['name'] = v_cone.NameValidator() + self._validators['opacity'] = v_cone.OpacityValidator() + self._validators['reversescale'] = v_cone.ReversescaleValidator() + self._validators['scene'] = v_cone.SceneValidator() + self._validators['selectedpoints'] = v_cone.SelectedpointsValidator() + self._validators['showlegend'] = v_cone.ShowlegendValidator() + self._validators['showscale'] = v_cone.ShowscaleValidator() + self._validators['sizemode'] = v_cone.SizemodeValidator() + self._validators['sizeref'] = v_cone.SizerefValidator() + self._validators['stream'] = v_cone.StreamValidator() + self._validators['text'] = v_cone.TextValidator() + self._validators['textsrc'] = v_cone.TextsrcValidator() + self._validators['u'] = v_cone.UValidator() + self._validators['uid'] = v_cone.UidValidator() + self._validators['usrc'] = v_cone.UsrcValidator() + self._validators['v'] = v_cone.VValidator() + self._validators['visible'] = v_cone.VisibleValidator() + self._validators['vsrc'] = v_cone.VsrcValidator() + self._validators['w'] = v_cone.WValidator() + self._validators['wsrc'] = v_cone.WsrcValidator() + self._validators['x'] = v_cone.XValidator() + self._validators['xsrc'] = v_cone.XsrcValidator() + self._validators['y'] = v_cone.YValidator() + self._validators['ysrc'] = v_cone.YsrcValidator() + self._validators['z'] = v_cone.ZValidator() + self._validators['zsrc'] = v_cone.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('anchor', None) + self.anchor = anchor if anchor is not None else v + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('lighting', None) + self.lighting = lighting if lighting is not None else v + v = arg.pop('lightposition', None) + self.lightposition = lightposition if lightposition is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('scene', None) + self.scene = scene if scene is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('u', None) + self.u = u if u is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('usrc', None) + self.usrc = usrc if usrc is not None else v + v = arg.pop('v', None) + self.v = v if v is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('vsrc', None) + self.vsrc = vsrc if vsrc is not None else v + v = arg.pop('w', None) + self.w = w if w is not None else v + v = arg.pop('wsrc', None) + self.wsrc = wsrc if wsrc is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'cone' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='cone' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_contour.py b/plotly/graph_objs/_contour.py new file mode 100644 index 0000000000..05063fc539 --- /dev/null +++ b/plotly/graph_objs/_contour.py @@ -0,0 +1,2042 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Contour(BaseTraceType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # autocontour + # ----------- + @property + def autocontour(self): + """ + Determines whether or not the contour level attributes are + picked by an algorithm. If *true*, the number of contour levels + can be set in `ncontours`. If *false*, set the contour level + attributes in `contours`. + + The 'autocontour' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocontour'] + + @autocontour.setter + def autocontour(self, val): + self['autocontour'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.contour.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.contour.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.contour.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the `z` data are filled in. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # contours + # -------- + @property + def contours(self): + """ + The 'contours' property is an instance of Contours + that may be specified as: + - An instance of plotly.graph_objs.contour.Contours + - A dict of string/value properties that will be passed + to the Contours constructor + + Supported dict properties: + + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *heatmap*, + a heatmap gradient coloring is applied between + each contour level. If *lines*, coloring is + done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound. + + Returns + ------- + plotly.graph_objs.contour.Contours + """ + return self['contours'] + + @contours.setter + def contours(self, val): + self['contours'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line color, + marker color, or marker line color, whichever is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to contour.colorscale + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.contour.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.contour.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.contour.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the contour level. Has no + effect if `contours.coloring` is set to + *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.contour.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # ncontours + # --------- + @property + def ncontours(self): + """ + Sets the maximum number of contour levels. The actual number of + contours will be chosen automatically to be less than or equal + to the value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` is missing. + + The 'ncontours' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['ncontours'] + + @ncontours.setter + def ncontours(self, val): + self['ncontours'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.contour.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.contour.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each z value. + + The 'text' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # transpose + # --------- + @property + def transpose(self): + """ + Transposes the z data. + + The 'transpose' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['transpose'] + + @transpose.setter + def transpose(self, val): + self['transpose'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # xtype + # ----- + @property + def xtype(self): + """ + If *array*, the heatmap's x coordinates are given by *x* (the + default behavior when `x` is provided). If *scaled*, the + heatmap's x coordinates are given by *x0* and *dx* (the default + behavior when `x` is not provided). + + The 'xtype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['xtype'] + + @xtype.setter + def xtype(self, val): + self['xtype'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # ytype + # ----- + @property + def ytype(self): + """ + If *array*, the heatmap's y coordinates are given by *y* (the + default behavior when `y` is provided) If *scaled*, the + heatmap's y coordinates are given by *y0* and *dy* (the default + behavior when `y` is not provided) + + The 'ytype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['ytype'] + + @ytype.setter + def ytype(self, val): + self['ytype'] = val + + # z + # - + @property + def z(self): + """ + Sets the z data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zhoverformat + # ------------ + @property + def zhoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. See: https + ://github.com/d3/d3-format/blob/master/README.md#locale_format + + The 'zhoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['zhoverformat'] + + @zhoverformat.setter + def zhoverformat(self, val): + self['zhoverformat'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.contour.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + contours + plotly.graph_objs.contour.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contour.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contour.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contour.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + connectgaps=None, + contours=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Contour object + + The data from which contour lines are computed is set in `z`. + Data in `z` must be a {2D array} of numbers. Say that `z` has N + rows and M columns, then by default, these N rows correspond to + N y coordinates (set in `y` or auto-generated) and the M + columns correspond to M x coordinates (set in `x` or auto- + generated). By setting `transpose` to *true*, the above + behavior is flipped. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Contour + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.contour.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + contours + plotly.graph_objs.contour.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contour.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contour.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contour.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Contour + """ + super(Contour, self).__init__('contour') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Contour +constructor must be a dict or +an instance of plotly.graph_objs.Contour""" + ) + + # Import validators + # ----------------- + from plotly.validators import (contour as v_contour) + + # Initialize validators + # --------------------- + self._validators['autocolorscale' + ] = v_contour.AutocolorscaleValidator() + self._validators['autocontour'] = v_contour.AutocontourValidator() + self._validators['colorbar'] = v_contour.ColorBarValidator() + self._validators['colorscale'] = v_contour.ColorscaleValidator() + self._validators['connectgaps'] = v_contour.ConnectgapsValidator() + self._validators['contours'] = v_contour.ContoursValidator() + self._validators['customdata'] = v_contour.CustomdataValidator() + self._validators['customdatasrc'] = v_contour.CustomdatasrcValidator() + self._validators['dx'] = v_contour.DxValidator() + self._validators['dy'] = v_contour.DyValidator() + self._validators['fillcolor'] = v_contour.FillcolorValidator() + self._validators['hoverinfo'] = v_contour.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_contour.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_contour.HoverlabelValidator() + self._validators['ids'] = v_contour.IdsValidator() + self._validators['idssrc'] = v_contour.IdssrcValidator() + self._validators['legendgroup'] = v_contour.LegendgroupValidator() + self._validators['line'] = v_contour.LineValidator() + self._validators['name'] = v_contour.NameValidator() + self._validators['ncontours'] = v_contour.NcontoursValidator() + self._validators['opacity'] = v_contour.OpacityValidator() + self._validators['reversescale'] = v_contour.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_contour.SelectedpointsValidator() + self._validators['showlegend'] = v_contour.ShowlegendValidator() + self._validators['showscale'] = v_contour.ShowscaleValidator() + self._validators['stream'] = v_contour.StreamValidator() + self._validators['text'] = v_contour.TextValidator() + self._validators['textsrc'] = v_contour.TextsrcValidator() + self._validators['transpose'] = v_contour.TransposeValidator() + self._validators['uid'] = v_contour.UidValidator() + self._validators['visible'] = v_contour.VisibleValidator() + self._validators['x'] = v_contour.XValidator() + self._validators['x0'] = v_contour.X0Validator() + self._validators['xaxis'] = v_contour.XAxisValidator() + self._validators['xcalendar'] = v_contour.XcalendarValidator() + self._validators['xsrc'] = v_contour.XsrcValidator() + self._validators['xtype'] = v_contour.XtypeValidator() + self._validators['y'] = v_contour.YValidator() + self._validators['y0'] = v_contour.Y0Validator() + self._validators['yaxis'] = v_contour.YAxisValidator() + self._validators['ycalendar'] = v_contour.YcalendarValidator() + self._validators['ysrc'] = v_contour.YsrcValidator() + self._validators['ytype'] = v_contour.YtypeValidator() + self._validators['z'] = v_contour.ZValidator() + self._validators['zauto'] = v_contour.ZautoValidator() + self._validators['zhoverformat'] = v_contour.ZhoverformatValidator() + self._validators['zmax'] = v_contour.ZmaxValidator() + self._validators['zmin'] = v_contour.ZminValidator() + self._validators['zsrc'] = v_contour.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('autocontour', None) + self.autocontour = autocontour if autocontour is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('contours', None) + self.contours = contours if contours is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('ncontours', None) + self.ncontours = ncontours if ncontours is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('transpose', None) + self.transpose = transpose if transpose is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('xtype', None) + self.xtype = xtype if xtype is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('ytype', None) + self.ytype = ytype if ytype is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zhoverformat', None) + self.zhoverformat = zhoverformat if zhoverformat is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'contour' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='contour' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_contourcarpet.py b/plotly/graph_objs/_contourcarpet.py new file mode 100644 index 0000000000..abdd213dc1 --- /dev/null +++ b/plotly/graph_objs/_contourcarpet.py @@ -0,0 +1,1941 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Contourcarpet(BaseTraceType): + + # a + # - + @property + def a(self): + """ + Sets the x coordinates. + + The 'a' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['a'] + + @a.setter + def a(self, val): + self['a'] = val + + # a0 + # -- + @property + def a0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'a0' property accepts values of any type + + Returns + ------- + Any + """ + return self['a0'] + + @a0.setter + def a0(self, val): + self['a0'] = val + + # asrc + # ---- + @property + def asrc(self): + """ + Sets the source reference on plot.ly for a . + + The 'asrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['asrc'] + + @asrc.setter + def asrc(self, val): + self['asrc'] = val + + # atype + # ----- + @property + def atype(self): + """ + If *array*, the heatmap's x coordinates are given by *x* (the + default behavior when `x` is provided). If *scaled*, the + heatmap's x coordinates are given by *x0* and *dx* (the default + behavior when `x` is not provided). + + The 'atype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['atype'] + + @atype.setter + def atype(self, val): + self['atype'] = val + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # autocontour + # ----------- + @property + def autocontour(self): + """ + Determines whether or not the contour level attributes are + picked by an algorithm. If *true*, the number of contour levels + can be set in `ncontours`. If *false*, set the contour level + attributes in `contours`. + + The 'autocontour' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocontour'] + + @autocontour.setter + def autocontour(self, val): + self['autocontour'] = val + + # b + # - + @property + def b(self): + """ + Sets the y coordinates. + + The 'b' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # b0 + # -- + @property + def b0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'b0' property accepts values of any type + + Returns + ------- + Any + """ + return self['b0'] + + @b0.setter + def b0(self, val): + self['b0'] = val + + # bsrc + # ---- + @property + def bsrc(self): + """ + Sets the source reference on plot.ly for b . + + The 'bsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bsrc'] + + @bsrc.setter + def bsrc(self, val): + self['bsrc'] = val + + # btype + # ----- + @property + def btype(self): + """ + If *array*, the heatmap's y coordinates are given by *y* (the + default behavior when `y` is provided) If *scaled*, the + heatmap's y coordinates are given by *y0* and *dy* (the default + behavior when `y` is not provided) + + The 'btype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['btype'] + + @btype.setter + def btype(self, val): + self['btype'] = val + + # carpet + # ------ + @property + def carpet(self): + """ + The `carpet` of the carpet axes on which this contour trace + lies + + The 'carpet' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['carpet'] + + @carpet.setter + def carpet(self, val): + self['carpet'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.contourcarpet.colorbar.Tickfo + rmatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.contourcarpet.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # contours + # -------- + @property + def contours(self): + """ + The 'contours' property is an instance of Contours + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.Contours + - A dict of string/value properties that will be passed + to the Contours constructor + + Supported dict properties: + + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *lines*, + coloring is done on the contour lines. If + *none*, no coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound. + + Returns + ------- + plotly.graph_objs.contourcarpet.Contours + """ + return self['contours'] + + @contours.setter + def contours(self, val): + self['contours'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # da + # -- + @property + def da(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'da' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['da'] + + @da.setter + def da(self, val): + self['da'] = val + + # db + # -- + @property + def db(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'db' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['db'] + + @db.setter + def db(self, val): + self['db'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line color, + marker color, or marker line color, whichever is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to contourcarpet.colorscale + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.contourcarpet.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the contour level. Has no if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.contourcarpet.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # ncontours + # --------- + @property + def ncontours(self): + """ + Sets the maximum number of contour levels. The actual number of + contours will be chosen automatically to be less than or equal + to the value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` is missing. + + The 'ncontours' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['ncontours'] + + @ncontours.setter + def ncontours(self, val): + self['ncontours'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.contourcarpet.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each z value. + + The 'text' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # transpose + # --------- + @property + def transpose(self): + """ + Transposes the z data. + + The 'transpose' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['transpose'] + + @transpose.setter + def transpose(self, val): + self['transpose'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # z + # - + @property + def z(self): + """ + Sets the z data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + a + Sets the x coordinates. + a0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + asrc + Sets the source reference on plot.ly for a . + atype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + b + Sets the y coordinates. + b0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + bsrc + Sets the source reference on plot.ly for b . + btype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + carpet + The `carpet` of the carpet axes on which this contour + trace lies + colorbar + plotly.graph_objs.contourcarpet.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.contourcarpet.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the x coordinate step. See `x0` for more info. + db + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contourcarpet.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contourcarpet.Line instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contourcarpet.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + a=None, + a0=None, + asrc=None, + atype=None, + autocolorscale=None, + autocontour=None, + b=None, + b0=None, + bsrc=None, + btype=None, + carpet=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + xaxis=None, + yaxis=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Contourcarpet object + + Plots contours on either the first carpet axis or the carpet + axis with a matching `carpet` attribute. Data `z` is + interpreted as matching that of the corresponding carpet axis. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Contourcarpet + a + Sets the x coordinates. + a0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + asrc + Sets the source reference on plot.ly for a . + atype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + b + Sets the y coordinates. + b0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + bsrc + Sets the source reference on plot.ly for b . + btype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + carpet + The `carpet` of the carpet axes on which this contour + trace lies + colorbar + plotly.graph_objs.contourcarpet.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.contourcarpet.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the x coordinate step. See `x0` for more info. + db + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contourcarpet.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contourcarpet.Line instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contourcarpet.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Contourcarpet + """ + super(Contourcarpet, self).__init__('contourcarpet') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Contourcarpet +constructor must be a dict or +an instance of plotly.graph_objs.Contourcarpet""" + ) + + # Import validators + # ----------------- + from plotly.validators import (contourcarpet as v_contourcarpet) + + # Initialize validators + # --------------------- + self._validators['a'] = v_contourcarpet.AValidator() + self._validators['a0'] = v_contourcarpet.A0Validator() + self._validators['asrc'] = v_contourcarpet.AsrcValidator() + self._validators['atype'] = v_contourcarpet.AtypeValidator() + self._validators['autocolorscale' + ] = v_contourcarpet.AutocolorscaleValidator() + self._validators['autocontour' + ] = v_contourcarpet.AutocontourValidator() + self._validators['b'] = v_contourcarpet.BValidator() + self._validators['b0'] = v_contourcarpet.B0Validator() + self._validators['bsrc'] = v_contourcarpet.BsrcValidator() + self._validators['btype'] = v_contourcarpet.BtypeValidator() + self._validators['carpet'] = v_contourcarpet.CarpetValidator() + self._validators['colorbar'] = v_contourcarpet.ColorBarValidator() + self._validators['colorscale'] = v_contourcarpet.ColorscaleValidator() + self._validators['contours'] = v_contourcarpet.ContoursValidator() + self._validators['customdata'] = v_contourcarpet.CustomdataValidator() + self._validators['customdatasrc' + ] = v_contourcarpet.CustomdatasrcValidator() + self._validators['da'] = v_contourcarpet.DaValidator() + self._validators['db'] = v_contourcarpet.DbValidator() + self._validators['fillcolor'] = v_contourcarpet.FillcolorValidator() + self._validators['hoverinfo'] = v_contourcarpet.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_contourcarpet.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_contourcarpet.HoverlabelValidator() + self._validators['ids'] = v_contourcarpet.IdsValidator() + self._validators['idssrc'] = v_contourcarpet.IdssrcValidator() + self._validators['legendgroup' + ] = v_contourcarpet.LegendgroupValidator() + self._validators['line'] = v_contourcarpet.LineValidator() + self._validators['name'] = v_contourcarpet.NameValidator() + self._validators['ncontours'] = v_contourcarpet.NcontoursValidator() + self._validators['opacity'] = v_contourcarpet.OpacityValidator() + self._validators['reversescale' + ] = v_contourcarpet.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_contourcarpet.SelectedpointsValidator() + self._validators['showlegend'] = v_contourcarpet.ShowlegendValidator() + self._validators['showscale'] = v_contourcarpet.ShowscaleValidator() + self._validators['stream'] = v_contourcarpet.StreamValidator() + self._validators['text'] = v_contourcarpet.TextValidator() + self._validators['textsrc'] = v_contourcarpet.TextsrcValidator() + self._validators['transpose'] = v_contourcarpet.TransposeValidator() + self._validators['uid'] = v_contourcarpet.UidValidator() + self._validators['visible'] = v_contourcarpet.VisibleValidator() + self._validators['xaxis'] = v_contourcarpet.XAxisValidator() + self._validators['yaxis'] = v_contourcarpet.YAxisValidator() + self._validators['z'] = v_contourcarpet.ZValidator() + self._validators['zauto'] = v_contourcarpet.ZautoValidator() + self._validators['zmax'] = v_contourcarpet.ZmaxValidator() + self._validators['zmin'] = v_contourcarpet.ZminValidator() + self._validators['zsrc'] = v_contourcarpet.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('a', None) + self.a = a if a is not None else v + v = arg.pop('a0', None) + self.a0 = a0 if a0 is not None else v + v = arg.pop('asrc', None) + self.asrc = asrc if asrc is not None else v + v = arg.pop('atype', None) + self.atype = atype if atype is not None else v + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('autocontour', None) + self.autocontour = autocontour if autocontour is not None else v + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('b0', None) + self.b0 = b0 if b0 is not None else v + v = arg.pop('bsrc', None) + self.bsrc = bsrc if bsrc is not None else v + v = arg.pop('btype', None) + self.btype = btype if btype is not None else v + v = arg.pop('carpet', None) + self.carpet = carpet if carpet is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('contours', None) + self.contours = contours if contours is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('da', None) + self.da = da if da is not None else v + v = arg.pop('db', None) + self.db = db if db is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('ncontours', None) + self.ncontours = ncontours if ncontours is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('transpose', None) + self.transpose = transpose if transpose is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'contourcarpet' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='contourcarpet' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_deprecations.py b/plotly/graph_objs/_deprecations.py new file mode 100644 index 0000000000..f6ea86d66c --- /dev/null +++ b/plotly/graph_objs/_deprecations.py @@ -0,0 +1,698 @@ +import warnings + +warnings.filterwarnings( + 'default', r'plotly\.graph_objs\.\w+ is deprecated', DeprecationWarning +) + + +class Data(list): + """ + plotly.graph_objs.Data is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Data is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Data is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. +""", DeprecationWarning + ) + super(Data, self).__init__(*args, **kwargs) + + +class Annotations(list): + """ + plotly.graph_objs.Annotations is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.layout.Annotations + - plotly.graph_objs.layout.scene.Annotations + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Annotations is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.layout.Annotations + - plotly.graph_objs.layout.scene.Annotations + + """ + warnings.warn( + """plotly.graph_objs.Annotations is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.layout.Annotations + - plotly.graph_objs.layout.scene.Annotations +""", DeprecationWarning + ) + super(Annotations, self).__init__(*args, **kwargs) + + +class Frames(list): + """ + plotly.graph_objs.Frames is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Frame + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Frames is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Frame + + """ + warnings.warn( + """plotly.graph_objs.Frames is deprecated. +Please replace it with a list or tuple of instances of the following types + - plotly.graph_objs.Frame +""", DeprecationWarning + ) + super(Frames, self).__init__(*args, **kwargs) + + +class AngularAxis(dict): + """ + plotly.graph_objs.AngularAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.AngularAxis + - plotly.graph_objs.layout.polar.AngularAxis + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.AngularAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.AngularAxis + - plotly.graph_objs.layout.polar.AngularAxis + + """ + warnings.warn( + """plotly.graph_objs.AngularAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.AngularAxis + - plotly.graph_objs.layout.polar.AngularAxis +""", DeprecationWarning + ) + super(AngularAxis, self).__init__(*args, **kwargs) + + +class Annotation(dict): + """ + plotly.graph_objs.Annotation is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Annotation + - plotly.graph_objs.layout.scene.Annotation + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Annotation is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Annotation + - plotly.graph_objs.layout.scene.Annotation + + """ + warnings.warn( + """plotly.graph_objs.Annotation is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Annotation + - plotly.graph_objs.layout.scene.Annotation +""", DeprecationWarning + ) + super(Annotation, self).__init__(*args, **kwargs) + + +class ColorBar(dict): + """ + plotly.graph_objs.ColorBar is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.marker.ColorBar + - plotly.graph_objs.surface.ColorBar + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.ColorBar is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.marker.ColorBar + - plotly.graph_objs.surface.ColorBar + - etc. + + """ + warnings.warn( + """plotly.graph_objs.ColorBar is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.marker.ColorBar + - plotly.graph_objs.surface.ColorBar + - etc. +""", DeprecationWarning + ) + super(ColorBar, self).__init__(*args, **kwargs) + + +class Contours(dict): + """ + plotly.graph_objs.Contours is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.contour.Contours + - plotly.graph_objs.surface.Contours + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Contours is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.contour.Contours + - plotly.graph_objs.surface.Contours + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Contours is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.contour.Contours + - plotly.graph_objs.surface.Contours + - etc. +""", DeprecationWarning + ) + super(Contours, self).__init__(*args, **kwargs) + + +class ErrorX(dict): + """ + plotly.graph_objs.ErrorX is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorX + - plotly.graph_objs.histogram.ErrorX + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.ErrorX is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorX + - plotly.graph_objs.histogram.ErrorX + - etc. + + """ + warnings.warn( + """plotly.graph_objs.ErrorX is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorX + - plotly.graph_objs.histogram.ErrorX + - etc. +""", DeprecationWarning + ) + super(ErrorX, self).__init__(*args, **kwargs) + + +class ErrorY(dict): + """ + plotly.graph_objs.ErrorY is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorY + - plotly.graph_objs.histogram.ErrorY + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.ErrorY is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorY + - plotly.graph_objs.histogram.ErrorY + - etc. + + """ + warnings.warn( + """plotly.graph_objs.ErrorY is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.ErrorY + - plotly.graph_objs.histogram.ErrorY + - etc. +""", DeprecationWarning + ) + super(ErrorY, self).__init__(*args, **kwargs) + + +class ErrorZ(dict): + """ + plotly.graph_objs.ErrorZ is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter3d.ErrorZ + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.ErrorZ is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter3d.ErrorZ + + """ + warnings.warn( + """plotly.graph_objs.ErrorZ is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter3d.ErrorZ +""", DeprecationWarning + ) + super(ErrorZ, self).__init__(*args, **kwargs) + + +class Font(dict): + """ + plotly.graph_objs.Font is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Font + - plotly.graph_objs.layout.hoverlabel.Font + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Font is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Font + - plotly.graph_objs.layout.hoverlabel.Font + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Font is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Font + - plotly.graph_objs.layout.hoverlabel.Font + - etc. +""", DeprecationWarning + ) + super(Font, self).__init__(*args, **kwargs) + + +class Legend(dict): + """ + plotly.graph_objs.Legend is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Legend + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Legend is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Legend + + """ + warnings.warn( + """plotly.graph_objs.Legend is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Legend +""", DeprecationWarning + ) + super(Legend, self).__init__(*args, **kwargs) + + +class Line(dict): + """ + plotly.graph_objs.Line is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Line + - plotly.graph_objs.layout.shape.Line + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Line is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Line + - plotly.graph_objs.layout.shape.Line + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Line is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Line + - plotly.graph_objs.layout.shape.Line + - etc. +""", DeprecationWarning + ) + super(Line, self).__init__(*args, **kwargs) + + +class Margin(dict): + """ + plotly.graph_objs.Margin is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Margin + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Margin is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Margin + + """ + warnings.warn( + """plotly.graph_objs.Margin is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.Margin +""", DeprecationWarning + ) + super(Margin, self).__init__(*args, **kwargs) + + +class Marker(dict): + """ + plotly.graph_objs.Marker is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Marker + - plotly.graph_objs.histogram.selected.Marker + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Marker is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Marker + - plotly.graph_objs.histogram.selected.Marker + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Marker is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Marker + - plotly.graph_objs.histogram.selected.Marker + - etc. +""", DeprecationWarning + ) + super(Marker, self).__init__(*args, **kwargs) + + +class RadialAxis(dict): + """ + plotly.graph_objs.RadialAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.RadialAxis + - plotly.graph_objs.layout.polar.RadialAxis + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.RadialAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.RadialAxis + - plotly.graph_objs.layout.polar.RadialAxis + + """ + warnings.warn( + """plotly.graph_objs.RadialAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.RadialAxis + - plotly.graph_objs.layout.polar.RadialAxis +""", DeprecationWarning + ) + super(RadialAxis, self).__init__(*args, **kwargs) + + +class Scene(dict): + """ + plotly.graph_objs.Scene is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scene + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Scene is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scene + + """ + warnings.warn( + """plotly.graph_objs.Scene is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scene +""", DeprecationWarning + ) + super(Scene, self).__init__(*args, **kwargs) + + +class Stream(dict): + """ + plotly.graph_objs.Stream is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Stream + - plotly.graph_objs.area.Stream + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Stream is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Stream + - plotly.graph_objs.area.Stream + + """ + warnings.warn( + """plotly.graph_objs.Stream is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.scatter.Stream + - plotly.graph_objs.area.Stream +""", DeprecationWarning + ) + super(Stream, self).__init__(*args, **kwargs) + + +class XAxis(dict): + """ + plotly.graph_objs.XAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.XAxis + - plotly.graph_objs.layout.scene.XAxis + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.XAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.XAxis + - plotly.graph_objs.layout.scene.XAxis + + """ + warnings.warn( + """plotly.graph_objs.XAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.XAxis + - plotly.graph_objs.layout.scene.XAxis +""", DeprecationWarning + ) + super(XAxis, self).__init__(*args, **kwargs) + + +class YAxis(dict): + """ + plotly.graph_objs.YAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.YAxis + - plotly.graph_objs.layout.scene.YAxis + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.YAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.YAxis + - plotly.graph_objs.layout.scene.YAxis + + """ + warnings.warn( + """plotly.graph_objs.YAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.YAxis + - plotly.graph_objs.layout.scene.YAxis +""", DeprecationWarning + ) + super(YAxis, self).__init__(*args, **kwargs) + + +class ZAxis(dict): + """ + plotly.graph_objs.ZAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.scene.ZAxis + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.ZAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.scene.ZAxis + + """ + warnings.warn( + """plotly.graph_objs.ZAxis is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.layout.scene.ZAxis +""", DeprecationWarning + ) + super(ZAxis, self).__init__(*args, **kwargs) + + +class XBins(dict): + """ + plotly.graph_objs.XBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.XBins + - plotly.graph_objs.histogram2d.XBins + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.XBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.XBins + - plotly.graph_objs.histogram2d.XBins + + """ + warnings.warn( + """plotly.graph_objs.XBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.XBins + - plotly.graph_objs.histogram2d.XBins +""", DeprecationWarning + ) + super(XBins, self).__init__(*args, **kwargs) + + +class YBins(dict): + """ + plotly.graph_objs.YBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.YBins + - plotly.graph_objs.histogram2d.YBins + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.YBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.YBins + - plotly.graph_objs.histogram2d.YBins + + """ + warnings.warn( + """plotly.graph_objs.YBins is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.histogram.YBins + - plotly.graph_objs.histogram2d.YBins +""", DeprecationWarning + ) + super(YBins, self).__init__(*args, **kwargs) + + +class Trace(dict): + """ + plotly.graph_objs.Trace is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Trace is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. + + """ + warnings.warn( + """plotly.graph_objs.Trace is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Scatter + - plotly.graph_objs.Bar + - plotly.graph_objs.Area + - plotly.graph_objs.Histogram + - etc. +""", DeprecationWarning + ) + super(Trace, self).__init__(*args, **kwargs) + + +class Histogram2dcontour(dict): + """ + plotly.graph_objs.Histogram2dcontour is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Histogram2dContour + + """ + + def __init__(self, *args, **kwargs): + """ + plotly.graph_objs.Histogram2dcontour is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Histogram2dContour + + """ + warnings.warn( + """plotly.graph_objs.Histogram2dcontour is deprecated. +Please replace it with one of the following more specific types + - plotly.graph_objs.Histogram2dContour +""", DeprecationWarning + ) + super(Histogram2dcontour, self).__init__(*args, **kwargs) diff --git a/plotly/graph_objs/_figure.py b/plotly/graph_objs/_figure.py new file mode 100644 index 0000000000..18cd543262 --- /dev/null +++ b/plotly/graph_objs/_figure.py @@ -0,0 +1,8449 @@ +from plotly.basedatatypes import BaseFigure +from plotly.graph_objs import ( + Area, Bar, Box, Candlestick, Carpet, Choropleth, Cone, Contour, + Contourcarpet, Heatmap, Heatmapgl, Histogram, Histogram2d, + Histogram2dContour, Mesh3d, Ohlc, Parcoords, Pie, Pointcloud, Sankey, + Scatter, Scatter3d, Scattercarpet, Scattergeo, Scattergl, Scattermapbox, + Scatterpolar, Scatterpolargl, Scatterternary, Splom, Surface, Table, Violin +) + + +class Figure(BaseFigure): + + def __init__(self, data=None, layout=None, frames=None): + """ + Create a new Figure instance + + Parameters + ---------- + data + The 'data' property is a tuple of trace instances + that may be specified as: + - A list or tuple of trace instances + (e.g. [Scatter(...), Bar(...)]) + - A list or tuple of dicts of string/value properties where: + - The 'type' property specifies the trace type + One of: ['area', 'bar', 'box', 'candlestick', 'carpet', + 'choropleth', 'cone', 'contour', + 'contourcarpet', 'heatmap', 'heatmapgl', + 'histogram', 'histogram2d', + 'histogram2dcontour', 'mesh3d', 'ohlc', + 'parcoords', 'pie', 'pointcloud', 'sankey', + 'scatter', 'scatter3d', 'scattercarpet', + 'scattergeo', 'scattergl', 'scattermapbox', + 'scatterpolar', 'scatterpolargl', + 'scatterternary', 'splom', 'surface', 'table', + 'violin'] + + - All remaining properties are passed to the constructor of + the specified trace type + + (e.g. [{'type': 'scatter', ...}, {'type': 'bar, ...}]) + layout + The 'layout' property is an instance of Layout + that may be specified as: + - An instance of plotly.graph_objs.Layout + - A dict of string/value properties that will be passed + to the Layout constructor + + Supported dict properties: + + angularaxis + plotly.graph_objs.layout.AngularAxis instance + or dict with compatible properties + annotations + plotly.graph_objs.layout.Annotation instance or + dict with compatible properties + autosize + Determines whether or not a layout width or + height that has been left undefined by the user + is initialized on each relayout. Note that, + regardless of this attribute, an undefined + layout width or height is always initialized on + the first call to plot. + bargap + Sets the gap (in plot fraction) between bars of + adjacent location coordinates. + bargroupgap + Sets the gap (in plot fraction) between bars of + the same location coordinate. + barmode + Determines how bars at the same location + coordinate are displayed on the graph. With + *stack*, the bars are stacked on top of one + another With *relative*, the bars are stacked + on top of one another, with negative values + below the axis, positive values above With + *group*, the bars are plotted next to one + another centered around the shared location. + With *overlay*, the bars are plotted over one + another, you might need to an *opacity* to see + multiple bars. + barnorm + Sets the normalization for bar traces on the + graph. With *fraction*, the value of each bar + is divide by the sum of the values at the + location coordinate. With *percent*, the + results form *fraction* are presented in + percents. + boxgap + Sets the gap (in plot fraction) between boxes + of adjacent location coordinates. + boxgroupgap + Sets the gap (in plot fraction) between boxes + of the same location coordinate. + boxmode + Determines how boxes at the same location + coordinate are displayed on the graph. If + *group*, the boxes are plotted next to one + another centered around the shared location. If + *overlay*, the boxes are plotted over one + another, you might need to set *opacity* to see + them multiple boxes. + calendar + Sets the default calendar system to use for + interpreting and displaying dates throughout + the plot. + colorway + Sets the default trace colors. + datarevision + If provided, a changed value tells + `Plotly.react` that one or more data arrays has + changed. This way you can modify arrays in- + place rather than making a complete new copy + for an incremental change. If NOT provided, + `Plotly.react` assumes that data arrays are + being treated as immutable, thus any data array + with a different identity from its predecessor + contains new data. + direction + For polar plots only. Sets the direction + corresponding to positive angles. + dragmode + Determines the mode of drag interactions. + *select* and *lasso* apply only to scatter + traces with markers or text. *orbit* and + *turntable* apply only to 3D scenes. + font + Sets the global font. Note that fonts used in + traces and other layout components inherit from + the global font. + geo + plotly.graph_objs.layout.Geo instance or dict + with compatible properties + grid + plotly.graph_objs.layout.Grid instance or dict + with compatible properties + height + Sets the plot's height (in px). + hiddenlabels + + hiddenlabelssrc + Sets the source reference on plot.ly for + hiddenlabels . + hidesources + Determines whether or not a text link citing + the data source is placed at the bottom-right + cored of the figure. Has only an effect only on + graphs that have been generated via forked + graphs from the plotly service (at + https://plot.ly or on-premise). + hoverdistance + Sets the default distance (in pixels) to look + for data to add hover labels (-1 means no + cutoff, 0 means no looking for data). This is + only a real distance for hovering on point-like + objects, like scatter points. For area-like + objects (bars, scatter fills, etc) hovering is + on inside the area and off outside, but these + objects will not supersede hover on point-like + objects in case of conflict. + hoverlabel + plotly.graph_objs.layout.Hoverlabel instance or + dict with compatible properties + hovermode + Determines the mode of hover interactions. + images + plotly.graph_objs.layout.Image instance or dict + with compatible properties + legend + plotly.graph_objs.layout.Legend instance or + dict with compatible properties + mapbox + plotly.graph_objs.layout.Mapbox instance or + dict with compatible properties + margin + plotly.graph_objs.layout.Margin instance or + dict with compatible properties + orientation + For polar plots only. Rotates the entire polar + by the given angle. + paper_bgcolor + Sets the color of paper where the graph is + drawn. + plot_bgcolor + Sets the color of plotting area in-between x + and y axes. + polar + plotly.graph_objs.layout.Polar instance or dict + with compatible properties + radialaxis + plotly.graph_objs.layout.RadialAxis instance or + dict with compatible properties + scene + plotly.graph_objs.layout.Scene instance or dict + with compatible properties + selectdirection + When "dragmode" is set to "select", this limits + the selection of the drag to horizontal, + vertical or diagonal. "h" only allows + horizontal selection, "v" only vertical, "d" + only diagonal and "any" sets no limit. + separators + Sets the decimal and thousand separators. For + example, *. * puts a '.' before decimals and a + space between thousands. In English locales, + dflt is *.,* but other locales may alter this + default. + shapes + plotly.graph_objs.layout.Shape instance or dict + with compatible properties + showlegend + Determines whether or not a legend is drawn. + sliders + plotly.graph_objs.layout.Slider instance or + dict with compatible properties + spikedistance + Sets the default distance (in pixels) to look + for data to draw spikelines to (-1 means no + cutoff, 0 means no looking for data). As with + hoverdistance, distance does not apply to area- + like objects. In addition, some objects can be + hovered on but will not generate spikelines, + such as scatter fills. + ternary + plotly.graph_objs.layout.Ternary instance or + dict with compatible properties + title + Sets the plot's title. + titlefont + Sets the title font. + updatemenus + plotly.graph_objs.layout.Updatemenu instance or + dict with compatible properties + violingap + Sets the gap (in plot fraction) between violins + of adjacent location coordinates. + violingroupgap + Sets the gap (in plot fraction) between violins + of the same location coordinate. + violinmode + Determines how violins at the same location + coordinate are displayed on the graph. If + *group*, the violins are plotted next to one + another centered around the shared location. If + *overlay*, the violins are plotted over one + another, you might need to set *opacity* to see + them multiple violins. + width + Sets the plot's width (in px). + xaxis + plotly.graph_objs.layout.XAxis instance or dict + with compatible properties + yaxis + plotly.graph_objs.layout.YAxis instance or dict + with compatible properties + frames + The 'frames' property is a tuple of instances of + Frame that may be specified as: + - A list or tuple of instances of plotly.graph_objs.Frame + - A list or tuple of dicts of string/value properties that + will be passed to the Frame constructor + + Supported dict properties: + + baseframe + The name of the frame into which this frame's + properties are merged before applying. This is + used to unify properties and avoid needing to + specify the same values for the same properties + in multiple frames. + data + A list of traces this frame modifies. The + format is identical to the normal trace + definition. + group + An identifier that specifies the group to which + the frame belongs, used by animate to select a + subset of frames. + layout + Layout properties which this frame modifies. + The format is identical to the normal layout + definition. + name + A label by which to identify the frame + traces + A list of trace indices that identify the + respective traces in the data attribute + """ + super(Figure, self).__init__(data, layout, frames) + + def add_area( + self, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + tsrc=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Area trace + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.area.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.area.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.area.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + tsrc + Sets the source reference on plot.ly for t . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Area + """ + new_trace = Area( + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + tsrc=tsrc, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_bar( + self, + base=None, + basesrc=None, + cliponaxis=None, + constraintext=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + legendgroup=None, + marker=None, + name=None, + offset=None, + offsetsrc=None, + opacity=None, + orientation=None, + outsidetextfont=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + width=None, + widthsrc=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Bar trace + + The data visualized by the span of the bars is set in `y` if + `orientation` is set th *v* (the default) and the labels are + set in `x`. By setting `orientation` to *h*, the roles are + interchanged. + + Parameters + ---------- + base + Sets where the bar base is drawn (in position axis + units). In *stack* or *relative* barmode, traces that + set *base* will be excluded and drawn in *overlay* mode + instead. + basesrc + Sets the source reference on plot.ly for base . + cliponaxis + Determines whether the text nodes are clipped about the + subplot axes. To show the text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + constraintext + Constrain the size of text inside or outside a bar to + be no larger than the bar itself. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.bar.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.bar.ErrorY instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.bar.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `text` lying inside the bar. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.bar.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + offset + Shifts the position where the bar is drawn (in position + axis units). In *group* barmode, traces that set + *offset* will be excluded and drawn in *overlay* mode + instead. + offsetsrc + Sets the source reference on plot.ly for offset . + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + outsidetextfont + Sets the font used for `text` lying outside the bar. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.bar.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.bar.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the font used for `text`. + textposition + Specifies the location of the `text`. *inside* + positions `text` inside, next to the bar end (rotated + and scaled if needed). *outside* positions `text` + outside, next to the bar end (scaled if needed). *auto* + positions `text` inside or outside so that `text` size + is maximized. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.bar.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + width + Sets the bar width (in position axis units). + widthsrc + Sets the source reference on plot.ly for width . + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Bar + """ + new_trace = Bar( + base=base, + basesrc=basesrc, + cliponaxis=cliponaxis, + constraintext=constraintext, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + insidetextfont=insidetextfont, + legendgroup=legendgroup, + marker=marker, + name=name, + offset=offset, + offsetsrc=offsetsrc, + opacity=opacity, + orientation=orientation, + outsidetextfont=outsidetextfont, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + tsrc=tsrc, + uid=uid, + unselected=unselected, + visible=visible, + width=width, + widthsrc=widthsrc, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_box( + self, + boxmean=None, + boxpoints=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + name=None, + notched=None, + notchwidth=None, + opacity=None, + orientation=None, + pointpos=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + whiskerwidth=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Box trace + + In vertical (horizontal) box plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + box per distinct x (y) value is drawn If no `x` (`y`) {array} + is provided, a single box is drawn. That box position is then + positioned with with `name` or with `x0` (`y0`) if provided. + Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The + second quartile (Q2) is marked by a line inside the box. By + default, the whiskers correspond to the box' edges +/- 1.5 + times the interquartile range (IQR = Q3-Q1), see *boxpoints* + for other options. + + Parameters + ---------- + boxmean + If *true*, the mean of the box(es)' underlying + distribution is drawn as a dashed line inside the + box(es). If *sd* the standard deviation is also drawn. + boxpoints + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the box(es) are shown with no sample + points + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.box.Hoverlabel instance or dict with + compatible properties + hoveron + Do the hover effects highlight individual boxes or + sample points or both? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the box(es). + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.box.Line instance or dict with + compatible properties + marker + plotly.graph_objs.box.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + notched + Determines whether or not notches should be drawn. + notchwidth + Sets the width of the notches relative to the box' + width. For example, with 0, the notches are as wide as + the box(es). + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the box(es). If *v* (*h*), the + distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the box(es). If *0*, the sample points are places over + the center of the box(es). Positive (negative) values + correspond to positions to the right (left) for + vertical boxes and above (below) for horizontal boxes + selected + plotly.graph_objs.box.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.box.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.box.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Box + """ + new_trace = Box( + boxmean=boxmean, + boxpoints=boxpoints, + customdata=customdata, + customdatasrc=customdatasrc, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + jitter=jitter, + legendgroup=legendgroup, + line=line, + marker=marker, + name=name, + notched=notched, + notchwidth=notchwidth, + opacity=opacity, + orientation=orientation, + pointpos=pointpos, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + whiskerwidth=whiskerwidth, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_candlestick( + self, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + whiskerwidth=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Candlestick trace + + The candlestick is a style of financial chart describing open, + high, low and close for a given `x` coordinate (most likely + time). The boxes represent the spread between the `open` and + `close` values and the lines represent the spread between the + `low` and `high` values Sample points where the close value is + higher (lower) then the open value are called increasing + (decreasing). By default, increasing candles are drawn in green + whereas decreasing are drawn in red. + + Parameters + ---------- + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.candlestick.Decreasing instance or + dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.candlestick.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.candlestick.Increasing instance or + dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.candlestick.Line instance or dict + with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.candlestick.Stream instance or dict + with compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Candlestick + """ + new_trace = Candlestick( + close=close, + closesrc=closesrc, + customdata=customdata, + customdatasrc=customdatasrc, + decreasing=decreasing, + high=high, + highsrc=highsrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + increasing=increasing, + legendgroup=legendgroup, + line=line, + low=low, + lowsrc=lowsrc, + name=name, + opacity=opacity, + open=open, + opensrc=opensrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + whiskerwidth=whiskerwidth, + x=x, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_carpet( + self, + a=None, + a0=None, + aaxis=None, + asrc=None, + b=None, + b0=None, + baxis=None, + bsrc=None, + carpet=None, + cheaterslope=None, + color=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + font=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xsrc=None, + y=None, + yaxis=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Carpet trace + + The data describing carpet axis layout is set in `y` and + (optionally) also `x`. If only `y` is present, `x` the plot is + interpreted as a cheater plot and is filled in using the `y` + values. `x` and `y` may either be 2D arrays matching with each + dimension matching that of `a` and `b`, or they may be 1D + arrays with total length equal to that of `a` and `b`. + + Parameters + ---------- + a + An array containing values of the first parameter value + a0 + Alternate to `a`. Builds a linear space of a + coordinates. Use with `da` where `a0` is the starting + coordinate and `da` the step. + aaxis + plotly.graph_objs.carpet.Aaxis instance or dict with + compatible properties + asrc + Sets the source reference on plot.ly for a . + b + A two dimensional array of y coordinates at each carpet + point. + b0 + Alternate to `b`. Builds a linear space of a + coordinates. Use with `db` where `b0` is the starting + coordinate and `db` the step. + baxis + plotly.graph_objs.carpet.Baxis instance or dict with + compatible properties + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + cheaterslope + The shift applied to each successive row of data in + creating a cheater plot. Only used if `x` is been + ommitted. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the a coordinate step. See `a0` for more info. + db + Sets the b coordinate step. See `b0` for more info. + font + The default font used for axis & tick labels on this + carpet + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.carpet.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.carpet.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + A two dimensional array of x coordinates at each carpet + point. If ommitted, the plot is a cheater plot and the + xaxis is hidden by default. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + A two dimensional array of y coordinates at each carpet + point. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Carpet + """ + new_trace = Carpet( + a=a, + a0=a0, + aaxis=aaxis, + asrc=asrc, + b=b, + b0=b0, + baxis=baxis, + bsrc=bsrc, + carpet=carpet, + cheaterslope=cheaterslope, + color=color, + customdata=customdata, + customdatasrc=customdatasrc, + da=da, + db=db, + font=font, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_choropleth( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + locationmode=None, + locations=None, + locationssrc=None, + marker=None, + name=None, + opacity=None, + reversescale=None, + selected=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Choropleth trace + + The data that describes the choropleth value-to-color mapping + is set in `z`. The geographic locations corresponding to each + value in `z` are set in `locations`. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.choropleth.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.choropleth.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. See + `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + marker + plotly.graph_objs.choropleth.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selected + plotly.graph_objs.choropleth.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.choropleth.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each location. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.choropleth.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + z + Sets the color values. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Choropleth + """ + new_trace = Choropleth( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + geo=geo, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + locationmode=locationmode, + locations=locations, + locationssrc=locationssrc, + marker=marker, + name=name, + opacity=opacity, + reversescale=reversescale, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_cone( + self, + anchor=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + sizemode=None, + sizeref=None, + stream=None, + text=None, + textsrc=None, + u=None, + uid=None, + usrc=None, + v=None, + visible=None, + vsrc=None, + w=None, + wsrc=None, + x=None, + xsrc=None, + y=None, + ysrc=None, + z=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Cone trace + + Use cone traces to visualize vector fields. Specify a vector + field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and + 3 vector component arrays `u`, `v`, `w`. The cones are drawn + exactly at the positions given by `x`, `y` and `z`. + + Parameters + ---------- + anchor + Sets the cones' anchor with respect to their x/y/z + positions. Note that *cm* denote the cone's center of + mass which corresponds to 1/4 from the tail to tip. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + colorbar + plotly.graph_objs.cone.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.cone.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.cone.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.cone.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + sizemode + Determines whether `sizeref` is set as a *scaled* (i.e + unitless) scalar (normalized by the max u/v/w norm in + the vector field) or as *absolute* value (in the same + units as the vector field). + sizeref + Adjusts the cone size scaling. The size of the cones is + determined by their u/v/w norm multiplied a factor and + `sizeref`. This factor (computed internally) + corresponds to the minimum "time" to travel across two + successive x/y/z positions at the average velocity of + those two successive positions. All cones in a given + trace use the same factor. With `sizemode` set to + *scaled*, `sizeref` is unitless, its default value is + *0.5* With `sizemode` set to *absolute*, `sizeref` has + the same units as the u/v/w vector field, its the + default value is half the sample's maximum vector norm. + stream + plotly.graph_objs.cone.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the cones. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + u + Sets the x components of the vector field. + uid + + usrc + Sets the source reference on plot.ly for u . + v + Sets the y components of the vector field. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + vsrc + Sets the source reference on plot.ly for v . + w + Sets the z components of the vector field. + wsrc + Sets the source reference on plot.ly for w . + x + Sets the x coordinates of the vector field and of the + displayed cones. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates of the vector field and of the + displayed cones. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates of the vector field and of the + displayed cones. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Cone + """ + new_trace = Cone( + anchor=anchor, + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + sizemode=sizemode, + sizeref=sizeref, + stream=stream, + text=text, + textsrc=textsrc, + u=u, + uid=uid, + usrc=usrc, + v=v, + visible=visible, + vsrc=vsrc, + w=w, + wsrc=wsrc, + x=x, + xsrc=xsrc, + y=y, + ysrc=ysrc, + z=z, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_contour( + self, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + connectgaps=None, + contours=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Contour trace + + The data from which contour lines are computed is set in `z`. + Data in `z` must be a {2D array} of numbers. Say that `z` has N + rows and M columns, then by default, these N rows correspond to + N y coordinates (set in `y` or auto-generated) and the M + columns correspond to M x coordinates (set in `x` or auto- + generated). By setting `transpose` to *true*, the above + behavior is flipped. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.contour.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + contours + plotly.graph_objs.contour.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contour.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contour.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contour.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Contour + """ + new_trace = Contour( + autocolorscale=autocolorscale, + autocontour=autocontour, + colorbar=colorbar, + colorscale=colorscale, + connectgaps=connectgaps, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + name=name, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_contourcarpet( + self, + a=None, + a0=None, + asrc=None, + atype=None, + autocolorscale=None, + autocontour=None, + b=None, + b0=None, + bsrc=None, + btype=None, + carpet=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + xaxis=None, + yaxis=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Contourcarpet trace + + Plots contours on either the first carpet axis or the carpet + axis with a matching `carpet` attribute. Data `z` is + interpreted as matching that of the corresponding carpet axis. + + Parameters + ---------- + a + Sets the x coordinates. + a0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + asrc + Sets the source reference on plot.ly for a . + atype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + b + Sets the y coordinates. + b0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + bsrc + Sets the source reference on plot.ly for b . + btype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + carpet + The `carpet` of the carpet axes on which this contour + trace lies + colorbar + plotly.graph_objs.contourcarpet.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.contourcarpet.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the x coordinate step. See `x0` for more info. + db + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contourcarpet.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contourcarpet.Line instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contourcarpet.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Contourcarpet + """ + new_trace = Contourcarpet( + a=a, + a0=a0, + asrc=asrc, + atype=atype, + autocolorscale=autocolorscale, + autocontour=autocontour, + b=b, + b0=b0, + bsrc=bsrc, + btype=btype, + carpet=carpet, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + da=da, + db=db, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + name=name, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + xaxis=xaxis, + yaxis=yaxis, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_heatmap( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xgap=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ygap=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Heatmap trace + + The data that describes the heatmap value-to-color mapping is + set in `z`. Data in `z` can either be a {2D array} of values + (ragged or not) or a 1D array of values. In the case where `z` + is a {2D array}, say that `z` has N rows and M columns. Then, + by default, the resulting heatmap will have N partitions along + the y axis and M partitions along the x axis. In other words, + the i-th row/ j-th column cell in `z` is mapped to the i-th + partition of the y axis (starting from the bottom of the plot) + and the j-th partition of the x-axis (starting from the left of + the plot). This behavior can be flipped by using `transpose`. + Moreover, `x` (`y`) can be provided with M or M+1 (N or N+1) + elements. If M (N), then the coordinates correspond to the + center of the heatmap cells and the cells have equal width. If + M+1 (N+1), then the coordinates correspond to the edges of the + heatmap cells. In the case where `z` is a 1D {array}, the x and + y coordinates must be provided in `x` and `y` respectively to + form data triplets. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmap.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmap.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmap.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Heatmap + """ + new_trace = Heatmap( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xgap=xgap, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ygap=ygap, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsmooth=zsmooth, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_heatmapgl( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Heatmapgl trace + + WebGL version of the heatmap trace type. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmapgl.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmapgl.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmapgl.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Heatmapgl + """ + new_trace = Heatmapgl( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram( + self, + autobinx=None, + autobiny=None, + cumulative=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + orientation=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram trace + + The sample data from which statistics are computed is set in + `x` for vertically spanning histograms and in `y` for + horizontally spanning histograms. Binning options are set + `xbins` and `ybins` respectively if no aggregation data is + provided. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + cumulative + plotly.graph_objs.histogram.Cumulative instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.histogram.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.histogram.ErrorY instance or dict + with compatible properties + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + selected + plotly.graph_objs.histogram.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.histogram.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.histogram.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram.XBins instance or dict with + compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram.YBins instance or dict with + compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram + """ + new_trace = Histogram( + autobinx=autobinx, + autobiny=autobiny, + cumulative=cumulative, + customdata=customdata, + customdatasrc=customdatasrc, + error_x=error_x, + error_y=error_y, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + opacity=opacity, + orientation=orientation, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram2d( + self, + autobinx=None, + autobiny=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xgap=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ygap=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram2d trace + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a heatmap. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.histogram2d.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2d.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram2d.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2d.Stream instance or dict + with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2d.XBins instance or dict + with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2d.YBins instance or dict + with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram2d + """ + new_trace = Histogram2d( + autobinx=autobinx, + autobiny=autobiny, + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xgap=xgap, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ygap=ygap, + ysrc=ysrc, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsmooth=zsmooth, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram2dcontour( + self, + autobinx=None, + autobiny=None, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram2dContour trace + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a contour plot. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.histogram2dcontour.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.histogram2dcontour.Contours instance + or dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2dcontour.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.histogram2dcontour.Line instance or + dict with compatible properties + marker + plotly.graph_objs.histogram2dcontour.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2dcontour.Stream instance or + dict with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2dcontour.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2dcontour.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram2dContour + """ + new_trace = Histogram2dContour( + autobinx=autobinx, + autobiny=autobiny, + autocolorscale=autocolorscale, + autocontour=autocontour, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_mesh3d( + self, + alphahull=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + contour=None, + customdata=None, + customdatasrc=None, + delaunayaxis=None, + facecolor=None, + facecolorsrc=None, + flatshading=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + i=None, + ids=None, + idssrc=None, + intensity=None, + intensitysrc=None, + isrc=None, + j=None, + jsrc=None, + k=None, + ksrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + vertexcolor=None, + vertexcolorsrc=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Mesh3d trace + + Draws sets of triangles with coordinates given by three + 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, + `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha- + shape algorithm or (4) the Convex-hull algorithm + + Parameters + ---------- + alphahull + Determines how the mesh surface triangles are derived + from the set of vertices (points) represented by the + `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays + are not supplied. For general use of `mesh3d` it is + preferred that `i`, `j`, `k` are supplied. If *-1*, + Delaunay triangulation is used, which is mainly + suitable if the mesh is a single, more or less layer + surface that is perpendicular to `delaunayaxis`. In + case the `delaunayaxis` intersects the mesh surface at + more than one point it will result triangles that are + very long in the dimension of `delaunayaxis`. If *>0*, + the alpha-shape algorithm is used. In this case, the + positive `alphahull` value signals the use of the + alpha-shape algorithm, _and_ its value acts as the + parameter for the mesh fitting. If *0*, the convex- + hull algorithm is used. It is suitable for convex + bodies or if the intention is to enclose the `x`, `y` + and `z` point set into a convex hull. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color of the whole mesh + colorbar + plotly.graph_objs.mesh3d.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + contour + plotly.graph_objs.mesh3d.Contour instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + delaunayaxis + Sets the Delaunay axis, which is the axis that is + perpendicular to the surface of the Delaunay + triangulation. It has an effect if `i`, `j`, `k` are + not provided and `alphahull` is set to indicate + Delaunay triangulation. + facecolor + Sets the color of each face Overrides *color* and + *vertexcolor*. + facecolorsrc + Sets the source reference on plot.ly for facecolor . + flatshading + Determines whether or not normal smoothing is applied + to the meshes, creating meshes with an angular, low- + poly look via flat reflections. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.mesh3d.Hoverlabel instance or dict + with compatible properties + i + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *first* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `i[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `i` represents a point in space, which + is the first vertex of a triangle. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + intensity + Sets the vertex intensity values, used for plotting + fields on meshes + intensitysrc + Sets the source reference on plot.ly for intensity . + isrc + Sets the source reference on plot.ly for i . + j + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *second* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `j[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `j` represents a point in space, which + is the second vertex of a triangle. + jsrc + Sets the source reference on plot.ly for j . + k + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *third* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `k[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `k` represents a point in space, which + is the third vertex of a triangle. + ksrc + Sets the source reference on plot.ly for k . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.mesh3d.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.mesh3d.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.mesh3d.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the vertices. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + vertexcolor + Sets the color of each vertex Overrides *color*. + vertexcolorsrc + Sets the source reference on plot.ly for vertexcolor . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the X coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the Y coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the Z coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Mesh3d + """ + new_trace = Mesh3d( + alphahull=alphahull, + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + color=color, + colorbar=colorbar, + colorscale=colorscale, + contour=contour, + customdata=customdata, + customdatasrc=customdatasrc, + delaunayaxis=delaunayaxis, + facecolor=facecolor, + facecolorsrc=facecolorsrc, + flatshading=flatshading, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + i=i, + ids=ids, + idssrc=idssrc, + intensity=intensity, + intensitysrc=intensitysrc, + isrc=isrc, + j=j, + jsrc=jsrc, + k=k, + ksrc=ksrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + vertexcolor=vertexcolor, + vertexcolorsrc=vertexcolorsrc, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_ohlc( + self, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + tickwidth=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Ohlc trace + + The ohlc (short for Open-High-Low-Close) is a style of + financial chart describing open, high, low and close for a + given `x` coordinate (most likely time). The tip of the lines + represent the `low` and `high` values and the horizontal + segments represent the `open` and `close` values. Sample points + where the close value is higher (lower) then the open value are + called increasing (decreasing). By default, increasing items + are drawn in green whereas decreasing are drawn in red. + + Parameters + ---------- + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.ohlc.Decreasing instance or dict with + compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.ohlc.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.ohlc.Increasing instance or dict with + compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.ohlc.Line instance or dict with + compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.ohlc.Stream instance or dict with + compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + tickwidth + Sets the width of the open/close tick marks relative to + the *x* minimal interval. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Ohlc + """ + new_trace = Ohlc( + close=close, + closesrc=closesrc, + customdata=customdata, + customdatasrc=customdatasrc, + decreasing=decreasing, + high=high, + highsrc=highsrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + increasing=increasing, + legendgroup=legendgroup, + line=line, + low=low, + lowsrc=lowsrc, + name=name, + opacity=opacity, + open=open, + opensrc=opensrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + tickwidth=tickwidth, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_parcoords( + self, + customdata=None, + customdatasrc=None, + dimensions=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + labelfont=None, + legendgroup=None, + line=None, + name=None, + opacity=None, + rangefont=None, + selectedpoints=None, + showlegend=None, + stream=None, + tickfont=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Parcoords trace + + Parallel coordinates for multidimensional exploratory data + analysis. The samples are specified in `dimensions`. The colors + are set in `line.color`. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dimensions + The dimensions (variables) of the parallel coordinates + chart. 2..60 dimensions are supported. + domain + plotly.graph_objs.parcoords.Domain instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.parcoords.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + labelfont + Sets the font for the `dimension` labels. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.parcoords.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + rangefont + Sets the font for the `dimension` range values. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.parcoords.Stream instance or dict + with compatible properties + tickfont + Sets the font for the `dimension` tick values. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Parcoords + """ + new_trace = Parcoords( + customdata=customdata, + customdatasrc=customdatasrc, + dimensions=dimensions, + domain=domain, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + labelfont=labelfont, + legendgroup=legendgroup, + line=line, + name=name, + opacity=opacity, + rangefont=rangefont, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + tickfont=tickfont, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_pie( + self, + customdata=None, + customdatasrc=None, + direction=None, + dlabel=None, + domain=None, + hole=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + label0=None, + labels=None, + labelssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + outsidetextfont=None, + pull=None, + pullsrc=None, + rotation=None, + scalegroup=None, + selectedpoints=None, + showlegend=None, + sort=None, + stream=None, + text=None, + textfont=None, + textinfo=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + values=None, + valuessrc=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Pie trace + + A data visualized by the sectors of the pie is set in `values`. + The sector labels are set in `labels`. The sector colors are + set in `marker.colors` + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + direction + Specifies the direction at which succeeding sectors + follow one another. + dlabel + Sets the label step. See `label0` for more info. + domain + plotly.graph_objs.pie.Domain instance or dict with + compatible properties + hole + Sets the fraction of the radius to cut out of the pie. + Use this to make a donut chart. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pie.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each sector. + If a single string, the same string appears for all + data points. If an array of string, the items are + mapped in order of this trace's sectors. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `textinfo` lying inside the pie. + label0 + Alternate to `labels`. Builds a numeric set of labels. + Use with `dlabel` where `label0` is the starting label + and `dlabel` the step. + labels + Sets the sector labels. If `labels` entries are + duplicated, we sum associated `values` or simply count + occurrences if `values` is not provided. For other + array attributes (including color) we use the first + non-empty entry among all occurrences of the label. + labelssrc + Sets the source reference on plot.ly for labels . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pie.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + outsidetextfont + Sets the font used for `textinfo` lying outside the + pie. + pull + Sets the fraction of larger radius to pull the sectors + out from the center. This can be a constant to pull all + slices apart from each other equally or an array to + highlight one or more slices. + pullsrc + Sets the source reference on plot.ly for pull . + rotation + Instead of the first slice starting at 12 o'clock, + rotate to some other angle. + scalegroup + If there are multiple pies that should be sized + according to their totals, link them by providing a + non-empty group id here shared by every trace in the + same group. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + sort + Determines whether or not the sectors are reordered + from largest to smallest. + stream + plotly.graph_objs.pie.Stream instance or dict with + compatible properties + text + Sets text elements associated with each sector. If + trace `textinfo` contains a *text* flag, these elements + will seen on the chart. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textfont + Sets the font used for `textinfo`. + textinfo + Determines which trace information appear on the graph. + textposition + Specifies the location of the `textinfo`. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + values + Sets the values of the sectors of this pie chart. If + omitted, we count occurrences of each label. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Pie + """ + new_trace = Pie( + customdata=customdata, + customdatasrc=customdatasrc, + direction=direction, + dlabel=dlabel, + domain=domain, + hole=hole, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + insidetextfont=insidetextfont, + label0=label0, + labels=labels, + labelssrc=labelssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + outsidetextfont=outsidetextfont, + pull=pull, + pullsrc=pullsrc, + rotation=rotation, + scalegroup=scalegroup, + selectedpoints=selectedpoints, + showlegend=showlegend, + sort=sort, + stream=stream, + text=text, + textfont=textfont, + textinfo=textinfo, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + values=values, + valuessrc=valuessrc, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_pointcloud( + self, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + indices=None, + indicessrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbounds=None, + xboundssrc=None, + xsrc=None, + xy=None, + xysrc=None, + y=None, + yaxis=None, + ybounds=None, + yboundssrc=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Pointcloud trace + + The data visualized as a point cloud set in `x` and `y` using + the WebGl plotting engine. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pointcloud.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + indices + A sequential value, 0..n, supply it to avoid creating + this array inside plotting. If specified, it must be a + typed `Int32Array` array. Its length must be equal to + or greater than the number of points. For the best + performance and memory use, create one large `indices` + typed array that is guaranteed to be at least as long + as the largest number of points during use, and reuse + it on each `Plotly.restyle()` call. + indicessrc + Sets the source reference on plot.ly for indices . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pointcloud.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.pointcloud.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbounds + Specify `xbounds` in the shape of `[xMin, xMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `ybounds` for the performance + benefits. + xboundssrc + Sets the source reference on plot.ly for xbounds . + xsrc + Sets the source reference on plot.ly for x . + xy + Faster alternative to specifying `x` and `y` + separately. If supplied, it must be a typed + `Float32Array` array that represents points such that + `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]` + xysrc + Sets the source reference on plot.ly for xy . + y + Sets the y coordinates. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybounds + Specify `ybounds` in the shape of `[yMin, yMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `xbounds` for the performance + benefits. + yboundssrc + Sets the source reference on plot.ly for ybounds . + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Pointcloud + """ + new_trace = Pointcloud( + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + indices=indices, + indicessrc=indicessrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbounds=xbounds, + xboundssrc=xboundssrc, + xsrc=xsrc, + xy=xy, + xysrc=xysrc, + y=y, + yaxis=yaxis, + ybounds=ybounds, + yboundssrc=yboundssrc, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_sankey( + self, + arrangement=None, + customdata=None, + customdatasrc=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + link=None, + name=None, + node=None, + opacity=None, + orientation=None, + selectedpoints=None, + showlegend=None, + stream=None, + textfont=None, + uid=None, + valueformat=None, + valuesuffix=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Sankey trace + + Sankey plots for network flow data analysis. The nodes are + specified in `nodes` and the links between sources and targets + in `links`. The colors are set in `nodes[i].color` and + `links[i].color`; otherwise defaults are used. + + Parameters + ---------- + arrangement + If value is `snap` (the default), the node arrangement + is assisted by automatic snapping of elements to + preserve space between nodes specified via `nodepad`. + If value is `perpendicular`, the nodes can only move + along a line perpendicular to the flow. If value is + `freeform`, the nodes can freely move on the plane. If + value is `fixed`, the nodes are stationary. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.sankey.Domain instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.sankey.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + link + The links of the Sankey plot. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + node + The nodes of the Sankey plot. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the Sankey diagram. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.sankey.Stream instance or dict with + compatible properties + textfont + Sets the font for node labels + uid + + valueformat + Sets the value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + valuesuffix + Adds a unit to follow the value in the hover tooltip. + Add a space if a separation is necessary from the + value. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Sankey + """ + new_trace = Sankey( + arrangement=arrangement, + customdata=customdata, + customdatasrc=customdatasrc, + domain=domain, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + link=link, + name=name, + node=node, + opacity=opacity, + orientation=orientation, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + textfont=textfont, + uid=uid, + valueformat=valueformat, + valuesuffix=valuesuffix, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatter( + self, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatter trace + + The scatter trace type encompasses line charts, scatter charts, + text charts, and bubble charts. The data visualized as scatter + point or lines is set in `x` and `y`. Text (appearing either on + the chart or on hover only) is via `text`. Bubble charts are + achieved by setting `marker.size` and/or `marker.color` to + numerical arrays. + + Parameters + ---------- + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scatter.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.scatter.ErrorY instance or dict with + compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter.Marker instance or dict with + compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatter.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.scatter.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatter + """ + new_trace = Scatter( + cliponaxis=cliponaxis, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + tsrc=tsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatter3d( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + error_z=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + projection=None, + scene=None, + selectedpoints=None, + showlegend=None, + stream=None, + surfaceaxis=None, + surfacecolor=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatter3d trace + + The data visualized as scatter point or lines in 3D dimension + is set in `x`, `y`, `z`. Text (appearing either on the chart or + on hover only) is via `text`. Bubble charts are achieved by + setting `marker.size` and/or `marker.color` Projections are + achieved via `projection`. Surface fills are achieved via + `surfaceaxis`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.scatter3d.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scatter3d.ErrorY instance or dict + with compatible properties + error_z + plotly.graph_objs.scatter3d.ErrorZ instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter3d.Hoverlabel instance or dict + with compatible properties + hovertext + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter3d.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter3d.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + projection + plotly.graph_objs.scatter3d.Projection instance or dict + with compatible properties + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter3d.Stream instance or dict + with compatible properties + surfaceaxis + If *-1*, the scatter points are not fill with a surface + If *0*, *1*, *2*, the scatter points are filled with a + Delaunay surface about the x, y, z respectively. + surfacecolor + Sets the surface fill color. + text + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatter3d + """ + new_trace = Scatter3d( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + error_x=error_x, + error_y=error_y, + error_z=error_z, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + projection=projection, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + surfaceaxis=surfaceaxis, + surfacecolor=surfacecolor, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattercarpet( + self, + a=None, + asrc=None, + b=None, + bsrc=None, + carpet=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxis=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattercarpet trace + + Plots a scatter trace on either the first carpet axis or the + carpet axis with a matching `carpet` attribute. + + Parameters + ---------- + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattercarpet.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattercarpet.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scattercarpet.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattercarpet.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattercarpet.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattercarpet.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattercarpet + """ + new_trace = Scattercarpet( + a=a, + asrc=asrc, + b=b, + bsrc=bsrc, + carpet=carpet, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + xaxis=xaxis, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattergeo( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + locationmode=None, + locations=None, + locationssrc=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattergeo trace + + The data visualized as scatter point or lines on a geographic + map is provided either by longitude/latitude pairs in `lon` and + `lat` respectively or by geographic location IDs or names in + `locations`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergeo.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair or item in `locations`. If a single string, the + same string appears over all the data points. If an + array of string, the items are mapped in order to the + this trace's (lon,lat) or `locations` coordinates. To + be seen, trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergeo.Line instance or dict with + compatible properties + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + Coordinates correspond to the centroid of each location + given. See `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattergeo.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergeo.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergeo.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (lon,lat) pair + or item in `locations`. If a single string, the same + string appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (lon,lat) or `locations` coordinates. If trace + `hoverinfo` contains a *text* flag and *hovertext* is + not set, these elements will be seen in the hover + labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergeo.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattergeo + """ + new_trace = Scattergeo( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + geo=geo, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + lat=lat, + latsrc=latsrc, + legendgroup=legendgroup, + line=line, + locationmode=locationmode, + locations=locations, + locationssrc=locationssrc, + lon=lon, + lonsrc=lonsrc, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattergl( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattergl trace + + The data visualized as scatter point or lines is set in `x` and + `y` using the WebGL plotting engine. Bubble charts are achieved + by setting `marker.size` and/or `marker.color` to a numerical + arrays. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scattergl.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scattergl.ErrorY instance or dict + with compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergl.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergl.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scattergl.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergl.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergl.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergl.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattergl + """ + new_trace = Scattergl( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattermapbox( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattermapbox trace + + The data visualized as scatter point, lines or marker symbols + on a Mapbox GL geographic map is provided by longitude/latitude + pairs in `lon` and `lat`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattermapbox.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (lon,lat) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattermapbox.Line instance or dict + with compatible properties + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattermapbox.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattermapbox.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattermapbox.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a mapbox subplot. If *mapbox* (the default value), + the data refer to `layout.mapbox`. If *mapbox2*, the + data refer to `layout.mapbox2`, and so on. + text + Sets text elements associated with each (lon,lat) pair + If a single string, the same string appears over all + the data points. If an array of string, the items are + mapped in order to the this trace's (lon,lat) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattermapbox.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattermapbox + """ + new_trace = Scattermapbox( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + lat=lat, + latsrc=latsrc, + legendgroup=legendgroup, + line=line, + lon=lon, + lonsrc=lonsrc, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textfont=textfont, + textposition=textposition, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterpolar( + self, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterpolar trace + + The scatterpolar trace type encompasses line charts, scatter + charts, text charts, and bubble charts in polar coordinates. + The data visualized as scatter point or lines is set in `r` + (radial) and `theta` (angular) coordinates Text (appearing + either on the chart or on hover only) is via `text`. Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterpolar has a subset of + the options available to scatter. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolar.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolar.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolar.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolar.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolar.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolar.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterpolar + """ + new_trace = Scatterpolar( + cliponaxis=cliponaxis, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + theta=theta, + thetasrc=thetasrc, + thetaunit=thetaunit, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterpolargl( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterpolargl trace + + The scatterpolargl trace type encompasses line charts, scatter + charts, and bubble charts in polar coordinates using the WebGL + plotting engine. The data visualized as scatter point or lines + is set in `r` (radial) and `theta` (angular) coordinates Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolargl.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolargl.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolargl.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolargl.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolargl.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolargl.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterpolargl + """ + new_trace = Scatterpolargl( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textsrc=textsrc, + theta=theta, + thetasrc=thetasrc, + thetaunit=thetaunit, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterternary( + self, + a=None, + asrc=None, + b=None, + bsrc=None, + c=None, + cliponaxis=None, + connectgaps=None, + csrc=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + sum=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterternary trace + + Provides similar functionality to the *scatter* type but on a + ternary phase diagram. The data is provided by at least two + arrays out of `a`, `b`, `c` triplets. + + Parameters + ---------- + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + c + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + csrc + Sets the source reference on plot.ly for c . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterternary.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (a,b,c) + point. If a single string, the same string appears over + all the data points. If an array of strings, the items + are mapped in order to the the data points in (a,b,c). + To be seen, trace `hoverinfo` must contain a *text* + flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterternary.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterternary.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scatterternary.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterternary.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a ternary subplot. If *ternary* (the default + value), the data refer to `layout.ternary`. If + *ternary2*, the data refer to `layout.ternary2`, and so + on. + sum + The number each triplet should sum to, if only two of + `a`, `b`, and `c` are provided. This overrides + `ternary.sum` to normalize this specific trace, but + does not affect the values displayed on the axes. 0 (or + missing) means to use ternary.sum + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scatterternary.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterternary + """ + new_trace = Scatterternary( + a=a, + asrc=asrc, + b=b, + bsrc=bsrc, + c=c, + cliponaxis=cliponaxis, + connectgaps=connectgaps, + csrc=csrc, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + sum=sum, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_splom( + self, + customdata=None, + customdatasrc=None, + diagonal=None, + dimensions=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + showlowerhalf=None, + showupperhalf=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxes=None, + yaxes=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Splom trace + + Splom traces generate scatter plot matrix visualizations. Each + splom `dimensions` items correspond to a generated axis. Values + for each of those dimensions are set in `dimensions[i].values`. + Splom traces support all `scattergl` marker style attributes. + Specify `layout.grid` attributes and/or layout x-axis and + y-axis attributes for more control over the axis positioning + and style. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + diagonal + plotly.graph_objs.splom.Diagonal instance or dict with + compatible properties + dimensions + plotly.graph_objs.splom.Dimension instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.splom.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.splom.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.splom.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showlowerhalf + Determines whether or not subplots on the lower half + from the diagonal are displayed. + showupperhalf + Determines whether or not subplots on the upper half + from the diagonal are displayed. + stream + plotly.graph_objs.splom.Stream instance or dict with + compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.splom.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxes + Sets the list of x axes corresponding to this splom + trace. By default, a splom will match the first N xaxes + where N is the number of input dimensions. + yaxes + Sets the list of y axes corresponding to this splom + trace. By default, a splom will match the first N yaxes + where N is the number of input dimensions. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Splom + """ + new_trace = Splom( + customdata=customdata, + customdatasrc=customdatasrc, + diagonal=diagonal, + dimensions=dimensions, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + showlowerhalf=showlowerhalf, + showupperhalf=showupperhalf, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + xaxes=xaxes, + yaxes=yaxes, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_surface( + self, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + hidesurface=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + surfacecolor=None, + surfacecolorsrc=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Surface trace + + The data the describes the coordinates of the surface is set in + `z`. Data in `z` should be a {2D array}. Coordinates in `x` and + `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph + parametric surfaces). If not provided in `x` and `y`, the x and + y coordinates are assumed to be linear starting at 0 with a + unit step. The color scale corresponds to the `z` values by + default. For custom color scales, use `surfacecolor` which + should be a {2D array}, where its bounds can be controlled + using `cmin` and `cmax`. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + cauto + Determines the whether or not the color domain is + computed with respect to the input data. + cmax + Sets the upper bound of color domain. + cmin + Sets the lower bound of color domain. + colorbar + plotly.graph_objs.surface.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.surface.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hidesurface + Determines whether or not a surface is drawn. For + example, set `hidesurface` to *false* `contours.x.show` + to *true* and `contours.y.show` to *true* to draw a + wire frame plot. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.surface.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.surface.Lighting instance or dict + with compatible properties + lightposition + plotly.graph_objs.surface.Lightposition instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Reverses the colorscale. + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.surface.Stream instance or dict with + compatible properties + surfacecolor + Sets the surface color values, used for setting a color + scale independent of `z`. + surfacecolorsrc + Sets the source reference on plot.ly for surfacecolor + . + text + Sets the text elements associated with each z value. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Surface + """ + new_trace = Surface( + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + hidesurface=hidesurface, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + surfacecolor=surfacecolor, + surfacecolorsrc=surfacecolorsrc, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_table( + self, + cells=None, + columnorder=None, + columnordersrc=None, + columnwidth=None, + columnwidthsrc=None, + customdata=None, + customdatasrc=None, + domain=None, + header=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Table trace + + Table view for detailed data viewing. The data are arranged in + a grid of rows and columns. Most styling can be specified for + columns, rows or individual cells. Table is using a column- + major order, ie. the grid is represented as a vector of column + vectors. + + Parameters + ---------- + cells + plotly.graph_objs.table.Cells instance or dict with + compatible properties + columnorder + Specifies the rendered order of the data columns; for + example, a value `2` at position `0` means that column + index `0` in the data will be rendered as the third + column, as columns have an index base of zero. + columnordersrc + Sets the source reference on plot.ly for columnorder . + columnwidth + The width of columns expressed as a ratio. Columns fill + the available width in proportion of their specified + column widths. + columnwidthsrc + Sets the source reference on plot.ly for columnwidth . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.table.Domain instance or dict with + compatible properties + header + plotly.graph_objs.table.Header instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.table.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.table.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Table + """ + new_trace = Table( + cells=cells, + columnorder=columnorder, + columnordersrc=columnordersrc, + columnwidth=columnwidth, + columnwidthsrc=columnwidthsrc, + customdata=customdata, + customdatasrc=customdatasrc, + domain=domain, + header=header, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_violin( + self, + bandwidth=None, + box=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + meanline=None, + name=None, + opacity=None, + orientation=None, + pointpos=None, + points=None, + scalegroup=None, + scalemode=None, + selected=None, + selectedpoints=None, + showlegend=None, + side=None, + span=None, + spanmode=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Violin trace + + In vertical (horizontal) violin plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + violin per distinct x (y) value is drawn If no `x` (`y`) + {array} is provided, a single violin is drawn. That violin + position is then positioned with with `name` or with `x0` + (`y0`) if provided. + + Parameters + ---------- + bandwidth + Sets the bandwidth used to compute the kernel density + estimate. By default, the bandwidth is determined by + Silverman's rule of thumb. + box + plotly.graph_objs.violin.Box instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.violin.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual violins or + sample points or the kernel density estimate or any + combination of them? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the violins. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.violin.Line instance or dict with + compatible properties + marker + plotly.graph_objs.violin.Marker instance or dict with + compatible properties + meanline + plotly.graph_objs.violin.Meanline instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the violin(s). If *v* (*h*), + the distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the violins. If *0*, the sample points are places over + the center of the violins. Positive (negative) values + correspond to positions to the right (left) for + vertical violins and above (below) for horizontal + violins. + points + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the violins are shown with no sample + points + scalegroup + If there are multiple violins that should be sized + according to to some metric (see `scalemode`), link + them by providing a non-empty group id here shared by + every trace in the same group. + scalemode + Sets the metric by which the width of each violin is + determined.*width* means each violin has the same (max) + width*count* means the violins are scaled by the number + of sample points makingup each violin. + selected + plotly.graph_objs.violin.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + side + Determines on which side of the position value the + density function making up one half of a violin is + plotted. Useful when comparing two violin traces under + *overlay* mode, where one trace has `side` set to + *positive* and the other to *negative*. + span + Sets the span in data space for which the density + function will be computed. Has an effect only when + `spanmode` is set to *manual*. + spanmode + Sets the method by which the span in data space where + the density function will be computed. *soft* means the + span goes from the sample's minimum value minus two + bandwidths to the sample's maximum value plus two + bandwidths. *hard* means the span goes from the + sample's minimum to its maximum value. For custom span + settings, use mode *manual* and fill in the `span` + attribute. + stream + plotly.graph_objs.violin.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.violin.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Violin + """ + new_trace = Violin( + bandwidth=bandwidth, + box=box, + customdata=customdata, + customdatasrc=customdatasrc, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + jitter=jitter, + legendgroup=legendgroup, + line=line, + marker=marker, + meanline=meanline, + name=name, + opacity=opacity, + orientation=orientation, + pointpos=pointpos, + points=points, + scalegroup=scalegroup, + scalemode=scalemode, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + side=side, + span=span, + spanmode=spanmode, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) diff --git a/plotly/graph_objs/_figurewidget.py b/plotly/graph_objs/_figurewidget.py new file mode 100644 index 0000000000..ef52fe4626 --- /dev/null +++ b/plotly/graph_objs/_figurewidget.py @@ -0,0 +1,8449 @@ +from plotly.basewidget import BaseFigureWidget +from plotly.graph_objs import ( + Area, Bar, Box, Candlestick, Carpet, Choropleth, Cone, Contour, + Contourcarpet, Heatmap, Heatmapgl, Histogram, Histogram2d, + Histogram2dContour, Mesh3d, Ohlc, Parcoords, Pie, Pointcloud, Sankey, + Scatter, Scatter3d, Scattercarpet, Scattergeo, Scattergl, Scattermapbox, + Scatterpolar, Scatterpolargl, Scatterternary, Splom, Surface, Table, Violin +) + + +class FigureWidget(BaseFigureWidget): + + def __init__(self, data=None, layout=None, frames=None): + """ + Create a new FigureWidget instance + + Parameters + ---------- + data + The 'data' property is a tuple of trace instances + that may be specified as: + - A list or tuple of trace instances + (e.g. [Scatter(...), Bar(...)]) + - A list or tuple of dicts of string/value properties where: + - The 'type' property specifies the trace type + One of: ['area', 'bar', 'box', 'candlestick', 'carpet', + 'choropleth', 'cone', 'contour', + 'contourcarpet', 'heatmap', 'heatmapgl', + 'histogram', 'histogram2d', + 'histogram2dcontour', 'mesh3d', 'ohlc', + 'parcoords', 'pie', 'pointcloud', 'sankey', + 'scatter', 'scatter3d', 'scattercarpet', + 'scattergeo', 'scattergl', 'scattermapbox', + 'scatterpolar', 'scatterpolargl', + 'scatterternary', 'splom', 'surface', 'table', + 'violin'] + + - All remaining properties are passed to the constructor of + the specified trace type + + (e.g. [{'type': 'scatter', ...}, {'type': 'bar, ...}]) + layout + The 'layout' property is an instance of Layout + that may be specified as: + - An instance of plotly.graph_objs.Layout + - A dict of string/value properties that will be passed + to the Layout constructor + + Supported dict properties: + + angularaxis + plotly.graph_objs.layout.AngularAxis instance + or dict with compatible properties + annotations + plotly.graph_objs.layout.Annotation instance or + dict with compatible properties + autosize + Determines whether or not a layout width or + height that has been left undefined by the user + is initialized on each relayout. Note that, + regardless of this attribute, an undefined + layout width or height is always initialized on + the first call to plot. + bargap + Sets the gap (in plot fraction) between bars of + adjacent location coordinates. + bargroupgap + Sets the gap (in plot fraction) between bars of + the same location coordinate. + barmode + Determines how bars at the same location + coordinate are displayed on the graph. With + *stack*, the bars are stacked on top of one + another With *relative*, the bars are stacked + on top of one another, with negative values + below the axis, positive values above With + *group*, the bars are plotted next to one + another centered around the shared location. + With *overlay*, the bars are plotted over one + another, you might need to an *opacity* to see + multiple bars. + barnorm + Sets the normalization for bar traces on the + graph. With *fraction*, the value of each bar + is divide by the sum of the values at the + location coordinate. With *percent*, the + results form *fraction* are presented in + percents. + boxgap + Sets the gap (in plot fraction) between boxes + of adjacent location coordinates. + boxgroupgap + Sets the gap (in plot fraction) between boxes + of the same location coordinate. + boxmode + Determines how boxes at the same location + coordinate are displayed on the graph. If + *group*, the boxes are plotted next to one + another centered around the shared location. If + *overlay*, the boxes are plotted over one + another, you might need to set *opacity* to see + them multiple boxes. + calendar + Sets the default calendar system to use for + interpreting and displaying dates throughout + the plot. + colorway + Sets the default trace colors. + datarevision + If provided, a changed value tells + `Plotly.react` that one or more data arrays has + changed. This way you can modify arrays in- + place rather than making a complete new copy + for an incremental change. If NOT provided, + `Plotly.react` assumes that data arrays are + being treated as immutable, thus any data array + with a different identity from its predecessor + contains new data. + direction + For polar plots only. Sets the direction + corresponding to positive angles. + dragmode + Determines the mode of drag interactions. + *select* and *lasso* apply only to scatter + traces with markers or text. *orbit* and + *turntable* apply only to 3D scenes. + font + Sets the global font. Note that fonts used in + traces and other layout components inherit from + the global font. + geo + plotly.graph_objs.layout.Geo instance or dict + with compatible properties + grid + plotly.graph_objs.layout.Grid instance or dict + with compatible properties + height + Sets the plot's height (in px). + hiddenlabels + + hiddenlabelssrc + Sets the source reference on plot.ly for + hiddenlabels . + hidesources + Determines whether or not a text link citing + the data source is placed at the bottom-right + cored of the figure. Has only an effect only on + graphs that have been generated via forked + graphs from the plotly service (at + https://plot.ly or on-premise). + hoverdistance + Sets the default distance (in pixels) to look + for data to add hover labels (-1 means no + cutoff, 0 means no looking for data). This is + only a real distance for hovering on point-like + objects, like scatter points. For area-like + objects (bars, scatter fills, etc) hovering is + on inside the area and off outside, but these + objects will not supersede hover on point-like + objects in case of conflict. + hoverlabel + plotly.graph_objs.layout.Hoverlabel instance or + dict with compatible properties + hovermode + Determines the mode of hover interactions. + images + plotly.graph_objs.layout.Image instance or dict + with compatible properties + legend + plotly.graph_objs.layout.Legend instance or + dict with compatible properties + mapbox + plotly.graph_objs.layout.Mapbox instance or + dict with compatible properties + margin + plotly.graph_objs.layout.Margin instance or + dict with compatible properties + orientation + For polar plots only. Rotates the entire polar + by the given angle. + paper_bgcolor + Sets the color of paper where the graph is + drawn. + plot_bgcolor + Sets the color of plotting area in-between x + and y axes. + polar + plotly.graph_objs.layout.Polar instance or dict + with compatible properties + radialaxis + plotly.graph_objs.layout.RadialAxis instance or + dict with compatible properties + scene + plotly.graph_objs.layout.Scene instance or dict + with compatible properties + selectdirection + When "dragmode" is set to "select", this limits + the selection of the drag to horizontal, + vertical or diagonal. "h" only allows + horizontal selection, "v" only vertical, "d" + only diagonal and "any" sets no limit. + separators + Sets the decimal and thousand separators. For + example, *. * puts a '.' before decimals and a + space between thousands. In English locales, + dflt is *.,* but other locales may alter this + default. + shapes + plotly.graph_objs.layout.Shape instance or dict + with compatible properties + showlegend + Determines whether or not a legend is drawn. + sliders + plotly.graph_objs.layout.Slider instance or + dict with compatible properties + spikedistance + Sets the default distance (in pixels) to look + for data to draw spikelines to (-1 means no + cutoff, 0 means no looking for data). As with + hoverdistance, distance does not apply to area- + like objects. In addition, some objects can be + hovered on but will not generate spikelines, + such as scatter fills. + ternary + plotly.graph_objs.layout.Ternary instance or + dict with compatible properties + title + Sets the plot's title. + titlefont + Sets the title font. + updatemenus + plotly.graph_objs.layout.Updatemenu instance or + dict with compatible properties + violingap + Sets the gap (in plot fraction) between violins + of adjacent location coordinates. + violingroupgap + Sets the gap (in plot fraction) between violins + of the same location coordinate. + violinmode + Determines how violins at the same location + coordinate are displayed on the graph. If + *group*, the violins are plotted next to one + another centered around the shared location. If + *overlay*, the violins are plotted over one + another, you might need to set *opacity* to see + them multiple violins. + width + Sets the plot's width (in px). + xaxis + plotly.graph_objs.layout.XAxis instance or dict + with compatible properties + yaxis + plotly.graph_objs.layout.YAxis instance or dict + with compatible properties + frames + The 'frames' property is a tuple of instances of + Frame that may be specified as: + - A list or tuple of instances of plotly.graph_objs.Frame + - A list or tuple of dicts of string/value properties that + will be passed to the Frame constructor + + Supported dict properties: + + baseframe + The name of the frame into which this frame's + properties are merged before applying. This is + used to unify properties and avoid needing to + specify the same values for the same properties + in multiple frames. + data + A list of traces this frame modifies. The + format is identical to the normal trace + definition. + group + An identifier that specifies the group to which + the frame belongs, used by animate to select a + subset of frames. + layout + Layout properties which this frame modifies. + The format is identical to the normal layout + definition. + name + A label by which to identify the frame + traces + A list of trace indices that identify the + respective traces in the data attribute + """ + super(FigureWidget, self).__init__(data, layout, frames) + + def add_area( + self, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + tsrc=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Area trace + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.area.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.area.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.area.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + tsrc + Sets the source reference on plot.ly for t . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Area + """ + new_trace = Area( + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + tsrc=tsrc, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_bar( + self, + base=None, + basesrc=None, + cliponaxis=None, + constraintext=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + legendgroup=None, + marker=None, + name=None, + offset=None, + offsetsrc=None, + opacity=None, + orientation=None, + outsidetextfont=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + width=None, + widthsrc=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Bar trace + + The data visualized by the span of the bars is set in `y` if + `orientation` is set th *v* (the default) and the labels are + set in `x`. By setting `orientation` to *h*, the roles are + interchanged. + + Parameters + ---------- + base + Sets where the bar base is drawn (in position axis + units). In *stack* or *relative* barmode, traces that + set *base* will be excluded and drawn in *overlay* mode + instead. + basesrc + Sets the source reference on plot.ly for base . + cliponaxis + Determines whether the text nodes are clipped about the + subplot axes. To show the text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + constraintext + Constrain the size of text inside or outside a bar to + be no larger than the bar itself. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.bar.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.bar.ErrorY instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.bar.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `text` lying inside the bar. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.bar.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + offset + Shifts the position where the bar is drawn (in position + axis units). In *group* barmode, traces that set + *offset* will be excluded and drawn in *overlay* mode + instead. + offsetsrc + Sets the source reference on plot.ly for offset . + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + outsidetextfont + Sets the font used for `text` lying outside the bar. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.bar.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.bar.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the font used for `text`. + textposition + Specifies the location of the `text`. *inside* + positions `text` inside, next to the bar end (rotated + and scaled if needed). *outside* positions `text` + outside, next to the bar end (scaled if needed). *auto* + positions `text` inside or outside so that `text` size + is maximized. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.bar.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + width + Sets the bar width (in position axis units). + widthsrc + Sets the source reference on plot.ly for width . + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Bar + """ + new_trace = Bar( + base=base, + basesrc=basesrc, + cliponaxis=cliponaxis, + constraintext=constraintext, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + insidetextfont=insidetextfont, + legendgroup=legendgroup, + marker=marker, + name=name, + offset=offset, + offsetsrc=offsetsrc, + opacity=opacity, + orientation=orientation, + outsidetextfont=outsidetextfont, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + tsrc=tsrc, + uid=uid, + unselected=unselected, + visible=visible, + width=width, + widthsrc=widthsrc, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_box( + self, + boxmean=None, + boxpoints=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + name=None, + notched=None, + notchwidth=None, + opacity=None, + orientation=None, + pointpos=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + whiskerwidth=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Box trace + + In vertical (horizontal) box plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + box per distinct x (y) value is drawn If no `x` (`y`) {array} + is provided, a single box is drawn. That box position is then + positioned with with `name` or with `x0` (`y0`) if provided. + Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The + second quartile (Q2) is marked by a line inside the box. By + default, the whiskers correspond to the box' edges +/- 1.5 + times the interquartile range (IQR = Q3-Q1), see *boxpoints* + for other options. + + Parameters + ---------- + boxmean + If *true*, the mean of the box(es)' underlying + distribution is drawn as a dashed line inside the + box(es). If *sd* the standard deviation is also drawn. + boxpoints + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the box(es) are shown with no sample + points + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.box.Hoverlabel instance or dict with + compatible properties + hoveron + Do the hover effects highlight individual boxes or + sample points or both? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the box(es). + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.box.Line instance or dict with + compatible properties + marker + plotly.graph_objs.box.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + notched + Determines whether or not notches should be drawn. + notchwidth + Sets the width of the notches relative to the box' + width. For example, with 0, the notches are as wide as + the box(es). + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the box(es). If *v* (*h*), the + distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the box(es). If *0*, the sample points are places over + the center of the box(es). Positive (negative) values + correspond to positions to the right (left) for + vertical boxes and above (below) for horizontal boxes + selected + plotly.graph_objs.box.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.box.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.box.Unselected instance or dict with + compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Box + """ + new_trace = Box( + boxmean=boxmean, + boxpoints=boxpoints, + customdata=customdata, + customdatasrc=customdatasrc, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + jitter=jitter, + legendgroup=legendgroup, + line=line, + marker=marker, + name=name, + notched=notched, + notchwidth=notchwidth, + opacity=opacity, + orientation=orientation, + pointpos=pointpos, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + whiskerwidth=whiskerwidth, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_candlestick( + self, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + whiskerwidth=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Candlestick trace + + The candlestick is a style of financial chart describing open, + high, low and close for a given `x` coordinate (most likely + time). The boxes represent the spread between the `open` and + `close` values and the lines represent the spread between the + `low` and `high` values Sample points where the close value is + higher (lower) then the open value are called increasing + (decreasing). By default, increasing candles are drawn in green + whereas decreasing are drawn in red. + + Parameters + ---------- + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.candlestick.Decreasing instance or + dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.candlestick.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.candlestick.Increasing instance or + dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.candlestick.Line instance or dict + with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.candlestick.Stream instance or dict + with compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + whiskerwidth + Sets the width of the whiskers relative to the box' + width. For example, with 1, the whiskers are as wide as + the box(es). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Candlestick + """ + new_trace = Candlestick( + close=close, + closesrc=closesrc, + customdata=customdata, + customdatasrc=customdatasrc, + decreasing=decreasing, + high=high, + highsrc=highsrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + increasing=increasing, + legendgroup=legendgroup, + line=line, + low=low, + lowsrc=lowsrc, + name=name, + opacity=opacity, + open=open, + opensrc=opensrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + whiskerwidth=whiskerwidth, + x=x, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_carpet( + self, + a=None, + a0=None, + aaxis=None, + asrc=None, + b=None, + b0=None, + baxis=None, + bsrc=None, + carpet=None, + cheaterslope=None, + color=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + font=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xsrc=None, + y=None, + yaxis=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Carpet trace + + The data describing carpet axis layout is set in `y` and + (optionally) also `x`. If only `y` is present, `x` the plot is + interpreted as a cheater plot and is filled in using the `y` + values. `x` and `y` may either be 2D arrays matching with each + dimension matching that of `a` and `b`, or they may be 1D + arrays with total length equal to that of `a` and `b`. + + Parameters + ---------- + a + An array containing values of the first parameter value + a0 + Alternate to `a`. Builds a linear space of a + coordinates. Use with `da` where `a0` is the starting + coordinate and `da` the step. + aaxis + plotly.graph_objs.carpet.Aaxis instance or dict with + compatible properties + asrc + Sets the source reference on plot.ly for a . + b + A two dimensional array of y coordinates at each carpet + point. + b0 + Alternate to `b`. Builds a linear space of a + coordinates. Use with `db` where `b0` is the starting + coordinate and `db` the step. + baxis + plotly.graph_objs.carpet.Baxis instance or dict with + compatible properties + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + cheaterslope + The shift applied to each successive row of data in + creating a cheater plot. Only used if `x` is been + ommitted. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the a coordinate step. See `a0` for more info. + db + Sets the b coordinate step. See `b0` for more info. + font + The default font used for axis & tick labels on this + carpet + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.carpet.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.carpet.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + A two dimensional array of x coordinates at each carpet + point. If ommitted, the plot is a cheater plot and the + xaxis is hidden by default. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + A two dimensional array of y coordinates at each carpet + point. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Carpet + """ + new_trace = Carpet( + a=a, + a0=a0, + aaxis=aaxis, + asrc=asrc, + b=b, + b0=b0, + baxis=baxis, + bsrc=bsrc, + carpet=carpet, + cheaterslope=cheaterslope, + color=color, + customdata=customdata, + customdatasrc=customdatasrc, + da=da, + db=db, + font=font, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_choropleth( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + locationmode=None, + locations=None, + locationssrc=None, + marker=None, + name=None, + opacity=None, + reversescale=None, + selected=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Choropleth trace + + The data that describes the choropleth value-to-color mapping + is set in `z`. The geographic locations corresponding to each + value in `z` are set in `locations`. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.choropleth.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.choropleth.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. See + `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + marker + plotly.graph_objs.choropleth.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selected + plotly.graph_objs.choropleth.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.choropleth.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each location. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.choropleth.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + z + Sets the color values. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Choropleth + """ + new_trace = Choropleth( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + geo=geo, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + locationmode=locationmode, + locations=locations, + locationssrc=locationssrc, + marker=marker, + name=name, + opacity=opacity, + reversescale=reversescale, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_cone( + self, + anchor=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + sizemode=None, + sizeref=None, + stream=None, + text=None, + textsrc=None, + u=None, + uid=None, + usrc=None, + v=None, + visible=None, + vsrc=None, + w=None, + wsrc=None, + x=None, + xsrc=None, + y=None, + ysrc=None, + z=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Cone trace + + Use cone traces to visualize vector fields. Specify a vector + field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and + 3 vector component arrays `u`, `v`, `w`. The cones are drawn + exactly at the positions given by `x`, `y` and `z`. + + Parameters + ---------- + anchor + Sets the cones' anchor with respect to their x/y/z + positions. Note that *cm* denote the cone's center of + mass which corresponds to 1/4 from the tail to tip. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + colorbar + plotly.graph_objs.cone.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.cone.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.cone.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.cone.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + sizemode + Determines whether `sizeref` is set as a *scaled* (i.e + unitless) scalar (normalized by the max u/v/w norm in + the vector field) or as *absolute* value (in the same + units as the vector field). + sizeref + Adjusts the cone size scaling. The size of the cones is + determined by their u/v/w norm multiplied a factor and + `sizeref`. This factor (computed internally) + corresponds to the minimum "time" to travel across two + successive x/y/z positions at the average velocity of + those two successive positions. All cones in a given + trace use the same factor. With `sizemode` set to + *scaled*, `sizeref` is unitless, its default value is + *0.5* With `sizemode` set to *absolute*, `sizeref` has + the same units as the u/v/w vector field, its the + default value is half the sample's maximum vector norm. + stream + plotly.graph_objs.cone.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the cones. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + u + Sets the x components of the vector field. + uid + + usrc + Sets the source reference on plot.ly for u . + v + Sets the y components of the vector field. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + vsrc + Sets the source reference on plot.ly for v . + w + Sets the z components of the vector field. + wsrc + Sets the source reference on plot.ly for w . + x + Sets the x coordinates of the vector field and of the + displayed cones. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates of the vector field and of the + displayed cones. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates of the vector field and of the + displayed cones. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Cone + """ + new_trace = Cone( + anchor=anchor, + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + sizemode=sizemode, + sizeref=sizeref, + stream=stream, + text=text, + textsrc=textsrc, + u=u, + uid=uid, + usrc=usrc, + v=v, + visible=visible, + vsrc=vsrc, + w=w, + wsrc=wsrc, + x=x, + xsrc=xsrc, + y=y, + ysrc=ysrc, + z=z, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_contour( + self, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + connectgaps=None, + contours=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Contour trace + + The data from which contour lines are computed is set in `z`. + Data in `z` must be a {2D array} of numbers. Say that `z` has N + rows and M columns, then by default, these N rows correspond to + N y coordinates (set in `y` or auto-generated) and the M + columns correspond to M x coordinates (set in `x` or auto- + generated). By setting `transpose` to *true*, the above + behavior is flipped. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.contour.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + contours + plotly.graph_objs.contour.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contour.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contour.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contour.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Contour + """ + new_trace = Contour( + autocolorscale=autocolorscale, + autocontour=autocontour, + colorbar=colorbar, + colorscale=colorscale, + connectgaps=connectgaps, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + name=name, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_contourcarpet( + self, + a=None, + a0=None, + asrc=None, + atype=None, + autocolorscale=None, + autocontour=None, + b=None, + b0=None, + bsrc=None, + btype=None, + carpet=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + da=None, + db=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + name=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + xaxis=None, + yaxis=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Contourcarpet trace + + Plots contours on either the first carpet axis or the carpet + axis with a matching `carpet` attribute. Data `z` is + interpreted as matching that of the corresponding carpet axis. + + Parameters + ---------- + a + Sets the x coordinates. + a0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + asrc + Sets the source reference on plot.ly for a . + atype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + b + Sets the y coordinates. + b0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + bsrc + Sets the source reference on plot.ly for b . + btype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + carpet + The `carpet` of the carpet axes on which this contour + trace lies + colorbar + plotly.graph_objs.contourcarpet.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.contourcarpet.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + da + Sets the x coordinate step. See `x0` for more info. + db + Sets the y coordinate step. See `y0` for more info. + fillcolor + Sets the fill color if `contours.type` is *constraint*. + Defaults to a half-transparent variant of the line + color, marker color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.contourcarpet.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.contourcarpet.Line instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.contourcarpet.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Contourcarpet + """ + new_trace = Contourcarpet( + a=a, + a0=a0, + asrc=asrc, + atype=atype, + autocolorscale=autocolorscale, + autocontour=autocontour, + b=b, + b0=b0, + bsrc=bsrc, + btype=btype, + carpet=carpet, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + da=da, + db=db, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + name=name, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + xaxis=xaxis, + yaxis=yaxis, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_heatmap( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xgap=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ygap=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Heatmap trace + + The data that describes the heatmap value-to-color mapping is + set in `z`. Data in `z` can either be a {2D array} of values + (ragged or not) or a 1D array of values. In the case where `z` + is a {2D array}, say that `z` has N rows and M columns. Then, + by default, the resulting heatmap will have N partitions along + the y axis and M partitions along the x axis. In other words, + the i-th row/ j-th column cell in `z` is mapped to the i-th + partition of the y axis (starting from the bottom of the plot) + and the j-th partition of the x-axis (starting from the left of + the plot). This behavior can be flipped by using `transpose`. + Moreover, `x` (`y`) can be provided with M or M+1 (N or N+1) + elements. If M (N), then the coordinates correspond to the + center of the heatmap cells and the cells have equal width. If + M+1 (N+1), then the coordinates correspond to the edges of the + heatmap cells. In the case where `z` is a 1D {array}, the x and + y coordinates must be provided in `x` and `y` respectively to + form data triplets. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmap.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmap.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmap.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Heatmap + """ + new_trace = Heatmap( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xgap=xgap, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ygap=ygap, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsmooth=zsmooth, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_heatmapgl( + self, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Heatmapgl trace + + WebGL version of the heatmap trace type. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmapgl.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmapgl.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmapgl.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Heatmapgl + """ + new_trace = Heatmapgl( + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + transpose=transpose, + uid=uid, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xsrc=xsrc, + xtype=xtype, + y=y, + y0=y0, + yaxis=yaxis, + ysrc=ysrc, + ytype=ytype, + z=z, + zauto=zauto, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram( + self, + autobinx=None, + autobiny=None, + cumulative=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + orientation=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram trace + + The sample data from which statistics are computed is set in + `x` for vertically spanning histograms and in `y` for + horizontally spanning histograms. Binning options are set + `xbins` and `ybins` respectively if no aggregation data is + provided. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + cumulative + plotly.graph_objs.histogram.Cumulative instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.histogram.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.histogram.ErrorY instance or dict + with compatible properties + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + selected + plotly.graph_objs.histogram.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.histogram.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.histogram.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram.XBins instance or dict with + compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram.YBins instance or dict with + compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram + """ + new_trace = Histogram( + autobinx=autobinx, + autobiny=autobiny, + cumulative=cumulative, + customdata=customdata, + customdatasrc=customdatasrc, + error_x=error_x, + error_y=error_y, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + opacity=opacity, + orientation=orientation, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram2d( + self, + autobinx=None, + autobiny=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xgap=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ygap=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram2d trace + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a heatmap. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.histogram2d.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2d.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram2d.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2d.Stream instance or dict + with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2d.XBins instance or dict + with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2d.YBins instance or dict + with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram2d + """ + new_trace = Histogram2d( + autobinx=autobinx, + autobiny=autobiny, + autocolorscale=autocolorscale, + colorbar=colorbar, + colorscale=colorscale, + customdata=customdata, + customdatasrc=customdatasrc, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xgap=xgap, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ygap=ygap, + ysrc=ysrc, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsmooth=zsmooth, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_histogram2dcontour( + self, + autobinx=None, + autobiny=None, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Histogram2dContour trace + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a contour plot. + + Parameters + ---------- + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.histogram2dcontour.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.histogram2dcontour.Contours instance + or dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2dcontour.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.histogram2dcontour.Line instance or + dict with compatible properties + marker + plotly.graph_objs.histogram2dcontour.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2dcontour.Stream instance or + dict with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2dcontour.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2dcontour.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Histogram2dContour + """ + new_trace = Histogram2dContour( + autobinx=autobinx, + autobiny=autobiny, + autocolorscale=autocolorscale, + autocontour=autocontour, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + histfunc=histfunc, + histnorm=histnorm, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + name=name, + nbinsx=nbinsx, + nbinsy=nbinsy, + ncontours=ncontours, + opacity=opacity, + reversescale=reversescale, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbins=xbins, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + yaxis=yaxis, + ybins=ybins, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zauto=zauto, + zhoverformat=zhoverformat, + zmax=zmax, + zmin=zmin, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_mesh3d( + self, + alphahull=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + contour=None, + customdata=None, + customdatasrc=None, + delaunayaxis=None, + facecolor=None, + facecolorsrc=None, + flatshading=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + i=None, + ids=None, + idssrc=None, + intensity=None, + intensitysrc=None, + isrc=None, + j=None, + jsrc=None, + k=None, + ksrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + vertexcolor=None, + vertexcolorsrc=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Mesh3d trace + + Draws sets of triangles with coordinates given by three + 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, + `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha- + shape algorithm or (4) the Convex-hull algorithm + + Parameters + ---------- + alphahull + Determines how the mesh surface triangles are derived + from the set of vertices (points) represented by the + `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays + are not supplied. For general use of `mesh3d` it is + preferred that `i`, `j`, `k` are supplied. If *-1*, + Delaunay triangulation is used, which is mainly + suitable if the mesh is a single, more or less layer + surface that is perpendicular to `delaunayaxis`. In + case the `delaunayaxis` intersects the mesh surface at + more than one point it will result triangles that are + very long in the dimension of `delaunayaxis`. If *>0*, + the alpha-shape algorithm is used. In this case, the + positive `alphahull` value signals the use of the + alpha-shape algorithm, _and_ its value acts as the + parameter for the mesh fitting. If *0*, the convex- + hull algorithm is used. It is suitable for convex + bodies or if the intention is to enclose the `x`, `y` + and `z` point set into a convex hull. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color of the whole mesh + colorbar + plotly.graph_objs.mesh3d.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + contour + plotly.graph_objs.mesh3d.Contour instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + delaunayaxis + Sets the Delaunay axis, which is the axis that is + perpendicular to the surface of the Delaunay + triangulation. It has an effect if `i`, `j`, `k` are + not provided and `alphahull` is set to indicate + Delaunay triangulation. + facecolor + Sets the color of each face Overrides *color* and + *vertexcolor*. + facecolorsrc + Sets the source reference on plot.ly for facecolor . + flatshading + Determines whether or not normal smoothing is applied + to the meshes, creating meshes with an angular, low- + poly look via flat reflections. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.mesh3d.Hoverlabel instance or dict + with compatible properties + i + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *first* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `i[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `i` represents a point in space, which + is the first vertex of a triangle. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + intensity + Sets the vertex intensity values, used for plotting + fields on meshes + intensitysrc + Sets the source reference on plot.ly for intensity . + isrc + Sets the source reference on plot.ly for i . + j + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *second* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `j[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `j` represents a point in space, which + is the second vertex of a triangle. + jsrc + Sets the source reference on plot.ly for j . + k + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *third* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `k[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `k` represents a point in space, which + is the third vertex of a triangle. + ksrc + Sets the source reference on plot.ly for k . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.mesh3d.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.mesh3d.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.mesh3d.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the vertices. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + vertexcolor + Sets the color of each vertex Overrides *color*. + vertexcolorsrc + Sets the source reference on plot.ly for vertexcolor . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the X coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the Y coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the Z coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Mesh3d + """ + new_trace = Mesh3d( + alphahull=alphahull, + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + color=color, + colorbar=colorbar, + colorscale=colorscale, + contour=contour, + customdata=customdata, + customdatasrc=customdatasrc, + delaunayaxis=delaunayaxis, + facecolor=facecolor, + facecolorsrc=facecolorsrc, + flatshading=flatshading, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + i=i, + ids=ids, + idssrc=idssrc, + intensity=intensity, + intensitysrc=intensitysrc, + isrc=isrc, + j=j, + jsrc=jsrc, + k=k, + ksrc=ksrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + vertexcolor=vertexcolor, + vertexcolorsrc=vertexcolorsrc, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_ohlc( + self, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + tickwidth=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Ohlc trace + + The ohlc (short for Open-High-Low-Close) is a style of + financial chart describing open, high, low and close for a + given `x` coordinate (most likely time). The tip of the lines + represent the `low` and `high` values and the horizontal + segments represent the `open` and `close` values. Sample points + where the close value is higher (lower) then the open value are + called increasing (decreasing). By default, increasing items + are drawn in green whereas decreasing are drawn in red. + + Parameters + ---------- + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.ohlc.Decreasing instance or dict with + compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.ohlc.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.ohlc.Increasing instance or dict with + compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.ohlc.Line instance or dict with + compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.ohlc.Stream instance or dict with + compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + tickwidth + Sets the width of the open/close tick marks relative to + the *x* minimal interval. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Ohlc + """ + new_trace = Ohlc( + close=close, + closesrc=closesrc, + customdata=customdata, + customdatasrc=customdatasrc, + decreasing=decreasing, + high=high, + highsrc=highsrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + increasing=increasing, + legendgroup=legendgroup, + line=line, + low=low, + lowsrc=lowsrc, + name=name, + opacity=opacity, + open=open, + opensrc=opensrc, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + tickwidth=tickwidth, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_parcoords( + self, + customdata=None, + customdatasrc=None, + dimensions=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + labelfont=None, + legendgroup=None, + line=None, + name=None, + opacity=None, + rangefont=None, + selectedpoints=None, + showlegend=None, + stream=None, + tickfont=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Parcoords trace + + Parallel coordinates for multidimensional exploratory data + analysis. The samples are specified in `dimensions`. The colors + are set in `line.color`. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dimensions + The dimensions (variables) of the parallel coordinates + chart. 2..60 dimensions are supported. + domain + plotly.graph_objs.parcoords.Domain instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.parcoords.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + labelfont + Sets the font for the `dimension` labels. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.parcoords.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + rangefont + Sets the font for the `dimension` range values. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.parcoords.Stream instance or dict + with compatible properties + tickfont + Sets the font for the `dimension` tick values. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Parcoords + """ + new_trace = Parcoords( + customdata=customdata, + customdatasrc=customdatasrc, + dimensions=dimensions, + domain=domain, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + labelfont=labelfont, + legendgroup=legendgroup, + line=line, + name=name, + opacity=opacity, + rangefont=rangefont, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + tickfont=tickfont, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_pie( + self, + customdata=None, + customdatasrc=None, + direction=None, + dlabel=None, + domain=None, + hole=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + label0=None, + labels=None, + labelssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + outsidetextfont=None, + pull=None, + pullsrc=None, + rotation=None, + scalegroup=None, + selectedpoints=None, + showlegend=None, + sort=None, + stream=None, + text=None, + textfont=None, + textinfo=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + values=None, + valuessrc=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Pie trace + + A data visualized by the sectors of the pie is set in `values`. + The sector labels are set in `labels`. The sector colors are + set in `marker.colors` + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + direction + Specifies the direction at which succeeding sectors + follow one another. + dlabel + Sets the label step. See `label0` for more info. + domain + plotly.graph_objs.pie.Domain instance or dict with + compatible properties + hole + Sets the fraction of the radius to cut out of the pie. + Use this to make a donut chart. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pie.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each sector. + If a single string, the same string appears for all + data points. If an array of string, the items are + mapped in order of this trace's sectors. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `textinfo` lying inside the pie. + label0 + Alternate to `labels`. Builds a numeric set of labels. + Use with `dlabel` where `label0` is the starting label + and `dlabel` the step. + labels + Sets the sector labels. If `labels` entries are + duplicated, we sum associated `values` or simply count + occurrences if `values` is not provided. For other + array attributes (including color) we use the first + non-empty entry among all occurrences of the label. + labelssrc + Sets the source reference on plot.ly for labels . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pie.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + outsidetextfont + Sets the font used for `textinfo` lying outside the + pie. + pull + Sets the fraction of larger radius to pull the sectors + out from the center. This can be a constant to pull all + slices apart from each other equally or an array to + highlight one or more slices. + pullsrc + Sets the source reference on plot.ly for pull . + rotation + Instead of the first slice starting at 12 o'clock, + rotate to some other angle. + scalegroup + If there are multiple pies that should be sized + according to their totals, link them by providing a + non-empty group id here shared by every trace in the + same group. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + sort + Determines whether or not the sectors are reordered + from largest to smallest. + stream + plotly.graph_objs.pie.Stream instance or dict with + compatible properties + text + Sets text elements associated with each sector. If + trace `textinfo` contains a *text* flag, these elements + will seen on the chart. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textfont + Sets the font used for `textinfo`. + textinfo + Determines which trace information appear on the graph. + textposition + Specifies the location of the `textinfo`. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + values + Sets the values of the sectors of this pie chart. If + omitted, we count occurrences of each label. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Pie + """ + new_trace = Pie( + customdata=customdata, + customdatasrc=customdatasrc, + direction=direction, + dlabel=dlabel, + domain=domain, + hole=hole, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + insidetextfont=insidetextfont, + label0=label0, + labels=labels, + labelssrc=labelssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + outsidetextfont=outsidetextfont, + pull=pull, + pullsrc=pullsrc, + rotation=rotation, + scalegroup=scalegroup, + selectedpoints=selectedpoints, + showlegend=showlegend, + sort=sort, + stream=stream, + text=text, + textfont=textfont, + textinfo=textinfo, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + values=values, + valuessrc=valuessrc, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_pointcloud( + self, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + indices=None, + indicessrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbounds=None, + xboundssrc=None, + xsrc=None, + xy=None, + xysrc=None, + y=None, + yaxis=None, + ybounds=None, + yboundssrc=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Pointcloud trace + + The data visualized as a point cloud set in `x` and `y` using + the WebGl plotting engine. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pointcloud.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + indices + A sequential value, 0..n, supply it to avoid creating + this array inside plotting. If specified, it must be a + typed `Int32Array` array. Its length must be equal to + or greater than the number of points. For the best + performance and memory use, create one large `indices` + typed array that is guaranteed to be at least as long + as the largest number of points during use, and reuse + it on each `Plotly.restyle()` call. + indicessrc + Sets the source reference on plot.ly for indices . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pointcloud.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.pointcloud.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbounds + Specify `xbounds` in the shape of `[xMin, xMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `ybounds` for the performance + benefits. + xboundssrc + Sets the source reference on plot.ly for xbounds . + xsrc + Sets the source reference on plot.ly for x . + xy + Faster alternative to specifying `x` and `y` + separately. If supplied, it must be a typed + `Float32Array` array that represents points such that + `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]` + xysrc + Sets the source reference on plot.ly for xy . + y + Sets the y coordinates. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybounds + Specify `ybounds` in the shape of `[yMin, yMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `xbounds` for the performance + benefits. + yboundssrc + Sets the source reference on plot.ly for ybounds . + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Pointcloud + """ + new_trace = Pointcloud( + customdata=customdata, + customdatasrc=customdatasrc, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + indices=indices, + indicessrc=indicessrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xaxis=xaxis, + xbounds=xbounds, + xboundssrc=xboundssrc, + xsrc=xsrc, + xy=xy, + xysrc=xysrc, + y=y, + yaxis=yaxis, + ybounds=ybounds, + yboundssrc=yboundssrc, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_sankey( + self, + arrangement=None, + customdata=None, + customdatasrc=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + link=None, + name=None, + node=None, + opacity=None, + orientation=None, + selectedpoints=None, + showlegend=None, + stream=None, + textfont=None, + uid=None, + valueformat=None, + valuesuffix=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Sankey trace + + Sankey plots for network flow data analysis. The nodes are + specified in `nodes` and the links between sources and targets + in `links`. The colors are set in `nodes[i].color` and + `links[i].color`; otherwise defaults are used. + + Parameters + ---------- + arrangement + If value is `snap` (the default), the node arrangement + is assisted by automatic snapping of elements to + preserve space between nodes specified via `nodepad`. + If value is `perpendicular`, the nodes can only move + along a line perpendicular to the flow. If value is + `freeform`, the nodes can freely move on the plane. If + value is `fixed`, the nodes are stationary. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.sankey.Domain instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.sankey.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + link + The links of the Sankey plot. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + node + The nodes of the Sankey plot. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the Sankey diagram. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.sankey.Stream instance or dict with + compatible properties + textfont + Sets the font for node labels + uid + + valueformat + Sets the value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + valuesuffix + Adds a unit to follow the value in the hover tooltip. + Add a space if a separation is necessary from the + value. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Sankey + """ + new_trace = Sankey( + arrangement=arrangement, + customdata=customdata, + customdatasrc=customdatasrc, + domain=domain, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + link=link, + name=name, + node=node, + opacity=opacity, + orientation=orientation, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + textfont=textfont, + uid=uid, + valueformat=valueformat, + valuesuffix=valuesuffix, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatter( + self, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatter trace + + The scatter trace type encompasses line charts, scatter charts, + text charts, and bubble charts. The data visualized as scatter + point or lines is set in `x` and `y`. Text (appearing either on + the chart or on hover only) is via `text`. Bubble charts are + achieved by setting `marker.size` and/or `marker.color` to + numerical arrays. + + Parameters + ---------- + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scatter.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.scatter.ErrorY instance or dict with + compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter.Marker instance or dict with + compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatter.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.scatter.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatter + """ + new_trace = Scatter( + cliponaxis=cliponaxis, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + t=t, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + tsrc=tsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatter3d( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + error_z=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + projection=None, + scene=None, + selectedpoints=None, + showlegend=None, + stream=None, + surfaceaxis=None, + surfacecolor=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatter3d trace + + The data visualized as scatter point or lines in 3D dimension + is set in `x`, `y`, `z`. Text (appearing either on the chart or + on hover only) is via `text`. Bubble charts are achieved by + setting `marker.size` and/or `marker.color` Projections are + achieved via `projection`. Surface fills are achieved via + `surfaceaxis`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.scatter3d.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scatter3d.ErrorY instance or dict + with compatible properties + error_z + plotly.graph_objs.scatter3d.ErrorZ instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter3d.Hoverlabel instance or dict + with compatible properties + hovertext + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter3d.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter3d.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + projection + plotly.graph_objs.scatter3d.Projection instance or dict + with compatible properties + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter3d.Stream instance or dict + with compatible properties + surfaceaxis + If *-1*, the scatter points are not fill with a surface + If *0*, *1*, *2*, the scatter points are filled with a + Delaunay surface about the x, y, z respectively. + surfacecolor + Sets the surface fill color. + text + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatter3d + """ + new_trace = Scatter3d( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + error_x=error_x, + error_y=error_y, + error_z=error_z, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + projection=projection, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + surfaceaxis=surfaceaxis, + surfacecolor=surfacecolor, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattercarpet( + self, + a=None, + asrc=None, + b=None, + bsrc=None, + carpet=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxis=None, + yaxis=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattercarpet trace + + Plots a scatter trace on either the first carpet axis or the + carpet axis with a matching `carpet` attribute. + + Parameters + ---------- + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattercarpet.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattercarpet.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scattercarpet.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattercarpet.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattercarpet.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattercarpet.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattercarpet + """ + new_trace = Scattercarpet( + a=a, + asrc=asrc, + b=b, + bsrc=bsrc, + carpet=carpet, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + xaxis=xaxis, + yaxis=yaxis, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattergeo( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + locationmode=None, + locations=None, + locationssrc=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattergeo trace + + The data visualized as scatter point or lines on a geographic + map is provided either by longitude/latitude pairs in `lon` and + `lat` respectively or by geographic location IDs or names in + `locations`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergeo.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair or item in `locations`. If a single string, the + same string appears over all the data points. If an + array of string, the items are mapped in order to the + this trace's (lon,lat) or `locations` coordinates. To + be seen, trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergeo.Line instance or dict with + compatible properties + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + Coordinates correspond to the centroid of each location + given. See `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattergeo.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergeo.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergeo.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (lon,lat) pair + or item in `locations`. If a single string, the same + string appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (lon,lat) or `locations` coordinates. If trace + `hoverinfo` contains a *text* flag and *hovertext* is + not set, these elements will be seen in the hover + labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergeo.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattergeo + """ + new_trace = Scattergeo( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + geo=geo, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + lat=lat, + latsrc=latsrc, + legendgroup=legendgroup, + line=line, + locationmode=locationmode, + locations=locations, + locationssrc=locationssrc, + lon=lon, + lonsrc=lonsrc, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattergl( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattergl trace + + The data visualized as scatter point or lines is set in `x` and + `y` using the WebGL plotting engine. Bubble charts are achieved + by setting `marker.size` and/or `marker.color` to a numerical + arrays. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scattergl.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scattergl.ErrorY instance or dict + with compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergl.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergl.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scattergl.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergl.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergl.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergl.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattergl + """ + new_trace = Scattergl( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + dx=dx, + dy=dy, + error_x=error_x, + error_y=error_y, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ycalendar=ycalendar, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scattermapbox( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scattermapbox trace + + The data visualized as scatter point, lines or marker symbols + on a Mapbox GL geographic map is provided by longitude/latitude + pairs in `lon` and `lat`. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattermapbox.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (lon,lat) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattermapbox.Line instance or dict + with compatible properties + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattermapbox.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattermapbox.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattermapbox.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a mapbox subplot. If *mapbox* (the default value), + the data refer to `layout.mapbox`. If *mapbox2*, the + data refer to `layout.mapbox2`, and so on. + text + Sets text elements associated with each (lon,lat) pair + If a single string, the same string appears over all + the data points. If an array of string, the items are + mapped in order to the this trace's (lon,lat) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattermapbox.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scattermapbox + """ + new_trace = Scattermapbox( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + lat=lat, + latsrc=latsrc, + legendgroup=legendgroup, + line=line, + lon=lon, + lonsrc=lonsrc, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textfont=textfont, + textposition=textposition, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterpolar( + self, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterpolar trace + + The scatterpolar trace type encompasses line charts, scatter + charts, text charts, and bubble charts in polar coordinates. + The data visualized as scatter point or lines is set in `r` + (radial) and `theta` (angular) coordinates Text (appearing + either on the chart or on hover only) is via `text`. Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterpolar has a subset of + the options available to scatter. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolar.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolar.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolar.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolar.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolar.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolar.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterpolar + """ + new_trace = Scatterpolar( + cliponaxis=cliponaxis, + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + theta=theta, + thetasrc=thetasrc, + thetaunit=thetaunit, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterpolargl( + self, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterpolargl trace + + The scatterpolargl trace type encompasses line charts, scatter + charts, and bubble charts in polar coordinates using the WebGL + plotting engine. The data visualized as scatter point or lines + is set in `r` (radial) and `theta` (angular) coordinates Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolargl.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolargl.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolargl.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolargl.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolargl.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolargl.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterpolargl + """ + new_trace = Scatterpolargl( + connectgaps=connectgaps, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + r=r, + rsrc=rsrc, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + text=text, + textsrc=textsrc, + theta=theta, + thetasrc=thetasrc, + thetaunit=thetaunit, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_scatterternary( + self, + a=None, + asrc=None, + b=None, + bsrc=None, + c=None, + cliponaxis=None, + connectgaps=None, + csrc=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + sum=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Scatterternary trace + + Provides similar functionality to the *scatter* type but on a + ternary phase diagram. The data is provided by at least two + arrays out of `a`, `b`, `c` triplets. + + Parameters + ---------- + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + c + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + csrc + Sets the source reference on plot.ly for c . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterternary.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (a,b,c) + point. If a single string, the same string appears over + all the data points. If an array of strings, the items + are mapped in order to the the data points in (a,b,c). + To be seen, trace `hoverinfo` must contain a *text* + flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterternary.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterternary.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scatterternary.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterternary.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a ternary subplot. If *ternary* (the default + value), the data refer to `layout.ternary`. If + *ternary2*, the data refer to `layout.ternary2`, and so + on. + sum + The number each triplet should sum to, if only two of + `a`, `b`, and `c` are provided. This overrides + `ternary.sum` to normalize this specific trace, but + does not affect the values displayed on the axes. 0 (or + missing) means to use ternary.sum + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scatterternary.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Scatterternary + """ + new_trace = Scatterternary( + a=a, + asrc=asrc, + b=b, + bsrc=bsrc, + c=c, + cliponaxis=cliponaxis, + connectgaps=connectgaps, + csrc=csrc, + customdata=customdata, + customdatasrc=customdatasrc, + fill=fill, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + hovertext=hovertext, + hovertextsrc=hovertextsrc, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + line=line, + marker=marker, + mode=mode, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + subplot=subplot, + sum=sum, + text=text, + textfont=textfont, + textposition=textposition, + textpositionsrc=textpositionsrc, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_splom( + self, + customdata=None, + customdatasrc=None, + diagonal=None, + dimensions=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + showlowerhalf=None, + showupperhalf=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxes=None, + yaxes=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Splom trace + + Splom traces generate scatter plot matrix visualizations. Each + splom `dimensions` items correspond to a generated axis. Values + for each of those dimensions are set in `dimensions[i].values`. + Splom traces support all `scattergl` marker style attributes. + Specify `layout.grid` attributes and/or layout x-axis and + y-axis attributes for more control over the axis positioning + and style. + + Parameters + ---------- + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + diagonal + plotly.graph_objs.splom.Diagonal instance or dict with + compatible properties + dimensions + plotly.graph_objs.splom.Dimension instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.splom.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.splom.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.splom.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showlowerhalf + Determines whether or not subplots on the lower half + from the diagonal are displayed. + showupperhalf + Determines whether or not subplots on the upper half + from the diagonal are displayed. + stream + plotly.graph_objs.splom.Stream instance or dict with + compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.splom.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxes + Sets the list of x axes corresponding to this splom + trace. By default, a splom will match the first N xaxes + where N is the number of input dimensions. + yaxes + Sets the list of y axes corresponding to this splom + trace. By default, a splom will match the first N yaxes + where N is the number of input dimensions. + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Splom + """ + new_trace = Splom( + customdata=customdata, + customdatasrc=customdatasrc, + diagonal=diagonal, + dimensions=dimensions, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + marker=marker, + name=name, + opacity=opacity, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + showlowerhalf=showlowerhalf, + showupperhalf=showupperhalf, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + xaxes=xaxes, + yaxes=yaxes, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_surface( + self, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + hidesurface=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + surfacecolor=None, + surfacecolorsrc=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Surface trace + + The data the describes the coordinates of the surface is set in + `z`. Data in `z` should be a {2D array}. Coordinates in `x` and + `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph + parametric surfaces). If not provided in `x` and `y`, the x and + y coordinates are assumed to be linear starting at 0 with a + unit step. The color scale corresponds to the `z` values by + default. For custom color scales, use `surfacecolor` which + should be a {2D array}, where its bounds can be controlled + using `cmin` and `cmax`. + + Parameters + ---------- + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + cauto + Determines the whether or not the color domain is + computed with respect to the input data. + cmax + Sets the upper bound of color domain. + cmin + Sets the lower bound of color domain. + colorbar + plotly.graph_objs.surface.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.surface.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hidesurface + Determines whether or not a surface is drawn. For + example, set `hidesurface` to *false* `contours.x.show` + to *true* and `contours.y.show` to *true* to draw a + wire frame plot. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.surface.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.surface.Lighting instance or dict + with compatible properties + lightposition + plotly.graph_objs.surface.Lightposition instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Reverses the colorscale. + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.surface.Stream instance or dict with + compatible properties + surfacecolor + Sets the surface color values, used for setting a color + scale independent of `z`. + surfacecolorsrc + Sets the source reference on plot.ly for surfacecolor + . + text + Sets the text elements associated with each z value. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Surface + """ + new_trace = Surface( + autocolorscale=autocolorscale, + cauto=cauto, + cmax=cmax, + cmin=cmin, + colorbar=colorbar, + colorscale=colorscale, + contours=contours, + customdata=customdata, + customdatasrc=customdatasrc, + hidesurface=hidesurface, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + lighting=lighting, + lightposition=lightposition, + name=name, + opacity=opacity, + reversescale=reversescale, + scene=scene, + selectedpoints=selectedpoints, + showlegend=showlegend, + showscale=showscale, + stream=stream, + surfacecolor=surfacecolor, + surfacecolorsrc=surfacecolorsrc, + text=text, + textsrc=textsrc, + uid=uid, + visible=visible, + x=x, + xcalendar=xcalendar, + xsrc=xsrc, + y=y, + ycalendar=ycalendar, + ysrc=ysrc, + z=z, + zcalendar=zcalendar, + zsrc=zsrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_table( + self, + cells=None, + columnorder=None, + columnordersrc=None, + columnwidth=None, + columnwidthsrc=None, + customdata=None, + customdatasrc=None, + domain=None, + header=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Table trace + + Table view for detailed data viewing. The data are arranged in + a grid of rows and columns. Most styling can be specified for + columns, rows or individual cells. Table is using a column- + major order, ie. the grid is represented as a vector of column + vectors. + + Parameters + ---------- + cells + plotly.graph_objs.table.Cells instance or dict with + compatible properties + columnorder + Specifies the rendered order of the data columns; for + example, a value `2` at position `0` means that column + index `0` in the data will be rendered as the third + column, as columns have an index base of zero. + columnordersrc + Sets the source reference on plot.ly for columnorder . + columnwidth + The width of columns expressed as a ratio. Columns fill + the available width in proportion of their specified + column widths. + columnwidthsrc + Sets the source reference on plot.ly for columnwidth . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.table.Domain instance or dict with + compatible properties + header + plotly.graph_objs.table.Header instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.table.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.table.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Table + """ + new_trace = Table( + cells=cells, + columnorder=columnorder, + columnordersrc=columnordersrc, + columnwidth=columnwidth, + columnwidthsrc=columnwidthsrc, + customdata=customdata, + customdatasrc=customdatasrc, + domain=domain, + header=header, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + ids=ids, + idssrc=idssrc, + legendgroup=legendgroup, + name=name, + opacity=opacity, + selectedpoints=selectedpoints, + showlegend=showlegend, + stream=stream, + uid=uid, + visible=visible, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) + + def add_violin( + self, + bandwidth=None, + box=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + meanline=None, + name=None, + opacity=None, + orientation=None, + pointpos=None, + points=None, + scalegroup=None, + scalemode=None, + selected=None, + selectedpoints=None, + showlegend=None, + side=None, + span=None, + spanmode=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + row=None, + col=None, + **kwargs + ): + """ + Add a new Violin trace + + In vertical (horizontal) violin plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + violin per distinct x (y) value is drawn If no `x` (`y`) + {array} is provided, a single violin is drawn. That violin + position is then positioned with with `name` or with `x0` + (`y0`) if provided. + + Parameters + ---------- + bandwidth + Sets the bandwidth used to compute the kernel density + estimate. By default, the bandwidth is determined by + Silverman's rule of thumb. + box + plotly.graph_objs.violin.Box instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.violin.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual violins or + sample points or the kernel density estimate or any + combination of them? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the violins. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.violin.Line instance or dict with + compatible properties + marker + plotly.graph_objs.violin.Marker instance or dict with + compatible properties + meanline + plotly.graph_objs.violin.Meanline instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the violin(s). If *v* (*h*), + the distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the violins. If *0*, the sample points are places over + the center of the violins. Positive (negative) values + correspond to positions to the right (left) for + vertical violins and above (below) for horizontal + violins. + points + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the violins are shown with no sample + points + scalegroup + If there are multiple violins that should be sized + according to to some metric (see `scalemode`), link + them by providing a non-empty group id here shared by + every trace in the same group. + scalemode + Sets the metric by which the width of each violin is + determined.*width* means each violin has the same (max) + width*count* means the violins are scaled by the number + of sample points makingup each violin. + selected + plotly.graph_objs.violin.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + side + Determines on which side of the position value the + density function making up one half of a violin is + plotted. Useful when comparing two violin traces under + *overlay* mode, where one trace has `side` set to + *positive* and the other to *negative*. + span + Sets the span in data space for which the density + function will be computed. Has an effect only when + `spanmode` is set to *manual*. + spanmode + Sets the method by which the span in data space where + the density function will be computed. *soft* means the + span goes from the sample's minimum value minus two + bandwidths to the sample's maximum value plus two + bandwidths. *hard* means the span goes from the + sample's minimum to its maximum value. For custom span + settings, use mode *manual* and fill in the `span` + attribute. + stream + plotly.graph_objs.violin.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.violin.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + row : int or None (default) + Subplot row index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + col : int or None (default) + Subplot col index (starting from 1) for the trace to be + added. Only valid if figure was created using + `plotly.tools.make_subplots` + + Returns + ------- + Violin + """ + new_trace = Violin( + bandwidth=bandwidth, + box=box, + customdata=customdata, + customdatasrc=customdatasrc, + fillcolor=fillcolor, + hoverinfo=hoverinfo, + hoverinfosrc=hoverinfosrc, + hoverlabel=hoverlabel, + hoveron=hoveron, + ids=ids, + idssrc=idssrc, + jitter=jitter, + legendgroup=legendgroup, + line=line, + marker=marker, + meanline=meanline, + name=name, + opacity=opacity, + orientation=orientation, + pointpos=pointpos, + points=points, + scalegroup=scalegroup, + scalemode=scalemode, + selected=selected, + selectedpoints=selectedpoints, + showlegend=showlegend, + side=side, + span=span, + spanmode=spanmode, + stream=stream, + text=text, + textsrc=textsrc, + uid=uid, + unselected=unselected, + visible=visible, + x=x, + x0=x0, + xaxis=xaxis, + xsrc=xsrc, + y=y, + y0=y0, + yaxis=yaxis, + ysrc=ysrc, + **kwargs + ) + return self.add_trace(new_trace, row=row, col=col) diff --git a/plotly/graph_objs/_frame.py b/plotly/graph_objs/_frame.py new file mode 100644 index 0000000000..717fe6f6d0 --- /dev/null +++ b/plotly/graph_objs/_frame.py @@ -0,0 +1,255 @@ +from plotly.basedatatypes import BaseFrameHierarchyType +import copy + + +class Frame(BaseFrameHierarchyType): + + # baseframe + # --------- + @property + def baseframe(self): + """ + The name of the frame into which this frame's properties are + merged before applying. This is used to unify properties and + avoid needing to specify the same values for the same + properties in multiple frames. + + The 'baseframe' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['baseframe'] + + @baseframe.setter + def baseframe(self, val): + self['baseframe'] = val + + # data + # ---- + @property + def data(self): + """ + A list of traces this frame modifies. The format is identical + to the normal trace definition. + + Returns + ------- + Any + """ + return self['data'] + + @data.setter + def data(self, val): + self['data'] = val + + # group + # ----- + @property + def group(self): + """ + An identifier that specifies the group to which the frame + belongs, used by animate to select a subset of frames. + + The 'group' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['group'] + + @group.setter + def group(self, val): + self['group'] = val + + # layout + # ------ + @property + def layout(self): + """ + Layout properties which this frame modifies. The format is + identical to the normal layout definition. + + Returns + ------- + Any + """ + return self['layout'] + + @layout.setter + def layout(self, val): + self['layout'] = val + + # name + # ---- + @property + def name(self): + """ + A label by which to identify the frame + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # traces + # ------ + @property + def traces(self): + """ + A list of trace indices that identify the respective traces in + the data attribute + + The 'traces' property accepts values of any type + + Returns + ------- + Any + """ + return self['traces'] + + @traces.setter + def traces(self, val): + self['traces'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + baseframe + The name of the frame into which this frame's + properties are merged before applying. This is used to + unify properties and avoid needing to specify the same + values for the same properties in multiple frames. + data + A list of traces this frame modifies. The format is + identical to the normal trace definition. + group + An identifier that specifies the group to which the + frame belongs, used by animate to select a subset of + frames. + layout + Layout properties which this frame modifies. The format + is identical to the normal layout definition. + name + A label by which to identify the frame + traces + A list of trace indices that identify the respective + traces in the data attribute + """ + + def __init__( + self, + arg=None, + baseframe=None, + data=None, + group=None, + layout=None, + name=None, + traces=None, + **kwargs + ): + """ + Construct a new Frame object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Frame + baseframe + The name of the frame into which this frame's + properties are merged before applying. This is used to + unify properties and avoid needing to specify the same + values for the same properties in multiple frames. + data + A list of traces this frame modifies. The format is + identical to the normal trace definition. + group + An identifier that specifies the group to which the + frame belongs, used by animate to select a subset of + frames. + layout + Layout properties which this frame modifies. The format + is identical to the normal layout definition. + name + A label by which to identify the frame + traces + A list of trace indices that identify the respective + traces in the data attribute + + Returns + ------- + Frame + """ + super(Frame, self).__init__('frames') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Frame +constructor must be a dict or +an instance of plotly.graph_objs.Frame""" + ) + + # Import validators + # ----------------- + from plotly.validators import (frame as v_frame) + + # Initialize validators + # --------------------- + self._validators['baseframe'] = v_frame.BaseframeValidator() + self._validators['data'] = v_frame.DataValidator() + self._validators['group'] = v_frame.GroupValidator() + self._validators['layout'] = v_frame.LayoutValidator() + self._validators['name'] = v_frame.NameValidator() + self._validators['traces'] = v_frame.TracesValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('baseframe', None) + self.baseframe = baseframe if baseframe is not None else v + v = arg.pop('data', None) + self.data = data if data is not None else v + v = arg.pop('group', None) + self.group = group if group is not None else v + v = arg.pop('layout', None) + self.layout = layout if layout is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('traces', None) + self.traces = traces if traces is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_heatmap.py b/plotly/graph_objs/_heatmap.py new file mode 100644 index 0000000000..6979c0d4f8 --- /dev/null +++ b/plotly/graph_objs/_heatmap.py @@ -0,0 +1,1839 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Heatmap(BaseTraceType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.heatmap.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmap.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.heatmap.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the `z` data are filled in. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.heatmap.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.heatmap.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.heatmap.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.heatmap.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each z value. + + The 'text' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # transpose + # --------- + @property + def transpose(self): + """ + Transposes the z data. + + The 'transpose' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['transpose'] + + @transpose.setter + def transpose(self, val): + self['transpose'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xgap + # ---- + @property + def xgap(self): + """ + Sets the horizontal gap (in pixels) between bricks. + + The 'xgap' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xgap'] + + @xgap.setter + def xgap(self, val): + self['xgap'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # xtype + # ----- + @property + def xtype(self): + """ + If *array*, the heatmap's x coordinates are given by *x* (the + default behavior when `x` is provided). If *scaled*, the + heatmap's x coordinates are given by *x0* and *dx* (the default + behavior when `x` is not provided). + + The 'xtype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['xtype'] + + @xtype.setter + def xtype(self, val): + self['xtype'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ygap + # ---- + @property + def ygap(self): + """ + Sets the vertical gap (in pixels) between bricks. + + The 'ygap' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ygap'] + + @ygap.setter + def ygap(self, val): + self['ygap'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # ytype + # ----- + @property + def ytype(self): + """ + If *array*, the heatmap's y coordinates are given by *y* (the + default behavior when `y` is provided) If *scaled*, the + heatmap's y coordinates are given by *y0* and *dy* (the default + behavior when `y` is not provided) + + The 'ytype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['ytype'] + + @ytype.setter + def ytype(self, val): + self['ytype'] = val + + # z + # - + @property + def z(self): + """ + Sets the z data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zhoverformat + # ------------ + @property + def zhoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. See: https + ://github.com/d3/d3-format/blob/master/README.md#locale_format + + The 'zhoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['zhoverformat'] + + @zhoverformat.setter + def zhoverformat(self, val): + self['zhoverformat'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsmooth + # ------- + @property + def zsmooth(self): + """ + Picks a smoothing algorithm use to smooth `z` data. + + The 'zsmooth' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fast', 'best', False] + + Returns + ------- + Any + """ + return self['zsmooth'] + + @zsmooth.setter + def zsmooth(self, val): + self['zsmooth'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmap.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmap.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmap.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xgap=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ygap=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Heatmap object + + The data that describes the heatmap value-to-color mapping is + set in `z`. Data in `z` can either be a {2D array} of values + (ragged or not) or a 1D array of values. In the case where `z` + is a {2D array}, say that `z` has N rows and M columns. Then, + by default, the resulting heatmap will have N partitions along + the y axis and M partitions along the x axis. In other words, + the i-th row/ j-th column cell in `z` is mapped to the i-th + partition of the y axis (starting from the bottom of the plot) + and the j-th partition of the x-axis (starting from the left of + the plot). This behavior can be flipped by using `transpose`. + Moreover, `x` (`y`) can be provided with M or M+1 (N or N+1) + elements. If M (N), then the coordinates correspond to the + center of the heatmap cells and the cells have equal width. If + M+1 (N+1), then the coordinates correspond to the edges of the + heatmap cells. In the case where `z` is a 1D {array}, the x and + y coordinates must be provided in `x` and `y` respectively to + form data triplets. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Heatmap + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmap.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the `z` data are filled in. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmap.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmap.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Heatmap + """ + super(Heatmap, self).__init__('heatmap') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Heatmap +constructor must be a dict or +an instance of plotly.graph_objs.Heatmap""" + ) + + # Import validators + # ----------------- + from plotly.validators import (heatmap as v_heatmap) + + # Initialize validators + # --------------------- + self._validators['autocolorscale' + ] = v_heatmap.AutocolorscaleValidator() + self._validators['colorbar'] = v_heatmap.ColorBarValidator() + self._validators['colorscale'] = v_heatmap.ColorscaleValidator() + self._validators['connectgaps'] = v_heatmap.ConnectgapsValidator() + self._validators['customdata'] = v_heatmap.CustomdataValidator() + self._validators['customdatasrc'] = v_heatmap.CustomdatasrcValidator() + self._validators['dx'] = v_heatmap.DxValidator() + self._validators['dy'] = v_heatmap.DyValidator() + self._validators['hoverinfo'] = v_heatmap.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_heatmap.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_heatmap.HoverlabelValidator() + self._validators['ids'] = v_heatmap.IdsValidator() + self._validators['idssrc'] = v_heatmap.IdssrcValidator() + self._validators['legendgroup'] = v_heatmap.LegendgroupValidator() + self._validators['name'] = v_heatmap.NameValidator() + self._validators['opacity'] = v_heatmap.OpacityValidator() + self._validators['reversescale'] = v_heatmap.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_heatmap.SelectedpointsValidator() + self._validators['showlegend'] = v_heatmap.ShowlegendValidator() + self._validators['showscale'] = v_heatmap.ShowscaleValidator() + self._validators['stream'] = v_heatmap.StreamValidator() + self._validators['text'] = v_heatmap.TextValidator() + self._validators['textsrc'] = v_heatmap.TextsrcValidator() + self._validators['transpose'] = v_heatmap.TransposeValidator() + self._validators['uid'] = v_heatmap.UidValidator() + self._validators['visible'] = v_heatmap.VisibleValidator() + self._validators['x'] = v_heatmap.XValidator() + self._validators['x0'] = v_heatmap.X0Validator() + self._validators['xaxis'] = v_heatmap.XAxisValidator() + self._validators['xcalendar'] = v_heatmap.XcalendarValidator() + self._validators['xgap'] = v_heatmap.XgapValidator() + self._validators['xsrc'] = v_heatmap.XsrcValidator() + self._validators['xtype'] = v_heatmap.XtypeValidator() + self._validators['y'] = v_heatmap.YValidator() + self._validators['y0'] = v_heatmap.Y0Validator() + self._validators['yaxis'] = v_heatmap.YAxisValidator() + self._validators['ycalendar'] = v_heatmap.YcalendarValidator() + self._validators['ygap'] = v_heatmap.YgapValidator() + self._validators['ysrc'] = v_heatmap.YsrcValidator() + self._validators['ytype'] = v_heatmap.YtypeValidator() + self._validators['z'] = v_heatmap.ZValidator() + self._validators['zauto'] = v_heatmap.ZautoValidator() + self._validators['zhoverformat'] = v_heatmap.ZhoverformatValidator() + self._validators['zmax'] = v_heatmap.ZmaxValidator() + self._validators['zmin'] = v_heatmap.ZminValidator() + self._validators['zsmooth'] = v_heatmap.ZsmoothValidator() + self._validators['zsrc'] = v_heatmap.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('transpose', None) + self.transpose = transpose if transpose is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xgap', None) + self.xgap = xgap if xgap is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('xtype', None) + self.xtype = xtype if xtype is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ygap', None) + self.ygap = ygap if ygap is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('ytype', None) + self.ytype = ytype if ytype is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zhoverformat', None) + self.zhoverformat = zhoverformat if zhoverformat is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsmooth', None) + self.zsmooth = zsmooth if zsmooth is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'heatmap' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='heatmap' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_heatmapgl.py b/plotly/graph_objs/_heatmapgl.py new file mode 100644 index 0000000000..2eb20d4181 --- /dev/null +++ b/plotly/graph_objs/_heatmapgl.py @@ -0,0 +1,1608 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Heatmapgl(BaseTraceType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmapgl.colorbar.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.heatmapgl.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.heatmapgl.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.heatmapgl.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each z value. + + The 'text' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # transpose + # --------- + @property + def transpose(self): + """ + Transposes the z data. + + The 'transpose' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['transpose'] + + @transpose.setter + def transpose(self, val): + self['transpose'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # xtype + # ----- + @property + def xtype(self): + """ + If *array*, the heatmap's x coordinates are given by *x* (the + default behavior when `x` is provided). If *scaled*, the + heatmap's x coordinates are given by *x0* and *dx* (the default + behavior when `x` is not provided). + + The 'xtype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['xtype'] + + @xtype.setter + def xtype(self, val): + self['xtype'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # ytype + # ----- + @property + def ytype(self): + """ + If *array*, the heatmap's y coordinates are given by *y* (the + default behavior when `y` is provided) If *scaled*, the + heatmap's y coordinates are given by *y0* and *dy* (the default + behavior when `y` is not provided) + + The 'ytype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['array', 'scaled'] + + Returns + ------- + Any + """ + return self['ytype'] + + @ytype.setter + def ytype(self, val): + self['ytype'] = val + + # z + # - + @property + def z(self): + """ + Sets the z data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmapgl.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmapgl.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmapgl.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + transpose=None, + uid=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + xtype=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + ytype=None, + z=None, + zauto=None, + zmax=None, + zmin=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Heatmapgl object + + WebGL version of the heatmap trace type. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Heatmapgl + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.heatmapgl.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.heatmapgl.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.heatmapgl.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each z value. + textsrc + Sets the source reference on plot.ly for text . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are given by + *x* (the default behavior when `x` is provided). If + *scaled*, the heatmap's x coordinates are given by *x0* + and *dx* (the default behavior when `x` is not + provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are given by + *y* (the default behavior when `y` is provided) If + *scaled*, the heatmap's y coordinates are given by *y0* + and *dy* (the default behavior when `y` is not + provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Heatmapgl + """ + super(Heatmapgl, self).__init__('heatmapgl') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Heatmapgl +constructor must be a dict or +an instance of plotly.graph_objs.Heatmapgl""" + ) + + # Import validators + # ----------------- + from plotly.validators import (heatmapgl as v_heatmapgl) + + # Initialize validators + # --------------------- + self._validators['autocolorscale' + ] = v_heatmapgl.AutocolorscaleValidator() + self._validators['colorbar'] = v_heatmapgl.ColorBarValidator() + self._validators['colorscale'] = v_heatmapgl.ColorscaleValidator() + self._validators['customdata'] = v_heatmapgl.CustomdataValidator() + self._validators['customdatasrc' + ] = v_heatmapgl.CustomdatasrcValidator() + self._validators['dx'] = v_heatmapgl.DxValidator() + self._validators['dy'] = v_heatmapgl.DyValidator() + self._validators['hoverinfo'] = v_heatmapgl.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_heatmapgl.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_heatmapgl.HoverlabelValidator() + self._validators['ids'] = v_heatmapgl.IdsValidator() + self._validators['idssrc'] = v_heatmapgl.IdssrcValidator() + self._validators['legendgroup'] = v_heatmapgl.LegendgroupValidator() + self._validators['name'] = v_heatmapgl.NameValidator() + self._validators['opacity'] = v_heatmapgl.OpacityValidator() + self._validators['reversescale'] = v_heatmapgl.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_heatmapgl.SelectedpointsValidator() + self._validators['showlegend'] = v_heatmapgl.ShowlegendValidator() + self._validators['showscale'] = v_heatmapgl.ShowscaleValidator() + self._validators['stream'] = v_heatmapgl.StreamValidator() + self._validators['text'] = v_heatmapgl.TextValidator() + self._validators['textsrc'] = v_heatmapgl.TextsrcValidator() + self._validators['transpose'] = v_heatmapgl.TransposeValidator() + self._validators['uid'] = v_heatmapgl.UidValidator() + self._validators['visible'] = v_heatmapgl.VisibleValidator() + self._validators['x'] = v_heatmapgl.XValidator() + self._validators['x0'] = v_heatmapgl.X0Validator() + self._validators['xaxis'] = v_heatmapgl.XAxisValidator() + self._validators['xsrc'] = v_heatmapgl.XsrcValidator() + self._validators['xtype'] = v_heatmapgl.XtypeValidator() + self._validators['y'] = v_heatmapgl.YValidator() + self._validators['y0'] = v_heatmapgl.Y0Validator() + self._validators['yaxis'] = v_heatmapgl.YAxisValidator() + self._validators['ysrc'] = v_heatmapgl.YsrcValidator() + self._validators['ytype'] = v_heatmapgl.YtypeValidator() + self._validators['z'] = v_heatmapgl.ZValidator() + self._validators['zauto'] = v_heatmapgl.ZautoValidator() + self._validators['zmax'] = v_heatmapgl.ZmaxValidator() + self._validators['zmin'] = v_heatmapgl.ZminValidator() + self._validators['zsrc'] = v_heatmapgl.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('transpose', None) + self.transpose = transpose if transpose is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('xtype', None) + self.xtype = xtype if xtype is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('ytype', None) + self.ytype = ytype if ytype is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'heatmapgl' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='heatmapgl' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_histogram.py b/plotly/graph_objs/_histogram.py new file mode 100644 index 0000000000..979f11a329 --- /dev/null +++ b/plotly/graph_objs/_histogram.py @@ -0,0 +1,1762 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Histogram(BaseTraceType): + + # autobinx + # -------- + @property + def autobinx(self): + """ + Determines whether or not the x axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + xbins. + + The 'autobinx' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobinx'] + + @autobinx.setter + def autobinx(self, val): + self['autobinx'] = val + + # autobiny + # -------- + @property + def autobiny(self): + """ + Determines whether or not the y axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + ybins. + + The 'autobiny' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobiny'] + + @autobiny.setter + def autobiny(self, val): + self['autobiny'] = val + + # cumulative + # ---------- + @property + def cumulative(self): + """ + The 'cumulative' property is an instance of Cumulative + that may be specified as: + - An instance of plotly.graph_objs.histogram.Cumulative + - A dict of string/value properties that will be passed + to the Cumulative constructor + + Supported dict properties: + + currentbin + Only applies if cumulative is enabled. Sets + whether the current bin is included, excluded, + or has half of its value included in the + current cumulative value. *include* is the + default for compatibility with various other + tools, however it introduces a half-bin bias to + the results. *exclude* makes the opposite half- + bin bias, and *half* removes it. + direction + Only applies if cumulative is enabled. If + *increasing* (default) we sum all prior bins, + so the result increases from left to right. If + *decreasing* we sum later bins so the result + decreases from left to right. + enabled + If true, display the cumulative distribution by + summing the binned values. Use the `direction` + and `centralbin` attributes to tune the + accumulation method. Note: in this mode, the + *density* `histnorm` settings behave the same + as their equivalents without *density*: ** and + *density* both rise to the number of data + points, and *probability* and *probability + density* both rise to the number of sample + points. + + Returns + ------- + plotly.graph_objs.histogram.Cumulative + """ + return self['cumulative'] + + @cumulative.setter + def cumulative(self, val): + self['cumulative'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # error_x + # ------- + @property + def error_x(self): + """ + The 'error_x' property is an instance of ErrorX + that may be specified as: + - An instance of plotly.graph_objs.histogram.ErrorX + - A dict of string/value properties that will be passed + to the ErrorX constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.histogram.ErrorX + """ + return self['error_x'] + + @error_x.setter + def error_x(self, val): + self['error_x'] = val + + # error_y + # ------- + @property + def error_y(self): + """ + The 'error_y' property is an instance of ErrorY + that may be specified as: + - An instance of plotly.graph_objs.histogram.ErrorY + - A dict of string/value properties that will be passed + to the ErrorY constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.histogram.ErrorY + """ + return self['error_y'] + + @error_y.setter + def error_y(self, val): + self['error_y'] = val + + # histfunc + # -------- + @property + def histfunc(self): + """ + Specifies the binning function used for this histogram trace. + If *count*, the histogram values are computed by counting the + number of values lying inside each bin. If *sum*, *avg*, *min*, + *max*, the histogram values are computed using the sum, the + average, the minimum or the maximum of the values lying inside + each bin respectively. + + The 'histfunc' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['count', 'sum', 'avg', 'min', 'max'] + + Returns + ------- + Any + """ + return self['histfunc'] + + @histfunc.setter + def histfunc(self, val): + self['histfunc'] = val + + # histnorm + # -------- + @property + def histnorm(self): + """ + Specifies the type of normalization used for this histogram + trace. If **, the span of each bar corresponds to the number of + occurrences (i.e. the number of data points lying inside the + bins). If *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences with + respect to the total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, the span of + each bar corresponds to the number of occurrences in a bin + divided by the size of the bin interval (here, the sum of all + bin AREAS equals the total number of sample points). If + *probability density*, the area of each bar corresponds to the + probability that an event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + + The 'histnorm' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['', 'percent', 'probability', 'density', 'probability + density'] + + Returns + ------- + Any + """ + return self['histnorm'] + + @histnorm.setter + def histnorm(self, val): + self['histnorm'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.histogram.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.histogram.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.histogram.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.histogram.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.histogram.marker.Line + instance or dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + + Returns + ------- + plotly.graph_objs.histogram.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # nbinsx + # ------ + @property + def nbinsx(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsx' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsx'] + + @nbinsx.setter + def nbinsx(self, val): + self['nbinsx'] = val + + # nbinsy + # ------ + @property + def nbinsy(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsy' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsy'] + + @nbinsy.setter + def nbinsy(self, val): + self['nbinsy'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the bars. With *v* (*h*), the value of + the each bar spans along the vertical (horizontal). + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.histogram.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.histogram.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.histogram.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.histogram.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.histogram.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.histogram.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.histogram.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.histogram.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.histogram.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.histogram.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the sample data to be binned on the x axis. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xbins + # ----- + @property + def xbins(self): + """ + The 'xbins' property is an instance of XBins + that may be specified as: + - An instance of plotly.graph_objs.histogram.XBins + - A dict of string/value properties that will be passed + to the XBins constructor + + Supported dict properties: + + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + plotly.graph_objs.histogram.XBins + """ + return self['xbins'] + + @xbins.setter + def xbins(self, val): + self['xbins'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the sample data to be binned on the y axis. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ybins + # ----- + @property + def ybins(self): + """ + The 'ybins' property is an instance of YBins + that may be specified as: + - An instance of plotly.graph_objs.histogram.YBins + - A dict of string/value properties that will be passed + to the YBins constructor + + Supported dict properties: + + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + plotly.graph_objs.histogram.YBins + """ + return self['ybins'] + + @ybins.setter + def ybins(self, val): + self['ybins'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + cumulative + plotly.graph_objs.histogram.Cumulative instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.histogram.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.histogram.ErrorY instance or dict + with compatible properties + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + selected + plotly.graph_objs.histogram.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.histogram.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.histogram.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram.XBins instance or dict with + compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram.YBins instance or dict with + compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + autobinx=None, + autobiny=None, + cumulative=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + orientation=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Histogram object + + The sample data from which statistics are computed is set in + `x` for vertically spanning histograms and in `y` for + horizontally spanning histograms. Binning options are set + `xbins` and `ybins` respectively if no aggregation data is + provided. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Histogram + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + cumulative + plotly.graph_objs.histogram.Cumulative instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.histogram.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.histogram.ErrorY instance or dict + with compatible properties + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* (*h*), the + value of the each bar spans along the vertical + (horizontal). + selected + plotly.graph_objs.histogram.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.histogram.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.histogram.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram.XBins instance or dict with + compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram.YBins instance or dict with + compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Histogram + """ + super(Histogram, self).__init__('histogram') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Histogram +constructor must be a dict or +an instance of plotly.graph_objs.Histogram""" + ) + + # Import validators + # ----------------- + from plotly.validators import (histogram as v_histogram) + + # Initialize validators + # --------------------- + self._validators['autobinx'] = v_histogram.AutobinxValidator() + self._validators['autobiny'] = v_histogram.AutobinyValidator() + self._validators['cumulative'] = v_histogram.CumulativeValidator() + self._validators['customdata'] = v_histogram.CustomdataValidator() + self._validators['customdatasrc' + ] = v_histogram.CustomdatasrcValidator() + self._validators['error_x'] = v_histogram.ErrorXValidator() + self._validators['error_y'] = v_histogram.ErrorYValidator() + self._validators['histfunc'] = v_histogram.HistfuncValidator() + self._validators['histnorm'] = v_histogram.HistnormValidator() + self._validators['hoverinfo'] = v_histogram.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_histogram.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_histogram.HoverlabelValidator() + self._validators['ids'] = v_histogram.IdsValidator() + self._validators['idssrc'] = v_histogram.IdssrcValidator() + self._validators['legendgroup'] = v_histogram.LegendgroupValidator() + self._validators['marker'] = v_histogram.MarkerValidator() + self._validators['name'] = v_histogram.NameValidator() + self._validators['nbinsx'] = v_histogram.NbinsxValidator() + self._validators['nbinsy'] = v_histogram.NbinsyValidator() + self._validators['opacity'] = v_histogram.OpacityValidator() + self._validators['orientation'] = v_histogram.OrientationValidator() + self._validators['selected'] = v_histogram.SelectedValidator() + self._validators['selectedpoints' + ] = v_histogram.SelectedpointsValidator() + self._validators['showlegend'] = v_histogram.ShowlegendValidator() + self._validators['stream'] = v_histogram.StreamValidator() + self._validators['text'] = v_histogram.TextValidator() + self._validators['textsrc'] = v_histogram.TextsrcValidator() + self._validators['uid'] = v_histogram.UidValidator() + self._validators['unselected'] = v_histogram.UnselectedValidator() + self._validators['visible'] = v_histogram.VisibleValidator() + self._validators['x'] = v_histogram.XValidator() + self._validators['xaxis'] = v_histogram.XAxisValidator() + self._validators['xbins'] = v_histogram.XBinsValidator() + self._validators['xcalendar'] = v_histogram.XcalendarValidator() + self._validators['xsrc'] = v_histogram.XsrcValidator() + self._validators['y'] = v_histogram.YValidator() + self._validators['yaxis'] = v_histogram.YAxisValidator() + self._validators['ybins'] = v_histogram.YBinsValidator() + self._validators['ycalendar'] = v_histogram.YcalendarValidator() + self._validators['ysrc'] = v_histogram.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autobinx', None) + self.autobinx = autobinx if autobinx is not None else v + v = arg.pop('autobiny', None) + self.autobiny = autobiny if autobiny is not None else v + v = arg.pop('cumulative', None) + self.cumulative = cumulative if cumulative is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('error_x', None) + self.error_x = error_x if error_x is not None else v + v = arg.pop('error_y', None) + self.error_y = error_y if error_y is not None else v + v = arg.pop('histfunc', None) + self.histfunc = histfunc if histfunc is not None else v + v = arg.pop('histnorm', None) + self.histnorm = histnorm if histnorm is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('nbinsx', None) + self.nbinsx = nbinsx if nbinsx is not None else v + v = arg.pop('nbinsy', None) + self.nbinsy = nbinsy if nbinsy is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xbins', None) + self.xbins = xbins if xbins is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ybins', None) + self.ybins = ybins if ybins is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'histogram' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='histogram' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_histogram2d.py b/plotly/graph_objs/_histogram2d.py new file mode 100644 index 0000000000..b6ca60f9e1 --- /dev/null +++ b/plotly/graph_objs/_histogram2d.py @@ -0,0 +1,1903 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Histogram2d(BaseTraceType): + + # autobinx + # -------- + @property + def autobinx(self): + """ + Determines whether or not the x axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + xbins. + + The 'autobinx' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobinx'] + + @autobinx.setter + def autobinx(self, val): + self['autobinx'] = val + + # autobiny + # -------- + @property + def autobiny(self): + """ + Determines whether or not the y axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + ybins. + + The 'autobiny' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobiny'] + + @autobiny.setter + def autobiny(self, val): + self['autobiny'] = val + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2d.colorbar.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.histogram2d.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # histfunc + # -------- + @property + def histfunc(self): + """ + Specifies the binning function used for this histogram trace. + If *count*, the histogram values are computed by counting the + number of values lying inside each bin. If *sum*, *avg*, *min*, + *max*, the histogram values are computed using the sum, the + average, the minimum or the maximum of the values lying inside + each bin respectively. + + The 'histfunc' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['count', 'sum', 'avg', 'min', 'max'] + + Returns + ------- + Any + """ + return self['histfunc'] + + @histfunc.setter + def histfunc(self, val): + self['histfunc'] = val + + # histnorm + # -------- + @property + def histnorm(self): + """ + Specifies the type of normalization used for this histogram + trace. If **, the span of each bar corresponds to the number of + occurrences (i.e. the number of data points lying inside the + bins). If *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences with + respect to the total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, the span of + each bar corresponds to the number of occurrences in a bin + divided by the size of the bin interval (here, the sum of all + bin AREAS equals the total number of sample points). If + *probability density*, the area of each bar corresponds to the + probability that an event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + + The 'histnorm' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['', 'percent', 'probability', 'density', 'probability + density'] + + Returns + ------- + Any + """ + return self['histnorm'] + + @histnorm.setter + def histnorm(self, val): + self['histnorm'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.histogram2d.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color + . + + Returns + ------- + plotly.graph_objs.histogram2d.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # nbinsx + # ------ + @property + def nbinsx(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsx' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsx'] + + @nbinsx.setter + def nbinsx(self, val): + self['nbinsx'] = val + + # nbinsy + # ------ + @property + def nbinsy(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsy' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsy'] + + @nbinsy.setter + def nbinsy(self, val): + self['nbinsy'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.histogram2d.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the sample data to be binned on the x axis. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xbins + # ----- + @property + def xbins(self): + """ + The 'xbins' property is an instance of XBins + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.XBins + - A dict of string/value properties that will be passed + to the XBins constructor + + Supported dict properties: + + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + plotly.graph_objs.histogram2d.XBins + """ + return self['xbins'] + + @xbins.setter + def xbins(self, val): + self['xbins'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xgap + # ---- + @property + def xgap(self): + """ + Sets the horizontal gap (in pixels) between bricks. + + The 'xgap' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xgap'] + + @xgap.setter + def xgap(self, val): + self['xgap'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the sample data to be binned on the y axis. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ybins + # ----- + @property + def ybins(self): + """ + The 'ybins' property is an instance of YBins + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.YBins + - A dict of string/value properties that will be passed + to the YBins constructor + + Supported dict properties: + + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + plotly.graph_objs.histogram2d.YBins + """ + return self['ybins'] + + @ybins.setter + def ybins(self, val): + self['ybins'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ygap + # ---- + @property + def ygap(self): + """ + Sets the vertical gap (in pixels) between bricks. + + The 'ygap' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ygap'] + + @ygap.setter + def ygap(self, val): + self['ygap'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the aggregation data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zhoverformat + # ------------ + @property + def zhoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. See: https + ://github.com/d3/d3-format/blob/master/README.md#locale_format + + The 'zhoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['zhoverformat'] + + @zhoverformat.setter + def zhoverformat(self, val): + self['zhoverformat'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsmooth + # ------- + @property + def zsmooth(self): + """ + Picks a smoothing algorithm use to smooth `z` data. + + The 'zsmooth' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fast', 'best', False] + + Returns + ------- + Any + """ + return self['zsmooth'] + + @zsmooth.setter + def zsmooth(self, val): + self['zsmooth'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.histogram2d.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2d.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram2d.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2d.Stream instance or dict + with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2d.XBins instance or dict + with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2d.YBins instance or dict + with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autobinx=None, + autobiny=None, + autocolorscale=None, + colorbar=None, + colorscale=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xgap=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ygap=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsmooth=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Histogram2d object + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a heatmap. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Histogram2d + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + colorbar + plotly.graph_objs.histogram2d.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2d.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.histogram2d.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2d.Stream instance or dict + with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2d.XBins instance or dict + with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xgap + Sets the horizontal gap (in pixels) between bricks. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2d.YBins instance or dict + with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ygap + Sets the vertical gap (in pixels) between bricks. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` data. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Histogram2d + """ + super(Histogram2d, self).__init__('histogram2d') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Histogram2d +constructor must be a dict or +an instance of plotly.graph_objs.Histogram2d""" + ) + + # Import validators + # ----------------- + from plotly.validators import (histogram2d as v_histogram2d) + + # Initialize validators + # --------------------- + self._validators['autobinx'] = v_histogram2d.AutobinxValidator() + self._validators['autobiny'] = v_histogram2d.AutobinyValidator() + self._validators['autocolorscale' + ] = v_histogram2d.AutocolorscaleValidator() + self._validators['colorbar'] = v_histogram2d.ColorBarValidator() + self._validators['colorscale'] = v_histogram2d.ColorscaleValidator() + self._validators['customdata'] = v_histogram2d.CustomdataValidator() + self._validators['customdatasrc' + ] = v_histogram2d.CustomdatasrcValidator() + self._validators['histfunc'] = v_histogram2d.HistfuncValidator() + self._validators['histnorm'] = v_histogram2d.HistnormValidator() + self._validators['hoverinfo'] = v_histogram2d.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_histogram2d.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_histogram2d.HoverlabelValidator() + self._validators['ids'] = v_histogram2d.IdsValidator() + self._validators['idssrc'] = v_histogram2d.IdssrcValidator() + self._validators['legendgroup'] = v_histogram2d.LegendgroupValidator() + self._validators['marker'] = v_histogram2d.MarkerValidator() + self._validators['name'] = v_histogram2d.NameValidator() + self._validators['nbinsx'] = v_histogram2d.NbinsxValidator() + self._validators['nbinsy'] = v_histogram2d.NbinsyValidator() + self._validators['opacity'] = v_histogram2d.OpacityValidator() + self._validators['reversescale' + ] = v_histogram2d.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_histogram2d.SelectedpointsValidator() + self._validators['showlegend'] = v_histogram2d.ShowlegendValidator() + self._validators['showscale'] = v_histogram2d.ShowscaleValidator() + self._validators['stream'] = v_histogram2d.StreamValidator() + self._validators['uid'] = v_histogram2d.UidValidator() + self._validators['visible'] = v_histogram2d.VisibleValidator() + self._validators['x'] = v_histogram2d.XValidator() + self._validators['xaxis'] = v_histogram2d.XAxisValidator() + self._validators['xbins'] = v_histogram2d.XBinsValidator() + self._validators['xcalendar'] = v_histogram2d.XcalendarValidator() + self._validators['xgap'] = v_histogram2d.XgapValidator() + self._validators['xsrc'] = v_histogram2d.XsrcValidator() + self._validators['y'] = v_histogram2d.YValidator() + self._validators['yaxis'] = v_histogram2d.YAxisValidator() + self._validators['ybins'] = v_histogram2d.YBinsValidator() + self._validators['ycalendar'] = v_histogram2d.YcalendarValidator() + self._validators['ygap'] = v_histogram2d.YgapValidator() + self._validators['ysrc'] = v_histogram2d.YsrcValidator() + self._validators['z'] = v_histogram2d.ZValidator() + self._validators['zauto'] = v_histogram2d.ZautoValidator() + self._validators['zhoverformat' + ] = v_histogram2d.ZhoverformatValidator() + self._validators['zmax'] = v_histogram2d.ZmaxValidator() + self._validators['zmin'] = v_histogram2d.ZminValidator() + self._validators['zsmooth'] = v_histogram2d.ZsmoothValidator() + self._validators['zsrc'] = v_histogram2d.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autobinx', None) + self.autobinx = autobinx if autobinx is not None else v + v = arg.pop('autobiny', None) + self.autobiny = autobiny if autobiny is not None else v + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('histfunc', None) + self.histfunc = histfunc if histfunc is not None else v + v = arg.pop('histnorm', None) + self.histnorm = histnorm if histnorm is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('nbinsx', None) + self.nbinsx = nbinsx if nbinsx is not None else v + v = arg.pop('nbinsy', None) + self.nbinsy = nbinsy if nbinsy is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xbins', None) + self.xbins = xbins if xbins is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xgap', None) + self.xgap = xgap if xgap is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ybins', None) + self.ybins = ybins if ybins is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ygap', None) + self.ygap = ygap if ygap is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zhoverformat', None) + self.zhoverformat = zhoverformat if zhoverformat is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsmooth', None) + self.zsmooth = zsmooth if zsmooth is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'histogram2d' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='histogram2d' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_histogram2dcontour.py b/plotly/graph_objs/_histogram2dcontour.py new file mode 100644 index 0000000000..de78376394 --- /dev/null +++ b/plotly/graph_objs/_histogram2dcontour.py @@ -0,0 +1,2052 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Histogram2dContour(BaseTraceType): + + # autobinx + # -------- + @property + def autobinx(self): + """ + Determines whether or not the x axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + xbins. + + The 'autobinx' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobinx'] + + @autobinx.setter + def autobinx(self, val): + self['autobinx'] = val + + # autobiny + # -------- + @property + def autobiny(self): + """ + Determines whether or not the y axis bin attributes are picked + by an algorithm. Note that this should be set to false if you + want to manually set the number of bins using the attributes in + ybins. + + The 'autobiny' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autobiny'] + + @autobiny.setter + def autobiny(self, val): + self['autobiny'] = val + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # autocontour + # ----------- + @property + def autocontour(self): + """ + Determines whether or not the contour level attributes are + picked by an algorithm. If *true*, the number of contour levels + can be set in `ncontours`. If *false*, set the contour level + attributes in `contours`. + + The 'autocontour' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocontour'] + + @autocontour.setter + def autocontour(self, val): + self['autocontour'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2dcontour.colorbar.T + ickformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.histogram2dcontour.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # contours + # -------- + @property + def contours(self): + """ + The 'contours' property is an instance of Contours + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.Contours + - A dict of string/value properties that will be passed + to the Contours constructor + + Supported dict properties: + + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *heatmap*, + a heatmap gradient coloring is applied between + each contour level. If *lines*, coloring is + done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound. + + Returns + ------- + plotly.graph_objs.histogram2dcontour.Contours + """ + return self['contours'] + + @contours.setter + def contours(self, val): + self['contours'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # histfunc + # -------- + @property + def histfunc(self): + """ + Specifies the binning function used for this histogram trace. + If *count*, the histogram values are computed by counting the + number of values lying inside each bin. If *sum*, *avg*, *min*, + *max*, the histogram values are computed using the sum, the + average, the minimum or the maximum of the values lying inside + each bin respectively. + + The 'histfunc' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['count', 'sum', 'avg', 'min', 'max'] + + Returns + ------- + Any + """ + return self['histfunc'] + + @histfunc.setter + def histfunc(self, val): + self['histfunc'] = val + + # histnorm + # -------- + @property + def histnorm(self): + """ + Specifies the type of normalization used for this histogram + trace. If **, the span of each bar corresponds to the number of + occurrences (i.e. the number of data points lying inside the + bins). If *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences with + respect to the total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, the span of + each bar corresponds to the number of occurrences in a bin + divided by the size of the bin interval (here, the sum of all + bin AREAS equals the total number of sample points). If + *probability density*, the area of each bar corresponds to the + probability that an event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + + The 'histnorm' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['', 'percent', 'probability', 'density', 'probability + density'] + + Returns + ------- + Any + """ + return self['histnorm'] + + @histnorm.setter + def histnorm(self, val): + self['histnorm'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.histogram2dcontour.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the contour level. Has no + effect if `contours.coloring` is set to + *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.histogram2dcontour.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color + . + + Returns + ------- + plotly.graph_objs.histogram2dcontour.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # nbinsx + # ------ + @property + def nbinsx(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsx' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsx'] + + @nbinsx.setter + def nbinsx(self, val): + self['nbinsx'] = val + + # nbinsy + # ------ + @property + def nbinsy(self): + """ + Specifies the maximum number of desired bins. This value will + be used in an algorithm that will decide the optimal bin size + such that the histogram best visualizes the distribution of the + data. + + The 'nbinsy' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nbinsy'] + + @nbinsy.setter + def nbinsy(self, val): + self['nbinsy'] = val + + # ncontours + # --------- + @property + def ncontours(self): + """ + Sets the maximum number of contour levels. The actual number of + contours will be chosen automatically to be less than or equal + to the value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` is missing. + + The 'ncontours' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['ncontours'] + + @ncontours.setter + def ncontours(self, val): + self['ncontours'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.histogram2dcontour.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the sample data to be binned on the x axis. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xbins + # ----- + @property + def xbins(self): + """ + The 'xbins' property is an instance of XBins + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.XBins + - A dict of string/value properties that will be passed + to the XBins constructor + + Supported dict properties: + + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + plotly.graph_objs.histogram2dcontour.XBins + """ + return self['xbins'] + + @xbins.setter + def xbins(self, val): + self['xbins'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the sample data to be binned on the y axis. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ybins + # ----- + @property + def ybins(self): + """ + The 'ybins' property is an instance of YBins + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.YBins + - A dict of string/value properties that will be passed + to the YBins constructor + + Supported dict properties: + + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + plotly.graph_objs.histogram2dcontour.YBins + """ + return self['ybins'] + + @ybins.setter + def ybins(self, val): + self['ybins'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the aggregation data. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zauto + # ----- + @property + def zauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'zauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zauto'] + + @zauto.setter + def zauto(self, val): + self['zauto'] = val + + # zhoverformat + # ------------ + @property + def zhoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. See: https + ://github.com/d3/d3-format/blob/master/README.md#locale_format + + The 'zhoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['zhoverformat'] + + @zhoverformat.setter + def zhoverformat(self, val): + self['zhoverformat'] = val + + # zmax + # ---- + @property + def zmax(self): + """ + Sets the upper bound of color domain. + + The 'zmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmax'] + + @zmax.setter + def zmax(self, val): + self['zmax'] = val + + # zmin + # ---- + @property + def zmin(self): + """ + Sets the lower bound of color domain. + + The 'zmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zmin'] + + @zmin.setter + def zmin(self, val): + self['zmin'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.histogram2dcontour.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.histogram2dcontour.Contours instance + or dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2dcontour.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.histogram2dcontour.Line instance or + dict with compatible properties + marker + plotly.graph_objs.histogram2dcontour.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2dcontour.Stream instance or + dict with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2dcontour.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2dcontour.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autobinx=None, + autobiny=None, + autocolorscale=None, + autocontour=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + histfunc=None, + histnorm=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + name=None, + nbinsx=None, + nbinsy=None, + ncontours=None, + opacity=None, + reversescale=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbins=None, + xcalendar=None, + xsrc=None, + y=None, + yaxis=None, + ybins=None, + ycalendar=None, + ysrc=None, + z=None, + zauto=None, + zhoverformat=None, + zmax=None, + zmin=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Histogram2dContour object + + The sample data from which statistics are computed is set in + `x` and `y` (where `x` and `y` represent marginal + distributions, binning is set in `xbins` and `ybins` in this + case) or `z` (where `z` represent the 2D distribution and + binning set, binning is set by `x` and `y` in this case). The + resulting distribution is visualized as a contour plot. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Histogram2dContour + autobinx + Determines whether or not the x axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in xbins. + autobiny + Determines whether or not the y axis bin attributes are + picked by an algorithm. Note that this should be set to + false if you want to manually set the number of bins + using the attributes in ybins. + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + autocontour + Determines whether or not the contour level attributes + are picked by an algorithm. If *true*, the number of + contour levels can be set in `ncontours`. If *false*, + set the contour level attributes in `contours`. + colorbar + plotly.graph_objs.histogram2dcontour.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.histogram2dcontour.Contours instance + or dict with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + histfunc + Specifies the binning function used for this histogram + trace. If *count*, the histogram values are computed by + counting the number of values lying inside each bin. If + *sum*, *avg*, *min*, *max*, the histogram values are + computed using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for this + histogram trace. If **, the span of each bar + corresponds to the number of occurrences (i.e. the + number of data points lying inside the bins). If + *percent* / *probability*, the span of each bar + corresponds to the percentage / fraction of occurrences + with respect to the total number of sample points + (here, the sum of all bin HEIGHTS equals 100% / 1). If + *density*, the span of each bar corresponds to the + number of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin AREAS equals + the total number of sample points). If *probability + density*, the area of each bar corresponds to the + probability that an event will fall into the + corresponding bin (here, the sum of all bin AREAS + equals 1). + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.histogram2dcontour.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.histogram2dcontour.Line instance or + dict with compatible properties + marker + plotly.graph_objs.histogram2dcontour.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + nbinsy + Specifies the maximum number of desired bins. This + value will be used in an algorithm that will decide the + optimal bin size such that the histogram best + visualizes the distribution of the data. + ncontours + Sets the maximum number of contour levels. The actual + number of contours will be chosen automatically to be + less than or equal to the value of `ncontours`. Has an + effect only if `autocontour` is *true* or if + `contours.size` is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.histogram2dcontour.Stream instance or + dict with compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the sample data to be binned on the x axis. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2dcontour.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y axis. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2dcontour.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain is + computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. See: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Histogram2dContour + """ + super(Histogram2dContour, self).__init__('histogram2dcontour') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Histogram2dContour +constructor must be a dict or +an instance of plotly.graph_objs.Histogram2dContour""" + ) + + # Import validators + # ----------------- + from plotly.validators import ( + histogram2dcontour as v_histogram2dcontour + ) + + # Initialize validators + # --------------------- + self._validators['autobinx'] = v_histogram2dcontour.AutobinxValidator() + self._validators['autobiny'] = v_histogram2dcontour.AutobinyValidator() + self._validators['autocolorscale' + ] = v_histogram2dcontour.AutocolorscaleValidator() + self._validators['autocontour' + ] = v_histogram2dcontour.AutocontourValidator() + self._validators['colorbar'] = v_histogram2dcontour.ColorBarValidator() + self._validators['colorscale' + ] = v_histogram2dcontour.ColorscaleValidator() + self._validators['contours'] = v_histogram2dcontour.ContoursValidator() + self._validators['customdata' + ] = v_histogram2dcontour.CustomdataValidator() + self._validators['customdatasrc' + ] = v_histogram2dcontour.CustomdatasrcValidator() + self._validators['histfunc'] = v_histogram2dcontour.HistfuncValidator() + self._validators['histnorm'] = v_histogram2dcontour.HistnormValidator() + self._validators['hoverinfo' + ] = v_histogram2dcontour.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_histogram2dcontour.HoverinfosrcValidator() + self._validators['hoverlabel' + ] = v_histogram2dcontour.HoverlabelValidator() + self._validators['ids'] = v_histogram2dcontour.IdsValidator() + self._validators['idssrc'] = v_histogram2dcontour.IdssrcValidator() + self._validators['legendgroup' + ] = v_histogram2dcontour.LegendgroupValidator() + self._validators['line'] = v_histogram2dcontour.LineValidator() + self._validators['marker'] = v_histogram2dcontour.MarkerValidator() + self._validators['name'] = v_histogram2dcontour.NameValidator() + self._validators['nbinsx'] = v_histogram2dcontour.NbinsxValidator() + self._validators['nbinsy'] = v_histogram2dcontour.NbinsyValidator() + self._validators['ncontours' + ] = v_histogram2dcontour.NcontoursValidator() + self._validators['opacity'] = v_histogram2dcontour.OpacityValidator() + self._validators['reversescale' + ] = v_histogram2dcontour.ReversescaleValidator() + self._validators['selectedpoints' + ] = v_histogram2dcontour.SelectedpointsValidator() + self._validators['showlegend' + ] = v_histogram2dcontour.ShowlegendValidator() + self._validators['showscale' + ] = v_histogram2dcontour.ShowscaleValidator() + self._validators['stream'] = v_histogram2dcontour.StreamValidator() + self._validators['uid'] = v_histogram2dcontour.UidValidator() + self._validators['visible'] = v_histogram2dcontour.VisibleValidator() + self._validators['x'] = v_histogram2dcontour.XValidator() + self._validators['xaxis'] = v_histogram2dcontour.XAxisValidator() + self._validators['xbins'] = v_histogram2dcontour.XBinsValidator() + self._validators['xcalendar' + ] = v_histogram2dcontour.XcalendarValidator() + self._validators['xsrc'] = v_histogram2dcontour.XsrcValidator() + self._validators['y'] = v_histogram2dcontour.YValidator() + self._validators['yaxis'] = v_histogram2dcontour.YAxisValidator() + self._validators['ybins'] = v_histogram2dcontour.YBinsValidator() + self._validators['ycalendar' + ] = v_histogram2dcontour.YcalendarValidator() + self._validators['ysrc'] = v_histogram2dcontour.YsrcValidator() + self._validators['z'] = v_histogram2dcontour.ZValidator() + self._validators['zauto'] = v_histogram2dcontour.ZautoValidator() + self._validators['zhoverformat' + ] = v_histogram2dcontour.ZhoverformatValidator() + self._validators['zmax'] = v_histogram2dcontour.ZmaxValidator() + self._validators['zmin'] = v_histogram2dcontour.ZminValidator() + self._validators['zsrc'] = v_histogram2dcontour.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autobinx', None) + self.autobinx = autobinx if autobinx is not None else v + v = arg.pop('autobiny', None) + self.autobiny = autobiny if autobiny is not None else v + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('autocontour', None) + self.autocontour = autocontour if autocontour is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('contours', None) + self.contours = contours if contours is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('histfunc', None) + self.histfunc = histfunc if histfunc is not None else v + v = arg.pop('histnorm', None) + self.histnorm = histnorm if histnorm is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('nbinsx', None) + self.nbinsx = nbinsx if nbinsx is not None else v + v = arg.pop('nbinsy', None) + self.nbinsy = nbinsy if nbinsy is not None else v + v = arg.pop('ncontours', None) + self.ncontours = ncontours if ncontours is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xbins', None) + self.xbins = xbins if xbins is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ybins', None) + self.ybins = ybins if ybins is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zauto', None) + self.zauto = zauto if zauto is not None else v + v = arg.pop('zhoverformat', None) + self.zhoverformat = zhoverformat if zhoverformat is not None else v + v = arg.pop('zmax', None) + self.zmax = zmax if zmax is not None else v + v = arg.pop('zmin', None) + self.zmin = zmin if zmin is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'histogram2dcontour' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='histogram2dcontour' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_layout.py b/plotly/graph_objs/_layout.py new file mode 100644 index 0000000000..db90079115 --- /dev/null +++ b/plotly/graph_objs/_layout.py @@ -0,0 +1,3595 @@ +from plotly.basedatatypes import BaseLayoutType +import copy + + +class Layout(BaseLayoutType): + + # angularaxis + # ----------- + @property + def angularaxis(self): + """ + The 'angularaxis' property is an instance of AngularAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.AngularAxis + - A dict of string/value properties that will be passed + to the AngularAxis constructor + + Supported dict properties: + + domain + Polar chart subplots are not supported yet. + This key has currently no effect. + endpadding + + range + Defines the start and end point of this angular + axis. + showline + Determines whether or not the line bounding + this angular axis will be shown on the figure. + showticklabels + Determines whether or not the angular axis + ticks will feature tick labels. + tickcolor + Sets the color of the tick lines on this + angular axis. + ticklen + Sets the length of the tick lines on this + angular axis. + tickorientation + Sets the orientation (from the paper + perspective) of the angular axis tick labels. + ticksuffix + Sets the length of the tick lines on this + angular axis. + visible + Determines whether or not this axis will be + visible. + + Returns + ------- + plotly.graph_objs.layout.AngularAxis + """ + return self['angularaxis'] + + @angularaxis.setter + def angularaxis(self, val): + self['angularaxis'] = val + + # annotations + # ----------- + @property + def annotations(self): + """ + The 'annotations' property is a tuple of instances of + Annotation that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.Annotation + - A list or tuple of dicts of string/value properties that + will be passed to the Annotation constructor + + Supported dict properties: + + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + arrowwidth + Sets the width (in px) of annotation arrow + line. + ax + Sets the x component of the arrow tail about + the arrow head. If `axref` is `pixel`, a + positive (negative) component corresponds to + an arrow pointing from right to left (left to + right). If `axref` is an axis, this is an + absolute value on that axis, like `x`, NOT a + relative value. + axref + Indicates in what terms the tail of the + annotation (ax,ay) is specified. If `pixel`, + `ax` is a relative offset in pixels from `x`. + If set to an x axis id (e.g. *x* or *x2*), `ax` + is specified in the same terms as that axis. + This is useful for trendline annotations which + should continue to indicate the correct trend + when zoomed. + ay + Sets the y component of the arrow tail about + the arrow head. If `ayref` is `pixel`, a + positive (negative) component corresponds to + an arrow pointing from bottom to top (top to + bottom). If `ayref` is an axis, this is an + absolute value on that axis, like `y`, NOT a + relative value. + ayref + Indicates in what terms the tail of the + annotation (ax,ay) is specified. If `pixel`, + `ay` is a relative offset in pixels from `y`. + If set to a y axis id (e.g. *y* or *y2*), `ay` + is specified in the same terms as that axis. + This is useful for trendline annotations which + should continue to indicate the correct trend + when zoomed. + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the + annotation `text`. + borderpad + Sets the padding (in px) between the `text` and + the enclosing border. + borderwidth + Sets the width (in px) of the border enclosing + the annotation `text`. + captureevents + Determines whether the annotation text box + captures mouse move and click events, or allows + those events to pass through to data points in + the plot that may be behind the annotation. By + default `captureevents` is *false* unless + `hovertext` is provided. If you use the event + `plotly_clickannotation` without `hovertext` + you must explicitly enable `captureevents`. + clicktoshow + Makes this annotation respond to clicks on the + plot. If you click a data point that exactly + matches the `x` and `y` values of this + annotation, and it is hidden (visible: false), + it will appear. In *onoff* mode, you must click + the same point again to make it disappear, so + if you click multiple points, you can show + multiple annotations. In *onout* mode, a click + anywhere else in the plot (on another data + point or not) will hide this annotation. If you + need to show/hide this annotation in response + to different `x` or `y` values, you can set + `xclick` and/or `yclick`. This is useful for + example to label the side of a bar. To label + markers though, `standoff` is preferred over + `xclick` and `yclick`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. + Taller text will be clipped. + hoverlabel + plotly.graph_objs.layout.annotation.Hoverlabel + instance or dict with compatible properties + hovertext + Sets text to appear when hovering over this + annotation. If omitted or blank, no hover label + will appear. + opacity + Sets the opacity of the annotation (text + + arrow). + showarrow + Determines whether or not the annotation is + drawn with an arrow. If *true*, `text` is + placed near the arrow's tail. If *false*, + `text` lines up with the `x` and `y` provided. + standoff + Sets a distance, in pixels, to move the end + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow + head, relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + startstandoff + Sets a distance, in pixels, to move the start + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. + Plotly uses a subset of HTML tags to do things + like newline (
), bold (), italics + (), hyperlinks (). + Tags , , are also + supported. + textangle + Sets the angle at which the `text` is drawn + with respect to the horizontal. + valign + Sets the vertical alignment of the `text` + within the box. Has an effect only if an + explicit height is set to override the text + height. + visible + Determines whether or not this annotation is + visible. + width + Sets an explicit width for the text box. null + (default) lets the text set the box width. + Wider text will be clipped. There is no + automatic wrapping; use
to start a new + line. + x + Sets the annotation's x position. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + xanchor + Sets the text box's horizontal position anchor + This anchor binds the `x` position to the + *left*, *center* or *right* of the annotation. + For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the + right-most portion of the annotation lines up + with the right-most edge of the plotting area. + If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + xclick + Toggle this annotation when clicking a data + point whose `x` value is `xclick` rather than + the annotation's `x` value. + xref + Sets the annotation's x coordinate axis. If set + to an x axis id (e.g. *x* or *x2*), the `x` + position refers to an x coordinate If set to + *paper*, the `x` position refers to the + distance from the left side of the plotting + area in normalized coordinates where 0 (1) + corresponds to the left (right) side. + xshift + Shifts the position of the whole annotation and + arrow to the right (positive) or left + (negative) by this many pixels. + y + Sets the annotation's y position. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + yanchor + Sets the text box's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the annotation. + For example, if `y` is set to 1, `yref` to + *paper* and `yanchor` to *top* then the top- + most portion of the annotation lines up with + the top-most edge of the plotting area. If + *auto*, the anchor is equivalent to *middle* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + yclick + Toggle this annotation when clicking a data + point whose `y` value is `yclick` rather than + the annotation's `y` value. + yref + Sets the annotation's y coordinate axis. If set + to an y axis id (e.g. *y* or *y2*), the `y` + position refers to an y coordinate If set to + *paper*, the `y` position refers to the + distance from the bottom of the plotting area + in normalized coordinates where 0 (1) + corresponds to the bottom (top). + yshift + Shifts the position of the whole annotation and + arrow up (positive) or down (negative) by this + many pixels. + + Returns + ------- + tuple[plotly.graph_objs.layout.Annotation] + """ + return self['annotations'] + + @annotations.setter + def annotations(self, val): + self['annotations'] = val + + # autosize + # -------- + @property + def autosize(self): + """ + Determines whether or not a layout width or height that has + been left undefined by the user is initialized on each + relayout. Note that, regardless of this attribute, an undefined + layout width or height is always initialized on the first call + to plot. + + The 'autosize' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autosize'] + + @autosize.setter + def autosize(self, val): + self['autosize'] = val + + # bargap + # ------ + @property + def bargap(self): + """ + Sets the gap (in plot fraction) between bars of adjacent + location coordinates. + + The 'bargap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['bargap'] + + @bargap.setter + def bargap(self, val): + self['bargap'] = val + + # bargroupgap + # ----------- + @property + def bargroupgap(self): + """ + Sets the gap (in plot fraction) between bars of the same + location coordinate. + + The 'bargroupgap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['bargroupgap'] + + @bargroupgap.setter + def bargroupgap(self, val): + self['bargroupgap'] = val + + # barmode + # ------- + @property + def barmode(self): + """ + Determines how bars at the same location coordinate are + displayed on the graph. With *stack*, the bars are stacked on + top of one another With *relative*, the bars are stacked on top + of one another, with negative values below the axis, positive + values above With *group*, the bars are plotted next to one + another centered around the shared location. With *overlay*, + the bars are plotted over one another, you might need to an + *opacity* to see multiple bars. + + The 'barmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['stack', 'group', 'overlay', 'relative'] + + Returns + ------- + Any + """ + return self['barmode'] + + @barmode.setter + def barmode(self, val): + self['barmode'] = val + + # barnorm + # ------- + @property + def barnorm(self): + """ + Sets the normalization for bar traces on the graph. With + *fraction*, the value of each bar is divide by the sum of the + values at the location coordinate. With *percent*, the results + form *fraction* are presented in percents. + + The 'barnorm' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['', 'fraction', 'percent'] + + Returns + ------- + Any + """ + return self['barnorm'] + + @barnorm.setter + def barnorm(self, val): + self['barnorm'] = val + + # boxgap + # ------ + @property + def boxgap(self): + """ + Sets the gap (in plot fraction) between boxes of adjacent + location coordinates. + + The 'boxgap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['boxgap'] + + @boxgap.setter + def boxgap(self, val): + self['boxgap'] = val + + # boxgroupgap + # ----------- + @property + def boxgroupgap(self): + """ + Sets the gap (in plot fraction) between boxes of the same + location coordinate. + + The 'boxgroupgap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['boxgroupgap'] + + @boxgroupgap.setter + def boxgroupgap(self, val): + self['boxgroupgap'] = val + + # boxmode + # ------- + @property + def boxmode(self): + """ + Determines how boxes at the same location coordinate are + displayed on the graph. If *group*, the boxes are plotted next + to one another centered around the shared location. If + *overlay*, the boxes are plotted over one another, you might + need to set *opacity* to see them multiple boxes. + + The 'boxmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['group', 'overlay'] + + Returns + ------- + Any + """ + return self['boxmode'] + + @boxmode.setter + def boxmode(self, val): + self['boxmode'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the default calendar system to use for interpreting and + displaying dates throughout the plot. + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # colorway + # -------- + @property + def colorway(self): + """ + Sets the default trace colors. + + The 'colorway' property is a colorlist that may be specified + as a tuple, list, one-dimensional numpy array, or pandas Series of valid + color strings + + Returns + ------- + list + """ + return self['colorway'] + + @colorway.setter + def colorway(self, val): + self['colorway'] = val + + # datarevision + # ------------ + @property + def datarevision(self): + """ + If provided, a changed value tells `Plotly.react` that one or + more data arrays has changed. This way you can modify arrays + in-place rather than making a complete new copy for an + incremental change. If NOT provided, `Plotly.react` assumes + that data arrays are being treated as immutable, thus any data + array with a different identity from its predecessor contains + new data. + + The 'datarevision' property accepts values of any type + + Returns + ------- + Any + """ + return self['datarevision'] + + @datarevision.setter + def datarevision(self, val): + self['datarevision'] = val + + # direction + # --------- + @property + def direction(self): + """ + For polar plots only. Sets the direction corresponding to + positive angles. + + The 'direction' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['clockwise', 'counterclockwise'] + + Returns + ------- + Any + """ + return self['direction'] + + @direction.setter + def direction(self, val): + self['direction'] = val + + # dragmode + # -------- + @property + def dragmode(self): + """ + Determines the mode of drag interactions. *select* and *lasso* + apply only to scatter traces with markers or text. *orbit* and + *turntable* apply only to 3D scenes. + + The 'dragmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['zoom', 'pan', 'select', 'lasso', 'orbit', 'turntable'] + + Returns + ------- + Any + """ + return self['dragmode'] + + @dragmode.setter + def dragmode(self, val): + self['dragmode'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the global font. Note that fonts used in traces and other + layout components inherit from the global font. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # geo + # --- + @property + def geo(self): + """ + The 'geo' property is an instance of Geo + that may be specified as: + - An instance of plotly.graph_objs.layout.Geo + - A dict of string/value properties that will be passed + to the Geo constructor + + Supported dict properties: + + bgcolor + Set the background color of the map + center + plotly.graph_objs.layout.geo.Center instance or + dict with compatible properties + coastlinecolor + Sets the coastline color. + coastlinewidth + Sets the coastline stroke width (in px). + countrycolor + Sets line color of the country boundaries. + countrywidth + Sets line width (in px) of the country + boundaries. + domain + plotly.graph_objs.layout.geo.Domain instance or + dict with compatible properties + framecolor + Sets the color the frame. + framewidth + Sets the stroke width (in px) of the frame. + lakecolor + Sets the color of the lakes. + landcolor + Sets the land mass color. + lataxis + plotly.graph_objs.layout.geo.Lataxis instance + or dict with compatible properties + lonaxis + plotly.graph_objs.layout.geo.Lonaxis instance + or dict with compatible properties + oceancolor + Sets the ocean color + projection + plotly.graph_objs.layout.geo.Projection + instance or dict with compatible properties + resolution + Sets the resolution of the base layers. The + values have units of km/mm e.g. 110 corresponds + to a scale ratio of 1:110,000,000. + rivercolor + Sets color of the rivers. + riverwidth + Sets the stroke width (in px) of the rivers. + scope + Set the scope of the map. + showcoastlines + Sets whether or not the coastlines are drawn. + showcountries + Sets whether or not country boundaries are + drawn. + showframe + Sets whether or not a frame is drawn around the + map. + showlakes + Sets whether or not lakes are drawn. + showland + Sets whether or not land masses are filled in + color. + showocean + Sets whether or not oceans are filled in color. + showrivers + Sets whether or not rivers are drawn. + showsubunits + Sets whether or not boundaries of subunits + within countries (e.g. states, provinces) are + drawn. + subunitcolor + Sets the color of the subunits boundaries. + subunitwidth + Sets the stroke width (in px) of the subunits + boundaries. + + Returns + ------- + plotly.graph_objs.layout.Geo + """ + return self['geo'] + + @geo.setter + def geo(self, val): + self['geo'] = val + + # grid + # ---- + @property + def grid(self): + """ + The 'grid' property is an instance of Grid + that may be specified as: + - An instance of plotly.graph_objs.layout.Grid + - A dict of string/value properties that will be passed + to the Grid constructor + + Supported dict properties: + + columns + The number of columns in the grid. If you + provide a 2D `subplots` array, the length of + its longest row is used as the default. If you + give an `xaxes` array, its length is used as + the default. But it's also possible to have a + different length, if you want to leave a row at + the end for non-cartesian subplots. + domain + plotly.graph_objs.layout.grid.Domain instance + or dict with compatible properties + pattern + If no `subplots`, `xaxes`, or `yaxes` are given + but we do have `rows` and `columns`, we can + generate defaults using consecutive axis IDs, + in two ways: *coupled* gives one x axis per + column and one y axis per row. *independent* + uses a new xy pair for each cell, left-to-right + across each row then iterating rows according + to `roworder`. + roworder + Is the first row the top or the bottom? Note + that columns are always enumerated from left to + right. + rows + The number of rows in the grid. If you provide + a 2D `subplots` array or a `yaxes` array, its + length is used as the default. But it's also + possible to have a different length, if you + want to leave a row at the end for non- + cartesian subplots. + subplots + Used for freeform grids, where some axes may be + shared across subplots but others are not. Each + entry should be a cartesian subplot id, like + *xy* or *x3y2*, or ** to leave that cell empty. + You may reuse x axes within the same column, + and y axes within the same row. Non-cartesian + subplots and traces that support `domain` can + place themselves in this grid separately using + the `gridcell` attribute. + xaxes + Used with `yaxes` when the x and y axes are + shared across columns and rows. Each entry + should be an x axis id like *x*, *x2*, etc., or + ** to not put an x axis in that column. Entries + other than ** must be unique. Ignored if + `subplots` is present. If missing but `yaxes` + is present, will generate consecutive IDs. + xgap + Horizontal space between grid cells, expressed + as a fraction of the total width available to + one cell. Defaults to 0.1 for coupled-axes + grids and 0.2 for independent grids. + xside + Sets where the x axis labels and titles go. + *bottom* means the very bottom of the grid. + *bottom plot* is the lowest plot that each x + axis is used in. *top* and *top plot* are + similar. + yaxes + Used with `yaxes` when the x and y axes are + shared across columns and rows. Each entry + should be an y axis id like *y*, *y2*, etc., or + ** to not put a y axis in that row. Entries + other than ** must be unique. Ignored if + `subplots` is present. If missing but `xaxes` + is present, will generate consecutive IDs. + ygap + Vertical space between grid cells, expressed as + a fraction of the total height available to one + cell. Defaults to 0.1 for coupled-axes grids + and 0.3 for independent grids. + yside + Sets where the y axis labels and titles go. + *left* means the very left edge of the grid. + *left plot* is the leftmost plot that each y + axis is used in. *right* and *right plot* are + similar. + + Returns + ------- + plotly.graph_objs.layout.Grid + """ + return self['grid'] + + @grid.setter + def grid(self, val): + self['grid'] = val + + # height + # ------ + @property + def height(self): + """ + Sets the plot's height (in px). + + The 'height' property is a number and may be specified as: + - An int or float in the interval [10, inf] + + Returns + ------- + int|float + """ + return self['height'] + + @height.setter + def height(self, val): + self['height'] = val + + # hiddenlabels + # ------------ + @property + def hiddenlabels(self): + """ + The 'hiddenlabels' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['hiddenlabels'] + + @hiddenlabels.setter + def hiddenlabels(self, val): + self['hiddenlabels'] = val + + # hiddenlabelssrc + # --------------- + @property + def hiddenlabelssrc(self): + """ + Sets the source reference on plot.ly for hiddenlabels . + + The 'hiddenlabelssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hiddenlabelssrc'] + + @hiddenlabelssrc.setter + def hiddenlabelssrc(self, val): + self['hiddenlabelssrc'] = val + + # hidesources + # ----------- + @property + def hidesources(self): + """ + Determines whether or not a text link citing the data source is + placed at the bottom-right cored of the figure. Has only an + effect only on graphs that have been generated via forked + graphs from the plotly service (at https://plot.ly or on- + premise). + + The 'hidesources' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['hidesources'] + + @hidesources.setter + def hidesources(self, val): + self['hidesources'] = val + + # hoverdistance + # ------------- + @property + def hoverdistance(self): + """ + Sets the default distance (in pixels) to look for data to add + hover labels (-1 means no cutoff, 0 means no looking for data). + This is only a real distance for hovering on point-like + objects, like scatter points. For area-like objects (bars, + scatter fills, etc) hovering is on inside the area and off + outside, but these objects will not supersede hover on point- + like objects in case of conflict. + + The 'hoverdistance' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + + Returns + ------- + int + """ + return self['hoverdistance'] + + @hoverdistance.setter + def hoverdistance(self, val): + self['hoverdistance'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.layout.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of all hover labels + on graph + bordercolor + Sets the border color of all hover labels on + graph. + font + Sets the default hover label font used by all + traces on the graph. + namelength + Sets the default length (in number of + characters) of the trace name in the hover + labels for all traces. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 + characters, and an integer >3 will show the + whole name if it is less than that many + characters, but if it is longer, will truncate + to `namelength - 3` characters and add an + ellipsis. + + Returns + ------- + plotly.graph_objs.layout.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovermode + # --------- + @property + def hovermode(self): + """ + Determines the mode of hover interactions. + + The 'hovermode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['x', 'y', 'closest', False] + + Returns + ------- + Any + """ + return self['hovermode'] + + @hovermode.setter + def hovermode(self, val): + self['hovermode'] = val + + # images + # ------ + @property + def images(self): + """ + The 'images' property is a tuple of instances of + Image that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.Image + - A list or tuple of dicts of string/value properties that + will be passed to the Image constructor + + Supported dict properties: + + layer + Specifies whether images are drawn below or + above traces. When `xref` and `yref` are both + set to `paper`, image is drawn below the entire + plot area. + opacity + Sets the opacity of the image. + sizex + Sets the image container size horizontally. The + image will be sized based on the `position` + value. When `xref` is set to `paper`, units are + sized relative to the plot width. + sizey + Sets the image container size vertically. The + image will be sized based on the `position` + value. When `yref` is set to `paper`, units are + sized relative to the plot height. + sizing + Specifies which dimension of the image to + constrain. + source + Specifies the URL of the image to be used. The + URL must be accessible from the domain where + the plot code is run, and can be either + relative or absolute. + visible + Determines whether or not this image is + visible. + x + Sets the image's x position. When `xref` is set + to `paper`, units are sized relative to the + plot height. See `xref` for more info + xanchor + Sets the anchor for the x position + xref + Sets the images's x coordinate axis. If set to + a x axis id (e.g. *x* or *x2*), the `x` + position refers to an x data coordinate If set + to *paper*, the `x` position refers to the + distance from the left of plot in normalized + coordinates where *0* (*1*) corresponds to the + left (right). + y + Sets the image's y position. When `yref` is set + to `paper`, units are sized relative to the + plot height. See `yref` for more info + yanchor + Sets the anchor for the y position. + yref + Sets the images's y coordinate axis. If set to + a y axis id (e.g. *y* or *y2*), the `y` + position refers to a y data coordinate. If set + to *paper*, the `y` position refers to the + distance from the bottom of the plot in + normalized coordinates where *0* (*1*) + corresponds to the bottom (top). + + Returns + ------- + tuple[plotly.graph_objs.layout.Image] + """ + return self['images'] + + @images.setter + def images(self, val): + self['images'] = val + + # legend + # ------ + @property + def legend(self): + """ + The 'legend' property is an instance of Legend + that may be specified as: + - An instance of plotly.graph_objs.layout.Legend + - A dict of string/value properties that will be passed + to the Legend constructor + + Supported dict properties: + + bgcolor + Sets the legend background color. + bordercolor + Sets the color of the border enclosing the + legend. + borderwidth + Sets the width (in px) of the border enclosing + the legend. + font + Sets the font used to text the legend items. + orientation + Sets the orientation of the legend. + tracegroupgap + Sets the amount of vertical space (in px) + between legend groups. + traceorder + Determines the order at which the legend items + are displayed. If *normal*, the items are + displayed top-to-bottom in the same order as + the input data. If *reversed*, the items are + displayed in the opposite order as *normal*. If + *grouped*, the items are displayed in groups + (when a trace `legendgroup` is provided). if + *grouped+reversed*, the items are displayed in + the opposite order as *grouped*. + x + Sets the x position (in normalized coordinates) + of the legend. + xanchor + Sets the legend's horizontal position anchor. + This anchor binds the `x` position to the + *left*, *center* or *right* of the legend. + y + Sets the y position (in normalized coordinates) + of the legend. + yanchor + Sets the legend's vertical position anchor This + anchor binds the `y` position to the *top*, + *middle* or *bottom* of the legend. + + Returns + ------- + plotly.graph_objs.layout.Legend + """ + return self['legend'] + + @legend.setter + def legend(self, val): + self['legend'] = val + + # mapbox + # ------ + @property + def mapbox(self): + """ + The 'mapbox' property is an instance of Mapbox + that may be specified as: + - An instance of plotly.graph_objs.layout.Mapbox + - A dict of string/value properties that will be passed + to the Mapbox constructor + + Supported dict properties: + + accesstoken + Sets the mapbox access token to be used for + this mapbox map. Alternatively, the mapbox + access token can be set in the configuration + options under `mapboxAccessToken`. + bearing + Sets the bearing angle of the map (in degrees + counter-clockwise from North). + center + plotly.graph_objs.layout.mapbox.Center instance + or dict with compatible properties + domain + plotly.graph_objs.layout.mapbox.Domain instance + or dict with compatible properties + layers + plotly.graph_objs.layout.mapbox.Layer instance + or dict with compatible properties + pitch + Sets the pitch angle of the map (in degrees, + where *0* means perpendicular to the surface of + the map). + style + Sets the Mapbox map style. Either input one of + the default Mapbox style names or the URL to a + custom style or a valid Mapbox style JSON. + zoom + Sets the zoom level of the map. + + Returns + ------- + plotly.graph_objs.layout.Mapbox + """ + return self['mapbox'] + + @mapbox.setter + def mapbox(self, val): + self['mapbox'] = val + + # margin + # ------ + @property + def margin(self): + """ + The 'margin' property is an instance of Margin + that may be specified as: + - An instance of plotly.graph_objs.layout.Margin + - A dict of string/value properties that will be passed + to the Margin constructor + + Supported dict properties: + + autoexpand + + b + Sets the bottom margin (in px). + l + Sets the left margin (in px). + pad + Sets the amount of padding (in px) between the + plotting area and the axis lines + r + Sets the right margin (in px). + t + Sets the top margin (in px). + + Returns + ------- + plotly.graph_objs.layout.Margin + """ + return self['margin'] + + @margin.setter + def margin(self, val): + self['margin'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + For polar plots only. Rotates the entire polar by the given + angle. + + The 'orientation' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # paper_bgcolor + # ------------- + @property + def paper_bgcolor(self): + """ + Sets the color of paper where the graph is drawn. + + The 'paper_bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['paper_bgcolor'] + + @paper_bgcolor.setter + def paper_bgcolor(self, val): + self['paper_bgcolor'] = val + + # plot_bgcolor + # ------------ + @property + def plot_bgcolor(self): + """ + Sets the color of plotting area in-between x and y axes. + + The 'plot_bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['plot_bgcolor'] + + @plot_bgcolor.setter + def plot_bgcolor(self, val): + self['plot_bgcolor'] = val + + # polar + # ----- + @property + def polar(self): + """ + The 'polar' property is an instance of Polar + that may be specified as: + - An instance of plotly.graph_objs.layout.Polar + - A dict of string/value properties that will be passed + to the Polar constructor + + Supported dict properties: + + angularaxis + plotly.graph_objs.layout.polar.AngularAxis + instance or dict with compatible properties + bgcolor + Set the background color of the subplot + domain + plotly.graph_objs.layout.polar.Domain instance + or dict with compatible properties + radialaxis + plotly.graph_objs.layout.polar.RadialAxis + instance or dict with compatible properties + sector + Sets angular span of this polar subplot with + two angles (in degrees). Sector are assumed to + be spanned in the counterclockwise direction + with *0* corresponding to rightmost limit of + the polar subplot. + + Returns + ------- + plotly.graph_objs.layout.Polar + """ + return self['polar'] + + @polar.setter + def polar(self, val): + self['polar'] = val + + # radialaxis + # ---------- + @property + def radialaxis(self): + """ + The 'radialaxis' property is an instance of RadialAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.RadialAxis + - A dict of string/value properties that will be passed + to the RadialAxis constructor + + Supported dict properties: + + domain + Polar chart subplots are not supported yet. + This key has currently no effect. + endpadding + + orientation + Sets the orientation (an angle with respect to + the origin) of the radial axis. + range + Defines the start and end point of this radial + axis. + showline + Determines whether or not the line bounding + this radial axis will be shown on the figure. + showticklabels + Determines whether or not the radial axis ticks + will feature tick labels. + tickcolor + Sets the color of the tick lines on this radial + axis. + ticklen + Sets the length of the tick lines on this + radial axis. + tickorientation + Sets the orientation (from the paper + perspective) of the radial axis tick labels. + ticksuffix + Sets the length of the tick lines on this + radial axis. + visible + Determines whether or not this axis will be + visible. + + Returns + ------- + plotly.graph_objs.layout.RadialAxis + """ + return self['radialaxis'] + + @radialaxis.setter + def radialaxis(self, val): + self['radialaxis'] = val + + # scene + # ----- + @property + def scene(self): + """ + The 'scene' property is an instance of Scene + that may be specified as: + - An instance of plotly.graph_objs.layout.Scene + - A dict of string/value properties that will be passed + to the Scene constructor + + Supported dict properties: + + annotations + plotly.graph_objs.layout.scene.Annotation + instance or dict with compatible properties + aspectmode + If *cube*, this scene's axes are drawn as a + cube, regardless of the axes' ranges. If + *data*, this scene's axes are drawn in + proportion with the axes' ranges. If *manual*, + this scene's axes are drawn in proportion with + the input of *aspectratio* (the default + behavior if *aspectratio* is provided). If + *auto*, this scene's axes are drawn using the + results of *data* except when one axis is more + than four times the size of the two others, + where in that case the results of *cube* are + used. + aspectratio + Sets this scene's axis aspectratio. + bgcolor + + camera + plotly.graph_objs.layout.scene.Camera instance + or dict with compatible properties + domain + plotly.graph_objs.layout.scene.Domain instance + or dict with compatible properties + dragmode + Determines the mode of drag interactions for + this scene. + hovermode + Determines the mode of hover interactions for + this scene. + xaxis + plotly.graph_objs.layout.scene.XAxis instance + or dict with compatible properties + yaxis + plotly.graph_objs.layout.scene.YAxis instance + or dict with compatible properties + zaxis + plotly.graph_objs.layout.scene.ZAxis instance + or dict with compatible properties + + Returns + ------- + plotly.graph_objs.layout.Scene + """ + return self['scene'] + + @scene.setter + def scene(self, val): + self['scene'] = val + + # selectdirection + # --------------- + @property + def selectdirection(self): + """ + When "dragmode" is set to "select", this limits the selection + of the drag to horizontal, vertical or diagonal. "h" only + allows horizontal selection, "v" only vertical, "d" only + diagonal and "any" sets no limit. + + The 'selectdirection' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['h', 'v', 'd', 'any'] + + Returns + ------- + Any + """ + return self['selectdirection'] + + @selectdirection.setter + def selectdirection(self, val): + self['selectdirection'] = val + + # separators + # ---------- + @property + def separators(self): + """ + Sets the decimal and thousand separators. For example, *. * + puts a '.' before decimals and a space between thousands. In + English locales, dflt is *.,* but other locales may alter this + default. + + The 'separators' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['separators'] + + @separators.setter + def separators(self, val): + self['separators'] = val + + # shapes + # ------ + @property + def shapes(self): + """ + The 'shapes' property is a tuple of instances of + Shape that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.Shape + - A list or tuple of dicts of string/value properties that + will be passed to the Shape constructor + + Supported dict properties: + + fillcolor + Sets the color filling the shape's interior. + layer + Specifies whether shapes are drawn below or + above traces. + line + plotly.graph_objs.layout.shape.Line instance or + dict with compatible properties + opacity + Sets the opacity of the shape. + path + For `type` *path* - a valid SVG path with the + pixel values replaced by data values in + `xsizemode`/`ysizemode` being *scaled* and + taken unmodified as pixels relative to + `xanchor` and `yanchor` in case of *pixel* size + mode. There are a few restrictions / quirks + only absolute instructions, not relative. So + the allowed segments are: M, L, H, V, Q, C, T, + S, and Z arcs (A) are not allowed because + radius rx and ry are relative. In the future we + could consider supporting relative commands, + but we would have to decide on how to handle + date and log axes. Note that even as is, Q and + C Bezier paths that are smooth on linear axes + may not be smooth on log, and vice versa. no + chained "polybezier" commands - specify the + segment type for each one. On category axes, + values are numbers scaled to the serial numbers + of categories because using the categories + themselves there would be no way to describe + fractional positions On data axes: because + space and T are both normal components of path + strings, we can't use either to separate date + from time parts. Therefore we'll use underscore + for this purpose: 2015-02-21_13:45:56.789 + type + Specifies the shape type to be drawn. If + *line*, a line is drawn from (`x0`,`y0`) to + (`x1`,`y1`) with respect to the axes' sizing + mode. If *circle*, a circle is drawn from + ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius + (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 + -`y0`)|) with respect to the axes' sizing mode. + If *rect*, a rectangle is drawn linking + (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), + (`x0`,`y1`), (`x0`,`y0`) with respect to the + axes' sizing mode. If *path*, draw a custom SVG + path using `path`. with respect to the axes' + sizing mode. + visible + Determines whether or not this shape is + visible. + x0 + Sets the shape's starting x position. See + `type` and `xsizemode` for more info. + x1 + Sets the shape's end x position. See `type` and + `xsizemode` for more info. + xanchor + Only relevant in conjunction with `xsizemode` + set to *pixel*. Specifies the anchor point on + the x axis to which `x0`, `x1` and x + coordinates within `path` are relative to. E.g. + useful to attach a pixel sized shape to a + certain data value. No effect when `xsizemode` + not set to *pixel*. + xref + Sets the shape's x coordinate axis. If set to + an x axis id (e.g. *x* or *x2*), the `x` + position refers to an x coordinate. If set to + *paper*, the `x` position refers to the + distance from the left side of the plotting + area in normalized coordinates where *0* (*1*) + corresponds to the left (right) side. If the + axis `type` is *log*, then you must take the + log of your desired range. If the axis `type` + is *date*, then you must convert the date to + unix time in milliseconds. + xsizemode + Sets the shapes's sizing mode along the x axis. + If set to *scaled*, `x0`, `x1` and x + coordinates within `path` refer to data values + on the x axis or a fraction of the plot area's + width (`xref` set to *paper*). If set to + *pixel*, `xanchor` specifies the x position in + terms of data or plot fraction but `x0`, `x1` + and x coordinates within `path` are pixels + relative to `xanchor`. This way, the shape can + have a fixed width while maintaining a position + relative to data or plot fraction. + y0 + Sets the shape's starting y position. See + `type` and `ysizemode` for more info. + y1 + Sets the shape's end y position. See `type` and + `ysizemode` for more info. + yanchor + Only relevant in conjunction with `ysizemode` + set to *pixel*. Specifies the anchor point on + the y axis to which `y0`, `y1` and y + coordinates within `path` are relative to. E.g. + useful to attach a pixel sized shape to a + certain data value. No effect when `ysizemode` + not set to *pixel*. + yref + Sets the annotation's y coordinate axis. If set + to an y axis id (e.g. *y* or *y2*), the `y` + position refers to an y coordinate If set to + *paper*, the `y` position refers to the + distance from the bottom of the plotting area + in normalized coordinates where *0* (*1*) + corresponds to the bottom (top). + ysizemode + Sets the shapes's sizing mode along the y axis. + If set to *scaled*, `y0`, `y1` and y + coordinates within `path` refer to data values + on the y axis or a fraction of the plot area's + height (`yref` set to *paper*). If set to + *pixel*, `yanchor` specifies the y position in + terms of data or plot fraction but `y0`, `y1` + and y coordinates within `path` are pixels + relative to `yanchor`. This way, the shape can + have a fixed height while maintaining a + position relative to data or plot fraction. + + Returns + ------- + tuple[plotly.graph_objs.layout.Shape] + """ + return self['shapes'] + + @shapes.setter + def shapes(self, val): + self['shapes'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not a legend is drawn. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # sliders + # ------- + @property + def sliders(self): + """ + The 'sliders' property is a tuple of instances of + Slider that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.Slider + - A list or tuple of dicts of string/value properties that + will be passed to the Slider constructor + + Supported dict properties: + + active + Determines which button (by index starting from + 0) is considered active. + activebgcolor + Sets the background color of the slider grip + while dragging. + bgcolor + Sets the background color of the slider. + bordercolor + Sets the color of the border enclosing the + slider. + borderwidth + Sets the width (in px) of the border enclosing + the slider. + currentvalue + plotly.graph_objs.layout.slider.Currentvalue + instance or dict with compatible properties + font + Sets the font of the slider step labels. + len + Sets the length of the slider This measure + excludes the padding of both ends. That is, the + slider's length is this length minus the + padding on both ends. + lenmode + Determines whether this slider length is set in + units of plot *fraction* or in *pixels. Use + `len` to set the value. + minorticklen + Sets the length in pixels of minor step tick + marks + pad + Set the padding of the slider component along + each side. + steps + plotly.graph_objs.layout.slider.Step instance + or dict with compatible properties + tickcolor + Sets the color of the border enclosing the + slider. + ticklen + Sets the length in pixels of step tick marks + tickwidth + Sets the tick width (in px). + transition + plotly.graph_objs.layout.slider.Transition + instance or dict with compatible properties + visible + Determines whether or not the slider is + visible. + x + Sets the x position (in normalized coordinates) + of the slider. + xanchor + Sets the slider's horizontal position anchor. + This anchor binds the `x` position to the + *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the slider. + yanchor + Sets the slider's vertical position anchor This + anchor binds the `y` position to the *top*, + *middle* or *bottom* of the range selector. + + Returns + ------- + tuple[plotly.graph_objs.layout.Slider] + """ + return self['sliders'] + + @sliders.setter + def sliders(self, val): + self['sliders'] = val + + # spikedistance + # ------------- + @property + def spikedistance(self): + """ + Sets the default distance (in pixels) to look for data to draw + spikelines to (-1 means no cutoff, 0 means no looking for + data). As with hoverdistance, distance does not apply to area- + like objects. In addition, some objects can be hovered on but + will not generate spikelines, such as scatter fills. + + The 'spikedistance' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + + Returns + ------- + int + """ + return self['spikedistance'] + + @spikedistance.setter + def spikedistance(self, val): + self['spikedistance'] = val + + # ternary + # ------- + @property + def ternary(self): + """ + The 'ternary' property is an instance of Ternary + that may be specified as: + - An instance of plotly.graph_objs.layout.Ternary + - A dict of string/value properties that will be passed + to the Ternary constructor + + Supported dict properties: + + aaxis + plotly.graph_objs.layout.ternary.Aaxis instance + or dict with compatible properties + baxis + plotly.graph_objs.layout.ternary.Baxis instance + or dict with compatible properties + bgcolor + Set the background color of the subplot + caxis + plotly.graph_objs.layout.ternary.Caxis instance + or dict with compatible properties + domain + plotly.graph_objs.layout.ternary.Domain + instance or dict with compatible properties + sum + The number each triplet should sum to, and the + maximum range of each axis + + Returns + ------- + plotly.graph_objs.layout.Ternary + """ + return self['ternary'] + + @ternary.setter + def ternary(self, val): + self['ternary'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the plot's title. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets the title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # updatemenus + # ----------- + @property + def updatemenus(self): + """ + The 'updatemenus' property is a tuple of instances of + Updatemenu that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.Updatemenu + - A list or tuple of dicts of string/value properties that + will be passed to the Updatemenu constructor + + Supported dict properties: + + active + Determines which button (by index starting from + 0) is considered active. + bgcolor + Sets the background color of the update menu + buttons. + bordercolor + Sets the color of the border enclosing the + update menu. + borderwidth + Sets the width (in px) of the border enclosing + the update menu. + buttons + plotly.graph_objs.layout.updatemenu.Button + instance or dict with compatible properties + direction + Determines the direction in which the buttons + are laid out, whether in a dropdown menu or a + row/column of buttons. For `left` and `up`, the + buttons will still appear in left-to-right or + top-to-bottom order respectively. + font + Sets the font of the update menu button text. + pad + Sets the padding around the buttons or dropdown + menu. + showactive + Highlights active dropdown item or active + button if true. + type + Determines whether the buttons are accessible + via a dropdown menu or whether the buttons are + stacked horizontally or vertically + visible + Determines whether or not the update menu is + visible. + x + Sets the x position (in normalized coordinates) + of the update menu. + xanchor + Sets the update menu's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the update menu. + yanchor + Sets the update menu's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the range + selector. + + Returns + ------- + tuple[plotly.graph_objs.layout.Updatemenu] + """ + return self['updatemenus'] + + @updatemenus.setter + def updatemenus(self, val): + self['updatemenus'] = val + + # violingap + # --------- + @property + def violingap(self): + """ + Sets the gap (in plot fraction) between violins of adjacent + location coordinates. + + The 'violingap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['violingap'] + + @violingap.setter + def violingap(self, val): + self['violingap'] = val + + # violingroupgap + # -------------- + @property + def violingroupgap(self): + """ + Sets the gap (in plot fraction) between violins of the same + location coordinate. + + The 'violingroupgap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['violingroupgap'] + + @violingroupgap.setter + def violingroupgap(self, val): + self['violingroupgap'] = val + + # violinmode + # ---------- + @property + def violinmode(self): + """ + Determines how violins at the same location coordinate are + displayed on the graph. If *group*, the violins are plotted + next to one another centered around the shared location. If + *overlay*, the violins are plotted over one another, you might + need to set *opacity* to see them multiple violins. + + The 'violinmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['group', 'overlay'] + + Returns + ------- + Any + """ + return self['violinmode'] + + @violinmode.setter + def violinmode(self, val): + self['violinmode'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the plot's width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [10, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + The 'xaxis' property is an instance of XAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.XAxis + - A dict of string/value properties that will be passed + to the XAxis constructor + + Supported dict properties: + + anchor + If set to an opposite-letter axis id (e.g. + `x2`, `y`), this axis is bound to the + corresponding opposite-letter axis. If set to + *free*, this axis' position is determined by + `position`. + automargin + Determines whether long tick labels + automatically grow the figure margins. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + constrain + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines how that + happens: by increasing the *range* (default), + or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines which + direction we push the originally specified plot + area. Options are *left*, *center* (default), + and *right* for x axes, and *top*, *middle* + (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot + fraction). + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + overlaying + If set a same-letter axis id, this axis is + overlaid on top of the corresponding same- + letter axis. If *false*, this axis does not + overlay any same-letter axes. + position + Sets the position of this axis in the plotting + space (in normalized coordinates). Only has an + effect if `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + rangeselector + plotly.graph_objs.layout.xaxis.Rangeselector + instance or dict with compatible properties + rangeslider + plotly.graph_objs.layout.xaxis.Rangeslider + instance or dict with compatible properties + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the + range of this axis changes together with the + range of the corresponding axis such that the + scale of pixels per unit is in a constant + ratio. Both axes are still zoomable, but when + you zoom one, the other will zoom the same + amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce + the constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` + but you can only link axes of the same `type`. + The linked axis can have the opposite letter + (to constrain the aspect ratio) or the same + letter (to match scales across subplots). Loops + (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant + and the last constraint encountered will be + ignored to avoid possible inconsistent + constraints via `scaleratio`. + scaleratio + If this axis is linked to another by + `scaleanchor`, this determines the pixel to + unit scale ratio. For example, if this value is + 10, then every unit on this axis spans 10 times + the number of pixels as a unit on the linked + axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Determines whether or not spikes (aka + droplines) are drawn for this axis. Note: This + only takes affect when hovermode = closest + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned + at the *bottom* (*left*) or *top* (*right*) of + the plotting area. + spikecolor + Sets the spike color. If undefined, will use + the series color + spikedash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line + If *toaxis*, the line is drawn from the data + point to the axis the series is plotted on. If + *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If + *marker*, then a marker dot is drawn on the + axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the + cursor or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.xaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + plotly.graph_objs.layout.XAxis + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + The 'yaxis' property is an instance of YAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.YAxis + - A dict of string/value properties that will be passed + to the YAxis constructor + + Supported dict properties: + + anchor + If set to an opposite-letter axis id (e.g. + `x2`, `y`), this axis is bound to the + corresponding opposite-letter axis. If set to + *free*, this axis' position is determined by + `position`. + automargin + Determines whether long tick labels + automatically grow the figure margins. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + constrain + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines how that + happens: by increasing the *range* (default), + or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines which + direction we push the originally specified plot + area. Options are *left*, *center* (default), + and *right* for x axes, and *top*, *middle* + (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot + fraction). + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + overlaying + If set a same-letter axis id, this axis is + overlaid on top of the corresponding same- + letter axis. If *false*, this axis does not + overlay any same-letter axes. + position + Sets the position of this axis in the plotting + space (in normalized coordinates). Only has an + effect if `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the + range of this axis changes together with the + range of the corresponding axis such that the + scale of pixels per unit is in a constant + ratio. Both axes are still zoomable, but when + you zoom one, the other will zoom the same + amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce + the constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` + but you can only link axes of the same `type`. + The linked axis can have the opposite letter + (to constrain the aspect ratio) or the same + letter (to match scales across subplots). Loops + (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant + and the last constraint encountered will be + ignored to avoid possible inconsistent + constraints via `scaleratio`. + scaleratio + If this axis is linked to another by + `scaleanchor`, this determines the pixel to + unit scale ratio. For example, if this value is + 10, then every unit on this axis spans 10 times + the number of pixels as a unit on the linked + axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Determines whether or not spikes (aka + droplines) are drawn for this axis. Note: This + only takes affect when hovermode = closest + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned + at the *bottom* (*left*) or *top* (*right*) of + the plotting area. + spikecolor + Sets the spike color. If undefined, will use + the series color + spikedash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line + If *toaxis*, the line is drawn from the data + point to the axis the series is plotted on. If + *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If + *marker*, then a marker dot is drawn on the + axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the + cursor or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.yaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + plotly.graph_objs.layout.YAxis + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + angularaxis + plotly.graph_objs.layout.AngularAxis instance or dict + with compatible properties + annotations + plotly.graph_objs.layout.Annotation instance or dict + with compatible properties + autosize + Determines whether or not a layout width or height that + has been left undefined by the user is initialized on + each relayout. Note that, regardless of this attribute, + an undefined layout width or height is always + initialized on the first call to plot. + bargap + Sets the gap (in plot fraction) between bars of + adjacent location coordinates. + bargroupgap + Sets the gap (in plot fraction) between bars of the + same location coordinate. + barmode + Determines how bars at the same location coordinate are + displayed on the graph. With *stack*, the bars are + stacked on top of one another With *relative*, the bars + are stacked on top of one another, with negative values + below the axis, positive values above With *group*, the + bars are plotted next to one another centered around + the shared location. With *overlay*, the bars are + plotted over one another, you might need to an + *opacity* to see multiple bars. + barnorm + Sets the normalization for bar traces on the graph. + With *fraction*, the value of each bar is divide by the + sum of the values at the location coordinate. With + *percent*, the results form *fraction* are presented in + percents. + boxgap + Sets the gap (in plot fraction) between boxes of + adjacent location coordinates. + boxgroupgap + Sets the gap (in plot fraction) between boxes of the + same location coordinate. + boxmode + Determines how boxes at the same location coordinate + are displayed on the graph. If *group*, the boxes are + plotted next to one another centered around the shared + location. If *overlay*, the boxes are plotted over one + another, you might need to set *opacity* to see them + multiple boxes. + calendar + Sets the default calendar system to use for + interpreting and displaying dates throughout the plot. + colorway + Sets the default trace colors. + datarevision + If provided, a changed value tells `Plotly.react` that + one or more data arrays has changed. This way you can + modify arrays in-place rather than making a complete + new copy for an incremental change. If NOT provided, + `Plotly.react` assumes that data arrays are being + treated as immutable, thus any data array with a + different identity from its predecessor contains new + data. + direction + For polar plots only. Sets the direction corresponding + to positive angles. + dragmode + Determines the mode of drag interactions. *select* and + *lasso* apply only to scatter traces with markers or + text. *orbit* and *turntable* apply only to 3D scenes. + font + Sets the global font. Note that fonts used in traces + and other layout components inherit from the global + font. + geo + plotly.graph_objs.layout.Geo instance or dict with + compatible properties + grid + plotly.graph_objs.layout.Grid instance or dict with + compatible properties + height + Sets the plot's height (in px). + hiddenlabels + + hiddenlabelssrc + Sets the source reference on plot.ly for hiddenlabels + . + hidesources + Determines whether or not a text link citing the data + source is placed at the bottom-right cored of the + figure. Has only an effect only on graphs that have + been generated via forked graphs from the plotly + service (at https://plot.ly or on-premise). + hoverdistance + Sets the default distance (in pixels) to look for data + to add hover labels (-1 means no cutoff, 0 means no + looking for data). This is only a real distance for + hovering on point-like objects, like scatter points. + For area-like objects (bars, scatter fills, etc) + hovering is on inside the area and off outside, but + these objects will not supersede hover on point-like + objects in case of conflict. + hoverlabel + plotly.graph_objs.layout.Hoverlabel instance or dict + with compatible properties + hovermode + Determines the mode of hover interactions. + images + plotly.graph_objs.layout.Image instance or dict with + compatible properties + legend + plotly.graph_objs.layout.Legend instance or dict with + compatible properties + mapbox + plotly.graph_objs.layout.Mapbox instance or dict with + compatible properties + margin + plotly.graph_objs.layout.Margin instance or dict with + compatible properties + orientation + For polar plots only. Rotates the entire polar by the + given angle. + paper_bgcolor + Sets the color of paper where the graph is drawn. + plot_bgcolor + Sets the color of plotting area in-between x and y + axes. + polar + plotly.graph_objs.layout.Polar instance or dict with + compatible properties + radialaxis + plotly.graph_objs.layout.RadialAxis instance or dict + with compatible properties + scene + plotly.graph_objs.layout.Scene instance or dict with + compatible properties + selectdirection + When "dragmode" is set to "select", this limits the + selection of the drag to horizontal, vertical or + diagonal. "h" only allows horizontal selection, "v" + only vertical, "d" only diagonal and "any" sets no + limit. + separators + Sets the decimal and thousand separators. For example, + *. * puts a '.' before decimals and a space between + thousands. In English locales, dflt is *.,* but other + locales may alter this default. + shapes + plotly.graph_objs.layout.Shape instance or dict with + compatible properties + showlegend + Determines whether or not a legend is drawn. + sliders + plotly.graph_objs.layout.Slider instance or dict with + compatible properties + spikedistance + Sets the default distance (in pixels) to look for data + to draw spikelines to (-1 means no cutoff, 0 means no + looking for data). As with hoverdistance, distance does + not apply to area-like objects. In addition, some + objects can be hovered on but will not generate + spikelines, such as scatter fills. + ternary + plotly.graph_objs.layout.Ternary instance or dict with + compatible properties + title + Sets the plot's title. + titlefont + Sets the title font. + updatemenus + plotly.graph_objs.layout.Updatemenu instance or dict + with compatible properties + violingap + Sets the gap (in plot fraction) between violins of + adjacent location coordinates. + violingroupgap + Sets the gap (in plot fraction) between violins of the + same location coordinate. + violinmode + Determines how violins at the same location coordinate + are displayed on the graph. If *group*, the violins are + plotted next to one another centered around the shared + location. If *overlay*, the violins are plotted over + one another, you might need to set *opacity* to see + them multiple violins. + width + Sets the plot's width (in px). + xaxis + plotly.graph_objs.layout.XAxis instance or dict with + compatible properties + yaxis + plotly.graph_objs.layout.YAxis instance or dict with + compatible properties + """ + + def __init__( + self, + arg=None, + angularaxis=None, + annotations=None, + autosize=None, + bargap=None, + bargroupgap=None, + barmode=None, + barnorm=None, + boxgap=None, + boxgroupgap=None, + boxmode=None, + calendar=None, + colorway=None, + datarevision=None, + direction=None, + dragmode=None, + font=None, + geo=None, + grid=None, + height=None, + hiddenlabels=None, + hiddenlabelssrc=None, + hidesources=None, + hoverdistance=None, + hoverlabel=None, + hovermode=None, + images=None, + legend=None, + mapbox=None, + margin=None, + orientation=None, + paper_bgcolor=None, + plot_bgcolor=None, + polar=None, + radialaxis=None, + scene=None, + selectdirection=None, + separators=None, + shapes=None, + showlegend=None, + sliders=None, + spikedistance=None, + ternary=None, + title=None, + titlefont=None, + updatemenus=None, + violingap=None, + violingroupgap=None, + violinmode=None, + width=None, + xaxis=None, + yaxis=None, + **kwargs + ): + """ + Construct a new Layout object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Layout + angularaxis + plotly.graph_objs.layout.AngularAxis instance or dict + with compatible properties + annotations + plotly.graph_objs.layout.Annotation instance or dict + with compatible properties + autosize + Determines whether or not a layout width or height that + has been left undefined by the user is initialized on + each relayout. Note that, regardless of this attribute, + an undefined layout width or height is always + initialized on the first call to plot. + bargap + Sets the gap (in plot fraction) between bars of + adjacent location coordinates. + bargroupgap + Sets the gap (in plot fraction) between bars of the + same location coordinate. + barmode + Determines how bars at the same location coordinate are + displayed on the graph. With *stack*, the bars are + stacked on top of one another With *relative*, the bars + are stacked on top of one another, with negative values + below the axis, positive values above With *group*, the + bars are plotted next to one another centered around + the shared location. With *overlay*, the bars are + plotted over one another, you might need to an + *opacity* to see multiple bars. + barnorm + Sets the normalization for bar traces on the graph. + With *fraction*, the value of each bar is divide by the + sum of the values at the location coordinate. With + *percent*, the results form *fraction* are presented in + percents. + boxgap + Sets the gap (in plot fraction) between boxes of + adjacent location coordinates. + boxgroupgap + Sets the gap (in plot fraction) between boxes of the + same location coordinate. + boxmode + Determines how boxes at the same location coordinate + are displayed on the graph. If *group*, the boxes are + plotted next to one another centered around the shared + location. If *overlay*, the boxes are plotted over one + another, you might need to set *opacity* to see them + multiple boxes. + calendar + Sets the default calendar system to use for + interpreting and displaying dates throughout the plot. + colorway + Sets the default trace colors. + datarevision + If provided, a changed value tells `Plotly.react` that + one or more data arrays has changed. This way you can + modify arrays in-place rather than making a complete + new copy for an incremental change. If NOT provided, + `Plotly.react` assumes that data arrays are being + treated as immutable, thus any data array with a + different identity from its predecessor contains new + data. + direction + For polar plots only. Sets the direction corresponding + to positive angles. + dragmode + Determines the mode of drag interactions. *select* and + *lasso* apply only to scatter traces with markers or + text. *orbit* and *turntable* apply only to 3D scenes. + font + Sets the global font. Note that fonts used in traces + and other layout components inherit from the global + font. + geo + plotly.graph_objs.layout.Geo instance or dict with + compatible properties + grid + plotly.graph_objs.layout.Grid instance or dict with + compatible properties + height + Sets the plot's height (in px). + hiddenlabels + + hiddenlabelssrc + Sets the source reference on plot.ly for hiddenlabels + . + hidesources + Determines whether or not a text link citing the data + source is placed at the bottom-right cored of the + figure. Has only an effect only on graphs that have + been generated via forked graphs from the plotly + service (at https://plot.ly or on-premise). + hoverdistance + Sets the default distance (in pixels) to look for data + to add hover labels (-1 means no cutoff, 0 means no + looking for data). This is only a real distance for + hovering on point-like objects, like scatter points. + For area-like objects (bars, scatter fills, etc) + hovering is on inside the area and off outside, but + these objects will not supersede hover on point-like + objects in case of conflict. + hoverlabel + plotly.graph_objs.layout.Hoverlabel instance or dict + with compatible properties + hovermode + Determines the mode of hover interactions. + images + plotly.graph_objs.layout.Image instance or dict with + compatible properties + legend + plotly.graph_objs.layout.Legend instance or dict with + compatible properties + mapbox + plotly.graph_objs.layout.Mapbox instance or dict with + compatible properties + margin + plotly.graph_objs.layout.Margin instance or dict with + compatible properties + orientation + For polar plots only. Rotates the entire polar by the + given angle. + paper_bgcolor + Sets the color of paper where the graph is drawn. + plot_bgcolor + Sets the color of plotting area in-between x and y + axes. + polar + plotly.graph_objs.layout.Polar instance or dict with + compatible properties + radialaxis + plotly.graph_objs.layout.RadialAxis instance or dict + with compatible properties + scene + plotly.graph_objs.layout.Scene instance or dict with + compatible properties + selectdirection + When "dragmode" is set to "select", this limits the + selection of the drag to horizontal, vertical or + diagonal. "h" only allows horizontal selection, "v" + only vertical, "d" only diagonal and "any" sets no + limit. + separators + Sets the decimal and thousand separators. For example, + *. * puts a '.' before decimals and a space between + thousands. In English locales, dflt is *.,* but other + locales may alter this default. + shapes + plotly.graph_objs.layout.Shape instance or dict with + compatible properties + showlegend + Determines whether or not a legend is drawn. + sliders + plotly.graph_objs.layout.Slider instance or dict with + compatible properties + spikedistance + Sets the default distance (in pixels) to look for data + to draw spikelines to (-1 means no cutoff, 0 means no + looking for data). As with hoverdistance, distance does + not apply to area-like objects. In addition, some + objects can be hovered on but will not generate + spikelines, such as scatter fills. + ternary + plotly.graph_objs.layout.Ternary instance or dict with + compatible properties + title + Sets the plot's title. + titlefont + Sets the title font. + updatemenus + plotly.graph_objs.layout.Updatemenu instance or dict + with compatible properties + violingap + Sets the gap (in plot fraction) between violins of + adjacent location coordinates. + violingroupgap + Sets the gap (in plot fraction) between violins of the + same location coordinate. + violinmode + Determines how violins at the same location coordinate + are displayed on the graph. If *group*, the violins are + plotted next to one another centered around the shared + location. If *overlay*, the violins are plotted over + one another, you might need to set *opacity* to see + them multiple violins. + width + Sets the plot's width (in px). + xaxis + plotly.graph_objs.layout.XAxis instance or dict with + compatible properties + yaxis + plotly.graph_objs.layout.YAxis instance or dict with + compatible properties + + Returns + ------- + Layout + """ + super(Layout, self).__init__('layout') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Layout +constructor must be a dict or +an instance of plotly.graph_objs.Layout""" + ) + + # Import validators + # ----------------- + from plotly.validators import (layout as v_layout) + + # Initialize validators + # --------------------- + self._validators['angularaxis'] = v_layout.AngularAxisValidator() + self._validators['annotations'] = v_layout.AnnotationsValidator() + self._validators['autosize'] = v_layout.AutosizeValidator() + self._validators['bargap'] = v_layout.BargapValidator() + self._validators['bargroupgap'] = v_layout.BargroupgapValidator() + self._validators['barmode'] = v_layout.BarmodeValidator() + self._validators['barnorm'] = v_layout.BarnormValidator() + self._validators['boxgap'] = v_layout.BoxgapValidator() + self._validators['boxgroupgap'] = v_layout.BoxgroupgapValidator() + self._validators['boxmode'] = v_layout.BoxmodeValidator() + self._validators['calendar'] = v_layout.CalendarValidator() + self._validators['colorway'] = v_layout.ColorwayValidator() + self._validators['datarevision'] = v_layout.DatarevisionValidator() + self._validators['direction'] = v_layout.DirectionValidator() + self._validators['dragmode'] = v_layout.DragmodeValidator() + self._validators['font'] = v_layout.FontValidator() + self._validators['geo'] = v_layout.GeoValidator() + self._validators['grid'] = v_layout.GridValidator() + self._validators['height'] = v_layout.HeightValidator() + self._validators['hiddenlabels'] = v_layout.HiddenlabelsValidator() + self._validators['hiddenlabelssrc' + ] = v_layout.HiddenlabelssrcValidator() + self._validators['hidesources'] = v_layout.HidesourcesValidator() + self._validators['hoverdistance'] = v_layout.HoverdistanceValidator() + self._validators['hoverlabel'] = v_layout.HoverlabelValidator() + self._validators['hovermode'] = v_layout.HovermodeValidator() + self._validators['images'] = v_layout.ImagesValidator() + self._validators['legend'] = v_layout.LegendValidator() + self._validators['mapbox'] = v_layout.MapboxValidator() + self._validators['margin'] = v_layout.MarginValidator() + self._validators['orientation'] = v_layout.OrientationValidator() + self._validators['paper_bgcolor'] = v_layout.PaperBgcolorValidator() + self._validators['plot_bgcolor'] = v_layout.PlotBgcolorValidator() + self._validators['polar'] = v_layout.PolarValidator() + self._validators['radialaxis'] = v_layout.RadialAxisValidator() + self._validators['scene'] = v_layout.SceneValidator() + self._validators['selectdirection' + ] = v_layout.SelectdirectionValidator() + self._validators['separators'] = v_layout.SeparatorsValidator() + self._validators['shapes'] = v_layout.ShapesValidator() + self._validators['showlegend'] = v_layout.ShowlegendValidator() + self._validators['sliders'] = v_layout.SlidersValidator() + self._validators['spikedistance'] = v_layout.SpikedistanceValidator() + self._validators['ternary'] = v_layout.TernaryValidator() + self._validators['title'] = v_layout.TitleValidator() + self._validators['titlefont'] = v_layout.TitlefontValidator() + self._validators['updatemenus'] = v_layout.UpdatemenusValidator() + self._validators['violingap'] = v_layout.ViolingapValidator() + self._validators['violingroupgap'] = v_layout.ViolingroupgapValidator() + self._validators['violinmode'] = v_layout.ViolinmodeValidator() + self._validators['width'] = v_layout.WidthValidator() + self._validators['xaxis'] = v_layout.XAxisValidator() + self._validators['yaxis'] = v_layout.YAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('angularaxis', None) + self.angularaxis = angularaxis if angularaxis is not None else v + v = arg.pop('annotations', None) + self.annotations = annotations if annotations is not None else v + v = arg.pop('autosize', None) + self.autosize = autosize if autosize is not None else v + v = arg.pop('bargap', None) + self.bargap = bargap if bargap is not None else v + v = arg.pop('bargroupgap', None) + self.bargroupgap = bargroupgap if bargroupgap is not None else v + v = arg.pop('barmode', None) + self.barmode = barmode if barmode is not None else v + v = arg.pop('barnorm', None) + self.barnorm = barnorm if barnorm is not None else v + v = arg.pop('boxgap', None) + self.boxgap = boxgap if boxgap is not None else v + v = arg.pop('boxgroupgap', None) + self.boxgroupgap = boxgroupgap if boxgroupgap is not None else v + v = arg.pop('boxmode', None) + self.boxmode = boxmode if boxmode is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('colorway', None) + self.colorway = colorway if colorway is not None else v + v = arg.pop('datarevision', None) + self.datarevision = datarevision if datarevision is not None else v + v = arg.pop('direction', None) + self.direction = direction if direction is not None else v + v = arg.pop('dragmode', None) + self.dragmode = dragmode if dragmode is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('geo', None) + self.geo = geo if geo is not None else v + v = arg.pop('grid', None) + self.grid = grid if grid is not None else v + v = arg.pop('height', None) + self.height = height if height is not None else v + v = arg.pop('hiddenlabels', None) + self.hiddenlabels = hiddenlabels if hiddenlabels is not None else v + v = arg.pop('hiddenlabelssrc', None) + self.hiddenlabelssrc = hiddenlabelssrc if hiddenlabelssrc is not None else v + v = arg.pop('hidesources', None) + self.hidesources = hidesources if hidesources is not None else v + v = arg.pop('hoverdistance', None) + self.hoverdistance = hoverdistance if hoverdistance is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovermode', None) + self.hovermode = hovermode if hovermode is not None else v + v = arg.pop('images', None) + self.images = images if images is not None else v + v = arg.pop('legend', None) + self.legend = legend if legend is not None else v + v = arg.pop('mapbox', None) + self.mapbox = mapbox if mapbox is not None else v + v = arg.pop('margin', None) + self.margin = margin if margin is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('paper_bgcolor', None) + self.paper_bgcolor = paper_bgcolor if paper_bgcolor is not None else v + v = arg.pop('plot_bgcolor', None) + self.plot_bgcolor = plot_bgcolor if plot_bgcolor is not None else v + v = arg.pop('polar', None) + self.polar = polar if polar is not None else v + v = arg.pop('radialaxis', None) + self.radialaxis = radialaxis if radialaxis is not None else v + v = arg.pop('scene', None) + self.scene = scene if scene is not None else v + v = arg.pop('selectdirection', None) + self.selectdirection = selectdirection if selectdirection is not None else v + v = arg.pop('separators', None) + self.separators = separators if separators is not None else v + v = arg.pop('shapes', None) + self.shapes = shapes if shapes is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('sliders', None) + self.sliders = sliders if sliders is not None else v + v = arg.pop('spikedistance', None) + self.spikedistance = spikedistance if spikedistance is not None else v + v = arg.pop('ternary', None) + self.ternary = ternary if ternary is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('updatemenus', None) + self.updatemenus = updatemenus if updatemenus is not None else v + v = arg.pop('violingap', None) + self.violingap = violingap if violingap is not None else v + v = arg.pop('violingroupgap', None) + self.violingroupgap = violingroupgap if violingroupgap is not None else v + v = arg.pop('violinmode', None) + self.violinmode = violinmode if violinmode is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_mesh3d.py b/plotly/graph_objs/_mesh3d.py new file mode 100644 index 0000000000..ad26b1186e --- /dev/null +++ b/plotly/graph_objs/_mesh3d.py @@ -0,0 +1,2303 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Mesh3d(BaseTraceType): + + # alphahull + # --------- + @property + def alphahull(self): + """ + Determines how the mesh surface triangles are derived from the + set of vertices (points) represented by the `x`, `y` and `z` + arrays, if the `i`, `j`, `k` arrays are not supplied. For + general use of `mesh3d` it is preferred that `i`, `j`, `k` are + supplied. If *-1*, Delaunay triangulation is used, which is + mainly suitable if the mesh is a single, more or less layer + surface that is perpendicular to `delaunayaxis`. In case the + `delaunayaxis` intersects the mesh surface at more than one + point it will result triangles that are very long in the + dimension of `delaunayaxis`. If *>0*, the alpha-shape algorithm + is used. In this case, the positive `alphahull` value signals + the use of the alpha-shape algorithm, _and_ its value acts as + the parameter for the mesh fitting. If *0*, the convex-hull + algorithm is used. It is suitable for convex bodies or if the + intention is to enclose the `x`, `y` and `z` point set into a + convex hull. + + The 'alphahull' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['alphahull'] + + @alphahull.setter + def alphahull(self, val): + self['alphahull'] = val + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `color` is set to a numerical array. + Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `color` is set to a numerical array and + `cmin`, `cmax` are set by the user. In this case, it controls + whether the range of colors in `colorscale` is mapped to the + range of values in the `color` array (`cauto: true`), or the + `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the upper bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmin` must be set as + well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the lower bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmax` must be set as + well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the color of the whole mesh + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to mesh3d.colorscale + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.mesh3d.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.mesh3d.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `color` is set to + a numerical array. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # contour + # ------- + @property + def contour(self): + """ + The 'contour' property is an instance of Contour + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.Contour + - A dict of string/value properties that will be passed + to the Contour constructor + + Supported dict properties: + + color + Sets the color of the contour lines. + show + Sets whether or not dynamic contours are shown + on hover + width + Sets the width of the contour lines. + + Returns + ------- + plotly.graph_objs.mesh3d.Contour + """ + return self['contour'] + + @contour.setter + def contour(self, val): + self['contour'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # delaunayaxis + # ------------ + @property + def delaunayaxis(self): + """ + Sets the Delaunay axis, which is the axis that is perpendicular + to the surface of the Delaunay triangulation. It has an effect + if `i`, `j`, `k` are not provided and `alphahull` is set to + indicate Delaunay triangulation. + + The 'delaunayaxis' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['x', 'y', 'z'] + + Returns + ------- + Any + """ + return self['delaunayaxis'] + + @delaunayaxis.setter + def delaunayaxis(self, val): + self['delaunayaxis'] = val + + # facecolor + # --------- + @property + def facecolor(self): + """ + Sets the color of each face Overrides *color* and + *vertexcolor*. + + The 'facecolor' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['facecolor'] + + @facecolor.setter + def facecolor(self, val): + self['facecolor'] = val + + # facecolorsrc + # ------------ + @property + def facecolorsrc(self): + """ + Sets the source reference on plot.ly for facecolor . + + The 'facecolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['facecolorsrc'] + + @facecolorsrc.setter + def facecolorsrc(self, val): + self['facecolorsrc'] = val + + # flatshading + # ----------- + @property + def flatshading(self): + """ + Determines whether or not normal smoothing is applied to the + meshes, creating meshes with an angular, low-poly look via flat + reflections. + + The 'flatshading' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['flatshading'] + + @flatshading.setter + def flatshading(self, val): + self['flatshading'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.mesh3d.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # i + # - + @property + def i(self): + """ + A vector of vertex indices, i.e. integer values between 0 and + the length of the vertex vectors, representing the *first* + vertex of a triangle. For example, `{i[m], j[m], k[m]}` + together represent face m (triangle m) in the mesh, where `i[m] + = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex + arrays. Therefore, each element in `i` represents a point in + space, which is the first vertex of a triangle. + + The 'i' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['i'] + + @i.setter + def i(self, val): + self['i'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # intensity + # --------- + @property + def intensity(self): + """ + Sets the vertex intensity values, used for plotting fields on + meshes + + The 'intensity' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['intensity'] + + @intensity.setter + def intensity(self, val): + self['intensity'] = val + + # intensitysrc + # ------------ + @property + def intensitysrc(self): + """ + Sets the source reference on plot.ly for intensity . + + The 'intensitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['intensitysrc'] + + @intensitysrc.setter + def intensitysrc(self, val): + self['intensitysrc'] = val + + # isrc + # ---- + @property + def isrc(self): + """ + Sets the source reference on plot.ly for i . + + The 'isrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['isrc'] + + @isrc.setter + def isrc(self, val): + self['isrc'] = val + + # j + # - + @property + def j(self): + """ + A vector of vertex indices, i.e. integer values between 0 and + the length of the vertex vectors, representing the *second* + vertex of a triangle. For example, `{i[m], j[m], k[m]}` + together represent face m (triangle m) in the mesh, where `j[m] + = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex + arrays. Therefore, each element in `j` represents a point in + space, which is the second vertex of a triangle. + + The 'j' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['j'] + + @j.setter + def j(self, val): + self['j'] = val + + # jsrc + # ---- + @property + def jsrc(self): + """ + Sets the source reference on plot.ly for j . + + The 'jsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['jsrc'] + + @jsrc.setter + def jsrc(self, val): + self['jsrc'] = val + + # k + # - + @property + def k(self): + """ + A vector of vertex indices, i.e. integer values between 0 and + the length of the vertex vectors, representing the *third* + vertex of a triangle. For example, `{i[m], j[m], k[m]}` + together represent face m (triangle m) in the mesh, where `k[m] + = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex + arrays. Therefore, each element in `k` represents a point in + space, which is the third vertex of a triangle. + + The 'k' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['k'] + + @k.setter + def k(self, val): + self['k'] = val + + # ksrc + # ---- + @property + def ksrc(self): + """ + Sets the source reference on plot.ly for k . + + The 'ksrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ksrc'] + + @ksrc.setter + def ksrc(self, val): + self['ksrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # lighting + # -------- + @property + def lighting(self): + """ + The 'lighting' property is an instance of Lighting + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.Lighting + - A dict of string/value properties that will be passed + to the Lighting constructor + + Supported dict properties: + + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids + math issues arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids + math issues arising from degenerate geometry. + + Returns + ------- + plotly.graph_objs.mesh3d.Lighting + """ + return self['lighting'] + + @lighting.setter + def lighting(self, val): + self['lighting'] = val + + # lightposition + # ------------- + @property + def lightposition(self): + """ + The 'lightposition' property is an instance of Lightposition + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.Lightposition + - A dict of string/value properties that will be passed + to the Lightposition constructor + + Supported dict properties: + + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex. + + Returns + ------- + plotly.graph_objs.mesh3d.Lightposition + """ + return self['lightposition'] + + @lightposition.setter + def lightposition(self, val): + self['lightposition'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the surface. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `color` is set to a numerical array. + Reverses the color mapping if true (`cmin` will correspond to + the last color in the array and `cmax` will correspond to the + first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # scene + # ----- + @property + def scene(self): + """ + Sets a reference between this trace's 3D coordinate system and + a 3D scene. If *scene* (the default value), the (x,y,z) + coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) + coordinates refer to `layout.scene2`, and so on. + + The 'scene' property is an identifier of a particular + subplot, of type 'scene', that may be specified as the string 'scene' + optionally followed by an integer >= 1 + (e.g. 'scene', 'scene1', 'scene2', 'scene3', etc.) + + Returns + ------- + str + """ + return self['scene'] + + @scene.setter + def scene(self, val): + self['scene'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.mesh3d.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with the vertices. If trace + `hoverinfo` contains a *text* flag and *hovertext* is not set, + these elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # vertexcolor + # ----------- + @property + def vertexcolor(self): + """ + Sets the color of each vertex Overrides *color*. + + The 'vertexcolor' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['vertexcolor'] + + @vertexcolor.setter + def vertexcolor(self, val): + self['vertexcolor'] = val + + # vertexcolorsrc + # -------------- + @property + def vertexcolorsrc(self): + """ + Sets the source reference on plot.ly for vertexcolor . + + The 'vertexcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['vertexcolorsrc'] + + @vertexcolorsrc.setter + def vertexcolorsrc(self, val): + self['vertexcolorsrc'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the X coordinates of the vertices. The nth element of + vectors `x`, `y` and `z` jointly represent the X, Y and Z + coordinates of the nth vertex. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the Y coordinates of the vertices. The nth element of + vectors `x`, `y` and `z` jointly represent the X, Y and Z + coordinates of the nth vertex. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the Z coordinates of the vertices. The nth element of + vectors `x`, `y` and `z` jointly represent the X, Y and Z + coordinates of the nth vertex. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zcalendar + # --------- + @property + def zcalendar(self): + """ + Sets the calendar system to use with `z` date data. + + The 'zcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['zcalendar'] + + @zcalendar.setter + def zcalendar(self, val): + self['zcalendar'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + alphahull + Determines how the mesh surface triangles are derived + from the set of vertices (points) represented by the + `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays + are not supplied. For general use of `mesh3d` it is + preferred that `i`, `j`, `k` are supplied. If *-1*, + Delaunay triangulation is used, which is mainly + suitable if the mesh is a single, more or less layer + surface that is perpendicular to `delaunayaxis`. In + case the `delaunayaxis` intersects the mesh surface at + more than one point it will result triangles that are + very long in the dimension of `delaunayaxis`. If *>0*, + the alpha-shape algorithm is used. In this case, the + positive `alphahull` value signals the use of the + alpha-shape algorithm, _and_ its value acts as the + parameter for the mesh fitting. If *0*, the convex- + hull algorithm is used. It is suitable for convex + bodies or if the intention is to enclose the `x`, `y` + and `z` point set into a convex hull. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color of the whole mesh + colorbar + plotly.graph_objs.mesh3d.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + contour + plotly.graph_objs.mesh3d.Contour instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + delaunayaxis + Sets the Delaunay axis, which is the axis that is + perpendicular to the surface of the Delaunay + triangulation. It has an effect if `i`, `j`, `k` are + not provided and `alphahull` is set to indicate + Delaunay triangulation. + facecolor + Sets the color of each face Overrides *color* and + *vertexcolor*. + facecolorsrc + Sets the source reference on plot.ly for facecolor . + flatshading + Determines whether or not normal smoothing is applied + to the meshes, creating meshes with an angular, low- + poly look via flat reflections. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.mesh3d.Hoverlabel instance or dict + with compatible properties + i + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *first* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `i[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `i` represents a point in space, which + is the first vertex of a triangle. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + intensity + Sets the vertex intensity values, used for plotting + fields on meshes + intensitysrc + Sets the source reference on plot.ly for intensity . + isrc + Sets the source reference on plot.ly for i . + j + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *second* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `j[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `j` represents a point in space, which + is the second vertex of a triangle. + jsrc + Sets the source reference on plot.ly for j . + k + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *third* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `k[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `k` represents a point in space, which + is the third vertex of a triangle. + ksrc + Sets the source reference on plot.ly for k . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.mesh3d.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.mesh3d.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.mesh3d.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the vertices. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + vertexcolor + Sets the color of each vertex Overrides *color*. + vertexcolorsrc + Sets the source reference on plot.ly for vertexcolor . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the X coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the Y coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the Z coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + alphahull=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + contour=None, + customdata=None, + customdatasrc=None, + delaunayaxis=None, + facecolor=None, + facecolorsrc=None, + flatshading=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + i=None, + ids=None, + idssrc=None, + intensity=None, + intensitysrc=None, + isrc=None, + j=None, + jsrc=None, + k=None, + ksrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + text=None, + textsrc=None, + uid=None, + vertexcolor=None, + vertexcolorsrc=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Mesh3d object + + Draws sets of triangles with coordinates given by three + 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, + `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha- + shape algorithm or (4) the Convex-hull algorithm + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Mesh3d + alphahull + Determines how the mesh surface triangles are derived + from the set of vertices (points) represented by the + `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays + are not supplied. For general use of `mesh3d` it is + preferred that `i`, `j`, `k` are supplied. If *-1*, + Delaunay triangulation is used, which is mainly + suitable if the mesh is a single, more or less layer + surface that is perpendicular to `delaunayaxis`. In + case the `delaunayaxis` intersects the mesh surface at + more than one point it will result triangles that are + very long in the dimension of `delaunayaxis`. If *>0*, + the alpha-shape algorithm is used. In this case, the + positive `alphahull` value signals the use of the + alpha-shape algorithm, _and_ its value acts as the + parameter for the mesh fitting. If *0*, the convex- + hull algorithm is used. It is suitable for convex + bodies or if the intention is to enclose the `x`, `y` + and `z` point set into a convex hull. + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color of the whole mesh + colorbar + plotly.graph_objs.mesh3d.ColorBar instance or dict with + compatible properties + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + contour + plotly.graph_objs.mesh3d.Contour instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + delaunayaxis + Sets the Delaunay axis, which is the axis that is + perpendicular to the surface of the Delaunay + triangulation. It has an effect if `i`, `j`, `k` are + not provided and `alphahull` is set to indicate + Delaunay triangulation. + facecolor + Sets the color of each face Overrides *color* and + *vertexcolor*. + facecolorsrc + Sets the source reference on plot.ly for facecolor . + flatshading + Determines whether or not normal smoothing is applied + to the meshes, creating meshes with an angular, low- + poly look via flat reflections. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.mesh3d.Hoverlabel instance or dict + with compatible properties + i + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *first* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `i[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `i` represents a point in space, which + is the first vertex of a triangle. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + intensity + Sets the vertex intensity values, used for plotting + fields on meshes + intensitysrc + Sets the source reference on plot.ly for intensity . + isrc + Sets the source reference on plot.ly for i . + j + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *second* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `j[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `j` represents a point in space, which + is the second vertex of a triangle. + jsrc + Sets the source reference on plot.ly for j . + k + A vector of vertex indices, i.e. integer values between + 0 and the length of the vertex vectors, representing + the *third* vertex of a triangle. For example, `{i[m], + j[m], k[m]}` together represent face m (triangle m) in + the mesh, where `k[m] = n` points to the triplet + `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, + each element in `k` represents a point in space, which + is the third vertex of a triangle. + ksrc + Sets the source reference on plot.ly for k . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.mesh3d.Lighting instance or dict with + compatible properties + lightposition + plotly.graph_objs.mesh3d.Lightposition instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.mesh3d.Stream instance or dict with + compatible properties + text + Sets the text elements associated with the vertices. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + vertexcolor + Sets the color of each vertex Overrides *color*. + vertexcolorsrc + Sets the source reference on plot.ly for vertexcolor . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the X coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the Y coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the Z coordinates of the vertices. The nth element + of vectors `x`, `y` and `z` jointly represent the X, Y + and Z coordinates of the nth vertex. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Mesh3d + """ + super(Mesh3d, self).__init__('mesh3d') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Mesh3d +constructor must be a dict or +an instance of plotly.graph_objs.Mesh3d""" + ) + + # Import validators + # ----------------- + from plotly.validators import (mesh3d as v_mesh3d) + + # Initialize validators + # --------------------- + self._validators['alphahull'] = v_mesh3d.AlphahullValidator() + self._validators['autocolorscale'] = v_mesh3d.AutocolorscaleValidator() + self._validators['cauto'] = v_mesh3d.CautoValidator() + self._validators['cmax'] = v_mesh3d.CmaxValidator() + self._validators['cmin'] = v_mesh3d.CminValidator() + self._validators['color'] = v_mesh3d.ColorValidator() + self._validators['colorbar'] = v_mesh3d.ColorBarValidator() + self._validators['colorscale'] = v_mesh3d.ColorscaleValidator() + self._validators['contour'] = v_mesh3d.ContourValidator() + self._validators['customdata'] = v_mesh3d.CustomdataValidator() + self._validators['customdatasrc'] = v_mesh3d.CustomdatasrcValidator() + self._validators['delaunayaxis'] = v_mesh3d.DelaunayaxisValidator() + self._validators['facecolor'] = v_mesh3d.FacecolorValidator() + self._validators['facecolorsrc'] = v_mesh3d.FacecolorsrcValidator() + self._validators['flatshading'] = v_mesh3d.FlatshadingValidator() + self._validators['hoverinfo'] = v_mesh3d.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_mesh3d.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_mesh3d.HoverlabelValidator() + self._validators['i'] = v_mesh3d.IValidator() + self._validators['ids'] = v_mesh3d.IdsValidator() + self._validators['idssrc'] = v_mesh3d.IdssrcValidator() + self._validators['intensity'] = v_mesh3d.IntensityValidator() + self._validators['intensitysrc'] = v_mesh3d.IntensitysrcValidator() + self._validators['isrc'] = v_mesh3d.IsrcValidator() + self._validators['j'] = v_mesh3d.JValidator() + self._validators['jsrc'] = v_mesh3d.JsrcValidator() + self._validators['k'] = v_mesh3d.KValidator() + self._validators['ksrc'] = v_mesh3d.KsrcValidator() + self._validators['legendgroup'] = v_mesh3d.LegendgroupValidator() + self._validators['lighting'] = v_mesh3d.LightingValidator() + self._validators['lightposition'] = v_mesh3d.LightpositionValidator() + self._validators['name'] = v_mesh3d.NameValidator() + self._validators['opacity'] = v_mesh3d.OpacityValidator() + self._validators['reversescale'] = v_mesh3d.ReversescaleValidator() + self._validators['scene'] = v_mesh3d.SceneValidator() + self._validators['selectedpoints'] = v_mesh3d.SelectedpointsValidator() + self._validators['showlegend'] = v_mesh3d.ShowlegendValidator() + self._validators['showscale'] = v_mesh3d.ShowscaleValidator() + self._validators['stream'] = v_mesh3d.StreamValidator() + self._validators['text'] = v_mesh3d.TextValidator() + self._validators['textsrc'] = v_mesh3d.TextsrcValidator() + self._validators['uid'] = v_mesh3d.UidValidator() + self._validators['vertexcolor'] = v_mesh3d.VertexcolorValidator() + self._validators['vertexcolorsrc'] = v_mesh3d.VertexcolorsrcValidator() + self._validators['visible'] = v_mesh3d.VisibleValidator() + self._validators['x'] = v_mesh3d.XValidator() + self._validators['xcalendar'] = v_mesh3d.XcalendarValidator() + self._validators['xsrc'] = v_mesh3d.XsrcValidator() + self._validators['y'] = v_mesh3d.YValidator() + self._validators['ycalendar'] = v_mesh3d.YcalendarValidator() + self._validators['ysrc'] = v_mesh3d.YsrcValidator() + self._validators['z'] = v_mesh3d.ZValidator() + self._validators['zcalendar'] = v_mesh3d.ZcalendarValidator() + self._validators['zsrc'] = v_mesh3d.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('alphahull', None) + self.alphahull = alphahull if alphahull is not None else v + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('contour', None) + self.contour = contour if contour is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('delaunayaxis', None) + self.delaunayaxis = delaunayaxis if delaunayaxis is not None else v + v = arg.pop('facecolor', None) + self.facecolor = facecolor if facecolor is not None else v + v = arg.pop('facecolorsrc', None) + self.facecolorsrc = facecolorsrc if facecolorsrc is not None else v + v = arg.pop('flatshading', None) + self.flatshading = flatshading if flatshading is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('i', None) + self.i = i if i is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('intensity', None) + self.intensity = intensity if intensity is not None else v + v = arg.pop('intensitysrc', None) + self.intensitysrc = intensitysrc if intensitysrc is not None else v + v = arg.pop('isrc', None) + self.isrc = isrc if isrc is not None else v + v = arg.pop('j', None) + self.j = j if j is not None else v + v = arg.pop('jsrc', None) + self.jsrc = jsrc if jsrc is not None else v + v = arg.pop('k', None) + self.k = k if k is not None else v + v = arg.pop('ksrc', None) + self.ksrc = ksrc if ksrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('lighting', None) + self.lighting = lighting if lighting is not None else v + v = arg.pop('lightposition', None) + self.lightposition = lightposition if lightposition is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('scene', None) + self.scene = scene if scene is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('vertexcolor', None) + self.vertexcolor = vertexcolor if vertexcolor is not None else v + v = arg.pop('vertexcolorsrc', None) + self.vertexcolorsrc = vertexcolorsrc if vertexcolorsrc is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zcalendar', None) + self.zcalendar = zcalendar if zcalendar is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'mesh3d' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='mesh3d' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_ohlc.py b/plotly/graph_objs/_ohlc.py new file mode 100644 index 0000000000..99478972c3 --- /dev/null +++ b/plotly/graph_objs/_ohlc.py @@ -0,0 +1,1233 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Ohlc(BaseTraceType): + + # close + # ----- + @property + def close(self): + """ + Sets the close values. + + The 'close' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['close'] + + @close.setter + def close(self, val): + self['close'] = val + + # closesrc + # -------- + @property + def closesrc(self): + """ + Sets the source reference on plot.ly for close . + + The 'closesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['closesrc'] + + @closesrc.setter + def closesrc(self, val): + self['closesrc'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # decreasing + # ---------- + @property + def decreasing(self): + """ + The 'decreasing' property is an instance of Decreasing + that may be specified as: + - An instance of plotly.graph_objs.ohlc.Decreasing + - A dict of string/value properties that will be passed + to the Decreasing constructor + + Supported dict properties: + + line + plotly.graph_objs.ohlc.decreasing.Line instance + or dict with compatible properties + + Returns + ------- + plotly.graph_objs.ohlc.Decreasing + """ + return self['decreasing'] + + @decreasing.setter + def decreasing(self, val): + self['decreasing'] = val + + # high + # ---- + @property + def high(self): + """ + Sets the high values. + + The 'high' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['high'] + + @high.setter + def high(self, val): + self['high'] = val + + # highsrc + # ------- + @property + def highsrc(self): + """ + Sets the source reference on plot.ly for high . + + The 'highsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['highsrc'] + + @highsrc.setter + def highsrc(self, val): + self['highsrc'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.ohlc.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.ohlc.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # increasing + # ---------- + @property + def increasing(self): + """ + The 'increasing' property is an instance of Increasing + that may be specified as: + - An instance of plotly.graph_objs.ohlc.Increasing + - A dict of string/value properties that will be passed + to the Increasing constructor + + Supported dict properties: + + line + plotly.graph_objs.ohlc.increasing.Line instance + or dict with compatible properties + + Returns + ------- + plotly.graph_objs.ohlc.Increasing + """ + return self['increasing'] + + @increasing.setter + def increasing(self, val): + self['increasing'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.ohlc.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + Note that this style setting can also be set + per direction via `increasing.line.dash` and + `decreasing.line.dash`. + width + [object Object] Note that this style setting + can also be set per direction via + `increasing.line.width` and + `decreasing.line.width`. + + Returns + ------- + plotly.graph_objs.ohlc.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # low + # --- + @property + def low(self): + """ + Sets the low values. + + The 'low' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['low'] + + @low.setter + def low(self, val): + self['low'] = val + + # lowsrc + # ------ + @property + def lowsrc(self): + """ + Sets the source reference on plot.ly for low . + + The 'lowsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['lowsrc'] + + @lowsrc.setter + def lowsrc(self, val): + self['lowsrc'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # open + # ---- + @property + def open(self): + """ + Sets the open values. + + The 'open' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['open'] + + @open.setter + def open(self, val): + self['open'] = val + + # opensrc + # ------- + @property + def opensrc(self): + """ + Sets the source reference on plot.ly for open . + + The 'opensrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opensrc'] + + @opensrc.setter + def opensrc(self, val): + self['opensrc'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.ohlc.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.ohlc.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets hover text elements associated with each sample point. If + a single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + this trace's sample points. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the width of the open/close tick marks relative to the *x* + minimal interval. + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, 0.5] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. If absent, linear coordinate will be + generated. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.ohlc.Decreasing instance or dict with + compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.ohlc.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.ohlc.Increasing instance or dict with + compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.ohlc.Line instance or dict with + compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.ohlc.Stream instance or dict with + compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + tickwidth + Sets the width of the open/close tick marks relative to + the *x* minimal interval. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + """ + + def __init__( + self, + arg=None, + close=None, + closesrc=None, + customdata=None, + customdatasrc=None, + decreasing=None, + high=None, + highsrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + increasing=None, + legendgroup=None, + line=None, + low=None, + lowsrc=None, + name=None, + opacity=None, + open=None, + opensrc=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + tickwidth=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xcalendar=None, + xsrc=None, + yaxis=None, + **kwargs + ): + """ + Construct a new Ohlc object + + The ohlc (short for Open-High-Low-Close) is a style of + financial chart describing open, high, low and close for a + given `x` coordinate (most likely time). The tip of the lines + represent the `low` and `high` values and the horizontal + segments represent the `open` and `close` values. Sample points + where the close value is higher (lower) then the open value are + called increasing (decreasing). By default, increasing items + are drawn in green whereas decreasing are drawn in red. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Ohlc + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + decreasing + plotly.graph_objs.ohlc.Decreasing instance or dict with + compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.ohlc.Hoverlabel instance or dict with + compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.ohlc.Increasing instance or dict with + compatible properties + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.ohlc.Line instance or dict with + compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open . + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.ohlc.Stream instance or dict with + compatible properties + text + Sets hover text elements associated with each sample + point. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text . + tickwidth + Sets the width of the open/close tick marks relative to + the *x* minimal interval. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. If absent, linear coordinate + will be generated. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + + Returns + ------- + Ohlc + """ + super(Ohlc, self).__init__('ohlc') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Ohlc +constructor must be a dict or +an instance of plotly.graph_objs.Ohlc""" + ) + + # Import validators + # ----------------- + from plotly.validators import (ohlc as v_ohlc) + + # Initialize validators + # --------------------- + self._validators['close'] = v_ohlc.CloseValidator() + self._validators['closesrc'] = v_ohlc.ClosesrcValidator() + self._validators['customdata'] = v_ohlc.CustomdataValidator() + self._validators['customdatasrc'] = v_ohlc.CustomdatasrcValidator() + self._validators['decreasing'] = v_ohlc.DecreasingValidator() + self._validators['high'] = v_ohlc.HighValidator() + self._validators['highsrc'] = v_ohlc.HighsrcValidator() + self._validators['hoverinfo'] = v_ohlc.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_ohlc.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_ohlc.HoverlabelValidator() + self._validators['ids'] = v_ohlc.IdsValidator() + self._validators['idssrc'] = v_ohlc.IdssrcValidator() + self._validators['increasing'] = v_ohlc.IncreasingValidator() + self._validators['legendgroup'] = v_ohlc.LegendgroupValidator() + self._validators['line'] = v_ohlc.LineValidator() + self._validators['low'] = v_ohlc.LowValidator() + self._validators['lowsrc'] = v_ohlc.LowsrcValidator() + self._validators['name'] = v_ohlc.NameValidator() + self._validators['opacity'] = v_ohlc.OpacityValidator() + self._validators['open'] = v_ohlc.OpenValidator() + self._validators['opensrc'] = v_ohlc.OpensrcValidator() + self._validators['selectedpoints'] = v_ohlc.SelectedpointsValidator() + self._validators['showlegend'] = v_ohlc.ShowlegendValidator() + self._validators['stream'] = v_ohlc.StreamValidator() + self._validators['text'] = v_ohlc.TextValidator() + self._validators['textsrc'] = v_ohlc.TextsrcValidator() + self._validators['tickwidth'] = v_ohlc.TickwidthValidator() + self._validators['uid'] = v_ohlc.UidValidator() + self._validators['visible'] = v_ohlc.VisibleValidator() + self._validators['x'] = v_ohlc.XValidator() + self._validators['xaxis'] = v_ohlc.XAxisValidator() + self._validators['xcalendar'] = v_ohlc.XcalendarValidator() + self._validators['xsrc'] = v_ohlc.XsrcValidator() + self._validators['yaxis'] = v_ohlc.YAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('close', None) + self.close = close if close is not None else v + v = arg.pop('closesrc', None) + self.closesrc = closesrc if closesrc is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('decreasing', None) + self.decreasing = decreasing if decreasing is not None else v + v = arg.pop('high', None) + self.high = high if high is not None else v + v = arg.pop('highsrc', None) + self.highsrc = highsrc if highsrc is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('increasing', None) + self.increasing = increasing if increasing is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('low', None) + self.low = low if low is not None else v + v = arg.pop('lowsrc', None) + self.lowsrc = lowsrc if lowsrc is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('open', None) + self.open = open if open is not None else v + v = arg.pop('opensrc', None) + self.opensrc = opensrc if opensrc is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'ohlc' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='ohlc' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_parcoords.py b/plotly/graph_objs/_parcoords.py new file mode 100644 index 0000000000..e3b40fc14b --- /dev/null +++ b/plotly/graph_objs/_parcoords.py @@ -0,0 +1,1016 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Parcoords(BaseTraceType): + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dimensions + # ---------- + @property + def dimensions(self): + """ + The dimensions (variables) of the parallel coordinates chart. + 2..60 dimensions are supported. + + The 'dimensions' property is a tuple of instances of + Dimension that may be specified as: + - A list or tuple of instances of plotly.graph_objs.parcoords.Dimension + - A list or tuple of dicts of string/value properties that + will be passed to the Dimension constructor + + Supported dict properties: + + constraintrange + The domain range to which the filter on the + dimension is constrained. Must be an array of + `[fromValue, toValue]` with `fromValue <= + toValue`, or if `multiselect` is not disabled, + you may give an array of arrays, where each + inner array is `[fromValue, toValue]`. + label + The shown name of the dimension. + multiselect + Do we allow multiple selection ranges or just a + single range? + range + The domain range that represents the full, + shown axis extent. Defaults to the `values` + extent. Must be an array of `[fromValue, + toValue]` with finite numbers as elements. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + values + Dimension values. `values[n]` represents the + value of the `n`th point in the dataset, + therefore the `values` vector for all + dimensions must be the same (longer vectors + will be truncated). Each value must be a finite + number. + valuessrc + Sets the source reference on plot.ly for + values . + visible + Shows the dimension when set to `true` (the + default). Hides the dimension for `false`. + + Returns + ------- + tuple[plotly.graph_objs.parcoords.Dimension] + """ + return self['dimensions'] + + @dimensions.setter + def dimensions(self, val): + self['dimensions'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this parcoords + trace . + row + If there is a layout grid, use the domain for + this row in the grid for this parcoords trace . + x + Sets the horizontal domain of this parcoords + trace (in plot fraction). + y + Sets the vertical domain of this parcoords + trace (in plot fraction). + + Returns + ------- + plotly.graph_objs.parcoords.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.parcoords.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # labelfont + # --------- + @property + def labelfont(self): + """ + Sets the font for the `dimension` labels. + + The 'labelfont' property is an instance of Labelfont + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Labelfont + - A dict of string/value properties that will be passed + to the Labelfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.parcoords.Labelfont + """ + return self['labelfont'] + + @labelfont.setter + def labelfont(self, val): + self['labelfont'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if line.color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + The default value is false, so that `parcoords` + colorscale can default to `Viridis`. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmin` must be set as well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmax` must be set as well. + color + Sets the line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.parcoords.line.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `line.cmin` and `line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a + colorbar is displayed. + + Returns + ------- + plotly.graph_objs.parcoords.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # rangefont + # --------- + @property + def rangefont(self): + """ + Sets the font for the `dimension` range values. + + The 'rangefont' property is an instance of Rangefont + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Rangefont + - A dict of string/value properties that will be passed + to the Rangefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.parcoords.Rangefont + """ + return self['rangefont'] + + @rangefont.setter + def rangefont(self, val): + self['rangefont'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.parcoords.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the font for the `dimension` tick values. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.parcoords.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.parcoords.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dimensions + The dimensions (variables) of the parallel coordinates + chart. 2..60 dimensions are supported. + domain + plotly.graph_objs.parcoords.Domain instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.parcoords.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + labelfont + Sets the font for the `dimension` labels. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.parcoords.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + rangefont + Sets the font for the `dimension` range values. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.parcoords.Stream instance or dict + with compatible properties + tickfont + Sets the font for the `dimension` tick values. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + customdata=None, + customdatasrc=None, + dimensions=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + labelfont=None, + legendgroup=None, + line=None, + name=None, + opacity=None, + rangefont=None, + selectedpoints=None, + showlegend=None, + stream=None, + tickfont=None, + uid=None, + visible=None, + **kwargs + ): + """ + Construct a new Parcoords object + + Parallel coordinates for multidimensional exploratory data + analysis. The samples are specified in `dimensions`. The colors + are set in `line.color`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Parcoords + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dimensions + The dimensions (variables) of the parallel coordinates + chart. 2..60 dimensions are supported. + domain + plotly.graph_objs.parcoords.Domain instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.parcoords.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + labelfont + Sets the font for the `dimension` labels. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.parcoords.Line instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + rangefont + Sets the font for the `dimension` range values. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.parcoords.Stream instance or dict + with compatible properties + tickfont + Sets the font for the `dimension` tick values. + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Parcoords + """ + super(Parcoords, self).__init__('parcoords') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Parcoords +constructor must be a dict or +an instance of plotly.graph_objs.Parcoords""" + ) + + # Import validators + # ----------------- + from plotly.validators import (parcoords as v_parcoords) + + # Initialize validators + # --------------------- + self._validators['customdata'] = v_parcoords.CustomdataValidator() + self._validators['customdatasrc' + ] = v_parcoords.CustomdatasrcValidator() + self._validators['dimensions'] = v_parcoords.DimensionsValidator() + self._validators['domain'] = v_parcoords.DomainValidator() + self._validators['hoverinfo'] = v_parcoords.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_parcoords.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_parcoords.HoverlabelValidator() + self._validators['ids'] = v_parcoords.IdsValidator() + self._validators['idssrc'] = v_parcoords.IdssrcValidator() + self._validators['labelfont'] = v_parcoords.LabelfontValidator() + self._validators['legendgroup'] = v_parcoords.LegendgroupValidator() + self._validators['line'] = v_parcoords.LineValidator() + self._validators['name'] = v_parcoords.NameValidator() + self._validators['opacity'] = v_parcoords.OpacityValidator() + self._validators['rangefont'] = v_parcoords.RangefontValidator() + self._validators['selectedpoints' + ] = v_parcoords.SelectedpointsValidator() + self._validators['showlegend'] = v_parcoords.ShowlegendValidator() + self._validators['stream'] = v_parcoords.StreamValidator() + self._validators['tickfont'] = v_parcoords.TickfontValidator() + self._validators['uid'] = v_parcoords.UidValidator() + self._validators['visible'] = v_parcoords.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dimensions', None) + self.dimensions = dimensions if dimensions is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('labelfont', None) + self.labelfont = labelfont if labelfont is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('rangefont', None) + self.rangefont = rangefont if rangefont is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'parcoords' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='parcoords' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_pie.py b/plotly/graph_objs/_pie.py new file mode 100644 index 0000000000..2bb7338054 --- /dev/null +++ b/plotly/graph_objs/_pie.py @@ -0,0 +1,1513 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Pie(BaseTraceType): + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # direction + # --------- + @property + def direction(self): + """ + Specifies the direction at which succeeding sectors follow one + another. + + The 'direction' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['clockwise', 'counterclockwise'] + + Returns + ------- + Any + """ + return self['direction'] + + @direction.setter + def direction(self, val): + self['direction'] = val + + # dlabel + # ------ + @property + def dlabel(self): + """ + Sets the label step. See `label0` for more info. + + The 'dlabel' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dlabel'] + + @dlabel.setter + def dlabel(self, val): + self['dlabel'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.pie.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this pie trace . + row + If there is a layout grid, use the domain for + this row in the grid for this pie trace . + x + Sets the horizontal domain of this pie trace + (in plot fraction). + y + Sets the vertical domain of this pie trace (in + plot fraction). + + Returns + ------- + plotly.graph_objs.pie.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # hole + # ---- + @property + def hole(self): + """ + Sets the fraction of the radius to cut out of the pie. Use this + to make a donut chart. + + The 'hole' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['hole'] + + @hole.setter + def hole(self, val): + self['hole'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['label', 'text', 'value', 'percent', 'name'] joined with '+' characters + (e.g. 'label+text') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.pie.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.pie.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each sector. If a + single string, the same string appears for all data points. If + an array of string, the items are mapped in order of this + trace's sectors. To be seen, trace `hoverinfo` must contain a + *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # insidetextfont + # -------------- + @property + def insidetextfont(self): + """ + Sets the font used for `textinfo` lying inside the pie. + + The 'insidetextfont' property is an instance of Insidetextfont + that may be specified as: + - An instance of plotly.graph_objs.pie.Insidetextfont + - A dict of string/value properties that will be passed + to the Insidetextfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.pie.Insidetextfont + """ + return self['insidetextfont'] + + @insidetextfont.setter + def insidetextfont(self, val): + self['insidetextfont'] = val + + # label0 + # ------ + @property + def label0(self): + """ + Alternate to `labels`. Builds a numeric set of labels. Use with + `dlabel` where `label0` is the starting label and `dlabel` the + step. + + The 'label0' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['label0'] + + @label0.setter + def label0(self, val): + self['label0'] = val + + # labels + # ------ + @property + def labels(self): + """ + Sets the sector labels. If `labels` entries are duplicated, we + sum associated `values` or simply count occurrences if `values` + is not provided. For other array attributes (including color) + we use the first non-empty entry among all occurrences of the + label. + + The 'labels' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['labels'] + + @labels.setter + def labels(self, val): + self['labels'] = val + + # labelssrc + # --------- + @property + def labelssrc(self): + """ + Sets the source reference on plot.ly for labels . + + The 'labelssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['labelssrc'] + + @labelssrc.setter + def labelssrc(self, val): + self['labelssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.pie.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + colors + Sets the color of each sector of this pie + chart. If not specified, the default trace + color set is used to pick the sector colors. + colorssrc + Sets the source reference on plot.ly for + colors . + line + plotly.graph_objs.pie.marker.Line instance or + dict with compatible properties + + Returns + ------- + plotly.graph_objs.pie.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # outsidetextfont + # --------------- + @property + def outsidetextfont(self): + """ + Sets the font used for `textinfo` lying outside the pie. + + The 'outsidetextfont' property is an instance of Outsidetextfont + that may be specified as: + - An instance of plotly.graph_objs.pie.Outsidetextfont + - A dict of string/value properties that will be passed + to the Outsidetextfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.pie.Outsidetextfont + """ + return self['outsidetextfont'] + + @outsidetextfont.setter + def outsidetextfont(self, val): + self['outsidetextfont'] = val + + # pull + # ---- + @property + def pull(self): + """ + Sets the fraction of larger radius to pull the sectors out from + the center. This can be a constant to pull all slices apart + from each other equally or an array to highlight one or more + slices. + + The 'pull' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['pull'] + + @pull.setter + def pull(self, val): + self['pull'] = val + + # pullsrc + # ------- + @property + def pullsrc(self): + """ + Sets the source reference on plot.ly for pull . + + The 'pullsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['pullsrc'] + + @pullsrc.setter + def pullsrc(self, val): + self['pullsrc'] = val + + # rotation + # -------- + @property + def rotation(self): + """ + Instead of the first slice starting at 12 o'clock, rotate to + some other angle. + + The 'rotation' property is a number and may be specified as: + - An int or float in the interval [-360, 360] + + Returns + ------- + int|float + """ + return self['rotation'] + + @rotation.setter + def rotation(self, val): + self['rotation'] = val + + # scalegroup + # ---------- + @property + def scalegroup(self): + """ + If there are multiple pies that should be sized according to + their totals, link them by providing a non-empty group id here + shared by every trace in the same group. + + The 'scalegroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['scalegroup'] + + @scalegroup.setter + def scalegroup(self, val): + self['scalegroup'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # sort + # ---- + @property + def sort(self): + """ + Determines whether or not the sectors are reordered from + largest to smallest. + + The 'sort' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['sort'] + + @sort.setter + def sort(self, val): + self['sort'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.pie.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.pie.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each sector. If trace + `textinfo` contains a *text* flag, these elements will seen on + the chart. If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in the + hover labels. + + The 'text' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the font used for `textinfo`. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.pie.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.pie.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textinfo + # -------- + @property + def textinfo(self): + """ + Determines which trace information appear on the graph. + + The 'textinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['label', 'text', 'value', 'percent'] joined with '+' characters + (e.g. 'label+text') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['textinfo'] + + @textinfo.setter + def textinfo(self, val): + self['textinfo'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Specifies the location of the `textinfo`. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['inside', 'outside', 'auto', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # values + # ------ + @property + def values(self): + """ + Sets the values of the sectors of this pie chart. If omitted, + we count occurrences of each label. + + The 'values' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['values'] + + @values.setter + def values(self, val): + self['values'] = val + + # valuessrc + # --------- + @property + def valuessrc(self): + """ + Sets the source reference on plot.ly for values . + + The 'valuessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuessrc'] + + @valuessrc.setter + def valuessrc(self, val): + self['valuessrc'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + direction + Specifies the direction at which succeeding sectors + follow one another. + dlabel + Sets the label step. See `label0` for more info. + domain + plotly.graph_objs.pie.Domain instance or dict with + compatible properties + hole + Sets the fraction of the radius to cut out of the pie. + Use this to make a donut chart. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pie.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each sector. + If a single string, the same string appears for all + data points. If an array of string, the items are + mapped in order of this trace's sectors. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `textinfo` lying inside the pie. + label0 + Alternate to `labels`. Builds a numeric set of labels. + Use with `dlabel` where `label0` is the starting label + and `dlabel` the step. + labels + Sets the sector labels. If `labels` entries are + duplicated, we sum associated `values` or simply count + occurrences if `values` is not provided. For other + array attributes (including color) we use the first + non-empty entry among all occurrences of the label. + labelssrc + Sets the source reference on plot.ly for labels . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pie.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + outsidetextfont + Sets the font used for `textinfo` lying outside the + pie. + pull + Sets the fraction of larger radius to pull the sectors + out from the center. This can be a constant to pull all + slices apart from each other equally or an array to + highlight one or more slices. + pullsrc + Sets the source reference on plot.ly for pull . + rotation + Instead of the first slice starting at 12 o'clock, + rotate to some other angle. + scalegroup + If there are multiple pies that should be sized + according to their totals, link them by providing a + non-empty group id here shared by every trace in the + same group. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + sort + Determines whether or not the sectors are reordered + from largest to smallest. + stream + plotly.graph_objs.pie.Stream instance or dict with + compatible properties + text + Sets text elements associated with each sector. If + trace `textinfo` contains a *text* flag, these elements + will seen on the chart. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textfont + Sets the font used for `textinfo`. + textinfo + Determines which trace information appear on the graph. + textposition + Specifies the location of the `textinfo`. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + values + Sets the values of the sectors of this pie chart. If + omitted, we count occurrences of each label. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + customdata=None, + customdatasrc=None, + direction=None, + dlabel=None, + domain=None, + hole=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + insidetextfont=None, + label0=None, + labels=None, + labelssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + outsidetextfont=None, + pull=None, + pullsrc=None, + rotation=None, + scalegroup=None, + selectedpoints=None, + showlegend=None, + sort=None, + stream=None, + text=None, + textfont=None, + textinfo=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + values=None, + valuessrc=None, + visible=None, + **kwargs + ): + """ + Construct a new Pie object + + A data visualized by the sectors of the pie is set in `values`. + The sector labels are set in `labels`. The sector colors are + set in `marker.colors` + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Pie + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + direction + Specifies the direction at which succeeding sectors + follow one another. + dlabel + Sets the label step. See `label0` for more info. + domain + plotly.graph_objs.pie.Domain instance or dict with + compatible properties + hole + Sets the fraction of the radius to cut out of the pie. + Use this to make a donut chart. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pie.Hoverlabel instance or dict with + compatible properties + hovertext + Sets hover text elements associated with each sector. + If a single string, the same string appears for all + data points. If an array of string, the items are + mapped in order of this trace's sectors. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `textinfo` lying inside the pie. + label0 + Alternate to `labels`. Builds a numeric set of labels. + Use with `dlabel` where `label0` is the starting label + and `dlabel` the step. + labels + Sets the sector labels. If `labels` entries are + duplicated, we sum associated `values` or simply count + occurrences if `values` is not provided. For other + array attributes (including color) we use the first + non-empty entry among all occurrences of the label. + labelssrc + Sets the source reference on plot.ly for labels . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pie.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + outsidetextfont + Sets the font used for `textinfo` lying outside the + pie. + pull + Sets the fraction of larger radius to pull the sectors + out from the center. This can be a constant to pull all + slices apart from each other equally or an array to + highlight one or more slices. + pullsrc + Sets the source reference on plot.ly for pull . + rotation + Instead of the first slice starting at 12 o'clock, + rotate to some other angle. + scalegroup + If there are multiple pies that should be sized + according to their totals, link them by providing a + non-empty group id here shared by every trace in the + same group. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + sort + Determines whether or not the sectors are reordered + from largest to smallest. + stream + plotly.graph_objs.pie.Stream instance or dict with + compatible properties + text + Sets text elements associated with each sector. If + trace `textinfo` contains a *text* flag, these elements + will seen on the chart. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textfont + Sets the font used for `textinfo`. + textinfo + Determines which trace information appear on the graph. + textposition + Specifies the location of the `textinfo`. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + values + Sets the values of the sectors of this pie chart. If + omitted, we count occurrences of each label. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Pie + """ + super(Pie, self).__init__('pie') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Pie +constructor must be a dict or +an instance of plotly.graph_objs.Pie""" + ) + + # Import validators + # ----------------- + from plotly.validators import (pie as v_pie) + + # Initialize validators + # --------------------- + self._validators['customdata'] = v_pie.CustomdataValidator() + self._validators['customdatasrc'] = v_pie.CustomdatasrcValidator() + self._validators['direction'] = v_pie.DirectionValidator() + self._validators['dlabel'] = v_pie.DlabelValidator() + self._validators['domain'] = v_pie.DomainValidator() + self._validators['hole'] = v_pie.HoleValidator() + self._validators['hoverinfo'] = v_pie.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_pie.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_pie.HoverlabelValidator() + self._validators['hovertext'] = v_pie.HovertextValidator() + self._validators['hovertextsrc'] = v_pie.HovertextsrcValidator() + self._validators['ids'] = v_pie.IdsValidator() + self._validators['idssrc'] = v_pie.IdssrcValidator() + self._validators['insidetextfont'] = v_pie.InsidetextfontValidator() + self._validators['label0'] = v_pie.Label0Validator() + self._validators['labels'] = v_pie.LabelsValidator() + self._validators['labelssrc'] = v_pie.LabelssrcValidator() + self._validators['legendgroup'] = v_pie.LegendgroupValidator() + self._validators['marker'] = v_pie.MarkerValidator() + self._validators['name'] = v_pie.NameValidator() + self._validators['opacity'] = v_pie.OpacityValidator() + self._validators['outsidetextfont'] = v_pie.OutsidetextfontValidator() + self._validators['pull'] = v_pie.PullValidator() + self._validators['pullsrc'] = v_pie.PullsrcValidator() + self._validators['rotation'] = v_pie.RotationValidator() + self._validators['scalegroup'] = v_pie.ScalegroupValidator() + self._validators['selectedpoints'] = v_pie.SelectedpointsValidator() + self._validators['showlegend'] = v_pie.ShowlegendValidator() + self._validators['sort'] = v_pie.SortValidator() + self._validators['stream'] = v_pie.StreamValidator() + self._validators['text'] = v_pie.TextValidator() + self._validators['textfont'] = v_pie.TextfontValidator() + self._validators['textinfo'] = v_pie.TextinfoValidator() + self._validators['textposition'] = v_pie.TextpositionValidator() + self._validators['textpositionsrc'] = v_pie.TextpositionsrcValidator() + self._validators['textsrc'] = v_pie.TextsrcValidator() + self._validators['uid'] = v_pie.UidValidator() + self._validators['values'] = v_pie.ValuesValidator() + self._validators['valuessrc'] = v_pie.ValuessrcValidator() + self._validators['visible'] = v_pie.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('direction', None) + self.direction = direction if direction is not None else v + v = arg.pop('dlabel', None) + self.dlabel = dlabel if dlabel is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('hole', None) + self.hole = hole if hole is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('insidetextfont', None) + self.insidetextfont = insidetextfont if insidetextfont is not None else v + v = arg.pop('label0', None) + self.label0 = label0 if label0 is not None else v + v = arg.pop('labels', None) + self.labels = labels if labels is not None else v + v = arg.pop('labelssrc', None) + self.labelssrc = labelssrc if labelssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('outsidetextfont', None) + self.outsidetextfont = outsidetextfont if outsidetextfont is not None else v + v = arg.pop('pull', None) + self.pull = pull if pull is not None else v + v = arg.pop('pullsrc', None) + self.pullsrc = pullsrc if pullsrc is not None else v + v = arg.pop('rotation', None) + self.rotation = rotation if rotation is not None else v + v = arg.pop('scalegroup', None) + self.scalegroup = scalegroup if scalegroup is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('sort', None) + self.sort = sort if sort is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textinfo', None) + self.textinfo = textinfo if textinfo is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('values', None) + self.values = values if values is not None else v + v = arg.pop('valuessrc', None) + self.valuessrc = valuessrc if valuessrc is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'pie' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='pie' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_pointcloud.py b/plotly/graph_objs/_pointcloud.py new file mode 100644 index 0000000000..be9d9479ba --- /dev/null +++ b/plotly/graph_objs/_pointcloud.py @@ -0,0 +1,1215 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Pointcloud(BaseTraceType): + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.pointcloud.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.pointcloud.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # indices + # ------- + @property + def indices(self): + """ + A sequential value, 0..n, supply it to avoid creating this + array inside plotting. If specified, it must be a typed + `Int32Array` array. Its length must be equal to or greater than + the number of points. For the best performance and memory use, + create one large `indices` typed array that is guaranteed to be + at least as long as the largest number of points during use, + and reuse it on each `Plotly.restyle()` call. + + The 'indices' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['indices'] + + @indices.setter + def indices(self, val): + self['indices'] = val + + # indicessrc + # ---------- + @property + def indicessrc(self): + """ + Sets the source reference on plot.ly for indices . + + The 'indicessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['indicessrc'] + + @indicessrc.setter + def indicessrc(self, val): + self['indicessrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.pointcloud.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + blend + Determines if colors are blended together for a + translucency effect in case `opacity` is + specified as a value less then `1`. Setting + `blend` to `true` reduces zoom/pan speed if + used with large numbers of points. + border + plotly.graph_objs.pointcloud.marker.Border + instance or dict with compatible properties + color + Sets the marker fill color. It accepts a + specific color.If the color is not fully opaque + and there are hundreds of thousandsof points, + it may cause slower zooming and panning. + opacity + Sets the marker opacity. The default value is + `1` (fully opaque). If the markers are not + fully opaque and there are hundreds of + thousands of points, it may cause slower + zooming and panning. Opacity fades the color + even if `blend` is left on `false` even if + there is no translucency effect in that case. + sizemax + Sets the maximum size (in px) of the rendered + marker points. Effective when the `pointcloud` + shows only few points. + sizemin + Sets the minimum size (in px) of the rendered + marker points, effective when the `pointcloud` + shows a million or more points. + + Returns + ------- + plotly.graph_objs.pointcloud.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.pointcloud.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.pointcloud.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xbounds + # ------- + @property + def xbounds(self): + """ + Specify `xbounds` in the shape of `[xMin, xMax] to avoid + looping through the `xy` typed array. Use it in conjunction + with `xy` and `ybounds` for the performance benefits. + + The 'xbounds' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['xbounds'] + + @xbounds.setter + def xbounds(self, val): + self['xbounds'] = val + + # xboundssrc + # ---------- + @property + def xboundssrc(self): + """ + Sets the source reference on plot.ly for xbounds . + + The 'xboundssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xboundssrc'] + + @xboundssrc.setter + def xboundssrc(self, val): + self['xboundssrc'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # xy + # -- + @property + def xy(self): + """ + Faster alternative to specifying `x` and `y` separately. If + supplied, it must be a typed `Float32Array` array that + represents points such that `xy[i * 2] = x[i]` and `xy[i * 2 + + 1] = y[i]` + + The 'xy' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['xy'] + + @xy.setter + def xy(self, val): + self['xy'] = val + + # xysrc + # ----- + @property + def xysrc(self): + """ + Sets the source reference on plot.ly for xy . + + The 'xysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xysrc'] + + @xysrc.setter + def xysrc(self, val): + self['xysrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ybounds + # ------- + @property + def ybounds(self): + """ + Specify `ybounds` in the shape of `[yMin, yMax] to avoid + looping through the `xy` typed array. Use it in conjunction + with `xy` and `xbounds` for the performance benefits. + + The 'ybounds' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ybounds'] + + @ybounds.setter + def ybounds(self, val): + self['ybounds'] = val + + # yboundssrc + # ---------- + @property + def yboundssrc(self): + """ + Sets the source reference on plot.ly for ybounds . + + The 'yboundssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['yboundssrc'] + + @yboundssrc.setter + def yboundssrc(self, val): + self['yboundssrc'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pointcloud.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + indices + A sequential value, 0..n, supply it to avoid creating + this array inside plotting. If specified, it must be a + typed `Int32Array` array. Its length must be equal to + or greater than the number of points. For the best + performance and memory use, create one large `indices` + typed array that is guaranteed to be at least as long + as the largest number of points during use, and reuse + it on each `Plotly.restyle()` call. + indicessrc + Sets the source reference on plot.ly for indices . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pointcloud.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.pointcloud.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbounds + Specify `xbounds` in the shape of `[xMin, xMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `ybounds` for the performance + benefits. + xboundssrc + Sets the source reference on plot.ly for xbounds . + xsrc + Sets the source reference on plot.ly for x . + xy + Faster alternative to specifying `x` and `y` + separately. If supplied, it must be a typed + `Float32Array` array that represents points such that + `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]` + xysrc + Sets the source reference on plot.ly for xy . + y + Sets the y coordinates. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybounds + Specify `ybounds` in the shape of `[yMin, yMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `xbounds` for the performance + benefits. + yboundssrc + Sets the source reference on plot.ly for ybounds . + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + customdata=None, + customdatasrc=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + indices=None, + indicessrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xaxis=None, + xbounds=None, + xboundssrc=None, + xsrc=None, + xy=None, + xysrc=None, + y=None, + yaxis=None, + ybounds=None, + yboundssrc=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Pointcloud object + + The data visualized as a point cloud set in `x` and `y` using + the WebGl plotting engine. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Pointcloud + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.pointcloud.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + indices + A sequential value, 0..n, supply it to avoid creating + this array inside plotting. If specified, it must be a + typed `Int32Array` array. Its length must be equal to + or greater than the number of points. For the best + performance and memory use, create one large `indices` + typed array that is guaranteed to be at least as long + as the largest number of points during use, and reuse + it on each `Plotly.restyle()` call. + indicessrc + Sets the source reference on plot.ly for indices . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.pointcloud.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.pointcloud.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xbounds + Specify `xbounds` in the shape of `[xMin, xMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `ybounds` for the performance + benefits. + xboundssrc + Sets the source reference on plot.ly for xbounds . + xsrc + Sets the source reference on plot.ly for x . + xy + Faster alternative to specifying `x` and `y` + separately. If supplied, it must be a typed + `Float32Array` array that represents points such that + `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]` + xysrc + Sets the source reference on plot.ly for xy . + y + Sets the y coordinates. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ybounds + Specify `ybounds` in the shape of `[yMin, yMax] to + avoid looping through the `xy` typed array. Use it in + conjunction with `xy` and `xbounds` for the performance + benefits. + yboundssrc + Sets the source reference on plot.ly for ybounds . + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Pointcloud + """ + super(Pointcloud, self).__init__('pointcloud') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Pointcloud +constructor must be a dict or +an instance of plotly.graph_objs.Pointcloud""" + ) + + # Import validators + # ----------------- + from plotly.validators import (pointcloud as v_pointcloud) + + # Initialize validators + # --------------------- + self._validators['customdata'] = v_pointcloud.CustomdataValidator() + self._validators['customdatasrc' + ] = v_pointcloud.CustomdatasrcValidator() + self._validators['hoverinfo'] = v_pointcloud.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_pointcloud.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_pointcloud.HoverlabelValidator() + self._validators['ids'] = v_pointcloud.IdsValidator() + self._validators['idssrc'] = v_pointcloud.IdssrcValidator() + self._validators['indices'] = v_pointcloud.IndicesValidator() + self._validators['indicessrc'] = v_pointcloud.IndicessrcValidator() + self._validators['legendgroup'] = v_pointcloud.LegendgroupValidator() + self._validators['marker'] = v_pointcloud.MarkerValidator() + self._validators['name'] = v_pointcloud.NameValidator() + self._validators['opacity'] = v_pointcloud.OpacityValidator() + self._validators['selectedpoints' + ] = v_pointcloud.SelectedpointsValidator() + self._validators['showlegend'] = v_pointcloud.ShowlegendValidator() + self._validators['stream'] = v_pointcloud.StreamValidator() + self._validators['text'] = v_pointcloud.TextValidator() + self._validators['textsrc'] = v_pointcloud.TextsrcValidator() + self._validators['uid'] = v_pointcloud.UidValidator() + self._validators['visible'] = v_pointcloud.VisibleValidator() + self._validators['x'] = v_pointcloud.XValidator() + self._validators['xaxis'] = v_pointcloud.XAxisValidator() + self._validators['xbounds'] = v_pointcloud.XboundsValidator() + self._validators['xboundssrc'] = v_pointcloud.XboundssrcValidator() + self._validators['xsrc'] = v_pointcloud.XsrcValidator() + self._validators['xy'] = v_pointcloud.XyValidator() + self._validators['xysrc'] = v_pointcloud.XysrcValidator() + self._validators['y'] = v_pointcloud.YValidator() + self._validators['yaxis'] = v_pointcloud.YAxisValidator() + self._validators['ybounds'] = v_pointcloud.YboundsValidator() + self._validators['yboundssrc'] = v_pointcloud.YboundssrcValidator() + self._validators['ysrc'] = v_pointcloud.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('indices', None) + self.indices = indices if indices is not None else v + v = arg.pop('indicessrc', None) + self.indicessrc = indicessrc if indicessrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xbounds', None) + self.xbounds = xbounds if xbounds is not None else v + v = arg.pop('xboundssrc', None) + self.xboundssrc = xboundssrc if xboundssrc is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('xy', None) + self.xy = xy if xy is not None else v + v = arg.pop('xysrc', None) + self.xysrc = xysrc if xysrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ybounds', None) + self.ybounds = ybounds if ybounds is not None else v + v = arg.pop('yboundssrc', None) + self.yboundssrc = yboundssrc if yboundssrc is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'pointcloud' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='pointcloud' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_sankey.py b/plotly/graph_objs/_sankey.py new file mode 100644 index 0000000000..fcbc19928f --- /dev/null +++ b/plotly/graph_objs/_sankey.py @@ -0,0 +1,989 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Sankey(BaseTraceType): + + # arrangement + # ----------- + @property + def arrangement(self): + """ + If value is `snap` (the default), the node arrangement is + assisted by automatic snapping of elements to preserve space + between nodes specified via `nodepad`. If value is + `perpendicular`, the nodes can only move along a line + perpendicular to the flow. If value is `freeform`, the nodes + can freely move on the plane. If value is `fixed`, the nodes + are stationary. + + The 'arrangement' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['snap', 'perpendicular', 'freeform', 'fixed'] + + Returns + ------- + Any + """ + return self['arrangement'] + + @arrangement.setter + def arrangement(self, val): + self['arrangement'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.sankey.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this sankey trace . + row + If there is a layout grid, use the domain for + this row in the grid for this sankey trace . + x + Sets the horizontal domain of this sankey trace + (in plot fraction). + y + Sets the vertical domain of this sankey trace + (in plot fraction). + + Returns + ------- + plotly.graph_objs.sankey.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['label', 'text', 'value', 'percent', 'name'] joined with '+' characters + (e.g. 'label+text') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.sankey.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.sankey.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # link + # ---- + @property + def link(self): + """ + The links of the Sankey plot. + + The 'link' property is an instance of Link + that may be specified as: + - An instance of plotly.graph_objs.sankey.Link + - A dict of string/value properties that will be passed + to the Link constructor + + Supported dict properties: + + color + Sets the `link` color. It can be a single + value, or an array for specifying color for + each `link`. If `link.color` is omitted, then + by default, a translucent grey link will be + used. + colorsrc + Sets the source reference on plot.ly for color + . + label + The shown name of the link. + labelsrc + Sets the source reference on plot.ly for label + . + line + plotly.graph_objs.sankey.link.Line instance or + dict with compatible properties + source + An integer number `[0..nodes.length - 1]` that + represents the source node. + sourcesrc + Sets the source reference on plot.ly for + source . + target + An integer number `[0..nodes.length - 1]` that + represents the target node. + targetsrc + Sets the source reference on plot.ly for + target . + value + A numeric value representing the flow volume + value. + valuesrc + Sets the source reference on plot.ly for value + . + + Returns + ------- + plotly.graph_objs.sankey.Link + """ + return self['link'] + + @link.setter + def link(self, val): + self['link'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # node + # ---- + @property + def node(self): + """ + The nodes of the Sankey plot. + + The 'node' property is an instance of Node + that may be specified as: + - An instance of plotly.graph_objs.sankey.Node + - A dict of string/value properties that will be passed + to the Node constructor + + Supported dict properties: + + color + Sets the `node` color. It can be a single + value, or an array for specifying color for + each `node`. If `node.color` is omitted, then + the default `Plotly` color palette will be + cycled through to have a variety of colors. + These defaults are not fully opaque, to allow + some visibility of what is beneath the node. + colorsrc + Sets the source reference on plot.ly for color + . + label + The shown name of the node. + labelsrc + Sets the source reference on plot.ly for label + . + line + plotly.graph_objs.sankey.node.Line instance or + dict with compatible properties + pad + Sets the padding (in px) between the `nodes`. + thickness + Sets the thickness (in px) of the `nodes`. + + Returns + ------- + plotly.graph_objs.sankey.Node + """ + return self['node'] + + @node.setter + def node(self, val): + self['node'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the Sankey diagram. + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.sankey.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.sankey.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the font for node labels + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.sankey.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.sankey.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # valueformat + # ----------- + @property + def valueformat(self): + """ + Sets the value formatting rule using d3 formatting mini- + language which is similar to those of Python. See https://githu + b.com/d3/d3-format/blob/master/README.md#locale_format + + The 'valueformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['valueformat'] + + @valueformat.setter + def valueformat(self, val): + self['valueformat'] = val + + # valuesuffix + # ----------- + @property + def valuesuffix(self): + """ + Adds a unit to follow the value in the hover tooltip. Add a + space if a separation is necessary from the value. + + The 'valuesuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['valuesuffix'] + + @valuesuffix.setter + def valuesuffix(self, val): + self['valuesuffix'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + arrangement + If value is `snap` (the default), the node arrangement + is assisted by automatic snapping of elements to + preserve space between nodes specified via `nodepad`. + If value is `perpendicular`, the nodes can only move + along a line perpendicular to the flow. If value is + `freeform`, the nodes can freely move on the plane. If + value is `fixed`, the nodes are stationary. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.sankey.Domain instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.sankey.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + link + The links of the Sankey plot. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + node + The nodes of the Sankey plot. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the Sankey diagram. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.sankey.Stream instance or dict with + compatible properties + textfont + Sets the font for node labels + uid + + valueformat + Sets the value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + valuesuffix + Adds a unit to follow the value in the hover tooltip. + Add a space if a separation is necessary from the + value. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + arrangement=None, + customdata=None, + customdatasrc=None, + domain=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + link=None, + name=None, + node=None, + opacity=None, + orientation=None, + selectedpoints=None, + showlegend=None, + stream=None, + textfont=None, + uid=None, + valueformat=None, + valuesuffix=None, + visible=None, + **kwargs + ): + """ + Construct a new Sankey object + + Sankey plots for network flow data analysis. The nodes are + specified in `nodes` and the links between sources and targets + in `links`. The colors are set in `nodes[i].color` and + `links[i].color`; otherwise defaults are used. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Sankey + arrangement + If value is `snap` (the default), the node arrangement + is assisted by automatic snapping of elements to + preserve space between nodes specified via `nodepad`. + If value is `perpendicular`, the nodes can only move + along a line perpendicular to the flow. If value is + `freeform`, the nodes can freely move on the plane. If + value is `fixed`, the nodes are stationary. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.sankey.Domain instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.sankey.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + link + The links of the Sankey plot. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + node + The nodes of the Sankey plot. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the Sankey diagram. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.sankey.Stream instance or dict with + compatible properties + textfont + Sets the font for node labels + uid + + valueformat + Sets the value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + valuesuffix + Adds a unit to follow the value in the hover tooltip. + Add a space if a separation is necessary from the + value. + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Sankey + """ + super(Sankey, self).__init__('sankey') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Sankey +constructor must be a dict or +an instance of plotly.graph_objs.Sankey""" + ) + + # Import validators + # ----------------- + from plotly.validators import (sankey as v_sankey) + + # Initialize validators + # --------------------- + self._validators['arrangement'] = v_sankey.ArrangementValidator() + self._validators['customdata'] = v_sankey.CustomdataValidator() + self._validators['customdatasrc'] = v_sankey.CustomdatasrcValidator() + self._validators['domain'] = v_sankey.DomainValidator() + self._validators['hoverinfo'] = v_sankey.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_sankey.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_sankey.HoverlabelValidator() + self._validators['ids'] = v_sankey.IdsValidator() + self._validators['idssrc'] = v_sankey.IdssrcValidator() + self._validators['legendgroup'] = v_sankey.LegendgroupValidator() + self._validators['link'] = v_sankey.LinkValidator() + self._validators['name'] = v_sankey.NameValidator() + self._validators['node'] = v_sankey.NodeValidator() + self._validators['opacity'] = v_sankey.OpacityValidator() + self._validators['orientation'] = v_sankey.OrientationValidator() + self._validators['selectedpoints'] = v_sankey.SelectedpointsValidator() + self._validators['showlegend'] = v_sankey.ShowlegendValidator() + self._validators['stream'] = v_sankey.StreamValidator() + self._validators['textfont'] = v_sankey.TextfontValidator() + self._validators['uid'] = v_sankey.UidValidator() + self._validators['valueformat'] = v_sankey.ValueformatValidator() + self._validators['valuesuffix'] = v_sankey.ValuesuffixValidator() + self._validators['visible'] = v_sankey.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('arrangement', None) + self.arrangement = arrangement if arrangement is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('link', None) + self.link = link if link is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('node', None) + self.node = node if node is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('valueformat', None) + self.valueformat = valueformat if valueformat is not None else v + v = arg.pop('valuesuffix', None) + self.valuesuffix = valuesuffix if valuesuffix is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'sankey' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='sankey' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scatter.py b/plotly/graph_objs/_scatter.py new file mode 100644 index 0000000000..60d08934bc --- /dev/null +++ b/plotly/graph_objs/_scatter.py @@ -0,0 +1,2153 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scatter(BaseTraceType): + + # cliponaxis + # ---------- + @property + def cliponaxis(self): + """ + Determines whether or not markers and text nodes are clipped + about the subplot axes. To show markers and text nodes above + axis lines and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + + The 'cliponaxis' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cliponaxis'] + + @cliponaxis.setter + def cliponaxis(self, val): + self['cliponaxis'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # error_x + # ------- + @property + def error_x(self): + """ + The 'error_x' property is an instance of ErrorX + that may be specified as: + - An instance of plotly.graph_objs.scatter.ErrorX + - A dict of string/value properties that will be passed + to the ErrorX constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scatter.ErrorX + """ + return self['error_x'] + + @error_x.setter + def error_x(self, val): + self['error_x'] = val + + # error_y + # ------- + @property + def error_y(self): + """ + The 'error_y' property is an instance of ErrorY + that may be specified as: + - An instance of plotly.graph_objs.scatter.ErrorY + - A dict of string/value properties that will be passed + to the ErrorY constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scatter.ErrorY + """ + return self['error_y'] + + @error_y.setter + def error_y(self, val): + self['error_y'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 + respectively. *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of the trace before + it, connecting those endpoints with straight lines (to make a + stacked area graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the space between two + traces if one completely encloses the other (eg consecutive + contour lines), and behaves like *toself* if there is no trace + before it. *tonext* should not be used if one trace does not + enclose the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', + 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scatter.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scatter.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (x,y) pair. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatter.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + simplify + Simplifies lines by removing nearly-collinear + points. When transitioning lines, it may be + desirable to disable this so that the number of + points along the resulting SVG path is + unaffected. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scatter.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatter.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatter.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatter.marker.Line instance + or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scatter.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # r + # - + @property + def r(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the radial coordinates. + + The 'r' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # rsrc + # ---- + @property + def rsrc(self): + """ + Sets the source reference on plot.ly for r . + + The 'rsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['rsrc'] + + @rsrc.setter + def rsrc(self, val): + self['rsrc'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scatter.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatter.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatter.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatter.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scatter.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scatter.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # t + # - + @property + def t(self): + """ + For legacy polar chart only.Please switch to *scatterpolar* + trace type.Sets the angular coordinates. + + The 't' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatter.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatter.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # tsrc + # ---- + @property + def tsrc(self): + """ + Sets the source reference on plot.ly for t . + + The 'tsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tsrc'] + + @tsrc.setter + def tsrc(self, val): + self['tsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scatter.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatter.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatter.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatter.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scatter.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.scatter.ErrorY instance or dict with + compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter.Marker instance or dict with + compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatter.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.scatter.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + t=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + tsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Scatter object + + The scatter trace type encompasses line charts, scatter charts, + text charts, and bubble charts. The data visualized as scatter + point or lines is set in `x` and `y`. Text (appearing either on + the chart or on hover only) is via `text`. Bubble charts are + achieved by setting `marker.size` and/or `marker.color` to + numerical arrays. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scatter + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scatter.ErrorX instance or dict with + compatible properties + error_y + plotly.graph_objs.scatter.ErrorY instance or dict with + compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter.Marker instance or dict with + compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatter.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter.Stream instance or dict with + compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular coordinates. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.scatter.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Scatter + """ + super(Scatter, self).__init__('scatter') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scatter +constructor must be a dict or +an instance of plotly.graph_objs.Scatter""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scatter as v_scatter) + + # Initialize validators + # --------------------- + self._validators['cliponaxis'] = v_scatter.CliponaxisValidator() + self._validators['connectgaps'] = v_scatter.ConnectgapsValidator() + self._validators['customdata'] = v_scatter.CustomdataValidator() + self._validators['customdatasrc'] = v_scatter.CustomdatasrcValidator() + self._validators['dx'] = v_scatter.DxValidator() + self._validators['dy'] = v_scatter.DyValidator() + self._validators['error_x'] = v_scatter.ErrorXValidator() + self._validators['error_y'] = v_scatter.ErrorYValidator() + self._validators['fill'] = v_scatter.FillValidator() + self._validators['fillcolor'] = v_scatter.FillcolorValidator() + self._validators['hoverinfo'] = v_scatter.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_scatter.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scatter.HoverlabelValidator() + self._validators['hoveron'] = v_scatter.HoveronValidator() + self._validators['hovertext'] = v_scatter.HovertextValidator() + self._validators['hovertextsrc'] = v_scatter.HovertextsrcValidator() + self._validators['ids'] = v_scatter.IdsValidator() + self._validators['idssrc'] = v_scatter.IdssrcValidator() + self._validators['legendgroup'] = v_scatter.LegendgroupValidator() + self._validators['line'] = v_scatter.LineValidator() + self._validators['marker'] = v_scatter.MarkerValidator() + self._validators['mode'] = v_scatter.ModeValidator() + self._validators['name'] = v_scatter.NameValidator() + self._validators['opacity'] = v_scatter.OpacityValidator() + self._validators['r'] = v_scatter.RValidator() + self._validators['rsrc'] = v_scatter.RsrcValidator() + self._validators['selected'] = v_scatter.SelectedValidator() + self._validators['selectedpoints' + ] = v_scatter.SelectedpointsValidator() + self._validators['showlegend'] = v_scatter.ShowlegendValidator() + self._validators['stream'] = v_scatter.StreamValidator() + self._validators['t'] = v_scatter.TValidator() + self._validators['text'] = v_scatter.TextValidator() + self._validators['textfont'] = v_scatter.TextfontValidator() + self._validators['textposition'] = v_scatter.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scatter.TextpositionsrcValidator() + self._validators['textsrc'] = v_scatter.TextsrcValidator() + self._validators['tsrc'] = v_scatter.TsrcValidator() + self._validators['uid'] = v_scatter.UidValidator() + self._validators['unselected'] = v_scatter.UnselectedValidator() + self._validators['visible'] = v_scatter.VisibleValidator() + self._validators['x'] = v_scatter.XValidator() + self._validators['x0'] = v_scatter.X0Validator() + self._validators['xaxis'] = v_scatter.XAxisValidator() + self._validators['xcalendar'] = v_scatter.XcalendarValidator() + self._validators['xsrc'] = v_scatter.XsrcValidator() + self._validators['y'] = v_scatter.YValidator() + self._validators['y0'] = v_scatter.Y0Validator() + self._validators['yaxis'] = v_scatter.YAxisValidator() + self._validators['ycalendar'] = v_scatter.YcalendarValidator() + self._validators['ysrc'] = v_scatter.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('cliponaxis', None) + self.cliponaxis = cliponaxis if cliponaxis is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('error_x', None) + self.error_x = error_x if error_x is not None else v + v = arg.pop('error_y', None) + self.error_y = error_y if error_y is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('rsrc', None) + self.rsrc = rsrc if rsrc is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('tsrc', None) + self.tsrc = tsrc if tsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scatter' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scatter' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scatter3d.py b/plotly/graph_objs/_scatter3d.py new file mode 100644 index 0000000000..394edd6683 --- /dev/null +++ b/plotly/graph_objs/_scatter3d.py @@ -0,0 +1,1934 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scatter3d(BaseTraceType): + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # error_x + # ------- + @property + def error_x(self): + """ + The 'error_x' property is an instance of ErrorX + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.ErrorX + - A dict of string/value properties that will be passed + to the ErrorX constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scatter3d.ErrorX + """ + return self['error_x'] + + @error_x.setter + def error_x(self, val): + self['error_x'] = val + + # error_y + # ------- + @property + def error_y(self): + """ + The 'error_y' property is an instance of ErrorY + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.ErrorY + - A dict of string/value properties that will be passed + to the ErrorY constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scatter3d.ErrorY + """ + return self['error_y'] + + @error_y.setter + def error_y(self, val): + self['error_y'] = val + + # error_z + # ------- + @property + def error_z(self): + """ + The 'error_z' property is an instance of ErrorZ + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.ErrorZ + - A dict of string/value properties that will be passed + to the ErrorZ constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scatter3d.ErrorZ + """ + return self['error_z'] + + @error_z.setter + def error_z(self, val): + self['error_z'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scatter3d.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets text elements associated with each (x,y,z) triplet. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y,z) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmin` must be set as well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmax` must be set as well. + color + Sets the line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `line.cmin` and `line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + dash + Sets the dash style of the lines. + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a + colorbar is displayed. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scatter3d.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter3d.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scatter3d.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. Note that the marker + opacity for scatter3d traces must be a scalar + value for performance reasons. To set a + blending opacity value (i.e. which is not + transparent), set *marker.color* to an rgba + color and use its alpha channel. + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scatter3d.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # projection + # ---------- + @property + def projection(self): + """ + The 'projection' property is an instance of Projection + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Projection + - A dict of string/value properties that will be passed + to the Projection constructor + + Supported dict properties: + + x + plotly.graph_objs.scatter3d.projection.X + instance or dict with compatible properties + y + plotly.graph_objs.scatter3d.projection.Y + instance or dict with compatible properties + z + plotly.graph_objs.scatter3d.projection.Z + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatter3d.Projection + """ + return self['projection'] + + @projection.setter + def projection(self, val): + self['projection'] = val + + # scene + # ----- + @property + def scene(self): + """ + Sets a reference between this trace's 3D coordinate system and + a 3D scene. If *scene* (the default value), the (x,y,z) + coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) + coordinates refer to `layout.scene2`, and so on. + + The 'scene' property is an identifier of a particular + subplot, of type 'scene', that may be specified as the string 'scene' + optionally followed by an integer >= 1 + (e.g. 'scene', 'scene1', 'scene2', 'scene3', etc.) + + Returns + ------- + str + """ + return self['scene'] + + @scene.setter + def scene(self, val): + self['scene'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scatter3d.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # surfaceaxis + # ----------- + @property + def surfaceaxis(self): + """ + If *-1*, the scatter points are not fill with a surface If *0*, + *1*, *2*, the scatter points are filled with a Delaunay surface + about the x, y, z respectively. + + The 'surfaceaxis' property is an enumeration that may be specified as: + - One of the following enumeration values: + [-1, 0, 1, 2] + + Returns + ------- + Any + """ + return self['surfaceaxis'] + + @surfaceaxis.setter + def surfaceaxis(self, val): + self['surfaceaxis'] = val + + # surfacecolor + # ------------ + @property + def surfacecolor(self): + """ + Sets the surface fill color. + + The 'surfacecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['surfacecolor'] + + @surfacecolor.setter + def surfacecolor(self, val): + self['surfacecolor'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y,z) triplet. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y,z) coordinates. If trace `hoverinfo` + contains a *text* flag and *hovertext* is not set, these + elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatter3d.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the z coordinates. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zcalendar + # --------- + @property + def zcalendar(self): + """ + Sets the calendar system to use with `z` date data. + + The 'zcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['zcalendar'] + + @zcalendar.setter + def zcalendar(self, val): + self['zcalendar'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.scatter3d.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scatter3d.ErrorY instance or dict + with compatible properties + error_z + plotly.graph_objs.scatter3d.ErrorZ instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter3d.Hoverlabel instance or dict + with compatible properties + hovertext + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter3d.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter3d.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + projection + plotly.graph_objs.scatter3d.Projection instance or dict + with compatible properties + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter3d.Stream instance or dict + with compatible properties + surfaceaxis + If *-1*, the scatter points are not fill with a surface + If *0*, *1*, *2*, the scatter points are filled with a + Delaunay surface about the x, y, z respectively. + surfacecolor + Sets the surface fill color. + text + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + error_x=None, + error_y=None, + error_z=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + projection=None, + scene=None, + selectedpoints=None, + showlegend=None, + stream=None, + surfaceaxis=None, + surfacecolor=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Scatter3d object + + The data visualized as scatter point or lines in 3D dimension + is set in `x`, `y`, `z`. Text (appearing either on the chart or + on hover only) is via `text`. Bubble charts are achieved by + setting `marker.size` and/or `marker.color` Projections are + achieved via `projection`. Surface fills are achieved via + `surfaceaxis`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scatter3d + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + error_x + plotly.graph_objs.scatter3d.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scatter3d.ErrorY instance or dict + with compatible properties + error_z + plotly.graph_objs.scatter3d.ErrorZ instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatter3d.Hoverlabel instance or dict + with compatible properties + hovertext + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatter3d.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scatter3d.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + projection + plotly.graph_objs.scatter3d.Projection instance or dict + with compatible properties + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatter3d.Stream instance or dict + with compatible properties + surfaceaxis + If *-1*, the scatter points are not fill with a surface + If *0*, *1*, *2*, the scatter points are filled with a + Delaunay surface about the x, y, z respectively. + surfacecolor + Sets the surface fill color. + text + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string appears + over all the data points. If an array of string, the + items are mapped in order to the this trace's (x,y,z) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Scatter3d + """ + super(Scatter3d, self).__init__('scatter3d') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scatter3d +constructor must be a dict or +an instance of plotly.graph_objs.Scatter3d""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scatter3d as v_scatter3d) + + # Initialize validators + # --------------------- + self._validators['connectgaps'] = v_scatter3d.ConnectgapsValidator() + self._validators['customdata'] = v_scatter3d.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scatter3d.CustomdatasrcValidator() + self._validators['error_x'] = v_scatter3d.ErrorXValidator() + self._validators['error_y'] = v_scatter3d.ErrorYValidator() + self._validators['error_z'] = v_scatter3d.ErrorZValidator() + self._validators['hoverinfo'] = v_scatter3d.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_scatter3d.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scatter3d.HoverlabelValidator() + self._validators['hovertext'] = v_scatter3d.HovertextValidator() + self._validators['hovertextsrc'] = v_scatter3d.HovertextsrcValidator() + self._validators['ids'] = v_scatter3d.IdsValidator() + self._validators['idssrc'] = v_scatter3d.IdssrcValidator() + self._validators['legendgroup'] = v_scatter3d.LegendgroupValidator() + self._validators['line'] = v_scatter3d.LineValidator() + self._validators['marker'] = v_scatter3d.MarkerValidator() + self._validators['mode'] = v_scatter3d.ModeValidator() + self._validators['name'] = v_scatter3d.NameValidator() + self._validators['opacity'] = v_scatter3d.OpacityValidator() + self._validators['projection'] = v_scatter3d.ProjectionValidator() + self._validators['scene'] = v_scatter3d.SceneValidator() + self._validators['selectedpoints' + ] = v_scatter3d.SelectedpointsValidator() + self._validators['showlegend'] = v_scatter3d.ShowlegendValidator() + self._validators['stream'] = v_scatter3d.StreamValidator() + self._validators['surfaceaxis'] = v_scatter3d.SurfaceaxisValidator() + self._validators['surfacecolor'] = v_scatter3d.SurfacecolorValidator() + self._validators['text'] = v_scatter3d.TextValidator() + self._validators['textfont'] = v_scatter3d.TextfontValidator() + self._validators['textposition'] = v_scatter3d.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scatter3d.TextpositionsrcValidator() + self._validators['textsrc'] = v_scatter3d.TextsrcValidator() + self._validators['uid'] = v_scatter3d.UidValidator() + self._validators['visible'] = v_scatter3d.VisibleValidator() + self._validators['x'] = v_scatter3d.XValidator() + self._validators['xcalendar'] = v_scatter3d.XcalendarValidator() + self._validators['xsrc'] = v_scatter3d.XsrcValidator() + self._validators['y'] = v_scatter3d.YValidator() + self._validators['ycalendar'] = v_scatter3d.YcalendarValidator() + self._validators['ysrc'] = v_scatter3d.YsrcValidator() + self._validators['z'] = v_scatter3d.ZValidator() + self._validators['zcalendar'] = v_scatter3d.ZcalendarValidator() + self._validators['zsrc'] = v_scatter3d.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('error_x', None) + self.error_x = error_x if error_x is not None else v + v = arg.pop('error_y', None) + self.error_y = error_y if error_y is not None else v + v = arg.pop('error_z', None) + self.error_z = error_z if error_z is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('projection', None) + self.projection = projection if projection is not None else v + v = arg.pop('scene', None) + self.scene = scene if scene is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('surfaceaxis', None) + self.surfaceaxis = surfaceaxis if surfaceaxis is not None else v + v = arg.pop('surfacecolor', None) + self.surfacecolor = surfacecolor if surfacecolor is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zcalendar', None) + self.zcalendar = zcalendar if zcalendar is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scatter3d' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scatter3d' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scattercarpet.py b/plotly/graph_objs/_scattercarpet.py new file mode 100644 index 0000000000..a1e417e756 --- /dev/null +++ b/plotly/graph_objs/_scattercarpet.py @@ -0,0 +1,1588 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scattercarpet(BaseTraceType): + + # a + # - + @property + def a(self): + """ + Sets the quantity of component `a` in each data point. If `a`, + `b`, and `c` are all provided, they need not be normalized, + only the relative values matter. If only two arrays are + provided they must be normalized to match `ternary.sum`. + + The 'a' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['a'] + + @a.setter + def a(self, val): + self['a'] = val + + # asrc + # ---- + @property + def asrc(self): + """ + Sets the source reference on plot.ly for a . + + The 'asrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['asrc'] + + @asrc.setter + def asrc(self, val): + self['asrc'] = val + + # b + # - + @property + def b(self): + """ + Sets the quantity of component `a` in each data point. If `a`, + `b`, and `c` are all provided, they need not be normalized, + only the relative values matter. If only two arrays are + provided they must be normalized to match `ternary.sum`. + + The 'b' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # bsrc + # ---- + @property + def bsrc(self): + """ + Sets the source reference on plot.ly for b . + + The 'bsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bsrc'] + + @bsrc.setter + def bsrc(self, val): + self['bsrc'] = val + + # carpet + # ------ + @property + def carpet(self): + """ + An identifier for this carpet, so that `scattercarpet` and + `scattercontour` traces can specify a carpet plot on which they + lie + + The 'carpet' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['carpet'] + + @carpet.setter + def carpet(self, val): + self['carpet'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. scatterternary has a subset of the options + available to scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between two traces if + one completely encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is no trace before + it. *tonext* should not be used if one trace does not enclose + the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['a', 'b', 'text', 'name', 'name'] joined with '+' characters + (e.g. 'a+b') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scattercarpet.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scattercarpet.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattercarpet.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scattercarpet.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattercarpet.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scattercarpet.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattercarpet.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.selected.Textfo + nt instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattercarpet.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scattercarpet.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (a,b,c) point. If a + single string, the same string appears over all the data + points. If an array of strings, the items are mapped in order + to the the data points in (a,b,c). + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattercarpet.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattercarpet.unselected.Mark + er instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.unselected.Text + font instance or dict with compatible + properties + + Returns + ------- + plotly.graph_objs.scattercarpet.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattercarpet.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattercarpet.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scattercarpet.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattercarpet.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattercarpet.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattercarpet.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + """ + + def __init__( + self, + arg=None, + a=None, + asrc=None, + b=None, + bsrc=None, + carpet=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxis=None, + yaxis=None, + **kwargs + ): + """ + Construct a new Scattercarpet object + + Plots a scatter trace on either the first carpet axis or the + carpet axis with a matching `carpet` attribute. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scattercarpet + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that `scattercarpet` + and `scattercontour` traces can specify a carpet plot + on which they lie + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattercarpet.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattercarpet.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scattercarpet.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattercarpet.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattercarpet.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattercarpet.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + + Returns + ------- + Scattercarpet + """ + super(Scattercarpet, self).__init__('scattercarpet') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scattercarpet +constructor must be a dict or +an instance of plotly.graph_objs.Scattercarpet""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scattercarpet as v_scattercarpet) + + # Initialize validators + # --------------------- + self._validators['a'] = v_scattercarpet.AValidator() + self._validators['asrc'] = v_scattercarpet.AsrcValidator() + self._validators['b'] = v_scattercarpet.BValidator() + self._validators['bsrc'] = v_scattercarpet.BsrcValidator() + self._validators['carpet'] = v_scattercarpet.CarpetValidator() + self._validators['connectgaps' + ] = v_scattercarpet.ConnectgapsValidator() + self._validators['customdata'] = v_scattercarpet.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scattercarpet.CustomdatasrcValidator() + self._validators['fill'] = v_scattercarpet.FillValidator() + self._validators['fillcolor'] = v_scattercarpet.FillcolorValidator() + self._validators['hoverinfo'] = v_scattercarpet.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_scattercarpet.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scattercarpet.HoverlabelValidator() + self._validators['hoveron'] = v_scattercarpet.HoveronValidator() + self._validators['ids'] = v_scattercarpet.IdsValidator() + self._validators['idssrc'] = v_scattercarpet.IdssrcValidator() + self._validators['legendgroup' + ] = v_scattercarpet.LegendgroupValidator() + self._validators['line'] = v_scattercarpet.LineValidator() + self._validators['marker'] = v_scattercarpet.MarkerValidator() + self._validators['mode'] = v_scattercarpet.ModeValidator() + self._validators['name'] = v_scattercarpet.NameValidator() + self._validators['opacity'] = v_scattercarpet.OpacityValidator() + self._validators['selected'] = v_scattercarpet.SelectedValidator() + self._validators['selectedpoints' + ] = v_scattercarpet.SelectedpointsValidator() + self._validators['showlegend'] = v_scattercarpet.ShowlegendValidator() + self._validators['stream'] = v_scattercarpet.StreamValidator() + self._validators['text'] = v_scattercarpet.TextValidator() + self._validators['textfont'] = v_scattercarpet.TextfontValidator() + self._validators['textposition' + ] = v_scattercarpet.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scattercarpet.TextpositionsrcValidator() + self._validators['textsrc'] = v_scattercarpet.TextsrcValidator() + self._validators['uid'] = v_scattercarpet.UidValidator() + self._validators['unselected'] = v_scattercarpet.UnselectedValidator() + self._validators['visible'] = v_scattercarpet.VisibleValidator() + self._validators['xaxis'] = v_scattercarpet.XAxisValidator() + self._validators['yaxis'] = v_scattercarpet.YAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('a', None) + self.a = a if a is not None else v + v = arg.pop('asrc', None) + self.asrc = asrc if asrc is not None else v + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('bsrc', None) + self.bsrc = bsrc if bsrc is not None else v + v = arg.pop('carpet', None) + self.carpet = carpet if carpet is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scattercarpet' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scattercarpet' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scattergeo.py b/plotly/graph_objs/_scattergeo.py new file mode 100644 index 0000000000..cde8121ddc --- /dev/null +++ b/plotly/graph_objs/_scattergeo.py @@ -0,0 +1,1597 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scattergeo(BaseTraceType): + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. *toself* connects the endpoints of the trace (or + each segment of the trace if it has gaps) into a closed shape. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'toself'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # geo + # --- + @property + def geo(self): + """ + Sets a reference between this trace's geospatial coordinates + and a geographic map. If *geo* (the default value), the + geospatial coordinates refer to `layout.geo`. If *geo2*, the + geospatial coordinates refer to `layout.geo2`, and so on. + + The 'geo' property is an identifier of a particular + subplot, of type 'geo', that may be specified as the string 'geo' + optionally followed by an integer >= 1 + (e.g. 'geo', 'geo1', 'geo2', 'geo3', etc.) + + Returns + ------- + str + """ + return self['geo'] + + @geo.setter + def geo(self, val): + self['geo'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lon', 'lat', 'location', 'text', 'name'] joined with '+' characters + (e.g. 'lon+lat') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scattergeo.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (lon,lat) pair or + item in `locations`. If a single string, the same string + appears over all the data points. If an array of string, the + items are mapped in order to the this trace's (lon,lat) or + `locations` coordinates. To be seen, trace `hoverinfo` must + contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # lat + # --- + @property + def lat(self): + """ + Sets the latitude coordinates (in degrees North). + + The 'lat' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['lat'] + + @lat.setter + def lat(self, val): + self['lat'] = val + + # latsrc + # ------ + @property + def latsrc(self): + """ + Sets the source reference on plot.ly for lat . + + The 'latsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['latsrc'] + + @latsrc.setter + def latsrc(self, val): + self['latsrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scattergeo.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # locationmode + # ------------ + @property + def locationmode(self): + """ + Determines the set of locations used to match entries in + `locations` to regions on the map. + + The 'locationmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['ISO-3', 'USA-states', 'country names'] + + Returns + ------- + Any + """ + return self['locationmode'] + + @locationmode.setter + def locationmode(self, val): + self['locationmode'] = val + + # locations + # --------- + @property + def locations(self): + """ + Sets the coordinates via location IDs or names. Coordinates + correspond to the centroid of each location given. See + `locationmode` for more info. + + The 'locations' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['locations'] + + @locations.setter + def locations(self, val): + self['locations'] = val + + # locationssrc + # ------------ + @property + def locationssrc(self): + """ + Sets the source reference on plot.ly for locations . + + The 'locationssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['locationssrc'] + + @locationssrc.setter + def locationssrc(self, val): + self['locationssrc'] = val + + # lon + # --- + @property + def lon(self): + """ + Sets the longitude coordinates (in degrees East). + + The 'lon' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['lon'] + + @lon.setter + def lon(self, val): + self['lon'] = val + + # lonsrc + # ------ + @property + def lonsrc(self): + """ + Sets the source reference on plot.ly for lon . + + The 'lonsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['lonsrc'] + + @lonsrc.setter + def lonsrc(self, val): + self['lonsrc'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergeo.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scattergeo.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattergeo.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scattergeo.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattergeo.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattergeo.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scattergeo.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (lon,lat) pair or item + in `locations`. If a single string, the same string appears + over all the data points. If an array of string, the items are + mapped in order to the this trace's (lon,lat) or `locations` + coordinates. If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in the + hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattergeo.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattergeo.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.unselected.Textfon + t instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattergeo.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergeo.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair or item in `locations`. If a single string, the + same string appears over all the data points. If an + array of string, the items are mapped in order to the + this trace's (lon,lat) or `locations` coordinates. To + be seen, trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergeo.Line instance or dict with + compatible properties + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + Coordinates correspond to the centroid of each location + given. See `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattergeo.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergeo.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergeo.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (lon,lat) pair + or item in `locations`. If a single string, the same + string appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (lon,lat) or `locations` coordinates. If trace + `hoverinfo` contains a *text* flag and *hovertext* is + not set, these elements will be seen in the hover + labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergeo.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + geo=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + locationmode=None, + locations=None, + locationssrc=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + **kwargs + ): + """ + Construct a new Scattergeo object + + The data visualized as scatter point or lines on a geographic + map is provided either by longitude/latitude pairs in `lon` and + `lat` respectively or by geographic location IDs or names in + `locations`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scattergeo + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + geo + Sets a reference between this trace's geospatial + coordinates and a geographic map. If *geo* (the default + value), the geospatial coordinates refer to + `layout.geo`. If *geo2*, the geospatial coordinates + refer to `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergeo.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair or item in `locations`. If a single string, the + same string appears over all the data points. If an + array of string, the items are mapped in order to the + this trace's (lon,lat) or `locations` coordinates. To + be seen, trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergeo.Line instance or dict with + compatible properties + locationmode + Determines the set of locations used to match entries + in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + Coordinates correspond to the centroid of each location + given. See `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for locations . + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattergeo.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergeo.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergeo.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (lon,lat) pair + or item in `locations`. If a single string, the same + string appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (lon,lat) or `locations` coordinates. If trace + `hoverinfo` contains a *text* flag and *hovertext* is + not set, these elements will be seen in the hover + labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergeo.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Scattergeo + """ + super(Scattergeo, self).__init__('scattergeo') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scattergeo +constructor must be a dict or +an instance of plotly.graph_objs.Scattergeo""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scattergeo as v_scattergeo) + + # Initialize validators + # --------------------- + self._validators['connectgaps'] = v_scattergeo.ConnectgapsValidator() + self._validators['customdata'] = v_scattergeo.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scattergeo.CustomdatasrcValidator() + self._validators['fill'] = v_scattergeo.FillValidator() + self._validators['fillcolor'] = v_scattergeo.FillcolorValidator() + self._validators['geo'] = v_scattergeo.GeoValidator() + self._validators['hoverinfo'] = v_scattergeo.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_scattergeo.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scattergeo.HoverlabelValidator() + self._validators['hovertext'] = v_scattergeo.HovertextValidator() + self._validators['hovertextsrc'] = v_scattergeo.HovertextsrcValidator() + self._validators['ids'] = v_scattergeo.IdsValidator() + self._validators['idssrc'] = v_scattergeo.IdssrcValidator() + self._validators['lat'] = v_scattergeo.LatValidator() + self._validators['latsrc'] = v_scattergeo.LatsrcValidator() + self._validators['legendgroup'] = v_scattergeo.LegendgroupValidator() + self._validators['line'] = v_scattergeo.LineValidator() + self._validators['locationmode'] = v_scattergeo.LocationmodeValidator() + self._validators['locations'] = v_scattergeo.LocationsValidator() + self._validators['locationssrc'] = v_scattergeo.LocationssrcValidator() + self._validators['lon'] = v_scattergeo.LonValidator() + self._validators['lonsrc'] = v_scattergeo.LonsrcValidator() + self._validators['marker'] = v_scattergeo.MarkerValidator() + self._validators['mode'] = v_scattergeo.ModeValidator() + self._validators['name'] = v_scattergeo.NameValidator() + self._validators['opacity'] = v_scattergeo.OpacityValidator() + self._validators['selected'] = v_scattergeo.SelectedValidator() + self._validators['selectedpoints' + ] = v_scattergeo.SelectedpointsValidator() + self._validators['showlegend'] = v_scattergeo.ShowlegendValidator() + self._validators['stream'] = v_scattergeo.StreamValidator() + self._validators['text'] = v_scattergeo.TextValidator() + self._validators['textfont'] = v_scattergeo.TextfontValidator() + self._validators['textposition'] = v_scattergeo.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scattergeo.TextpositionsrcValidator() + self._validators['textsrc'] = v_scattergeo.TextsrcValidator() + self._validators['uid'] = v_scattergeo.UidValidator() + self._validators['unselected'] = v_scattergeo.UnselectedValidator() + self._validators['visible'] = v_scattergeo.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('geo', None) + self.geo = geo if geo is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('lat', None) + self.lat = lat if lat is not None else v + v = arg.pop('latsrc', None) + self.latsrc = latsrc if latsrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('locationmode', None) + self.locationmode = locationmode if locationmode is not None else v + v = arg.pop('locations', None) + self.locations = locations if locations is not None else v + v = arg.pop('locationssrc', None) + self.locationssrc = locationssrc if locationssrc is not None else v + v = arg.pop('lon', None) + self.lon = lon if lon is not None else v + v = arg.pop('lonsrc', None) + self.lonsrc = lonsrc if lonsrc is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scattergeo' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scattergeo' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scattergl.py b/plotly/graph_objs/_scattergl.py new file mode 100644 index 0000000000..af22a540c4 --- /dev/null +++ b/plotly/graph_objs/_scattergl.py @@ -0,0 +1,1743 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scattergl(BaseTraceType): + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # dx + # -- + @property + def dx(self): + """ + Sets the x coordinate step. See `x0` for more info. + + The 'dx' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dx'] + + @dx.setter + def dx(self, val): + self['dx'] = val + + # dy + # -- + @property + def dy(self): + """ + Sets the y coordinate step. See `y0` for more info. + + The 'dy' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dy'] + + @dy.setter + def dy(self, val): + self['dy'] = val + + # error_x + # ------- + @property + def error_x(self): + """ + The 'error_x' property is an instance of ErrorX + that may be specified as: + - An instance of plotly.graph_objs.scattergl.ErrorX + - A dict of string/value properties that will be passed + to the ErrorX constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scattergl.ErrorX + """ + return self['error_x'] + + @error_x.setter + def error_x(self, val): + self['error_x'] = val + + # error_y + # ------- + @property + def error_y(self): + """ + The 'error_y' property is an instance of ErrorY + that may be specified as: + - An instance of plotly.graph_objs.scattergl.ErrorY + - A dict of string/value properties that will be passed + to the ErrorY constructor + + Supported dict properties: + + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars. + + Returns + ------- + plotly.graph_objs.scattergl.ErrorY + """ + return self['error_y'] + + @error_y.setter + def error_y(self, val): + self['error_y'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 + respectively. *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of the trace before + it, connecting those endpoints with straight lines (to make a + stacked area graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the space between two + traces if one completely encloses the other (eg consecutive + contour lines), and behaves like *toself* if there is no trace + before it. *tonext* should not be used if one trace does not + enclose the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', + 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scattergl.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scattergl.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergl.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scattergl.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scattergl.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattergl.selected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattergl.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scattergl.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair to appear on + hover. If a single string, the same string appears over all the + data points. If an array of string, the items are mapped in + order to the this trace's (x,y) coordinates. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scattergl.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattergl.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattergl.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Alternate to `x`. Builds a linear space of x coordinates. Use + with `dx` where `x0` is the starting coordinate and `dx` the + step. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Alternate to `y`. Builds a linear space of y coordinates. Use + with `dy` where `y0` is the starting coordinate and `dy` the + step. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scattergl.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scattergl.ErrorY instance or dict + with compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergl.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergl.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scattergl.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergl.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergl.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergl.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + dx=None, + dy=None, + error_x=None, + error_y=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xcalendar=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ycalendar=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Scattergl object + + The data visualized as scatter point or lines is set in `x` and + `y` using the WebGL plotting engine. Bubble charts are achieved + by setting `marker.size` and/or `marker.color` to a numerical + arrays. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scattergl + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + dx + Sets the x coordinate step. See `x0` for more info. + dy + Sets the y coordinate step. See `y0` for more info. + error_x + plotly.graph_objs.scattergl.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.scattergl.ErrorY instance or dict + with compatible properties + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattergl.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattergl.Line instance or dict with + compatible properties + marker + plotly.graph_objs.scattergl.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergl.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattergl.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattergl.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the starting + coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the starting + coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Scattergl + """ + super(Scattergl, self).__init__('scattergl') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scattergl +constructor must be a dict or +an instance of plotly.graph_objs.Scattergl""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scattergl as v_scattergl) + + # Initialize validators + # --------------------- + self._validators['connectgaps'] = v_scattergl.ConnectgapsValidator() + self._validators['customdata'] = v_scattergl.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scattergl.CustomdatasrcValidator() + self._validators['dx'] = v_scattergl.DxValidator() + self._validators['dy'] = v_scattergl.DyValidator() + self._validators['error_x'] = v_scattergl.ErrorXValidator() + self._validators['error_y'] = v_scattergl.ErrorYValidator() + self._validators['fill'] = v_scattergl.FillValidator() + self._validators['fillcolor'] = v_scattergl.FillcolorValidator() + self._validators['hoverinfo'] = v_scattergl.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_scattergl.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scattergl.HoverlabelValidator() + self._validators['hoveron'] = v_scattergl.HoveronValidator() + self._validators['ids'] = v_scattergl.IdsValidator() + self._validators['idssrc'] = v_scattergl.IdssrcValidator() + self._validators['legendgroup'] = v_scattergl.LegendgroupValidator() + self._validators['line'] = v_scattergl.LineValidator() + self._validators['marker'] = v_scattergl.MarkerValidator() + self._validators['mode'] = v_scattergl.ModeValidator() + self._validators['name'] = v_scattergl.NameValidator() + self._validators['opacity'] = v_scattergl.OpacityValidator() + self._validators['selected'] = v_scattergl.SelectedValidator() + self._validators['selectedpoints' + ] = v_scattergl.SelectedpointsValidator() + self._validators['showlegend'] = v_scattergl.ShowlegendValidator() + self._validators['stream'] = v_scattergl.StreamValidator() + self._validators['text'] = v_scattergl.TextValidator() + self._validators['textsrc'] = v_scattergl.TextsrcValidator() + self._validators['uid'] = v_scattergl.UidValidator() + self._validators['unselected'] = v_scattergl.UnselectedValidator() + self._validators['visible'] = v_scattergl.VisibleValidator() + self._validators['x'] = v_scattergl.XValidator() + self._validators['x0'] = v_scattergl.X0Validator() + self._validators['xaxis'] = v_scattergl.XAxisValidator() + self._validators['xcalendar'] = v_scattergl.XcalendarValidator() + self._validators['xsrc'] = v_scattergl.XsrcValidator() + self._validators['y'] = v_scattergl.YValidator() + self._validators['y0'] = v_scattergl.Y0Validator() + self._validators['yaxis'] = v_scattergl.YAxisValidator() + self._validators['ycalendar'] = v_scattergl.YcalendarValidator() + self._validators['ysrc'] = v_scattergl.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('dx', None) + self.dx = dx if dx is not None else v + v = arg.pop('dy', None) + self.dy = dy if dy is not None else v + v = arg.pop('error_x', None) + self.error_x = error_x if error_x is not None else v + v = arg.pop('error_y', None) + self.error_y = error_y if error_y is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scattergl' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scattergl' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scattermapbox.py b/plotly/graph_objs/_scattermapbox.py new file mode 100644 index 0000000000..7b029bb54f --- /dev/null +++ b/plotly/graph_objs/_scattermapbox.py @@ -0,0 +1,1438 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scattermapbox(BaseTraceType): + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. *toself* connects the endpoints of the trace (or + each segment of the trace if it has gaps) into a closed shape. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'toself'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lon', 'lat', 'text', 'name', 'name'] joined with '+' characters + (e.g. 'lon+lat') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scattermapbox.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (lon,lat) pair If + a single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (lon,lat) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # lat + # --- + @property + def lat(self): + """ + Sets the latitude coordinates (in degrees North). + + The 'lat' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['lat'] + + @lat.setter + def lat(self, val): + self['lat'] = val + + # latsrc + # ------ + @property + def latsrc(self): + """ + Sets the source reference on plot.ly for lat . + + The 'latsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['latsrc'] + + @latsrc.setter + def latsrc(self, val): + self['latsrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scattermapbox.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # lon + # --- + @property + def lon(self): + """ + Sets the longitude coordinates (in degrees East). + + The 'lon' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['lon'] + + @lon.setter + def lon(self, val): + self['lon'] = val + + # lonsrc + # ------ + @property + def lonsrc(self): + """ + Sets the source reference on plot.ly for lon . + + The 'lonsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['lonsrc'] + + @lonsrc.setter + def lonsrc(self, val): + self['lonsrc'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattermapbox.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol. Full list: + https://www.mapbox.com/maki-icons/ Note that + the array `marker.color` and `marker.size` are + only available for *circle* symbols. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scattermapbox.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattermapbox.selected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattermapbox.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scattermapbox.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # subplot + # ------- + @property + def subplot(self): + """ + Sets a reference between this trace's data coordinates and a + mapbox subplot. If *mapbox* (the default value), the data refer + to `layout.mapbox`. If *mapbox2*, the data refer to + `layout.mapbox2`, and so on. + + The 'subplot' property is an identifier of a particular + subplot, of type 'mapbox', that may be specified as the string 'mapbox' + optionally followed by an integer >= 1 + (e.g. 'mapbox', 'mapbox1', 'mapbox2', 'mapbox3', etc.) + + Returns + ------- + str + """ + return self['subplot'] + + @subplot.setter + def subplot(self, val): + self['subplot'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (lon,lat) pair If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (lon,lat) coordinates. If trace `hoverinfo` + contains a *text* flag and *hovertext* is not set, these + elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the icon text font. Has an effect only when `type` is set + to *symbol*. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattermapbox.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + + Returns + ------- + Any + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scattermapbox.unselected.Mark + er instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scattermapbox.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattermapbox.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (lon,lat) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattermapbox.Line instance or dict + with compatible properties + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattermapbox.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattermapbox.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattermapbox.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a mapbox subplot. If *mapbox* (the default value), + the data refer to `layout.mapbox`. If *mapbox2*, the + data refer to `layout.mapbox2`, and so on. + text + Sets text elements associated with each (lon,lat) pair + If a single string, the same string appears over all + the data points. If an array of string, the items are + mapped in order to the this trace's (lon,lat) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattermapbox.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + lat=None, + latsrc=None, + legendgroup=None, + line=None, + lon=None, + lonsrc=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + **kwargs + ): + """ + Construct a new Scattermapbox object + + The data visualized as scatter point, lines or marker symbols + on a Mapbox GL geographic map is provided by longitude/latitude + pairs in `lon` and `lat`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scattermapbox + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scattermapbox.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each (lon,lat) + pair If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (lon,lat) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scattermapbox.Line instance or dict + with compatible properties + lon + Sets the longitude coordinates (in degrees East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattermapbox.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattermapbox.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scattermapbox.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a mapbox subplot. If *mapbox* (the default value), + the data refer to `layout.mapbox`. If *mapbox2*, the + data refer to `layout.mapbox2`, and so on. + text + Sets text elements associated with each (lon,lat) pair + If a single string, the same string appears over all + the data points. If an array of string, the items are + mapped in order to the this trace's (lon,lat) + coordinates. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scattermapbox.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Scattermapbox + """ + super(Scattermapbox, self).__init__('scattermapbox') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scattermapbox +constructor must be a dict or +an instance of plotly.graph_objs.Scattermapbox""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scattermapbox as v_scattermapbox) + + # Initialize validators + # --------------------- + self._validators['connectgaps' + ] = v_scattermapbox.ConnectgapsValidator() + self._validators['customdata'] = v_scattermapbox.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scattermapbox.CustomdatasrcValidator() + self._validators['fill'] = v_scattermapbox.FillValidator() + self._validators['fillcolor'] = v_scattermapbox.FillcolorValidator() + self._validators['hoverinfo'] = v_scattermapbox.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_scattermapbox.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scattermapbox.HoverlabelValidator() + self._validators['hovertext'] = v_scattermapbox.HovertextValidator() + self._validators['hovertextsrc' + ] = v_scattermapbox.HovertextsrcValidator() + self._validators['ids'] = v_scattermapbox.IdsValidator() + self._validators['idssrc'] = v_scattermapbox.IdssrcValidator() + self._validators['lat'] = v_scattermapbox.LatValidator() + self._validators['latsrc'] = v_scattermapbox.LatsrcValidator() + self._validators['legendgroup' + ] = v_scattermapbox.LegendgroupValidator() + self._validators['line'] = v_scattermapbox.LineValidator() + self._validators['lon'] = v_scattermapbox.LonValidator() + self._validators['lonsrc'] = v_scattermapbox.LonsrcValidator() + self._validators['marker'] = v_scattermapbox.MarkerValidator() + self._validators['mode'] = v_scattermapbox.ModeValidator() + self._validators['name'] = v_scattermapbox.NameValidator() + self._validators['opacity'] = v_scattermapbox.OpacityValidator() + self._validators['selected'] = v_scattermapbox.SelectedValidator() + self._validators['selectedpoints' + ] = v_scattermapbox.SelectedpointsValidator() + self._validators['showlegend'] = v_scattermapbox.ShowlegendValidator() + self._validators['stream'] = v_scattermapbox.StreamValidator() + self._validators['subplot'] = v_scattermapbox.SubplotValidator() + self._validators['text'] = v_scattermapbox.TextValidator() + self._validators['textfont'] = v_scattermapbox.TextfontValidator() + self._validators['textposition' + ] = v_scattermapbox.TextpositionValidator() + self._validators['textsrc'] = v_scattermapbox.TextsrcValidator() + self._validators['uid'] = v_scattermapbox.UidValidator() + self._validators['unselected'] = v_scattermapbox.UnselectedValidator() + self._validators['visible'] = v_scattermapbox.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('lat', None) + self.lat = lat if lat is not None else v + v = arg.pop('latsrc', None) + self.latsrc = latsrc if latsrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('lon', None) + self.lon = lon if lon is not None else v + v = arg.pop('lonsrc', None) + self.lonsrc = lonsrc if lonsrc is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('subplot', None) + self.subplot = subplot if subplot is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scattermapbox' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scattermapbox' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scatterpolar.py b/plotly/graph_objs/_scatterpolar.py new file mode 100644 index 0000000000..4899a57dba --- /dev/null +++ b/plotly/graph_objs/_scatterpolar.py @@ -0,0 +1,1646 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scatterpolar(BaseTraceType): + + # cliponaxis + # ---------- + @property + def cliponaxis(self): + """ + Determines whether or not markers and text nodes are clipped + about the subplot axes. To show markers and text nodes above + axis lines and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + + The 'cliponaxis' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cliponaxis'] + + @cliponaxis.setter + def cliponaxis(self, val): + self['cliponaxis'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. scatterpolar has a subset of the options + available to scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between two traces if + one completely encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is no trace before + it. *tonext* should not be used if one trace does not enclose + the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['r', 'theta', 'text', 'name', 'name'] joined with '+' characters + (e.g. 'r+theta') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scatterpolar.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (x,y) pair. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scatterpolar.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolar.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatterpolar.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatterpolar.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scatterpolar.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # r + # - + @property + def r(self): + """ + Sets the radial coordinates + + The 'r' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # rsrc + # ---- + @property + def rsrc(self): + """ + Sets the source reference on plot.ly for r . + + The 'rsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['rsrc'] + + @rsrc.setter + def rsrc(self, val): + self['rsrc'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterpolar.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.selected.Textfon + t instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatterpolar.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scatterpolar.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # subplot + # ------- + @property + def subplot(self): + """ + Sets a reference between this trace's data coordinates and a + polar subplot. If *polar* (the default value), the data refer + to `layout.polar`. If *polar2*, the data refer to + `layout.polar2`, and so on. + + The 'subplot' property is an identifier of a particular + subplot, of type 'polar', that may be specified as the string 'polar' + optionally followed by an integer >= 1 + (e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.) + + Returns + ------- + str + """ + return self['subplot'] + + @subplot.setter + def subplot(self, val): + self['subplot'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatterpolar.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # theta + # ----- + @property + def theta(self): + """ + Sets the angular coordinates + + The 'theta' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['theta'] + + @theta.setter + def theta(self, val): + self['theta'] = val + + # thetasrc + # -------- + @property + def thetasrc(self): + """ + Sets the source reference on plot.ly for theta . + + The 'thetasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['thetasrc'] + + @thetasrc.setter + def thetasrc(self, val): + self['thetasrc'] = val + + # thetaunit + # --------- + @property + def thetaunit(self): + """ + Sets the unit of input *theta* values. Has an effect only when + on *linear* angular axes. + + The 'thetaunit' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radians', 'degrees', 'gradians'] + + Returns + ------- + Any + """ + return self['thetaunit'] + + @thetaunit.setter + def thetaunit(self, val): + self['thetaunit'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterpolar.unselected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.unselected.Textf + ont instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatterpolar.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterpolar has a subset of + the options available to scatter. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolar.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolar.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolar.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolar.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolar.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolar.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + cliponaxis=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + **kwargs + ): + """ + Construct a new Scatterpolar object + + The scatterpolar trace type encompasses line charts, scatter + charts, text charts, and bubble charts in polar coordinates. + The data visualized as scatter point or lines is set in `r` + (radial) and `theta` (angular) coordinates Text (appearing + either on the chart or on hover only) is via `text`. Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scatterpolar + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterpolar has a subset of + the options available to scatter. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolar.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (x,y) + pair. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolar.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolar.Marker instance or dict + with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolar.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolar.Stream instance or dict + with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolar.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Scatterpolar + """ + super(Scatterpolar, self).__init__('scatterpolar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scatterpolar +constructor must be a dict or +an instance of plotly.graph_objs.Scatterpolar""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scatterpolar as v_scatterpolar) + + # Initialize validators + # --------------------- + self._validators['cliponaxis'] = v_scatterpolar.CliponaxisValidator() + self._validators['connectgaps'] = v_scatterpolar.ConnectgapsValidator() + self._validators['customdata'] = v_scatterpolar.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scatterpolar.CustomdatasrcValidator() + self._validators['fill'] = v_scatterpolar.FillValidator() + self._validators['fillcolor'] = v_scatterpolar.FillcolorValidator() + self._validators['hoverinfo'] = v_scatterpolar.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_scatterpolar.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scatterpolar.HoverlabelValidator() + self._validators['hoveron'] = v_scatterpolar.HoveronValidator() + self._validators['hovertext'] = v_scatterpolar.HovertextValidator() + self._validators['hovertextsrc' + ] = v_scatterpolar.HovertextsrcValidator() + self._validators['ids'] = v_scatterpolar.IdsValidator() + self._validators['idssrc'] = v_scatterpolar.IdssrcValidator() + self._validators['legendgroup'] = v_scatterpolar.LegendgroupValidator() + self._validators['line'] = v_scatterpolar.LineValidator() + self._validators['marker'] = v_scatterpolar.MarkerValidator() + self._validators['mode'] = v_scatterpolar.ModeValidator() + self._validators['name'] = v_scatterpolar.NameValidator() + self._validators['opacity'] = v_scatterpolar.OpacityValidator() + self._validators['r'] = v_scatterpolar.RValidator() + self._validators['rsrc'] = v_scatterpolar.RsrcValidator() + self._validators['selected'] = v_scatterpolar.SelectedValidator() + self._validators['selectedpoints' + ] = v_scatterpolar.SelectedpointsValidator() + self._validators['showlegend'] = v_scatterpolar.ShowlegendValidator() + self._validators['stream'] = v_scatterpolar.StreamValidator() + self._validators['subplot'] = v_scatterpolar.SubplotValidator() + self._validators['text'] = v_scatterpolar.TextValidator() + self._validators['textfont'] = v_scatterpolar.TextfontValidator() + self._validators['textposition' + ] = v_scatterpolar.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scatterpolar.TextpositionsrcValidator() + self._validators['textsrc'] = v_scatterpolar.TextsrcValidator() + self._validators['theta'] = v_scatterpolar.ThetaValidator() + self._validators['thetasrc'] = v_scatterpolar.ThetasrcValidator() + self._validators['thetaunit'] = v_scatterpolar.ThetaunitValidator() + self._validators['uid'] = v_scatterpolar.UidValidator() + self._validators['unselected'] = v_scatterpolar.UnselectedValidator() + self._validators['visible'] = v_scatterpolar.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('cliponaxis', None) + self.cliponaxis = cliponaxis if cliponaxis is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('rsrc', None) + self.rsrc = rsrc if rsrc is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('subplot', None) + self.subplot = subplot if subplot is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('theta', None) + self.theta = theta if theta is not None else v + v = arg.pop('thetasrc', None) + self.thetasrc = thetasrc if thetasrc is not None else v + v = arg.pop('thetaunit', None) + self.thetaunit = thetaunit if thetaunit is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scatterpolar' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scatterpolar' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scatterpolargl.py b/plotly/graph_objs/_scatterpolargl.py new file mode 100644 index 0000000000..b8c16cccc9 --- /dev/null +++ b/plotly/graph_objs/_scatterpolargl.py @@ -0,0 +1,1402 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scatterpolargl(BaseTraceType): + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 + respectively. *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of the trace before + it, connecting those endpoints with straight lines (to make a + stacked area graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the space between two + traces if one completely encloses the other (eg consecutive + contour lines), and behaves like *toself* if there is no trace + before it. *tonext* should not be used if one trace does not + enclose the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', + 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['r', 'theta', 'text', 'name', 'name'] joined with '+' characters + (e.g. 'r+theta') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scatterpolargl.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scatterpolargl.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolargl.marker.ColorBa + r instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scatterpolargl.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scatterpolargl.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # r + # - + @property + def r(self): + """ + Sets the radial coordinates + + The 'r' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # rsrc + # ---- + @property + def rsrc(self): + """ + Sets the source reference on plot.ly for r . + + The 'rsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['rsrc'] + + @rsrc.setter + def rsrc(self, val): + self['rsrc'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterpolargl.selected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.selected.Textf + ont instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatterpolargl.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scatterpolargl.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # subplot + # ------- + @property + def subplot(self): + """ + Sets a reference between this trace's data coordinates and a + polar subplot. If *polar* (the default value), the data refer + to `layout.polar`. If *polar2*, the data refer to + `layout.polar2`, and so on. + + The 'subplot' property is an identifier of a particular + subplot, of type 'polar', that may be specified as the string 'polar' + optionally followed by an integer >= 1 + (e.g. 'polar', 'polar1', 'polar2', 'polar3', etc.) + + Returns + ------- + str + """ + return self['subplot'] + + @subplot.setter + def subplot(self, val): + self['subplot'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair. If a single + string, the same string appears over all the data points. If an + array of string, the items are mapped in order to the this + trace's (x,y) coordinates. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these elements will be + seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # theta + # ----- + @property + def theta(self): + """ + Sets the angular coordinates + + The 'theta' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['theta'] + + @theta.setter + def theta(self, val): + self['theta'] = val + + # thetasrc + # -------- + @property + def thetasrc(self): + """ + Sets the source reference on plot.ly for theta . + + The 'thetasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['thetasrc'] + + @thetasrc.setter + def thetasrc(self, val): + self['thetasrc'] = val + + # thetaunit + # --------- + @property + def thetaunit(self): + """ + Sets the unit of input *theta* values. Has an effect only when + on *linear* angular axes. + + The 'thetaunit' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radians', 'degrees', 'gradians'] + + Returns + ------- + Any + """ + return self['thetaunit'] + + @thetaunit.setter + def thetaunit(self, val): + self['thetaunit'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterpolargl.unselected.Mar + ker instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.unselected.Tex + tfont instance or dict with compatible + properties + + Returns + ------- + plotly.graph_objs.scatterpolargl.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolargl.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolargl.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolargl.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolargl.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolargl.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolargl.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + connectgaps=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + r=None, + rsrc=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + text=None, + textsrc=None, + theta=None, + thetasrc=None, + thetaunit=None, + uid=None, + unselected=None, + visible=None, + **kwargs + ): + """ + Construct a new Scatterpolargl object + + The scatterpolargl trace type encompasses line charts, scatter + charts, and bubble charts in polar coordinates using the WebGL + plotting engine. The data visualized as scatter point or lines + is set in `r` (radial) and `theta` (angular) coordinates Bubble + charts are achieved by setting `marker.size` and/or + `marker.color` to numerical arrays. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scatterpolargl + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. *tozerox* and *tozeroy* fill + to x=0 and y=0 respectively. *tonextx* and *tonexty* + fill between the endpoints of this trace and the + endpoints of the trace before it, connecting those + endpoints with straight lines (to make a stacked area + graph); if there is no trace before it, they behave + like *tozerox* and *tozeroy*. *toself* connects the + endpoints of the trace (or each segment of the trace if + it has gaps) into a closed shape. *tonext* fills the + space between two traces if one completely encloses the + other (eg consecutive contour lines), and behaves like + *toself* if there is no trace before it. *tonext* + should not be used if one trace does not enclose the + other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolargl.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterpolargl.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterpolargl.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolargl.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterpolargl.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a polar subplot. If *polar* (the default value), + the data refer to `layout.polar`. If *polar2*, the data + refer to `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) pair. If + a single string, the same string appears over all the + data points. If an array of string, the items are + mapped in order to the this trace's (x,y) coordinates. + If trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta . + thetaunit + Sets the unit of input *theta* values. Has an effect + only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolargl.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Scatterpolargl + """ + super(Scatterpolargl, self).__init__('scatterpolargl') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scatterpolargl +constructor must be a dict or +an instance of plotly.graph_objs.Scatterpolargl""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scatterpolargl as v_scatterpolargl) + + # Initialize validators + # --------------------- + self._validators['connectgaps' + ] = v_scatterpolargl.ConnectgapsValidator() + self._validators['customdata'] = v_scatterpolargl.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scatterpolargl.CustomdatasrcValidator() + self._validators['fill'] = v_scatterpolargl.FillValidator() + self._validators['fillcolor'] = v_scatterpolargl.FillcolorValidator() + self._validators['hoverinfo'] = v_scatterpolargl.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_scatterpolargl.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scatterpolargl.HoverlabelValidator() + self._validators['hoveron'] = v_scatterpolargl.HoveronValidator() + self._validators['ids'] = v_scatterpolargl.IdsValidator() + self._validators['idssrc'] = v_scatterpolargl.IdssrcValidator() + self._validators['legendgroup' + ] = v_scatterpolargl.LegendgroupValidator() + self._validators['line'] = v_scatterpolargl.LineValidator() + self._validators['marker'] = v_scatterpolargl.MarkerValidator() + self._validators['mode'] = v_scatterpolargl.ModeValidator() + self._validators['name'] = v_scatterpolargl.NameValidator() + self._validators['opacity'] = v_scatterpolargl.OpacityValidator() + self._validators['r'] = v_scatterpolargl.RValidator() + self._validators['rsrc'] = v_scatterpolargl.RsrcValidator() + self._validators['selected'] = v_scatterpolargl.SelectedValidator() + self._validators['selectedpoints' + ] = v_scatterpolargl.SelectedpointsValidator() + self._validators['showlegend'] = v_scatterpolargl.ShowlegendValidator() + self._validators['stream'] = v_scatterpolargl.StreamValidator() + self._validators['subplot'] = v_scatterpolargl.SubplotValidator() + self._validators['text'] = v_scatterpolargl.TextValidator() + self._validators['textsrc'] = v_scatterpolargl.TextsrcValidator() + self._validators['theta'] = v_scatterpolargl.ThetaValidator() + self._validators['thetasrc'] = v_scatterpolargl.ThetasrcValidator() + self._validators['thetaunit'] = v_scatterpolargl.ThetaunitValidator() + self._validators['uid'] = v_scatterpolargl.UidValidator() + self._validators['unselected'] = v_scatterpolargl.UnselectedValidator() + self._validators['visible'] = v_scatterpolargl.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('rsrc', None) + self.rsrc = rsrc if rsrc is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('subplot', None) + self.subplot = subplot if subplot is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('theta', None) + self.theta = theta if theta is not None else v + v = arg.pop('thetasrc', None) + self.thetasrc = thetasrc if thetasrc is not None else v + v = arg.pop('thetaunit', None) + self.thetaunit = thetaunit if thetaunit is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scatterpolargl' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scatterpolargl' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_scatterternary.py b/plotly/graph_objs/_scatterternary.py new file mode 100644 index 0000000000..24493deeea --- /dev/null +++ b/plotly/graph_objs/_scatterternary.py @@ -0,0 +1,1744 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Scatterternary(BaseTraceType): + + # a + # - + @property + def a(self): + """ + Sets the quantity of component `a` in each data point. If `a`, + `b`, and `c` are all provided, they need not be normalized, + only the relative values matter. If only two arrays are + provided they must be normalized to match `ternary.sum`. + + The 'a' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['a'] + + @a.setter + def a(self, val): + self['a'] = val + + # asrc + # ---- + @property + def asrc(self): + """ + Sets the source reference on plot.ly for a . + + The 'asrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['asrc'] + + @asrc.setter + def asrc(self, val): + self['asrc'] = val + + # b + # - + @property + def b(self): + """ + Sets the quantity of component `a` in each data point. If `a`, + `b`, and `c` are all provided, they need not be normalized, + only the relative values matter. If only two arrays are + provided they must be normalized to match `ternary.sum`. + + The 'b' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # bsrc + # ---- + @property + def bsrc(self): + """ + Sets the source reference on plot.ly for b . + + The 'bsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bsrc'] + + @bsrc.setter + def bsrc(self, val): + self['bsrc'] = val + + # c + # - + @property + def c(self): + """ + Sets the quantity of component `a` in each data point. If `a`, + `b`, and `c` are all provided, they need not be normalized, + only the relative values matter. If only two arrays are + provided they must be normalized to match `ternary.sum`. + + The 'c' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['c'] + + @c.setter + def c(self, val): + self['c'] = val + + # cliponaxis + # ---------- + @property + def cliponaxis(self): + """ + Determines whether or not markers and text nodes are clipped + about the subplot axes. To show markers and text nodes above + axis lines and tick labels, make sure to set `xaxis.layer` and + `yaxis.layer` to *below traces*. + + The 'cliponaxis' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cliponaxis'] + + @cliponaxis.setter + def cliponaxis(self, val): + self['cliponaxis'] = val + + # connectgaps + # ----------- + @property + def connectgaps(self): + """ + Determines whether or not gaps (i.e. {nan} or missing values) + in the provided data arrays are connected. + + The 'connectgaps' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['connectgaps'] + + @connectgaps.setter + def connectgaps(self, val): + self['connectgaps'] = val + + # csrc + # ---- + @property + def csrc(self): + """ + Sets the source reference on plot.ly for c . + + The 'csrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['csrc'] + + @csrc.setter + def csrc(self, val): + self['csrc'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + Sets the area to fill with a solid color. Use with `fillcolor` + if not *none*. scatterternary has a subset of the options + available to scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between two traces if + one completely encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is no trace before + it. *tonext* should not be used if one trace does not enclose + the other. + + The 'fill' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'toself', 'tonext'] + + Returns + ------- + Any + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['a', 'b', 'c', 'text', 'name'] joined with '+' characters + (e.g. 'a+b') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.scatterternary.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual points (markers or + line points) or do they highlight filled regions? If the fill + is *toself* or *tonext* and there are no markers or text, then + the default is *fills*, otherwise it is *points*. + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['points', 'fills'] joined with '+' characters + (e.g. 'points+fills') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets hover text elements associated with each (a,b,c) point. If + a single string, the same string appears over all the data + points. If an array of strings, the items are mapped in order + to the the data points in (a,b,c). To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # hovertextsrc + # ------------ + @property + def hovertextsrc(self): + """ + Sets the source reference on plot.ly for hovertext . + + The 'hovertextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hovertextsrc'] + + @hovertextsrc.setter + def hovertextsrc(self, val): + self['hovertextsrc'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.scatterternary.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterternary.marker.ColorBa + r instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatterternary.marker.Gradien + t instance or dict with compatible properties + line + plotly.graph_objs.scatterternary.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.scatterternary.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # mode + # ---- + @property + def mode(self): + """ + Determines the drawing mode for this scatter trace. If the + provided `mode` includes *text* then the `text` elements appear + at the coordinates. Otherwise, the `text` elements appear on + hover. If there are less than 20 points, then the default is + *lines+markers*. Otherwise, *lines*. + + The 'mode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['lines', 'markers', 'text'] joined with '+' characters + (e.g. 'lines+markers') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['mode'] + + @mode.setter + def mode(self, val): + self['mode'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterternary.selected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.selected.Textf + ont instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.scatterternary.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.scatterternary.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # subplot + # ------- + @property + def subplot(self): + """ + Sets a reference between this trace's data coordinates and a + ternary subplot. If *ternary* (the default value), the data + refer to `layout.ternary`. If *ternary2*, the data refer to + `layout.ternary2`, and so on. + + The 'subplot' property is an identifier of a particular + subplot, of type 'ternary', that may be specified as the string 'ternary' + optionally followed by an integer >= 1 + (e.g. 'ternary', 'ternary1', 'ternary2', 'ternary3', etc.) + + Returns + ------- + str + """ + return self['subplot'] + + @subplot.setter + def subplot(self, val): + self['subplot'] = val + + # sum + # --- + @property + def sum(self): + """ + The number each triplet should sum to, if only two of `a`, `b`, + and `c` are provided. This overrides `ternary.sum` to + normalize this specific trace, but does not affect the values + displayed on the axes. 0 (or missing) means to use + ternary.sum + + The 'sum' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sum'] + + @sum.setter + def sum(self, val): + self['sum'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (a,b,c) point. If a + single string, the same string appears over all the data + points. If an array of strings, the items are mapped in order + to the the data points in (a,b,c). If trace `hoverinfo` + contains a *text* flag and *hovertext* is not set, these + elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the text font. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatterternary.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # textpositionsrc + # --------------- + @property + def textpositionsrc(self): + """ + Sets the source reference on plot.ly for textposition . + + The 'textpositionsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textpositionsrc'] + + @textpositionsrc.setter + def textpositionsrc(self, val): + self['textpositionsrc'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.scatterternary.unselected.Mar + ker instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.unselected.Tex + tfont instance or dict with compatible + properties + + Returns + ------- + plotly.graph_objs.scatterternary.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + c + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + csrc + Sets the source reference on plot.ly for c . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterternary.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (a,b,c) + point. If a single string, the same string appears over + all the data points. If an array of strings, the items + are mapped in order to the the data points in (a,b,c). + To be seen, trace `hoverinfo` must contain a *text* + flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterternary.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterternary.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scatterternary.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterternary.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a ternary subplot. If *ternary* (the default + value), the data refer to `layout.ternary`. If + *ternary2*, the data refer to `layout.ternary2`, and so + on. + sum + The number each triplet should sum to, if only two of + `a`, `b`, and `c` are provided. This overrides + `ternary.sum` to normalize this specific trace, but + does not affect the values displayed on the axes. 0 (or + missing) means to use ternary.sum + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scatterternary.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + a=None, + asrc=None, + b=None, + bsrc=None, + c=None, + cliponaxis=None, + connectgaps=None, + csrc=None, + customdata=None, + customdatasrc=None, + fill=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + hovertext=None, + hovertextsrc=None, + ids=None, + idssrc=None, + legendgroup=None, + line=None, + marker=None, + mode=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + stream=None, + subplot=None, + sum=None, + text=None, + textfont=None, + textposition=None, + textpositionsrc=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + **kwargs + ): + """ + Construct a new Scatterternary object + + Provides similar functionality to the *scatter* type but on a + ternary phase diagram. The data is provided by at least two + arrays out of `a`, `b`, `c` triplets. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Scatterternary + a + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + c + Sets the quantity of component `a` in each data point. + If `a`, `b`, and `c` are all provided, they need not be + normalized, only the relative values matter. If only + two arrays are provided they must be normalized to + match `ternary.sum`. + cliponaxis + Determines whether or not markers and text nodes are + clipped about the subplot axes. To show markers and + text nodes above axis lines and tick labels, make sure + to set `xaxis.layer` and `yaxis.layer` to *below + traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or missing + values) in the provided data arrays are connected. + csrc + Sets the source reference on plot.ly for c . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fill + Sets the area to fill with a solid color. Use with + `fillcolor` if not *none*. scatterternary has a subset + of the options available to scatter. *toself* connects + the endpoints of the trace (or each segment of the + trace if it has gaps) into a closed shape. *tonext* + fills the space between two traces if one completely + encloses the other (eg consecutive contour lines), and + behaves like *toself* if there is no trace before it. + *tonext* should not be used if one trace does not + enclose the other. + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.scatterternary.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual points + (markers or line points) or do they highlight filled + regions? If the fill is *toself* or *tonext* and there + are no markers or text, then the default is *fills*, + otherwise it is *points*. + hovertext + Sets hover text elements associated with each (a,b,c) + point. If a single string, the same string appears over + all the data points. If an array of strings, the items + are mapped in order to the the data points in (a,b,c). + To be seen, trace `hoverinfo` must contain a *text* + flag. + hovertextsrc + Sets the source reference on plot.ly for hovertext . + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.scatterternary.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatterternary.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter trace. If + the provided `mode` includes *text* then the `text` + elements appear at the coordinates. Otherwise, the + `text` elements appear on hover. If there are less than + 20 points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scatterternary.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.scatterternary.Stream instance or + dict with compatible properties + subplot + Sets a reference between this trace's data coordinates + and a ternary subplot. If *ternary* (the default + value), the data refer to `layout.ternary`. If + *ternary2*, the data refer to `layout.ternary2`, and so + on. + sum + The number each triplet should sum to, if only two of + `a`, `b`, and `c` are provided. This overrides + `ternary.sum` to normalize this specific trace, but + does not affect the values displayed on the axes. 0 (or + missing) means to use ternary.sum + text + Sets text elements associated with each (a,b,c) point. + If a single string, the same string appears over all + the data points. If an array of strings, the items are + mapped in order to the the data points in (a,b,c). If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for textposition + . + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.scatterternary.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Scatterternary + """ + super(Scatterternary, self).__init__('scatterternary') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Scatterternary +constructor must be a dict or +an instance of plotly.graph_objs.Scatterternary""" + ) + + # Import validators + # ----------------- + from plotly.validators import (scatterternary as v_scatterternary) + + # Initialize validators + # --------------------- + self._validators['a'] = v_scatterternary.AValidator() + self._validators['asrc'] = v_scatterternary.AsrcValidator() + self._validators['b'] = v_scatterternary.BValidator() + self._validators['bsrc'] = v_scatterternary.BsrcValidator() + self._validators['c'] = v_scatterternary.CValidator() + self._validators['cliponaxis'] = v_scatterternary.CliponaxisValidator() + self._validators['connectgaps' + ] = v_scatterternary.ConnectgapsValidator() + self._validators['csrc'] = v_scatterternary.CsrcValidator() + self._validators['customdata'] = v_scatterternary.CustomdataValidator() + self._validators['customdatasrc' + ] = v_scatterternary.CustomdatasrcValidator() + self._validators['fill'] = v_scatterternary.FillValidator() + self._validators['fillcolor'] = v_scatterternary.FillcolorValidator() + self._validators['hoverinfo'] = v_scatterternary.HoverinfoValidator() + self._validators['hoverinfosrc' + ] = v_scatterternary.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_scatterternary.HoverlabelValidator() + self._validators['hoveron'] = v_scatterternary.HoveronValidator() + self._validators['hovertext'] = v_scatterternary.HovertextValidator() + self._validators['hovertextsrc' + ] = v_scatterternary.HovertextsrcValidator() + self._validators['ids'] = v_scatterternary.IdsValidator() + self._validators['idssrc'] = v_scatterternary.IdssrcValidator() + self._validators['legendgroup' + ] = v_scatterternary.LegendgroupValidator() + self._validators['line'] = v_scatterternary.LineValidator() + self._validators['marker'] = v_scatterternary.MarkerValidator() + self._validators['mode'] = v_scatterternary.ModeValidator() + self._validators['name'] = v_scatterternary.NameValidator() + self._validators['opacity'] = v_scatterternary.OpacityValidator() + self._validators['selected'] = v_scatterternary.SelectedValidator() + self._validators['selectedpoints' + ] = v_scatterternary.SelectedpointsValidator() + self._validators['showlegend'] = v_scatterternary.ShowlegendValidator() + self._validators['stream'] = v_scatterternary.StreamValidator() + self._validators['subplot'] = v_scatterternary.SubplotValidator() + self._validators['sum'] = v_scatterternary.SumValidator() + self._validators['text'] = v_scatterternary.TextValidator() + self._validators['textfont'] = v_scatterternary.TextfontValidator() + self._validators['textposition' + ] = v_scatterternary.TextpositionValidator() + self._validators['textpositionsrc' + ] = v_scatterternary.TextpositionsrcValidator() + self._validators['textsrc'] = v_scatterternary.TextsrcValidator() + self._validators['uid'] = v_scatterternary.UidValidator() + self._validators['unselected'] = v_scatterternary.UnselectedValidator() + self._validators['visible'] = v_scatterternary.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('a', None) + self.a = a if a is not None else v + v = arg.pop('asrc', None) + self.asrc = asrc if asrc is not None else v + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('bsrc', None) + self.bsrc = bsrc if bsrc is not None else v + v = arg.pop('c', None) + self.c = c if c is not None else v + v = arg.pop('cliponaxis', None) + self.cliponaxis = cliponaxis if cliponaxis is not None else v + v = arg.pop('connectgaps', None) + self.connectgaps = connectgaps if connectgaps is not None else v + v = arg.pop('csrc', None) + self.csrc = csrc if csrc is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('hovertextsrc', None) + self.hovertextsrc = hovertextsrc if hovertextsrc is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('mode', None) + self.mode = mode if mode is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('subplot', None) + self.subplot = subplot if subplot is not None else v + v = arg.pop('sum', None) + self.sum = sum if sum is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + v = arg.pop('textpositionsrc', None) + self.textpositionsrc = textpositionsrc if textpositionsrc is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'scatterternary' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='scatterternary' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_splom.py b/plotly/graph_objs/_splom.py new file mode 100644 index 0000000000..3dfe635828 --- /dev/null +++ b/plotly/graph_objs/_splom.py @@ -0,0 +1,1126 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Splom(BaseTraceType): + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # diagonal + # -------- + @property + def diagonal(self): + """ + The 'diagonal' property is an instance of Diagonal + that may be specified as: + - An instance of plotly.graph_objs.splom.Diagonal + - A dict of string/value properties that will be passed + to the Diagonal constructor + + Supported dict properties: + + visible + Determines whether or not subplots on the + diagonal are displayed. + + Returns + ------- + plotly.graph_objs.splom.Diagonal + """ + return self['diagonal'] + + @diagonal.setter + def diagonal(self, val): + self['diagonal'] = val + + # dimensions + # ---------- + @property + def dimensions(self): + """ + The 'dimensions' property is a tuple of instances of + Dimension that may be specified as: + - A list or tuple of instances of plotly.graph_objs.splom.Dimension + - A list or tuple of dicts of string/value properties that + will be passed to the Dimension constructor + + Supported dict properties: + + label + Sets the label corresponding to this splom + dimension. + values + Sets the dimension values to be plotted. + valuessrc + Sets the source reference on plot.ly for + values . + visible + Determines whether or not this dimension is + shown on the graph. Note that even visible + false dimension contribute to the default grid + generate by this splom trace. + + Returns + ------- + tuple[plotly.graph_objs.splom.Dimension] + """ + return self['dimensions'] + + @dimensions.setter + def dimensions(self, val): + self['dimensions'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.splom.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.splom.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.splom.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.splom.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.splom.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol . + + Returns + ------- + plotly.graph_objs.splom.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.splom.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.splom.selected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.splom.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showlowerhalf + # ------------- + @property + def showlowerhalf(self): + """ + Determines whether or not subplots on the lower half from the + diagonal are displayed. + + The 'showlowerhalf' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlowerhalf'] + + @showlowerhalf.setter + def showlowerhalf(self, val): + self['showlowerhalf'] = val + + # showupperhalf + # ------------- + @property + def showupperhalf(self): + """ + Determines whether or not subplots on the upper half from the + diagonal are displayed. + + The 'showupperhalf' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showupperhalf'] + + @showupperhalf.setter + def showupperhalf(self, val): + self['showupperhalf'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.splom.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.splom.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets text elements associated with each (x,y) pair to appear on + hover. If a single string, the same string appears over all the + data points. If an array of string, the items are mapped in + order to the this trace's (x,y) coordinates. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.splom.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.splom.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.splom.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # xaxes + # ----- + @property + def xaxes(self): + """ + Sets the list of x axes corresponding to this splom trace. By + default, a splom will match the first N xaxes where N is the + number of input dimensions. + + The 'xaxes' property is an info array that may be specified as a + list or tuple of up to 1 elements where: + + (0) The 'xaxes[0]' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + list + """ + return self['xaxes'] + + @xaxes.setter + def xaxes(self, val): + self['xaxes'] = val + + # yaxes + # ----- + @property + def yaxes(self): + """ + Sets the list of y axes corresponding to this splom trace. By + default, a splom will match the first N yaxes where N is the + number of input dimensions. + + The 'yaxes' property is an info array that may be specified as a + list or tuple of up to 1 elements where: + + (0) The 'yaxes[0]' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + list + """ + return self['yaxes'] + + @yaxes.setter + def yaxes(self, val): + self['yaxes'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + diagonal + plotly.graph_objs.splom.Diagonal instance or dict with + compatible properties + dimensions + plotly.graph_objs.splom.Dimension instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.splom.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.splom.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.splom.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showlowerhalf + Determines whether or not subplots on the lower half + from the diagonal are displayed. + showupperhalf + Determines whether or not subplots on the upper half + from the diagonal are displayed. + stream + plotly.graph_objs.splom.Stream instance or dict with + compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.splom.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxes + Sets the list of x axes corresponding to this splom + trace. By default, a splom will match the first N xaxes + where N is the number of input dimensions. + yaxes + Sets the list of y axes corresponding to this splom + trace. By default, a splom will match the first N yaxes + where N is the number of input dimensions. + """ + + def __init__( + self, + arg=None, + customdata=None, + customdatasrc=None, + diagonal=None, + dimensions=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + marker=None, + name=None, + opacity=None, + selected=None, + selectedpoints=None, + showlegend=None, + showlowerhalf=None, + showupperhalf=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + xaxes=None, + yaxes=None, + **kwargs + ): + """ + Construct a new Splom object + + Splom traces generate scatter plot matrix visualizations. Each + splom `dimensions` items correspond to a generated axis. Values + for each of those dimensions are set in `dimensions[i].values`. + Splom traces support all `scattergl` marker style attributes. + Specify `layout.grid` attributes and/or layout x-axis and + y-axis attributes for more control over the axis positioning + and style. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Splom + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + diagonal + plotly.graph_objs.splom.Diagonal instance or dict with + compatible properties + dimensions + plotly.graph_objs.splom.Dimension instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.splom.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + marker + plotly.graph_objs.splom.Marker instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.splom.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showlowerhalf + Determines whether or not subplots on the lower half + from the diagonal are displayed. + showupperhalf + Determines whether or not subplots on the upper half + from the diagonal are displayed. + stream + plotly.graph_objs.splom.Stream instance or dict with + compatible properties + text + Sets text elements associated with each (x,y) pair to + appear on hover. If a single string, the same string + appears over all the data points. If an array of + string, the items are mapped in order to the this + trace's (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.splom.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + xaxes + Sets the list of x axes corresponding to this splom + trace. By default, a splom will match the first N xaxes + where N is the number of input dimensions. + yaxes + Sets the list of y axes corresponding to this splom + trace. By default, a splom will match the first N yaxes + where N is the number of input dimensions. + + Returns + ------- + Splom + """ + super(Splom, self).__init__('splom') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Splom +constructor must be a dict or +an instance of plotly.graph_objs.Splom""" + ) + + # Import validators + # ----------------- + from plotly.validators import (splom as v_splom) + + # Initialize validators + # --------------------- + self._validators['customdata'] = v_splom.CustomdataValidator() + self._validators['customdatasrc'] = v_splom.CustomdatasrcValidator() + self._validators['diagonal'] = v_splom.DiagonalValidator() + self._validators['dimensions'] = v_splom.DimensionsValidator() + self._validators['hoverinfo'] = v_splom.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_splom.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_splom.HoverlabelValidator() + self._validators['ids'] = v_splom.IdsValidator() + self._validators['idssrc'] = v_splom.IdssrcValidator() + self._validators['legendgroup'] = v_splom.LegendgroupValidator() + self._validators['marker'] = v_splom.MarkerValidator() + self._validators['name'] = v_splom.NameValidator() + self._validators['opacity'] = v_splom.OpacityValidator() + self._validators['selected'] = v_splom.SelectedValidator() + self._validators['selectedpoints'] = v_splom.SelectedpointsValidator() + self._validators['showlegend'] = v_splom.ShowlegendValidator() + self._validators['showlowerhalf'] = v_splom.ShowlowerhalfValidator() + self._validators['showupperhalf'] = v_splom.ShowupperhalfValidator() + self._validators['stream'] = v_splom.StreamValidator() + self._validators['text'] = v_splom.TextValidator() + self._validators['textsrc'] = v_splom.TextsrcValidator() + self._validators['uid'] = v_splom.UidValidator() + self._validators['unselected'] = v_splom.UnselectedValidator() + self._validators['visible'] = v_splom.VisibleValidator() + self._validators['xaxes'] = v_splom.XaxesValidator() + self._validators['yaxes'] = v_splom.YaxesValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('diagonal', None) + self.diagonal = diagonal if diagonal is not None else v + v = arg.pop('dimensions', None) + self.dimensions = dimensions if dimensions is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showlowerhalf', None) + self.showlowerhalf = showlowerhalf if showlowerhalf is not None else v + v = arg.pop('showupperhalf', None) + self.showupperhalf = showupperhalf if showupperhalf is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('xaxes', None) + self.xaxes = xaxes if xaxes is not None else v + v = arg.pop('yaxes', None) + self.yaxes = yaxes if yaxes is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'splom' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='splom' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_surface.py b/plotly/graph_objs/_surface.py new file mode 100644 index 0000000000..b0d6962b30 --- /dev/null +++ b/plotly/graph_objs/_surface.py @@ -0,0 +1,1689 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Surface(BaseTraceType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Determines whether or not the colorscale is picked using the + sign of the input z values. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Determines the whether or not the color domain is computed with + respect to the input data. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Sets the upper bound of color domain. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Sets the lower bound of color domain. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.surface.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.surface.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.surface.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in z space, use zmin and zmax + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # contours + # -------- + @property + def contours(self): + """ + The 'contours' property is an instance of Contours + that may be specified as: + - An instance of plotly.graph_objs.surface.Contours + - A dict of string/value properties that will be passed + to the Contours constructor + + Supported dict properties: + + x + plotly.graph_objs.surface.contours.X instance + or dict with compatible properties + y + plotly.graph_objs.surface.contours.Y instance + or dict with compatible properties + z + plotly.graph_objs.surface.contours.Z instance + or dict with compatible properties + + Returns + ------- + plotly.graph_objs.surface.Contours + """ + return self['contours'] + + @contours.setter + def contours(self, val): + self['contours'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # hidesurface + # ----------- + @property + def hidesurface(self): + """ + Determines whether or not a surface is drawn. For example, set + `hidesurface` to *false* `contours.x.show` to *true* and + `contours.y.show` to *true* to draw a wire frame plot. + + The 'hidesurface' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['hidesurface'] + + @hidesurface.setter + def hidesurface(self, val): + self['hidesurface'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.surface.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.surface.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # lighting + # -------- + @property + def lighting(self): + """ + The 'lighting' property is an instance of Lighting + that may be specified as: + - An instance of plotly.graph_objs.surface.Lighting + - A dict of string/value properties that will be passed + to the Lighting constructor + + Supported dict properties: + + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine. + + Returns + ------- + plotly.graph_objs.surface.Lighting + """ + return self['lighting'] + + @lighting.setter + def lighting(self, val): + self['lighting'] = val + + # lightposition + # ------------- + @property + def lightposition(self): + """ + The 'lightposition' property is an instance of Lightposition + that may be specified as: + - An instance of plotly.graph_objs.surface.Lightposition + - A dict of string/value properties that will be passed + to the Lightposition constructor + + Supported dict properties: + + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex. + + Returns + ------- + plotly.graph_objs.surface.Lightposition + """ + return self['lightposition'] + + @lightposition.setter + def lightposition(self, val): + self['lightposition'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the surface. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Reverses the colorscale. + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # scene + # ----- + @property + def scene(self): + """ + Sets a reference between this trace's 3D coordinate system and + a 3D scene. If *scene* (the default value), the (x,y,z) + coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) + coordinates refer to `layout.scene2`, and so on. + + The 'scene' property is an identifier of a particular + subplot, of type 'scene', that may be specified as the string 'scene' + optionally followed by an integer >= 1 + (e.g. 'scene', 'scene1', 'scene2', 'scene3', etc.) + + Returns + ------- + str + """ + return self['scene'] + + @scene.setter + def scene(self, val): + self['scene'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Determines whether or not a colorbar is displayed for this + trace. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.surface.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.surface.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # surfacecolor + # ------------ + @property + def surfacecolor(self): + """ + Sets the surface color values, used for setting a color scale + independent of `z`. + + The 'surfacecolor' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['surfacecolor'] + + @surfacecolor.setter + def surfacecolor(self, val): + self['surfacecolor'] = val + + # surfacecolorsrc + # --------------- + @property + def surfacecolorsrc(self): + """ + Sets the source reference on plot.ly for surfacecolor . + + The 'surfacecolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['surfacecolorsrc'] + + @surfacecolorsrc.setter + def surfacecolorsrc(self, val): + self['surfacecolorsrc'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each z value. If trace + `hoverinfo` contains a *text* flag and *hovertext* is not set, + these elements will be seen in the hover labels. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x coordinates. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xcalendar + # --------- + @property + def xcalendar(self): + """ + Sets the calendar system to use with `x` date data. + + The 'xcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['xcalendar'] + + @xcalendar.setter + def xcalendar(self, val): + self['xcalendar'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y coordinates. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # ycalendar + # --------- + @property + def ycalendar(self): + """ + Sets the calendar system to use with `y` date data. + + The 'ycalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['ycalendar'] + + @ycalendar.setter + def ycalendar(self, val): + self['ycalendar'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # z + # - + @property + def z(self): + """ + Sets the z coordinates. + + The 'z' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # zcalendar + # --------- + @property + def zcalendar(self): + """ + Sets the calendar system to use with `z` date data. + + The 'zcalendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['zcalendar'] + + @zcalendar.setter + def zcalendar(self, val): + self['zcalendar'] = val + + # zsrc + # ---- + @property + def zsrc(self): + """ + Sets the source reference on plot.ly for z . + + The 'zsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['zsrc'] + + @zsrc.setter + def zsrc(self, val): + self['zsrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + cauto + Determines the whether or not the color domain is + computed with respect to the input data. + cmax + Sets the upper bound of color domain. + cmin + Sets the lower bound of color domain. + colorbar + plotly.graph_objs.surface.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.surface.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hidesurface + Determines whether or not a surface is drawn. For + example, set `hidesurface` to *false* `contours.x.show` + to *true* and `contours.y.show` to *true* to draw a + wire frame plot. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.surface.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.surface.Lighting instance or dict + with compatible properties + lightposition + plotly.graph_objs.surface.Lightposition instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Reverses the colorscale. + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.surface.Stream instance or dict with + compatible properties + surfacecolor + Sets the surface color values, used for setting a color + scale independent of `z`. + surfacecolorsrc + Sets the source reference on plot.ly for surfacecolor + . + text + Sets the text elements associated with each z value. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + colorbar=None, + colorscale=None, + contours=None, + customdata=None, + customdatasrc=None, + hidesurface=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + lighting=None, + lightposition=None, + name=None, + opacity=None, + reversescale=None, + scene=None, + selectedpoints=None, + showlegend=None, + showscale=None, + stream=None, + surfacecolor=None, + surfacecolorsrc=None, + text=None, + textsrc=None, + uid=None, + visible=None, + x=None, + xcalendar=None, + xsrc=None, + y=None, + ycalendar=None, + ysrc=None, + z=None, + zcalendar=None, + zsrc=None, + **kwargs + ): + """ + Construct a new Surface object + + The data the describes the coordinates of the surface is set in + `z`. Data in `z` should be a {2D array}. Coordinates in `x` and + `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph + parametric surfaces). If not provided in `x` and `y`, the x and + y coordinates are assumed to be linear starting at 0 with a + unit step. The color scale corresponds to the `z` values by + default. For custom color scales, use `surfacecolor` which + should be a {2D array}, where its bounds can be controlled + using `cmin` and `cmax`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Surface + autocolorscale + Determines whether or not the colorscale is picked + using the sign of the input z values. + cauto + Determines the whether or not the color domain is + computed with respect to the input data. + cmax + Sets the upper bound of color domain. + cmin + Sets the lower bound of color domain. + colorbar + plotly.graph_objs.surface.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, + rgba, hex, hsl, hsv, or named color string. At minimum, + a mapping for the lowest (0) and highest (1) values are + required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.surface.Contours instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + hidesurface + Determines whether or not a surface is drawn. For + example, set `hidesurface` to *false* `contours.x.show` + to *true* and `contours.y.show` to *true* to draw a + wire frame plot. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.surface.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + lighting + plotly.graph_objs.surface.Lighting instance or dict + with compatible properties + lightposition + plotly.graph_objs.surface.Lightposition instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Reverses the colorscale. + scene + Sets a reference between this trace's 3D coordinate + system and a 3D scene. If *scene* (the default value), + the (x,y,z) coordinates refer to `layout.scene`. If + *scene2*, the (x,y,z) coordinates refer to + `layout.scene2`, and so on. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + showscale + Determines whether or not a colorbar is displayed for + this trace. + stream + plotly.graph_objs.surface.Stream instance or dict with + compatible properties + surfacecolor + Sets the surface color values, used for setting a color + scale independent of `z`. + surfacecolorsrc + Sets the source reference on plot.ly for surfacecolor + . + text + Sets the text elements associated with each z value. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be seen in + the hover labels. + textsrc + Sets the source reference on plot.ly for text . + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date data. + zsrc + Sets the source reference on plot.ly for z . + + Returns + ------- + Surface + """ + super(Surface, self).__init__('surface') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Surface +constructor must be a dict or +an instance of plotly.graph_objs.Surface""" + ) + + # Import validators + # ----------------- + from plotly.validators import (surface as v_surface) + + # Initialize validators + # --------------------- + self._validators['autocolorscale' + ] = v_surface.AutocolorscaleValidator() + self._validators['cauto'] = v_surface.CautoValidator() + self._validators['cmax'] = v_surface.CmaxValidator() + self._validators['cmin'] = v_surface.CminValidator() + self._validators['colorbar'] = v_surface.ColorBarValidator() + self._validators['colorscale'] = v_surface.ColorscaleValidator() + self._validators['contours'] = v_surface.ContoursValidator() + self._validators['customdata'] = v_surface.CustomdataValidator() + self._validators['customdatasrc'] = v_surface.CustomdatasrcValidator() + self._validators['hidesurface'] = v_surface.HidesurfaceValidator() + self._validators['hoverinfo'] = v_surface.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_surface.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_surface.HoverlabelValidator() + self._validators['ids'] = v_surface.IdsValidator() + self._validators['idssrc'] = v_surface.IdssrcValidator() + self._validators['legendgroup'] = v_surface.LegendgroupValidator() + self._validators['lighting'] = v_surface.LightingValidator() + self._validators['lightposition'] = v_surface.LightpositionValidator() + self._validators['name'] = v_surface.NameValidator() + self._validators['opacity'] = v_surface.OpacityValidator() + self._validators['reversescale'] = v_surface.ReversescaleValidator() + self._validators['scene'] = v_surface.SceneValidator() + self._validators['selectedpoints' + ] = v_surface.SelectedpointsValidator() + self._validators['showlegend'] = v_surface.ShowlegendValidator() + self._validators['showscale'] = v_surface.ShowscaleValidator() + self._validators['stream'] = v_surface.StreamValidator() + self._validators['surfacecolor'] = v_surface.SurfacecolorValidator() + self._validators['surfacecolorsrc' + ] = v_surface.SurfacecolorsrcValidator() + self._validators['text'] = v_surface.TextValidator() + self._validators['textsrc'] = v_surface.TextsrcValidator() + self._validators['uid'] = v_surface.UidValidator() + self._validators['visible'] = v_surface.VisibleValidator() + self._validators['x'] = v_surface.XValidator() + self._validators['xcalendar'] = v_surface.XcalendarValidator() + self._validators['xsrc'] = v_surface.XsrcValidator() + self._validators['y'] = v_surface.YValidator() + self._validators['ycalendar'] = v_surface.YcalendarValidator() + self._validators['ysrc'] = v_surface.YsrcValidator() + self._validators['z'] = v_surface.ZValidator() + self._validators['zcalendar'] = v_surface.ZcalendarValidator() + self._validators['zsrc'] = v_surface.ZsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('contours', None) + self.contours = contours if contours is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('hidesurface', None) + self.hidesurface = hidesurface if hidesurface is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('lighting', None) + self.lighting = lighting if lighting is not None else v + v = arg.pop('lightposition', None) + self.lightposition = lightposition if lightposition is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('scene', None) + self.scene = scene if scene is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('surfacecolor', None) + self.surfacecolor = surfacecolor if surfacecolor is not None else v + v = arg.pop('surfacecolorsrc', None) + self.surfacecolorsrc = surfacecolorsrc if surfacecolorsrc is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xcalendar', None) + self.xcalendar = xcalendar if xcalendar is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('ycalendar', None) + self.ycalendar = ycalendar if ycalendar is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + v = arg.pop('zcalendar', None) + self.zcalendar = zcalendar if zcalendar is not None else v + v = arg.pop('zsrc', None) + self.zsrc = zsrc if zsrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'surface' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='surface' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_table.py b/plotly/graph_objs/_table.py new file mode 100644 index 0000000000..ec0a864ae3 --- /dev/null +++ b/plotly/graph_objs/_table.py @@ -0,0 +1,957 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Table(BaseTraceType): + + # cells + # ----- + @property + def cells(self): + """ + The 'cells' property is an instance of Cells + that may be specified as: + - An instance of plotly.graph_objs.table.Cells + - A dict of string/value properties that will be passed + to the Cells constructor + + Supported dict properties: + + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + alignsrc + Sets the source reference on plot.ly for align + . + fill + plotly.graph_objs.table.cells.Fill instance or + dict with compatible properties + font + plotly.graph_objs.table.cells.Font instance or + dict with compatible properties + format + Sets the cell value formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + formatsrc + Sets the source reference on plot.ly for + format . + height + The height of cells. + line + plotly.graph_objs.table.cells.Line instance or + dict with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for + prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for + suffix . + values + Cell values. `values[m][n]` represents the + value of the `n`th point in column `m`, + therefore the `values[m]` vector length for all + columns must be the same (longer vectors will + be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for + values . + + Returns + ------- + plotly.graph_objs.table.Cells + """ + return self['cells'] + + @cells.setter + def cells(self, val): + self['cells'] = val + + # columnorder + # ----------- + @property + def columnorder(self): + """ + Specifies the rendered order of the data columns; for example, + a value `2` at position `0` means that column index `0` in the + data will be rendered as the third column, as columns have an + index base of zero. + + The 'columnorder' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['columnorder'] + + @columnorder.setter + def columnorder(self, val): + self['columnorder'] = val + + # columnordersrc + # -------------- + @property + def columnordersrc(self): + """ + Sets the source reference on plot.ly for columnorder . + + The 'columnordersrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['columnordersrc'] + + @columnordersrc.setter + def columnordersrc(self, val): + self['columnordersrc'] = val + + # columnwidth + # ----------- + @property + def columnwidth(self): + """ + The width of columns expressed as a ratio. Columns fill the + available width in proportion of their specified column widths. + + The 'columnwidth' property is a number and may be specified as: + - An int or float + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['columnwidth'] + + @columnwidth.setter + def columnwidth(self, val): + self['columnwidth'] = val + + # columnwidthsrc + # -------------- + @property + def columnwidthsrc(self): + """ + Sets the source reference on plot.ly for columnwidth . + + The 'columnwidthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['columnwidthsrc'] + + @columnwidthsrc.setter + def columnwidthsrc(self, val): + self['columnwidthsrc'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.table.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this table trace . + row + If there is a layout grid, use the domain for + this row in the grid for this table trace . + x + Sets the horizontal domain of this table trace + (in plot fraction). + y + Sets the vertical domain of this table trace + (in plot fraction). + + Returns + ------- + plotly.graph_objs.table.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # header + # ------ + @property + def header(self): + """ + The 'header' property is an instance of Header + that may be specified as: + - An instance of plotly.graph_objs.table.Header + - A dict of string/value properties that will be passed + to the Header constructor + + Supported dict properties: + + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + alignsrc + Sets the source reference on plot.ly for align + . + fill + plotly.graph_objs.table.header.Fill instance or + dict with compatible properties + font + plotly.graph_objs.table.header.Font instance or + dict with compatible properties + format + Sets the cell value formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + formatsrc + Sets the source reference on plot.ly for + format . + height + The height of cells. + line + plotly.graph_objs.table.header.Line instance or + dict with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for + prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for + suffix . + values + Header cell values. `values[m][n]` represents + the value of the `n`th point in column `m`, + therefore the `values[m]` vector length for all + columns must be the same (longer vectors will + be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for + values . + + Returns + ------- + plotly.graph_objs.table.Header + """ + return self['header'] + + @header.setter + def header(self, val): + self['header'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.table.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.table.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.table.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.table.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + cells + plotly.graph_objs.table.Cells instance or dict with + compatible properties + columnorder + Specifies the rendered order of the data columns; for + example, a value `2` at position `0` means that column + index `0` in the data will be rendered as the third + column, as columns have an index base of zero. + columnordersrc + Sets the source reference on plot.ly for columnorder . + columnwidth + The width of columns expressed as a ratio. Columns fill + the available width in proportion of their specified + column widths. + columnwidthsrc + Sets the source reference on plot.ly for columnwidth . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.table.Domain instance or dict with + compatible properties + header + plotly.graph_objs.table.Header instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.table.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.table.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + """ + + def __init__( + self, + arg=None, + cells=None, + columnorder=None, + columnordersrc=None, + columnwidth=None, + columnwidthsrc=None, + customdata=None, + customdatasrc=None, + domain=None, + header=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + ids=None, + idssrc=None, + legendgroup=None, + name=None, + opacity=None, + selectedpoints=None, + showlegend=None, + stream=None, + uid=None, + visible=None, + **kwargs + ): + """ + Construct a new Table object + + Table view for detailed data viewing. The data are arranged in + a grid of rows and columns. Most styling can be specified for + columns, rows or individual cells. Table is using a column- + major order, ie. the grid is represented as a vector of column + vectors. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Table + cells + plotly.graph_objs.table.Cells instance or dict with + compatible properties + columnorder + Specifies the rendered order of the data columns; for + example, a value `2` at position `0` means that column + index `0` in the data will be rendered as the third + column, as columns have an index base of zero. + columnordersrc + Sets the source reference on plot.ly for columnorder . + columnwidth + The width of columns expressed as a ratio. Columns fill + the available width in proportion of their specified + column widths. + columnwidthsrc + Sets the source reference on plot.ly for columnwidth . + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + domain + plotly.graph_objs.table.Domain instance or dict with + compatible properties + header + plotly.graph_objs.table.Header instance or dict with + compatible properties + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.table.Hoverlabel instance or dict + with compatible properties + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + name + Sets the trace name. The trace name appear as the + legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + stream + plotly.graph_objs.table.Stream instance or dict with + compatible properties + uid + + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + + Returns + ------- + Table + """ + super(Table, self).__init__('table') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Table +constructor must be a dict or +an instance of plotly.graph_objs.Table""" + ) + + # Import validators + # ----------------- + from plotly.validators import (table as v_table) + + # Initialize validators + # --------------------- + self._validators['cells'] = v_table.CellsValidator() + self._validators['columnorder'] = v_table.ColumnorderValidator() + self._validators['columnordersrc'] = v_table.ColumnordersrcValidator() + self._validators['columnwidth'] = v_table.ColumnwidthValidator() + self._validators['columnwidthsrc'] = v_table.ColumnwidthsrcValidator() + self._validators['customdata'] = v_table.CustomdataValidator() + self._validators['customdatasrc'] = v_table.CustomdatasrcValidator() + self._validators['domain'] = v_table.DomainValidator() + self._validators['header'] = v_table.HeaderValidator() + self._validators['hoverinfo'] = v_table.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_table.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_table.HoverlabelValidator() + self._validators['ids'] = v_table.IdsValidator() + self._validators['idssrc'] = v_table.IdssrcValidator() + self._validators['legendgroup'] = v_table.LegendgroupValidator() + self._validators['name'] = v_table.NameValidator() + self._validators['opacity'] = v_table.OpacityValidator() + self._validators['selectedpoints'] = v_table.SelectedpointsValidator() + self._validators['showlegend'] = v_table.ShowlegendValidator() + self._validators['stream'] = v_table.StreamValidator() + self._validators['uid'] = v_table.UidValidator() + self._validators['visible'] = v_table.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('cells', None) + self.cells = cells if cells is not None else v + v = arg.pop('columnorder', None) + self.columnorder = columnorder if columnorder is not None else v + v = arg.pop('columnordersrc', None) + self.columnordersrc = columnordersrc if columnordersrc is not None else v + v = arg.pop('columnwidth', None) + self.columnwidth = columnwidth if columnwidth is not None else v + v = arg.pop('columnwidthsrc', None) + self.columnwidthsrc = columnwidthsrc if columnwidthsrc is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('header', None) + self.header = header if header is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'table' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='table' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/_violin.py b/plotly/graph_objs/_violin.py new file mode 100644 index 0000000000..70169ad21d --- /dev/null +++ b/plotly/graph_objs/_violin.py @@ -0,0 +1,1717 @@ +from plotly.basedatatypes import BaseTraceType +import copy + + +class Violin(BaseTraceType): + + # bandwidth + # --------- + @property + def bandwidth(self): + """ + Sets the bandwidth used to compute the kernel density estimate. + By default, the bandwidth is determined by Silverman's rule of + thumb. + + The 'bandwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['bandwidth'] + + @bandwidth.setter + def bandwidth(self, val): + self['bandwidth'] = val + + # box + # --- + @property + def box(self): + """ + The 'box' property is an instance of Box + that may be specified as: + - An instance of plotly.graph_objs.violin.Box + - A dict of string/value properties that will be passed + to the Box constructor + + Supported dict properties: + + fillcolor + Sets the inner box plot fill color. + line + plotly.graph_objs.violin.box.Line instance or + dict with compatible properties + visible + Determines if an miniature box plot is drawn + inside the violins. + width + Sets the width of the inner box plots relative + to the violins' width. For example, with 1, the + inner box plots are as wide as the violins. + + Returns + ------- + plotly.graph_objs.violin.Box + """ + return self['box'] + + @box.setter + def box(self, val): + self['box'] = val + + # customdata + # ---------- + @property + def customdata(self): + """ + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note that, + *scatter* traces also appends customdata items in the markers + DOM elements + + The 'customdata' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['customdata'] + + @customdata.setter + def customdata(self, val): + self['customdata'] = val + + # customdatasrc + # ------------- + @property + def customdatasrc(self): + """ + Sets the source reference on plot.ly for customdata . + + The 'customdatasrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['customdatasrc'] + + @customdatasrc.setter + def customdatasrc(self, val): + self['customdatasrc'] = val + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # hoverinfo + # --------- + @property + def hoverinfo(self): + """ + Determines which trace information appear on hover. If `none` + or `skip` are set, no information is displayed upon hovering. + But, if `none` is set, click and hover events are still fired. + + The 'hoverinfo' property is a flaglist and may be specified + as a string containing: + - Any combination of ['x', 'y', 'z', 'text', 'name'] joined with '+' characters + (e.g. 'x+y') + OR exactly one of ['all', 'none', 'skip'] (e.g. 'skip') + - A list or array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['hoverinfo'] + + @hoverinfo.setter + def hoverinfo(self, val): + self['hoverinfo'] = val + + # hoverinfosrc + # ------------ + @property + def hoverinfosrc(self): + """ + Sets the source reference on plot.ly for hoverinfo . + + The 'hoverinfosrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['hoverinfosrc'] + + @hoverinfosrc.setter + def hoverinfosrc(self, val): + self['hoverinfosrc'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.violin.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength . + + Returns + ------- + plotly.graph_objs.violin.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hoveron + # ------- + @property + def hoveron(self): + """ + Do the hover effects highlight individual violins or sample + points or the kernel density estimate or any combination of + them? + + The 'hoveron' property is a flaglist and may be specified + as a string containing: + - Any combination of ['violins', 'points', 'kde'] joined with '+' characters + (e.g. 'violins+points') + OR exactly one of ['all'] (e.g. 'all') + + Returns + ------- + Any + """ + return self['hoveron'] + + @hoveron.setter + def hoveron(self, val): + self['hoveron'] = val + + # ids + # --- + @property + def ids(self): + """ + Assigns id labels to each datum. These ids for object constancy + of data points during animation. Should be an array of strings, + not numbers or any other type. + + The 'ids' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ids'] + + @ids.setter + def ids(self, val): + self['ids'] = val + + # idssrc + # ------ + @property + def idssrc(self): + """ + Sets the source reference on plot.ly for ids . + + The 'idssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['idssrc'] + + @idssrc.setter + def idssrc(self, val): + self['idssrc'] = val + + # jitter + # ------ + @property + def jitter(self): + """ + Sets the amount of jitter in the sample points drawn. If *0*, + the sample points align along the distribution axis. If *1*, + the sample points are drawn in a random jitter of width equal + to the width of the violins. + + The 'jitter' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['jitter'] + + @jitter.setter + def jitter(self, val): + self['jitter'] = val + + # legendgroup + # ----------- + @property + def legendgroup(self): + """ + Sets the legend group for this trace. Traces part of the same + legend group hide/show at the same time when toggling legend + items. + + The 'legendgroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['legendgroup'] + + @legendgroup.setter + def legendgroup(self, val): + self['legendgroup'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.violin.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of line bounding the violin(s). + width + Sets the width (in px) of line bounding the + violin(s). + + Returns + ------- + plotly.graph_objs.violin.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.violin.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + line + plotly.graph_objs.violin.marker.Line instance + or dict with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + + Returns + ------- + plotly.graph_objs.violin.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # meanline + # -------- + @property + def meanline(self): + """ + The 'meanline' property is an instance of Meanline + that may be specified as: + - An instance of plotly.graph_objs.violin.Meanline + - A dict of string/value properties that will be passed + to the Meanline constructor + + Supported dict properties: + + color + Sets the mean line color. + visible + Determines if a line corresponding to the + sample's mean is shown inside the violins. If + `box.visible` is turned on, the mean line is + drawn inside the inner box. Otherwise, the mean + line is drawn from one side of the violin to + other. + width + Sets the mean line width. + + Returns + ------- + plotly.graph_objs.violin.Meanline + """ + return self['meanline'] + + @meanline.setter + def meanline(self, val): + self['meanline'] = val + + # name + # ---- + @property + def name(self): + """ + Sets the trace name. The trace name appear as the legend item + and on hover. For box traces, the name will also be used for + the position coordinate, if `x` and `x0` (`y` and `y0` if + horizontal) are missing and the position axis is categorical + + The 'name' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['name'] + + @name.setter + def name(self, val): + self['name'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the trace. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the violin(s). If *v* (*h*), the + distribution is visualized along the vertical (horizontal). + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # pointpos + # -------- + @property + def pointpos(self): + """ + Sets the position of the sample points in relation to the + violins. If *0*, the sample points are places over the center + of the violins. Positive (negative) values correspond to + positions to the right (left) for vertical violins and above + (below) for horizontal violins. + + The 'pointpos' property is a number and may be specified as: + - An int or float in the interval [-2, 2] + + Returns + ------- + int|float + """ + return self['pointpos'] + + @pointpos.setter + def pointpos(self, val): + self['pointpos'] = val + + # points + # ------ + @property + def points(self): + """ + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier points + are shown and points either less than 4*Q1-3*Q3 or greater than + 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all + sample points are shown If *false*, only the violins are shown + with no sample points + + The 'points' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'outliers', 'suspectedoutliers', False] + + Returns + ------- + Any + """ + return self['points'] + + @points.setter + def points(self, val): + self['points'] = val + + # scalegroup + # ---------- + @property + def scalegroup(self): + """ + If there are multiple violins that should be sized according to + to some metric (see `scalemode`), link them by providing a non- + empty group id here shared by every trace in the same group. + + The 'scalegroup' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['scalegroup'] + + @scalegroup.setter + def scalegroup(self, val): + self['scalegroup'] = val + + # scalemode + # --------- + @property + def scalemode(self): + """ + Sets the metric by which the width of each violin is + determined.*width* means each violin has the same (max) + width*count* means the violins are scaled by the number of + sample points makingup each violin. + + The 'scalemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['width', 'count'] + + Returns + ------- + Any + """ + return self['scalemode'] + + @scalemode.setter + def scalemode(self, val): + self['scalemode'] = val + + # selected + # -------- + @property + def selected(self): + """ + The 'selected' property is an instance of Selected + that may be specified as: + - An instance of plotly.graph_objs.violin.Selected + - A dict of string/value properties that will be passed + to the Selected constructor + + Supported dict properties: + + marker + plotly.graph_objs.violin.selected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.violin.Selected + """ + return self['selected'] + + @selected.setter + def selected(self, val): + self['selected'] = val + + # selectedpoints + # -------------- + @property + def selectedpoints(self): + """ + Array containing integer indices of selected points. Has an + effect only for traces that support selections. Note that an + empty array means an empty selection where the `unselected` are + turned on for all points, whereas, any other non-array values + means no selection all where the `selected` and `unselected` + styles have no effect. + + The 'selectedpoints' property accepts values of any type + + Returns + ------- + Any + """ + return self['selectedpoints'] + + @selectedpoints.setter + def selectedpoints(self, val): + self['selectedpoints'] = val + + # showlegend + # ---------- + @property + def showlegend(self): + """ + Determines whether or not an item corresponding to this trace + is shown in the legend. + + The 'showlegend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlegend'] + + @showlegend.setter + def showlegend(self, val): + self['showlegend'] = val + + # side + # ---- + @property + def side(self): + """ + Determines on which side of the position value the density + function making up one half of a violin is plotted. Useful when + comparing two violin traces under *overlay* mode, where one + trace has `side` set to *positive* and the other to *negative*. + + The 'side' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['both', 'positive', 'negative'] + + Returns + ------- + Any + """ + return self['side'] + + @side.setter + def side(self, val): + self['side'] = val + + # span + # ---- + @property + def span(self): + """ + Sets the span in data space for which the density function will + be computed. Has an effect only when `spanmode` is set to + *manual*. + + The 'span' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'span[0]' property accepts values of any type + (1) The 'span[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['span'] + + @span.setter + def span(self, val): + self['span'] = val + + # spanmode + # -------- + @property + def spanmode(self): + """ + Sets the method by which the span in data space where the + density function will be computed. *soft* means the span goes + from the sample's minimum value minus two bandwidths to the + sample's maximum value plus two bandwidths. *hard* means the + span goes from the sample's minimum to its maximum value. For + custom span settings, use mode *manual* and fill in the `span` + attribute. + + The 'spanmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['soft', 'hard', 'manual'] + + Returns + ------- + Any + """ + return self['spanmode'] + + @spanmode.setter + def spanmode(self, val): + self['spanmode'] = val + + # stream + # ------ + @property + def stream(self): + """ + The 'stream' property is an instance of Stream + that may be specified as: + - An instance of plotly.graph_objs.violin.Stream + - A dict of string/value properties that will be passed + to the Stream constructor + + Supported dict properties: + + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details. + + Returns + ------- + plotly.graph_objs.violin.Stream + """ + return self['stream'] + + @stream.setter + def stream(self, val): + self['stream'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text elements associated with each sample value. If a + single string, the same string appears over all the data + points. If an array of string, the items are mapped in order to + the this trace's (x,y) coordinates. To be seen, trace + `hoverinfo` must contain a *text* flag. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textsrc + # ------- + @property + def textsrc(self): + """ + Sets the source reference on plot.ly for text . + + The 'textsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['textsrc'] + + @textsrc.setter + def textsrc(self, val): + self['textsrc'] = val + + # uid + # --- + @property + def uid(self): + """ + The 'uid' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['uid'] + + @uid.setter + def uid(self, val): + self['uid'] = val + + # unselected + # ---------- + @property + def unselected(self): + """ + The 'unselected' property is an instance of Unselected + that may be specified as: + - An instance of plotly.graph_objs.violin.Unselected + - A dict of string/value properties that will be passed + to the Unselected constructor + + Supported dict properties: + + marker + plotly.graph_objs.violin.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.violin.Unselected + """ + return self['unselected'] + + @unselected.setter + def unselected(self, val): + self['unselected'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as a + legend item (provided that the legend itself is visible). + + The 'visible' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'legendonly'] + + Returns + ------- + Any + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x sample data or coordinates. See overview for more + info. + + The 'x' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # x0 + # -- + @property + def x0(self): + """ + Sets the x coordinate of the box. See overview for more info. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + Sets a reference between this trace's x coordinates and a 2D + cartesian x axis. If *x* (the default value), the x coordinates + refer to `layout.xaxis`. If *x2*, the x coordinates refer to + `layout.xaxis2`, and so on. + + The 'xaxis' property is an identifier of a particular + subplot, of type 'x', that may be specified as the string 'x' + optionally followed by an integer >= 1 + (e.g. 'x', 'x1', 'x2', 'x3', etc.) + + Returns + ------- + str + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # xsrc + # ---- + @property + def xsrc(self): + """ + Sets the source reference on plot.ly for x . + + The 'xsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['xsrc'] + + @xsrc.setter + def xsrc(self, val): + self['xsrc'] = val + + # y + # - + @property + def y(self): + """ + Sets the y sample data or coordinates. See overview for more + info. + + The 'y' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # y0 + # -- + @property + def y0(self): + """ + Sets the y coordinate of the box. See overview for more info. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + Sets a reference between this trace's y coordinates and a 2D + cartesian y axis. If *y* (the default value), the y coordinates + refer to `layout.yaxis`. If *y2*, the y coordinates refer to + `layout.yaxis2`, and so on. + + The 'yaxis' property is an identifier of a particular + subplot, of type 'y', that may be specified as the string 'y' + optionally followed by an integer >= 1 + (e.g. 'y', 'y1', 'y2', 'y3', etc.) + + Returns + ------- + str + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # ysrc + # ---- + @property + def ysrc(self): + """ + Sets the source reference on plot.ly for y . + + The 'ysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ysrc'] + + @ysrc.setter + def ysrc(self, val): + self['ysrc'] = val + + # type + # ---- + @property + def type(self): + return self._props['type'] + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return '' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bandwidth + Sets the bandwidth used to compute the kernel density + estimate. By default, the bandwidth is determined by + Silverman's rule of thumb. + box + plotly.graph_objs.violin.Box instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.violin.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual violins or + sample points or the kernel density estimate or any + combination of them? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the violins. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.violin.Line instance or dict with + compatible properties + marker + plotly.graph_objs.violin.Marker instance or dict with + compatible properties + meanline + plotly.graph_objs.violin.Meanline instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the violin(s). If *v* (*h*), + the distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the violins. If *0*, the sample points are places over + the center of the violins. Positive (negative) values + correspond to positions to the right (left) for + vertical violins and above (below) for horizontal + violins. + points + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the violins are shown with no sample + points + scalegroup + If there are multiple violins that should be sized + according to to some metric (see `scalemode`), link + them by providing a non-empty group id here shared by + every trace in the same group. + scalemode + Sets the metric by which the width of each violin is + determined.*width* means each violin has the same (max) + width*count* means the violins are scaled by the number + of sample points makingup each violin. + selected + plotly.graph_objs.violin.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + side + Determines on which side of the position value the + density function making up one half of a violin is + plotted. Useful when comparing two violin traces under + *overlay* mode, where one trace has `side` set to + *positive* and the other to *negative*. + span + Sets the span in data space for which the density + function will be computed. Has an effect only when + `spanmode` is set to *manual*. + spanmode + Sets the method by which the span in data space where + the density function will be computed. *soft* means the + span goes from the sample's minimum value minus two + bandwidths to the sample's maximum value plus two + bandwidths. *hard* means the span goes from the + sample's minimum to its maximum value. For custom span + settings, use mode *manual* and fill in the `span` + attribute. + stream + plotly.graph_objs.violin.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.violin.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + """ + + def __init__( + self, + arg=None, + bandwidth=None, + box=None, + customdata=None, + customdatasrc=None, + fillcolor=None, + hoverinfo=None, + hoverinfosrc=None, + hoverlabel=None, + hoveron=None, + ids=None, + idssrc=None, + jitter=None, + legendgroup=None, + line=None, + marker=None, + meanline=None, + name=None, + opacity=None, + orientation=None, + pointpos=None, + points=None, + scalegroup=None, + scalemode=None, + selected=None, + selectedpoints=None, + showlegend=None, + side=None, + span=None, + spanmode=None, + stream=None, + text=None, + textsrc=None, + uid=None, + unselected=None, + visible=None, + x=None, + x0=None, + xaxis=None, + xsrc=None, + y=None, + y0=None, + yaxis=None, + ysrc=None, + **kwargs + ): + """ + Construct a new Violin object + + In vertical (horizontal) violin plots, statistics are computed + using `y` (`x`) values. By supplying an `x` (`y`) array, one + violin per distinct x (y) value is drawn If no `x` (`y`) + {array} is provided, a single violin is drawn. That violin + position is then positioned with with `name` or with `x0` + (`y0`) if provided. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.Violin + bandwidth + Sets the bandwidth used to compute the kernel density + estimate. By default, the bandwidth is determined by + Silverman's rule of thumb. + box + plotly.graph_objs.violin.Box instance or dict with + compatible properties + customdata + Assigns extra data each datum. This may be useful when + listening to hover, click and selection events. Note + that, *scatter* traces also appends customdata items in + the markers DOM elements + customdatasrc + Sets the source reference on plot.ly for customdata . + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + hoverinfo + Determines which trace information appear on hover. If + `none` or `skip` are set, no information is displayed + upon hovering. But, if `none` is set, click and hover + events are still fired. + hoverinfosrc + Sets the source reference on plot.ly for hoverinfo . + hoverlabel + plotly.graph_objs.violin.Hoverlabel instance or dict + with compatible properties + hoveron + Do the hover effects highlight individual violins or + sample points or the kernel density estimate or any + combination of them? + ids + Assigns id labels to each datum. These ids for object + constancy of data points during animation. Should be an + array of strings, not numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points drawn. + If *0*, the sample points align along the distribution + axis. If *1*, the sample points are drawn in a random + jitter of width equal to the width of the violins. + legendgroup + Sets the legend group for this trace. Traces part of + the same legend group hide/show at the same time when + toggling legend items. + line + plotly.graph_objs.violin.Line instance or dict with + compatible properties + marker + plotly.graph_objs.violin.Marker instance or dict with + compatible properties + meanline + plotly.graph_objs.violin.Meanline instance or dict with + compatible properties + name + Sets the trace name. The trace name appear as the + legend item and on hover. For box traces, the name will + also be used for the position coordinate, if `x` and + `x0` (`y` and `y0` if horizontal) are missing and the + position axis is categorical + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the violin(s). If *v* (*h*), + the distribution is visualized along the vertical + (horizontal). + pointpos + Sets the position of the sample points in relation to + the violins. If *0*, the sample points are places over + the center of the violins. Positive (negative) values + correspond to positions to the right (left) for + vertical violins and above (below) for horizontal + violins. + points + If *outliers*, only the sample points lying outside the + whiskers are shown If *suspectedoutliers*, the outlier + points are shown and points either less than 4*Q1-3*Q3 + or greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are shown + If *false*, only the violins are shown with no sample + points + scalegroup + If there are multiple violins that should be sized + according to to some metric (see `scalemode`), link + them by providing a non-empty group id here shared by + every trace in the same group. + scalemode + Sets the metric by which the width of each violin is + determined.*width* means each violin has the same (max) + width*count* means the violins are scaled by the number + of sample points makingup each violin. + selected + plotly.graph_objs.violin.Selected instance or dict with + compatible properties + selectedpoints + Array containing integer indices of selected points. + Has an effect only for traces that support selections. + Note that an empty array means an empty selection where + the `unselected` are turned on for all points, whereas, + any other non-array values means no selection all where + the `selected` and `unselected` styles have no effect. + showlegend + Determines whether or not an item corresponding to this + trace is shown in the legend. + side + Determines on which side of the position value the + density function making up one half of a violin is + plotted. Useful when comparing two violin traces under + *overlay* mode, where one trace has `side` set to + *positive* and the other to *negative*. + span + Sets the span in data space for which the density + function will be computed. Has an effect only when + `spanmode` is set to *manual*. + spanmode + Sets the method by which the span in data space where + the density function will be computed. *soft* means the + span goes from the sample's minimum value minus two + bandwidths to the sample's maximum value plus two + bandwidths. *hard* means the span goes from the + sample's minimum to its maximum value. For custom span + settings, use mode *manual* and fill in the `span` + attribute. + stream + plotly.graph_objs.violin.Stream instance or dict with + compatible properties + text + Sets the text elements associated with each sample + value. If a single string, the same string appears over + all the data points. If an array of string, the items + are mapped in order to the this trace's (x,y) + coordinates. To be seen, trace `hoverinfo` must contain + a *text* flag. + textsrc + Sets the source reference on plot.ly for text . + uid + + unselected + plotly.graph_objs.violin.Unselected instance or dict + with compatible properties + visible + Determines whether or not this trace is visible. If + *legendonly*, the trace is not drawn, but can appear as + a legend item (provided that the legend itself is + visible). + x + Sets the x sample data or coordinates. See overview for + more info. + x0 + Sets the x coordinate of the box. See overview for more + info. + xaxis + Sets a reference between this trace's x coordinates and + a 2D cartesian x axis. If *x* (the default value), the + x coordinates refer to `layout.xaxis`. If *x2*, the x + coordinates refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See overview for + more info. + y0 + Sets the y coordinate of the box. See overview for more + info. + yaxis + Sets a reference between this trace's y coordinates and + a 2D cartesian y axis. If *y* (the default value), the + y coordinates refer to `layout.yaxis`. If *y2*, the y + coordinates refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + + Returns + ------- + Violin + """ + super(Violin, self).__init__('violin') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.Violin +constructor must be a dict or +an instance of plotly.graph_objs.Violin""" + ) + + # Import validators + # ----------------- + from plotly.validators import (violin as v_violin) + + # Initialize validators + # --------------------- + self._validators['bandwidth'] = v_violin.BandwidthValidator() + self._validators['box'] = v_violin.BoxValidator() + self._validators['customdata'] = v_violin.CustomdataValidator() + self._validators['customdatasrc'] = v_violin.CustomdatasrcValidator() + self._validators['fillcolor'] = v_violin.FillcolorValidator() + self._validators['hoverinfo'] = v_violin.HoverinfoValidator() + self._validators['hoverinfosrc'] = v_violin.HoverinfosrcValidator() + self._validators['hoverlabel'] = v_violin.HoverlabelValidator() + self._validators['hoveron'] = v_violin.HoveronValidator() + self._validators['ids'] = v_violin.IdsValidator() + self._validators['idssrc'] = v_violin.IdssrcValidator() + self._validators['jitter'] = v_violin.JitterValidator() + self._validators['legendgroup'] = v_violin.LegendgroupValidator() + self._validators['line'] = v_violin.LineValidator() + self._validators['marker'] = v_violin.MarkerValidator() + self._validators['meanline'] = v_violin.MeanlineValidator() + self._validators['name'] = v_violin.NameValidator() + self._validators['opacity'] = v_violin.OpacityValidator() + self._validators['orientation'] = v_violin.OrientationValidator() + self._validators['pointpos'] = v_violin.PointposValidator() + self._validators['points'] = v_violin.PointsValidator() + self._validators['scalegroup'] = v_violin.ScalegroupValidator() + self._validators['scalemode'] = v_violin.ScalemodeValidator() + self._validators['selected'] = v_violin.SelectedValidator() + self._validators['selectedpoints'] = v_violin.SelectedpointsValidator() + self._validators['showlegend'] = v_violin.ShowlegendValidator() + self._validators['side'] = v_violin.SideValidator() + self._validators['span'] = v_violin.SpanValidator() + self._validators['spanmode'] = v_violin.SpanmodeValidator() + self._validators['stream'] = v_violin.StreamValidator() + self._validators['text'] = v_violin.TextValidator() + self._validators['textsrc'] = v_violin.TextsrcValidator() + self._validators['uid'] = v_violin.UidValidator() + self._validators['unselected'] = v_violin.UnselectedValidator() + self._validators['visible'] = v_violin.VisibleValidator() + self._validators['x'] = v_violin.XValidator() + self._validators['x0'] = v_violin.X0Validator() + self._validators['xaxis'] = v_violin.XAxisValidator() + self._validators['xsrc'] = v_violin.XsrcValidator() + self._validators['y'] = v_violin.YValidator() + self._validators['y0'] = v_violin.Y0Validator() + self._validators['yaxis'] = v_violin.YAxisValidator() + self._validators['ysrc'] = v_violin.YsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bandwidth', None) + self.bandwidth = bandwidth if bandwidth is not None else v + v = arg.pop('box', None) + self.box = box if box is not None else v + v = arg.pop('customdata', None) + self.customdata = customdata if customdata is not None else v + v = arg.pop('customdatasrc', None) + self.customdatasrc = customdatasrc if customdatasrc is not None else v + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('hoverinfo', None) + self.hoverinfo = hoverinfo if hoverinfo is not None else v + v = arg.pop('hoverinfosrc', None) + self.hoverinfosrc = hoverinfosrc if hoverinfosrc is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hoveron', None) + self.hoveron = hoveron if hoveron is not None else v + v = arg.pop('ids', None) + self.ids = ids if ids is not None else v + v = arg.pop('idssrc', None) + self.idssrc = idssrc if idssrc is not None else v + v = arg.pop('jitter', None) + self.jitter = jitter if jitter is not None else v + v = arg.pop('legendgroup', None) + self.legendgroup = legendgroup if legendgroup is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('meanline', None) + self.meanline = meanline if meanline is not None else v + v = arg.pop('name', None) + self.name = name if name is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('pointpos', None) + self.pointpos = pointpos if pointpos is not None else v + v = arg.pop('points', None) + self.points = points if points is not None else v + v = arg.pop('scalegroup', None) + self.scalegroup = scalegroup if scalegroup is not None else v + v = arg.pop('scalemode', None) + self.scalemode = scalemode if scalemode is not None else v + v = arg.pop('selected', None) + self.selected = selected if selected is not None else v + v = arg.pop('selectedpoints', None) + self.selectedpoints = selectedpoints if selectedpoints is not None else v + v = arg.pop('showlegend', None) + self.showlegend = showlegend if showlegend is not None else v + v = arg.pop('side', None) + self.side = side if side is not None else v + v = arg.pop('span', None) + self.span = span if span is not None else v + v = arg.pop('spanmode', None) + self.spanmode = spanmode if spanmode is not None else v + v = arg.pop('stream', None) + self.stream = stream if stream is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textsrc', None) + self.textsrc = textsrc if textsrc is not None else v + v = arg.pop('uid', None) + self.uid = uid if uid is not None else v + v = arg.pop('unselected', None) + self.unselected = unselected if unselected is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('xsrc', None) + self.xsrc = xsrc if xsrc is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('ysrc', None) + self.ysrc = ysrc if ysrc is not None else v + + # Read-only literals + # ------------------ + from _plotly_utils.basevalidators import LiteralValidator + self._props['type'] = 'violin' + self._validators['type'] = LiteralValidator( + plotly_name='type', parent_name='violin' + ) + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/area/__init__.py b/plotly/graph_objs/area/__init__.py new file mode 100644 index 0000000000..b0ba112a9d --- /dev/null +++ b/plotly/graph_objs/area/__init__.py @@ -0,0 +1,4 @@ +from ._stream import Stream +from ._marker import Marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.area import hoverlabel diff --git a/plotly/graph_objs/area/_hoverlabel.py b/plotly/graph_objs/area/_hoverlabel.py new file mode 100644 index 0000000000..ffcbc56993 --- /dev/null +++ b/plotly/graph_objs/area/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.area.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.area.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'area' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.area.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.area.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.area.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.area import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/area/_marker.py b/plotly/graph_objs/area/_marker.py new file mode 100644 index 0000000000..c93d5b5c17 --- /dev/null +++ b/plotly/graph_objs/area/_marker.py @@ -0,0 +1,416 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'area' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + size + Sets the marker size (in px). + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + opacity=None, + opacitysrc=None, + size=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.area.Marker + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + size + Sets the marker size (in px). + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.area.Marker +constructor must be a dict or +an instance of plotly.graph_objs.area.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.area import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/area/_stream.py b/plotly/graph_objs/area/_stream.py new file mode 100644 index 0000000000..b707a0a436 --- /dev/null +++ b/plotly/graph_objs/area/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'area' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.area.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.area.Stream +constructor must be a dict or +an instance of plotly.graph_objs.area.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.area import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/area/hoverlabel/__init__.py b/plotly/graph_objs/area/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/area/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/area/hoverlabel/_font.py b/plotly/graph_objs/area/hoverlabel/_font.py new file mode 100644 index 0000000000..6452bb5913 --- /dev/null +++ b/plotly/graph_objs/area/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'area.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.area.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.area.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.area.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.area.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/__init__.py b/plotly/graph_objs/bar/__init__.py new file mode 100644 index 0000000000..3925f3dfaa --- /dev/null +++ b/plotly/graph_objs/bar/__init__.py @@ -0,0 +1,14 @@ +from ._unselected import Unselected +from plotly.graph_objs.bar import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.bar import selected +from ._outsidetextfont import Outsidetextfont +from ._marker import Marker +from plotly.graph_objs.bar import marker +from ._insidetextfont import Insidetextfont +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.bar import hoverlabel +from ._error_y import ErrorY +from ._error_x import ErrorX diff --git a/plotly/graph_objs/bar/_error_x.py b/plotly/graph_objs/bar/_error_x.py new file mode 100644 index 0000000000..bd7bf84c0a --- /dev/null +++ b/plotly/graph_objs/bar/_error_x.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorX(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_ystyle + # ----------- + @property + def copy_ystyle(self): + """ + The 'copy_ystyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_ystyle'] + + @copy_ystyle.setter + def copy_ystyle(self, val): + self['copy_ystyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_ystyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorX object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.ErrorX + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorX + """ + super(ErrorX, self).__init__('error_x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.ErrorX +constructor must be a dict or +an instance of plotly.graph_objs.bar.ErrorX""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (error_x as v_error_x) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_x.ArrayValidator() + self._validators['arrayminus'] = v_error_x.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_x.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_x.ArraysrcValidator() + self._validators['color'] = v_error_x.ColorValidator() + self._validators['copy_ystyle'] = v_error_x.CopyYstyleValidator() + self._validators['symmetric'] = v_error_x.SymmetricValidator() + self._validators['thickness'] = v_error_x.ThicknessValidator() + self._validators['traceref'] = v_error_x.TracerefValidator() + self._validators['tracerefminus'] = v_error_x.TracerefminusValidator() + self._validators['type'] = v_error_x.TypeValidator() + self._validators['value'] = v_error_x.ValueValidator() + self._validators['valueminus'] = v_error_x.ValueminusValidator() + self._validators['visible'] = v_error_x.VisibleValidator() + self._validators['width'] = v_error_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_ystyle', None) + self.copy_ystyle = copy_ystyle if copy_ystyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_error_y.py b/plotly/graph_objs/bar/_error_y.py new file mode 100644 index 0000000000..32f568c8da --- /dev/null +++ b/plotly/graph_objs/bar/_error_y.py @@ -0,0 +1,561 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorY(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorY object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.ErrorY + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorY + """ + super(ErrorY, self).__init__('error_y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.ErrorY +constructor must be a dict or +an instance of plotly.graph_objs.bar.ErrorY""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (error_y as v_error_y) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_y.ArrayValidator() + self._validators['arrayminus'] = v_error_y.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_y.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_y.ArraysrcValidator() + self._validators['color'] = v_error_y.ColorValidator() + self._validators['symmetric'] = v_error_y.SymmetricValidator() + self._validators['thickness'] = v_error_y.ThicknessValidator() + self._validators['traceref'] = v_error_y.TracerefValidator() + self._validators['tracerefminus'] = v_error_y.TracerefminusValidator() + self._validators['type'] = v_error_y.TypeValidator() + self._validators['value'] = v_error_y.ValueValidator() + self._validators['valueminus'] = v_error_y.ValueminusValidator() + self._validators['visible'] = v_error_y.VisibleValidator() + self._validators['width'] = v_error_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_hoverlabel.py b/plotly/graph_objs/bar/_hoverlabel.py new file mode 100644 index 0000000000..d254f62605 --- /dev/null +++ b/plotly/graph_objs/bar/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.bar.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.bar.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.bar.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_insidetextfont.py b/plotly/graph_objs/bar/_insidetextfont.py new file mode 100644 index 0000000000..0f2df4be1b --- /dev/null +++ b/plotly/graph_objs/bar/_insidetextfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Insidetextfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Insidetextfont object + + Sets the font used for `text` lying inside the bar. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Insidetextfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Insidetextfont + """ + super(Insidetextfont, self).__init__('insidetextfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Insidetextfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.Insidetextfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (insidetextfont as v_insidetextfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_insidetextfont.ColorValidator() + self._validators['colorsrc'] = v_insidetextfont.ColorsrcValidator() + self._validators['family'] = v_insidetextfont.FamilyValidator() + self._validators['familysrc'] = v_insidetextfont.FamilysrcValidator() + self._validators['size'] = v_insidetextfont.SizeValidator() + self._validators['sizesrc'] = v_insidetextfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_marker.py b/plotly/graph_objs/bar/_marker.py new file mode 100644 index 0000000000..b47b546f95 --- /dev/null +++ b/plotly/graph_objs/bar/_marker.py @@ -0,0 +1,876 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to bar.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.bar.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.bar.marker.colorbar.Tickforma + tstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.bar.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.bar.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.bar.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the bars. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.bar.marker.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.bar.marker.Line instance or dict with + compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.bar.marker.ColorBar instance or dict + with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.bar.marker.Line instance or dict with + compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Marker +constructor must be a dict or +an instance of plotly.graph_objs.bar.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_outsidetextfont.py b/plotly/graph_objs/bar/_outsidetextfont.py new file mode 100644 index 0000000000..11a83e4f82 --- /dev/null +++ b/plotly/graph_objs/bar/_outsidetextfont.py @@ -0,0 +1,313 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Outsidetextfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Outsidetextfont object + + Sets the font used for `text` lying outside the bar. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Outsidetextfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Outsidetextfont + """ + super(Outsidetextfont, self).__init__('outsidetextfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Outsidetextfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.Outsidetextfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import ( + outsidetextfont as v_outsidetextfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_outsidetextfont.ColorValidator() + self._validators['colorsrc'] = v_outsidetextfont.ColorsrcValidator() + self._validators['family'] = v_outsidetextfont.FamilyValidator() + self._validators['familysrc'] = v_outsidetextfont.FamilysrcValidator() + self._validators['size'] = v_outsidetextfont.SizeValidator() + self._validators['sizesrc'] = v_outsidetextfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_selected.py b/plotly/graph_objs/bar/_selected.py new file mode 100644 index 0000000000..2e5e3b5e8b --- /dev/null +++ b/plotly/graph_objs/bar/_selected.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.bar.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + + Returns + ------- + plotly.graph_objs.bar.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.bar.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.bar.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.bar.selected.Marker instance or dict + with compatible properties + textfont + plotly.graph_objs.bar.selected.Textfont instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Selected + marker + plotly.graph_objs.bar.selected.Marker instance or dict + with compatible properties + textfont + plotly.graph_objs.bar.selected.Textfont instance or + dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Selected +constructor must be a dict or +an instance of plotly.graph_objs.bar.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_stream.py b/plotly/graph_objs/bar/_stream.py new file mode 100644 index 0000000000..9eeaad73ea --- /dev/null +++ b/plotly/graph_objs/bar/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Stream +constructor must be a dict or +an instance of plotly.graph_objs.bar.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_textfont.py b/plotly/graph_objs/bar/_textfont.py new file mode 100644 index 0000000000..1bf5720fb7 --- /dev/null +++ b/plotly/graph_objs/bar/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the font used for `text`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/_unselected.py b/plotly/graph_objs/bar/_unselected.py new file mode 100644 index 0000000000..2a17bb3ccf --- /dev/null +++ b/plotly/graph_objs/bar/_unselected.py @@ -0,0 +1,139 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.bar.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.bar.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.bar.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.bar.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.bar.unselected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.bar.unselected.Textfont instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.Unselected + marker + plotly.graph_objs.bar.unselected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.bar.unselected.Textfont instance or + dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.bar.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/hoverlabel/__init__.py b/plotly/graph_objs/bar/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/bar/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/bar/hoverlabel/_font.py b/plotly/graph_objs/bar/hoverlabel/_font.py new file mode 100644 index 0000000000..9b8f78ecf7 --- /dev/null +++ b/plotly/graph_objs/bar/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.bar.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/marker/__init__.py b/plotly/graph_objs/bar/marker/__init__.py new file mode 100644 index 0000000000..e11d61b568 --- /dev/null +++ b/plotly/graph_objs/bar/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.bar.marker import colorbar diff --git a/plotly/graph_objs/bar/marker/_colorbar.py b/plotly/graph_objs/bar/marker/_colorbar.py new file mode 100644 index 0000000000..94a091a307 --- /dev/null +++ b/plotly/graph_objs/bar/marker/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.bar.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.bar.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.bar.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.bar.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.bar.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.bar.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.bar.marker.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.bar.marker.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.bar.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/marker/_line.py b/plotly/graph_objs/bar/marker/_line.py new file mode 100644 index 0000000000..21ad2570ec --- /dev/null +++ b/plotly/graph_objs/bar/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to bar.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.bar.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/marker/colorbar/__init__.py b/plotly/graph_objs/bar/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/bar/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/bar/marker/colorbar/_tickfont.py b/plotly/graph_objs/bar/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..c5224b2b61 --- /dev/null +++ b/plotly/graph_objs/bar/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.bar.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/bar/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..86ac85e240 --- /dev/null +++ b/plotly/graph_objs/bar/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.bar.marker.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.bar.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/marker/colorbar/_titlefont.py b/plotly/graph_objs/bar/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..170f76d860 --- /dev/null +++ b/plotly/graph_objs/bar/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.bar.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.bar.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/selected/__init__.py b/plotly/graph_objs/bar/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/bar/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/bar/selected/_marker.py b/plotly/graph_objs/bar/selected/_marker.py new file mode 100644 index 0000000000..e36ee41a57 --- /dev/null +++ b/plotly/graph_objs/bar/selected/_marker.py @@ -0,0 +1,157 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + """ + + def __init__(self, arg=None, color=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.bar.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/selected/_textfont.py b/plotly/graph_objs/bar/selected/_textfont.py new file mode 100644 index 0000000000..20c11cd9af --- /dev/null +++ b/plotly/graph_objs/bar/selected/_textfont.py @@ -0,0 +1,130 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.selected import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/unselected/__init__.py b/plotly/graph_objs/bar/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/bar/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/bar/unselected/_marker.py b/plotly/graph_objs/bar/unselected/_marker.py new file mode 100644 index 0000000000..577c438cf4 --- /dev/null +++ b/plotly/graph_objs/bar/unselected/_marker.py @@ -0,0 +1,163 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.bar.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.bar.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/bar/unselected/_textfont.py b/plotly/graph_objs/bar/unselected/_textfont.py new file mode 100644 index 0000000000..33a59f13c3 --- /dev/null +++ b/plotly/graph_objs/bar/unselected/_textfont.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'bar.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.bar.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.bar.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.bar.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.bar.unselected import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/__init__.py b/plotly/graph_objs/box/__init__.py new file mode 100644 index 0000000000..7ba9dd59bc --- /dev/null +++ b/plotly/graph_objs/box/__init__.py @@ -0,0 +1,10 @@ +from ._unselected import Unselected +from plotly.graph_objs.box import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.box import selected +from ._marker import Marker +from plotly.graph_objs.box import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.box import hoverlabel diff --git a/plotly/graph_objs/box/_hoverlabel.py b/plotly/graph_objs/box/_hoverlabel.py new file mode 100644 index 0000000000..650dd02026 --- /dev/null +++ b/plotly/graph_objs/box/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.box.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.box.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.box.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/_line.py b/plotly/graph_objs/box/_line.py new file mode 100644 index 0000000000..a85d52e927 --- /dev/null +++ b/plotly/graph_objs/box/_line.py @@ -0,0 +1,157 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of line bounding the box(es). + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of line bounding the box(es). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Line + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Line +constructor must be a dict or +an instance of plotly.graph_objs.box.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/_marker.py b/plotly/graph_objs/box/_marker.py new file mode 100644 index 0000000000..f0c4dc1de6 --- /dev/null +++ b/plotly/graph_objs/box/_marker.py @@ -0,0 +1,416 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.box.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier + sample points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the + outlier sample points. + width + Sets the width (in px) of the lines bounding + the marker points. + + Returns + ------- + plotly.graph_objs.box.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # outliercolor + # ------------ + @property + def outliercolor(self): + """ + Sets the color of the outlier sample points. + + The 'outliercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outliercolor'] + + @outliercolor.setter + def outliercolor(self, val): + self['outliercolor'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + + Returns + ------- + Any + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + line + plotly.graph_objs.box.marker.Line instance or dict with + compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + """ + + def __init__( + self, + arg=None, + color=None, + line=None, + opacity=None, + outliercolor=None, + size=None, + symbol=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Marker + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + line + plotly.graph_objs.box.marker.Line instance or dict with + compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Marker +constructor must be a dict or +an instance of plotly.graph_objs.box.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['outliercolor'] = v_marker.OutliercolorValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('outliercolor', None) + self.outliercolor = outliercolor if outliercolor is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/_selected.py b/plotly/graph_objs/box/_selected.py new file mode 100644 index 0000000000..71afeae87b --- /dev/null +++ b/plotly/graph_objs/box/_selected.py @@ -0,0 +1,103 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.box.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.box.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.box.selected.Marker instance or dict + with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Selected + marker + plotly.graph_objs.box.selected.Marker instance or dict + with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Selected +constructor must be a dict or +an instance of plotly.graph_objs.box.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/_stream.py b/plotly/graph_objs/box/_stream.py new file mode 100644 index 0000000000..3d93325777 --- /dev/null +++ b/plotly/graph_objs/box/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Stream +constructor must be a dict or +an instance of plotly.graph_objs.box.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/_unselected.py b/plotly/graph_objs/box/_unselected.py new file mode 100644 index 0000000000..e59bc10b08 --- /dev/null +++ b/plotly/graph_objs/box/_unselected.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.box.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.box.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.box.unselected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.Unselected + marker + plotly.graph_objs.box.unselected.Marker instance or + dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.box.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.box import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/hoverlabel/__init__.py b/plotly/graph_objs/box/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/box/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/box/hoverlabel/_font.py b/plotly/graph_objs/box/hoverlabel/_font.py new file mode 100644 index 0000000000..23504a9ce6 --- /dev/null +++ b/plotly/graph_objs/box/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.box.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.box.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/marker/__init__.py b/plotly/graph_objs/box/marker/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/box/marker/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/box/marker/_line.py b/plotly/graph_objs/box/marker/_line.py new file mode 100644 index 0000000000..a229ca5226 --- /dev/null +++ b/plotly/graph_objs/box/marker/_line.py @@ -0,0 +1,275 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # outliercolor + # ------------ + @property + def outliercolor(self): + """ + Sets the border line color of the outlier sample points. + Defaults to marker.color + + The 'outliercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outliercolor'] + + @outliercolor.setter + def outliercolor(self, val): + self['outliercolor'] = val + + # outlierwidth + # ------------ + @property + def outlierwidth(self): + """ + Sets the border line width (in px) of the outlier sample + points. + + The 'outlierwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlierwidth'] + + @outlierwidth.setter + def outlierwidth(self, val): + self['outlierwidth'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier sample + points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the outlier + sample points. + width + Sets the width (in px) of the lines bounding the marker + points. + """ + + def __init__( + self, + arg=None, + color=None, + outliercolor=None, + outlierwidth=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.marker.Line + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier sample + points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the outlier + sample points. + width + Sets the width (in px) of the lines bounding the marker + points. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.box.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.box.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['outliercolor'] = v_line.OutliercolorValidator() + self._validators['outlierwidth'] = v_line.OutlierwidthValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('outliercolor', None) + self.outliercolor = outliercolor if outliercolor is not None else v + v = arg.pop('outlierwidth', None) + self.outlierwidth = outlierwidth if outlierwidth is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/selected/__init__.py b/plotly/graph_objs/box/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/box/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/box/selected/_marker.py b/plotly/graph_objs/box/selected/_marker.py new file mode 100644 index 0000000000..ae70592661 --- /dev/null +++ b/plotly/graph_objs/box/selected/_marker.py @@ -0,0 +1,186 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.box.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.box.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/box/unselected/__init__.py b/plotly/graph_objs/box/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/box/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/box/unselected/_marker.py b/plotly/graph_objs/box/unselected/_marker.py new file mode 100644 index 0000000000..2b4769dd17 --- /dev/null +++ b/plotly/graph_objs/box/unselected/_marker.py @@ -0,0 +1,195 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'box.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.box.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.box.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.box.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.box.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/__init__.py b/plotly/graph_objs/candlestick/__init__.py new file mode 100644 index 0000000000..5fa8e67488 --- /dev/null +++ b/plotly/graph_objs/candlestick/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._line import Line +from ._increasing import Increasing +from plotly.graph_objs.candlestick import increasing +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.candlestick import hoverlabel +from ._decreasing import Decreasing +from plotly.graph_objs.candlestick import decreasing diff --git a/plotly/graph_objs/candlestick/_decreasing.py b/plotly/graph_objs/candlestick/_decreasing.py new file mode 100644 index 0000000000..4f957d4fcc --- /dev/null +++ b/plotly/graph_objs/candlestick/_decreasing.py @@ -0,0 +1,174 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Decreasing(BaseTraceHierarchyType): + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.candlestick.decreasing.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es). + + Returns + ------- + plotly.graph_objs.candlestick.decreasing.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + line + plotly.graph_objs.candlestick.decreasing.Line instance + or dict with compatible properties + """ + + def __init__(self, arg=None, fillcolor=None, line=None, **kwargs): + """ + Construct a new Decreasing object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.candlestick.Decreasing + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + line + plotly.graph_objs.candlestick.decreasing.Line instance + or dict with compatible properties + + Returns + ------- + Decreasing + """ + super(Decreasing, self).__init__('decreasing') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.Decreasing +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.Decreasing""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick import (decreasing as v_decreasing) + + # Initialize validators + # --------------------- + self._validators['fillcolor'] = v_decreasing.FillcolorValidator() + self._validators['line'] = v_decreasing.LineValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/_hoverlabel.py b/plotly/graph_objs/candlestick/_hoverlabel.py new file mode 100644 index 0000000000..ce8325f9f8 --- /dev/null +++ b/plotly/graph_objs/candlestick/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.candlestick.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.candlestick.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.candlestick.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/_increasing.py b/plotly/graph_objs/candlestick/_increasing.py new file mode 100644 index 0000000000..52fa31e56a --- /dev/null +++ b/plotly/graph_objs/candlestick/_increasing.py @@ -0,0 +1,174 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Increasing(BaseTraceHierarchyType): + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the fill color. Defaults to a half-transparent variant of + the line color, marker color, or marker line color, whichever + is available. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.candlestick.increasing.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es). + + Returns + ------- + plotly.graph_objs.candlestick.increasing.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + line + plotly.graph_objs.candlestick.increasing.Line instance + or dict with compatible properties + """ + + def __init__(self, arg=None, fillcolor=None, line=None, **kwargs): + """ + Construct a new Increasing object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.candlestick.Increasing + fillcolor + Sets the fill color. Defaults to a half-transparent + variant of the line color, marker color, or marker line + color, whichever is available. + line + plotly.graph_objs.candlestick.increasing.Line instance + or dict with compatible properties + + Returns + ------- + Increasing + """ + super(Increasing, self).__init__('increasing') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.Increasing +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.Increasing""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick import (increasing as v_increasing) + + # Initialize validators + # --------------------- + self._validators['fillcolor'] = v_increasing.FillcolorValidator() + self._validators['line'] = v_increasing.LineValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/_line.py b/plotly/graph_objs/candlestick/_line.py new file mode 100644 index 0000000000..1b615feeab --- /dev/null +++ b/plotly/graph_objs/candlestick/_line.py @@ -0,0 +1,99 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of line bounding the box(es). Note that + this style setting can also be set per direction via + `increasing.line.width` and `decreasing.line.width`. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + width + Sets the width (in px) of line bounding the box(es). + Note that this style setting can also be set per + direction via `increasing.line.width` and + `decreasing.line.width`. + """ + + def __init__(self, arg=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.candlestick.Line + width + Sets the width (in px) of line bounding the box(es). + Note that this style setting can also be set per + direction via `increasing.line.width` and + `decreasing.line.width`. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.Line +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/_stream.py b/plotly/graph_objs/candlestick/_stream.py new file mode 100644 index 0000000000..db0c9d4544 --- /dev/null +++ b/plotly/graph_objs/candlestick/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.candlestick.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.Stream +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/decreasing/__init__.py b/plotly/graph_objs/candlestick/decreasing/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/candlestick/decreasing/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/candlestick/decreasing/_line.py b/plotly/graph_objs/candlestick/decreasing/_line.py new file mode 100644 index 0000000000..e69ca67906 --- /dev/null +++ b/plotly/graph_objs/candlestick/decreasing/_line.py @@ -0,0 +1,158 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of line bounding the box(es). + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of line bounding the box(es). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick.decreasing' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.candlestick.decreasing.Line + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.decreasing.Line +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.decreasing.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick.decreasing import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/hoverlabel/__init__.py b/plotly/graph_objs/candlestick/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/candlestick/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/candlestick/hoverlabel/_font.py b/plotly/graph_objs/candlestick/hoverlabel/_font.py new file mode 100644 index 0000000000..c47ad75687 --- /dev/null +++ b/plotly/graph_objs/candlestick/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.candlestick.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/candlestick/increasing/__init__.py b/plotly/graph_objs/candlestick/increasing/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/candlestick/increasing/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/candlestick/increasing/_line.py b/plotly/graph_objs/candlestick/increasing/_line.py new file mode 100644 index 0000000000..e8e7151662 --- /dev/null +++ b/plotly/graph_objs/candlestick/increasing/_line.py @@ -0,0 +1,158 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of line bounding the box(es). + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of line bounding the box(es). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'candlestick.increasing' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.candlestick.increasing.Line + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the box(es). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.candlestick.increasing.Line +constructor must be a dict or +an instance of plotly.graph_objs.candlestick.increasing.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.candlestick.increasing import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/__init__.py b/plotly/graph_objs/carpet/__init__.py new file mode 100644 index 0000000000..1ed69a1bd0 --- /dev/null +++ b/plotly/graph_objs/carpet/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.carpet import hoverlabel +from ._font import Font +from ._baxis import Baxis +from plotly.graph_objs.carpet import baxis +from ._aaxis import Aaxis +from plotly.graph_objs.carpet import aaxis diff --git a/plotly/graph_objs/carpet/_aaxis.py b/plotly/graph_objs/carpet/_aaxis.py new file mode 100644 index 0000000000..a4f04d2729 --- /dev/null +++ b/plotly/graph_objs/carpet/_aaxis.py @@ -0,0 +1,2111 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Aaxis(BaseTraceHierarchyType): + + # arraydtick + # ---------- + @property + def arraydtick(self): + """ + The stride between grid lines along the axis + + The 'arraydtick' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['arraydtick'] + + @arraydtick.setter + def arraydtick(self, val): + self['arraydtick'] = val + + # arraytick0 + # ---------- + @property + def arraytick0(self): + """ + The starting index of grid lines along the axis + + The 'arraytick0' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['arraytick0'] + + @arraytick0.setter + def arraytick0(self, val): + self['arraytick0'] = val + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # cheatertype + # ----------- + @property + def cheatertype(self): + """ + The 'cheatertype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['index', 'value'] + + Returns + ------- + Any + """ + return self['cheatertype'] + + @cheatertype.setter + def cheatertype(self, val): + self['cheatertype'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + The stride between grid lines along the axis + + The 'dtick' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # endline + # ------- + @property + def endline(self): + """ + Determines whether or not a line is drawn at along the final + value of this axis. If *true*, the end line is drawn on top of + the grid lines. + + The 'endline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['endline'] + + @endline.setter + def endline(self, val): + self['endline'] = val + + # endlinecolor + # ------------ + @property + def endlinecolor(self): + """ + Sets the line color of the end line. + + The 'endlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['endlinecolor'] + + @endlinecolor.setter + def endlinecolor(self, val): + self['endlinecolor'] = val + + # endlinewidth + # ------------ + @property + def endlinewidth(self): + """ + Sets the width (in px) of the end line. + + The 'endlinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['endlinewidth'] + + @endlinewidth.setter + def endlinewidth(self, val): + self['endlinewidth'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # fixedrange + # ---------- + @property + def fixedrange(self): + """ + Determines whether or not this axis is zoom-able. If true, then + zoom is disabled. + + The 'fixedrange' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['fixedrange'] + + @fixedrange.setter + def fixedrange(self, val): + self['fixedrange'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the axis line color. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the axis line. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # labelpadding + # ------------ + @property + def labelpadding(self): + """ + Extra padding between label and the axis + + The 'labelpadding' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + + Returns + ------- + int + """ + return self['labelpadding'] + + @labelpadding.setter + def labelpadding(self, val): + self['labelpadding'] = val + + # labelprefix + # ----------- + @property + def labelprefix(self): + """ + Sets a axis label prefix. + + The 'labelprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelprefix'] + + @labelprefix.setter + def labelprefix(self, val): + self['labelprefix'] = val + + # labelsuffix + # ----------- + @property + def labelsuffix(self): + """ + Sets a axis label suffix. + + The 'labelsuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelsuffix'] + + @labelsuffix.setter + def labelsuffix(self, val): + self['labelsuffix'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # minorgridcolor + # -------------- + @property + def minorgridcolor(self): + """ + Sets the color of the grid lines. + + The 'minorgridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['minorgridcolor'] + + @minorgridcolor.setter + def minorgridcolor(self, val): + self['minorgridcolor'] = val + + # minorgridcount + # -------------- + @property + def minorgridcount(self): + """ + Sets the number of minor grid ticks per major grid tick + + The 'minorgridcount' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['minorgridcount'] + + @minorgridcount.setter + def minorgridcount(self, val): + self['minorgridcount'] = val + + # minorgridwidth + # -------------- + @property + def minorgridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'minorgridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['minorgridwidth'] + + @minorgridwidth.setter + def minorgridwidth(self, val): + self['minorgridwidth'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether axis labels are drawn on the low side, the + high side, both, or neither side of the axis. + + The 'showticklabels' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['start', 'end', 'both', 'none'] + + Returns + ------- + Any + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # startline + # --------- + @property + def startline(self): + """ + Determines whether or not a line is drawn at along the starting + value of this axis. If *true*, the start line is drawn on top + of the grid lines. + + The 'startline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['startline'] + + @startline.setter + def startline(self, val): + self['startline'] = val + + # startlinecolor + # -------------- + @property + def startlinecolor(self): + """ + Sets the line color of the start line. + + The 'startlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['startlinecolor'] + + @startlinecolor.setter + def startlinecolor(self, val): + self['startlinecolor'] = val + + # startlinewidth + # -------------- + @property + def startlinewidth(self): + """ + Sets the width (in px) of the start line. + + The 'startlinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['startlinewidth'] + + @startlinewidth.setter + def startlinewidth(self, val): + self['startlinewidth'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + The starting index of grid lines along the axis + + The 'tick0' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.carpet.aaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.carpet.aaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.carpet.aaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.carpet.aaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.carpet.aaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.carpet.aaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleoffset + # ----------- + @property + def titleoffset(self): + """ + An additional amount by which to offset the title from the tick + labels, given in pixels + + The 'titleoffset' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['titleoffset'] + + @titleoffset.setter + def titleoffset(self, val): + self['titleoffset'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at along the + final value of this axis. If *true*, the end line is + drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether axis labels are drawn on the low + side, the high side, both, or neither side of the axis. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at along the + starting value of this axis. If *true*, the start line + is drawn on top of the grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.aaxis.Tickformatstop instance + or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the title from + the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + """ + + def __init__( + self, + arg=None, + arraydtick=None, + arraytick0=None, + autorange=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + cheatertype=None, + color=None, + dtick=None, + endline=None, + endlinecolor=None, + endlinewidth=None, + exponentformat=None, + fixedrange=None, + gridcolor=None, + gridwidth=None, + labelpadding=None, + labelprefix=None, + labelsuffix=None, + linecolor=None, + linewidth=None, + minorgridcolor=None, + minorgridcount=None, + minorgridwidth=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + smoothing=None, + startline=None, + startlinecolor=None, + startlinewidth=None, + tick0=None, + tickangle=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + tickmode=None, + tickprefix=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + title=None, + titlefont=None, + titleoffset=None, + type=None, + **kwargs + ): + """ + Construct a new Aaxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.Aaxis + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at along the + final value of this axis. If *true*, the end line is + drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether axis labels are drawn on the low + side, the high side, both, or neither side of the axis. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at along the + starting value of this axis. If *true*, the start line + is drawn on top of the grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.aaxis.Tickformatstop instance + or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the title from + the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + + Returns + ------- + Aaxis + """ + super(Aaxis, self).__init__('aaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.Aaxis +constructor must be a dict or +an instance of plotly.graph_objs.carpet.Aaxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet import (aaxis as v_aaxis) + + # Initialize validators + # --------------------- + self._validators['arraydtick'] = v_aaxis.ArraydtickValidator() + self._validators['arraytick0'] = v_aaxis.Arraytick0Validator() + self._validators['autorange'] = v_aaxis.AutorangeValidator() + self._validators['categoryarray'] = v_aaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_aaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_aaxis.CategoryorderValidator() + self._validators['cheatertype'] = v_aaxis.CheatertypeValidator() + self._validators['color'] = v_aaxis.ColorValidator() + self._validators['dtick'] = v_aaxis.DtickValidator() + self._validators['endline'] = v_aaxis.EndlineValidator() + self._validators['endlinecolor'] = v_aaxis.EndlinecolorValidator() + self._validators['endlinewidth'] = v_aaxis.EndlinewidthValidator() + self._validators['exponentformat'] = v_aaxis.ExponentformatValidator() + self._validators['fixedrange'] = v_aaxis.FixedrangeValidator() + self._validators['gridcolor'] = v_aaxis.GridcolorValidator() + self._validators['gridwidth'] = v_aaxis.GridwidthValidator() + self._validators['labelpadding'] = v_aaxis.LabelpaddingValidator() + self._validators['labelprefix'] = v_aaxis.LabelprefixValidator() + self._validators['labelsuffix'] = v_aaxis.LabelsuffixValidator() + self._validators['linecolor'] = v_aaxis.LinecolorValidator() + self._validators['linewidth'] = v_aaxis.LinewidthValidator() + self._validators['minorgridcolor'] = v_aaxis.MinorgridcolorValidator() + self._validators['minorgridcount'] = v_aaxis.MinorgridcountValidator() + self._validators['minorgridwidth'] = v_aaxis.MinorgridwidthValidator() + self._validators['nticks'] = v_aaxis.NticksValidator() + self._validators['range'] = v_aaxis.RangeValidator() + self._validators['rangemode'] = v_aaxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_aaxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_aaxis.ShowexponentValidator() + self._validators['showgrid'] = v_aaxis.ShowgridValidator() + self._validators['showline'] = v_aaxis.ShowlineValidator() + self._validators['showticklabels'] = v_aaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_aaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_aaxis.ShowticksuffixValidator() + self._validators['smoothing'] = v_aaxis.SmoothingValidator() + self._validators['startline'] = v_aaxis.StartlineValidator() + self._validators['startlinecolor'] = v_aaxis.StartlinecolorValidator() + self._validators['startlinewidth'] = v_aaxis.StartlinewidthValidator() + self._validators['tick0'] = v_aaxis.Tick0Validator() + self._validators['tickangle'] = v_aaxis.TickangleValidator() + self._validators['tickfont'] = v_aaxis.TickfontValidator() + self._validators['tickformat'] = v_aaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_aaxis.TickformatstopsValidator() + self._validators['tickmode'] = v_aaxis.TickmodeValidator() + self._validators['tickprefix'] = v_aaxis.TickprefixValidator() + self._validators['ticksuffix'] = v_aaxis.TicksuffixValidator() + self._validators['ticktext'] = v_aaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_aaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_aaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_aaxis.TickvalssrcValidator() + self._validators['title'] = v_aaxis.TitleValidator() + self._validators['titlefont'] = v_aaxis.TitlefontValidator() + self._validators['titleoffset'] = v_aaxis.TitleoffsetValidator() + self._validators['type'] = v_aaxis.TypeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('arraydtick', None) + self.arraydtick = arraydtick if arraydtick is not None else v + v = arg.pop('arraytick0', None) + self.arraytick0 = arraytick0 if arraytick0 is not None else v + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('cheatertype', None) + self.cheatertype = cheatertype if cheatertype is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('endline', None) + self.endline = endline if endline is not None else v + v = arg.pop('endlinecolor', None) + self.endlinecolor = endlinecolor if endlinecolor is not None else v + v = arg.pop('endlinewidth', None) + self.endlinewidth = endlinewidth if endlinewidth is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('fixedrange', None) + self.fixedrange = fixedrange if fixedrange is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('labelpadding', None) + self.labelpadding = labelpadding if labelpadding is not None else v + v = arg.pop('labelprefix', None) + self.labelprefix = labelprefix if labelprefix is not None else v + v = arg.pop('labelsuffix', None) + self.labelsuffix = labelsuffix if labelsuffix is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('minorgridcolor', None) + self.minorgridcolor = minorgridcolor if minorgridcolor is not None else v + v = arg.pop('minorgridcount', None) + self.minorgridcount = minorgridcount if minorgridcount is not None else v + v = arg.pop('minorgridwidth', None) + self.minorgridwidth = minorgridwidth if minorgridwidth is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('startline', None) + self.startline = startline if startline is not None else v + v = arg.pop('startlinecolor', None) + self.startlinecolor = startlinecolor if startlinecolor is not None else v + v = arg.pop('startlinewidth', None) + self.startlinewidth = startlinewidth if startlinewidth is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleoffset', None) + self.titleoffset = titleoffset if titleoffset is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/_baxis.py b/plotly/graph_objs/carpet/_baxis.py new file mode 100644 index 0000000000..af83c76545 --- /dev/null +++ b/plotly/graph_objs/carpet/_baxis.py @@ -0,0 +1,2111 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Baxis(BaseTraceHierarchyType): + + # arraydtick + # ---------- + @property + def arraydtick(self): + """ + The stride between grid lines along the axis + + The 'arraydtick' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['arraydtick'] + + @arraydtick.setter + def arraydtick(self, val): + self['arraydtick'] = val + + # arraytick0 + # ---------- + @property + def arraytick0(self): + """ + The starting index of grid lines along the axis + + The 'arraytick0' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['arraytick0'] + + @arraytick0.setter + def arraytick0(self, val): + self['arraytick0'] = val + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # cheatertype + # ----------- + @property + def cheatertype(self): + """ + The 'cheatertype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['index', 'value'] + + Returns + ------- + Any + """ + return self['cheatertype'] + + @cheatertype.setter + def cheatertype(self, val): + self['cheatertype'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + The stride between grid lines along the axis + + The 'dtick' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # endline + # ------- + @property + def endline(self): + """ + Determines whether or not a line is drawn at along the final + value of this axis. If *true*, the end line is drawn on top of + the grid lines. + + The 'endline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['endline'] + + @endline.setter + def endline(self, val): + self['endline'] = val + + # endlinecolor + # ------------ + @property + def endlinecolor(self): + """ + Sets the line color of the end line. + + The 'endlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['endlinecolor'] + + @endlinecolor.setter + def endlinecolor(self, val): + self['endlinecolor'] = val + + # endlinewidth + # ------------ + @property + def endlinewidth(self): + """ + Sets the width (in px) of the end line. + + The 'endlinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['endlinewidth'] + + @endlinewidth.setter + def endlinewidth(self, val): + self['endlinewidth'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # fixedrange + # ---------- + @property + def fixedrange(self): + """ + Determines whether or not this axis is zoom-able. If true, then + zoom is disabled. + + The 'fixedrange' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['fixedrange'] + + @fixedrange.setter + def fixedrange(self, val): + self['fixedrange'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the axis line color. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the axis line. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # labelpadding + # ------------ + @property + def labelpadding(self): + """ + Extra padding between label and the axis + + The 'labelpadding' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + + Returns + ------- + int + """ + return self['labelpadding'] + + @labelpadding.setter + def labelpadding(self, val): + self['labelpadding'] = val + + # labelprefix + # ----------- + @property + def labelprefix(self): + """ + Sets a axis label prefix. + + The 'labelprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelprefix'] + + @labelprefix.setter + def labelprefix(self, val): + self['labelprefix'] = val + + # labelsuffix + # ----------- + @property + def labelsuffix(self): + """ + Sets a axis label suffix. + + The 'labelsuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelsuffix'] + + @labelsuffix.setter + def labelsuffix(self, val): + self['labelsuffix'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # minorgridcolor + # -------------- + @property + def minorgridcolor(self): + """ + Sets the color of the grid lines. + + The 'minorgridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['minorgridcolor'] + + @minorgridcolor.setter + def minorgridcolor(self, val): + self['minorgridcolor'] = val + + # minorgridcount + # -------------- + @property + def minorgridcount(self): + """ + Sets the number of minor grid ticks per major grid tick + + The 'minorgridcount' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['minorgridcount'] + + @minorgridcount.setter + def minorgridcount(self, val): + self['minorgridcount'] = val + + # minorgridwidth + # -------------- + @property + def minorgridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'minorgridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['minorgridwidth'] + + @minorgridwidth.setter + def minorgridwidth(self, val): + self['minorgridwidth'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether axis labels are drawn on the low side, the + high side, both, or neither side of the axis. + + The 'showticklabels' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['start', 'end', 'both', 'none'] + + Returns + ------- + Any + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # startline + # --------- + @property + def startline(self): + """ + Determines whether or not a line is drawn at along the starting + value of this axis. If *true*, the start line is drawn on top + of the grid lines. + + The 'startline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['startline'] + + @startline.setter + def startline(self, val): + self['startline'] = val + + # startlinecolor + # -------------- + @property + def startlinecolor(self): + """ + Sets the line color of the start line. + + The 'startlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['startlinecolor'] + + @startlinecolor.setter + def startlinecolor(self, val): + self['startlinecolor'] = val + + # startlinewidth + # -------------- + @property + def startlinewidth(self): + """ + Sets the width (in px) of the start line. + + The 'startlinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['startlinewidth'] + + @startlinewidth.setter + def startlinewidth(self, val): + self['startlinewidth'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + The starting index of grid lines along the axis + + The 'tick0' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.carpet.baxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.carpet.baxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.carpet.baxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.carpet.baxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.carpet.baxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.carpet.baxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleoffset + # ----------- + @property + def titleoffset(self): + """ + An additional amount by which to offset the title from the tick + labels, given in pixels + + The 'titleoffset' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['titleoffset'] + + @titleoffset.setter + def titleoffset(self, val): + self['titleoffset'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at along the + final value of this axis. If *true*, the end line is + drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether axis labels are drawn on the low + side, the high side, both, or neither side of the axis. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at along the + starting value of this axis. If *true*, the start line + is drawn on top of the grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.baxis.Tickformatstop instance + or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the title from + the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + """ + + def __init__( + self, + arg=None, + arraydtick=None, + arraytick0=None, + autorange=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + cheatertype=None, + color=None, + dtick=None, + endline=None, + endlinecolor=None, + endlinewidth=None, + exponentformat=None, + fixedrange=None, + gridcolor=None, + gridwidth=None, + labelpadding=None, + labelprefix=None, + labelsuffix=None, + linecolor=None, + linewidth=None, + minorgridcolor=None, + minorgridcount=None, + minorgridwidth=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + smoothing=None, + startline=None, + startlinecolor=None, + startlinewidth=None, + tick0=None, + tickangle=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + tickmode=None, + tickprefix=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + title=None, + titlefont=None, + titleoffset=None, + type=None, + **kwargs + ): + """ + Construct a new Baxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.Baxis + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at along the + final value of this axis. If *true*, the end line is + drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether axis labels are drawn on the low + side, the high side, both, or neither side of the axis. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at along the + starting value of this axis. If *true*, the start line + is drawn on top of the grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.baxis.Tickformatstop instance + or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the title from + the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + + Returns + ------- + Baxis + """ + super(Baxis, self).__init__('baxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.Baxis +constructor must be a dict or +an instance of plotly.graph_objs.carpet.Baxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet import (baxis as v_baxis) + + # Initialize validators + # --------------------- + self._validators['arraydtick'] = v_baxis.ArraydtickValidator() + self._validators['arraytick0'] = v_baxis.Arraytick0Validator() + self._validators['autorange'] = v_baxis.AutorangeValidator() + self._validators['categoryarray'] = v_baxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_baxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_baxis.CategoryorderValidator() + self._validators['cheatertype'] = v_baxis.CheatertypeValidator() + self._validators['color'] = v_baxis.ColorValidator() + self._validators['dtick'] = v_baxis.DtickValidator() + self._validators['endline'] = v_baxis.EndlineValidator() + self._validators['endlinecolor'] = v_baxis.EndlinecolorValidator() + self._validators['endlinewidth'] = v_baxis.EndlinewidthValidator() + self._validators['exponentformat'] = v_baxis.ExponentformatValidator() + self._validators['fixedrange'] = v_baxis.FixedrangeValidator() + self._validators['gridcolor'] = v_baxis.GridcolorValidator() + self._validators['gridwidth'] = v_baxis.GridwidthValidator() + self._validators['labelpadding'] = v_baxis.LabelpaddingValidator() + self._validators['labelprefix'] = v_baxis.LabelprefixValidator() + self._validators['labelsuffix'] = v_baxis.LabelsuffixValidator() + self._validators['linecolor'] = v_baxis.LinecolorValidator() + self._validators['linewidth'] = v_baxis.LinewidthValidator() + self._validators['minorgridcolor'] = v_baxis.MinorgridcolorValidator() + self._validators['minorgridcount'] = v_baxis.MinorgridcountValidator() + self._validators['minorgridwidth'] = v_baxis.MinorgridwidthValidator() + self._validators['nticks'] = v_baxis.NticksValidator() + self._validators['range'] = v_baxis.RangeValidator() + self._validators['rangemode'] = v_baxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_baxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_baxis.ShowexponentValidator() + self._validators['showgrid'] = v_baxis.ShowgridValidator() + self._validators['showline'] = v_baxis.ShowlineValidator() + self._validators['showticklabels'] = v_baxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_baxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_baxis.ShowticksuffixValidator() + self._validators['smoothing'] = v_baxis.SmoothingValidator() + self._validators['startline'] = v_baxis.StartlineValidator() + self._validators['startlinecolor'] = v_baxis.StartlinecolorValidator() + self._validators['startlinewidth'] = v_baxis.StartlinewidthValidator() + self._validators['tick0'] = v_baxis.Tick0Validator() + self._validators['tickangle'] = v_baxis.TickangleValidator() + self._validators['tickfont'] = v_baxis.TickfontValidator() + self._validators['tickformat'] = v_baxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_baxis.TickformatstopsValidator() + self._validators['tickmode'] = v_baxis.TickmodeValidator() + self._validators['tickprefix'] = v_baxis.TickprefixValidator() + self._validators['ticksuffix'] = v_baxis.TicksuffixValidator() + self._validators['ticktext'] = v_baxis.TicktextValidator() + self._validators['ticktextsrc'] = v_baxis.TicktextsrcValidator() + self._validators['tickvals'] = v_baxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_baxis.TickvalssrcValidator() + self._validators['title'] = v_baxis.TitleValidator() + self._validators['titlefont'] = v_baxis.TitlefontValidator() + self._validators['titleoffset'] = v_baxis.TitleoffsetValidator() + self._validators['type'] = v_baxis.TypeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('arraydtick', None) + self.arraydtick = arraydtick if arraydtick is not None else v + v = arg.pop('arraytick0', None) + self.arraytick0 = arraytick0 if arraytick0 is not None else v + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('cheatertype', None) + self.cheatertype = cheatertype if cheatertype is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('endline', None) + self.endline = endline if endline is not None else v + v = arg.pop('endlinecolor', None) + self.endlinecolor = endlinecolor if endlinecolor is not None else v + v = arg.pop('endlinewidth', None) + self.endlinewidth = endlinewidth if endlinewidth is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('fixedrange', None) + self.fixedrange = fixedrange if fixedrange is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('labelpadding', None) + self.labelpadding = labelpadding if labelpadding is not None else v + v = arg.pop('labelprefix', None) + self.labelprefix = labelprefix if labelprefix is not None else v + v = arg.pop('labelsuffix', None) + self.labelsuffix = labelsuffix if labelsuffix is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('minorgridcolor', None) + self.minorgridcolor = minorgridcolor if minorgridcolor is not None else v + v = arg.pop('minorgridcount', None) + self.minorgridcount = minorgridcount if minorgridcount is not None else v + v = arg.pop('minorgridwidth', None) + self.minorgridwidth = minorgridwidth if minorgridwidth is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('startline', None) + self.startline = startline if startline is not None else v + v = arg.pop('startlinecolor', None) + self.startlinecolor = startlinecolor if startlinecolor is not None else v + v = arg.pop('startlinewidth', None) + self.startlinewidth = startlinewidth if startlinewidth is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleoffset', None) + self.titleoffset = titleoffset if titleoffset is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/_font.py b/plotly/graph_objs/carpet/_font.py new file mode 100644 index 0000000000..b2613761be --- /dev/null +++ b/plotly/graph_objs/carpet/_font.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + The default font used for axis & tick labels on this carpet + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.Font +constructor must be a dict or +an instance of plotly.graph_objs.carpet.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/_hoverlabel.py b/plotly/graph_objs/carpet/_hoverlabel.py new file mode 100644 index 0000000000..ac5be27aab --- /dev/null +++ b/plotly/graph_objs/carpet/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.carpet.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.carpet.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.carpet.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/_stream.py b/plotly/graph_objs/carpet/_stream.py new file mode 100644 index 0000000000..f1492e3185 --- /dev/null +++ b/plotly/graph_objs/carpet/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.Stream +constructor must be a dict or +an instance of plotly.graph_objs.carpet.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/aaxis/__init__.py b/plotly/graph_objs/carpet/aaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/carpet/aaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/carpet/aaxis/_tickfont.py b/plotly/graph_objs/carpet/aaxis/_tickfont.py new file mode 100644 index 0000000000..8919aa6966 --- /dev/null +++ b/plotly/graph_objs/carpet/aaxis/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.aaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.aaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.carpet.aaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.aaxis import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/aaxis/_tickformatstop.py b/plotly/graph_objs/carpet/aaxis/_tickformatstop.py new file mode 100644 index 0000000000..c037fc5feb --- /dev/null +++ b/plotly/graph_objs/carpet/aaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.carpet.aaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.aaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.carpet.aaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.aaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/aaxis/_titlefont.py b/plotly/graph_objs/carpet/aaxis/_titlefont.py new file mode 100644 index 0000000000..0931c6ad9e --- /dev/null +++ b/plotly/graph_objs/carpet/aaxis/_titlefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.aaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.aaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.carpet.aaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.aaxis import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/baxis/__init__.py b/plotly/graph_objs/carpet/baxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/carpet/baxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/carpet/baxis/_tickfont.py b/plotly/graph_objs/carpet/baxis/_tickfont.py new file mode 100644 index 0000000000..9e4be67cb6 --- /dev/null +++ b/plotly/graph_objs/carpet/baxis/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.baxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.baxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.carpet.baxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.baxis import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/baxis/_tickformatstop.py b/plotly/graph_objs/carpet/baxis/_tickformatstop.py new file mode 100644 index 0000000000..c213c84920 --- /dev/null +++ b/plotly/graph_objs/carpet/baxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.carpet.baxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.baxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.carpet.baxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.baxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/baxis/_titlefont.py b/plotly/graph_objs/carpet/baxis/_titlefont.py new file mode 100644 index 0000000000..6c3775cd59 --- /dev/null +++ b/plotly/graph_objs/carpet/baxis/_titlefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.baxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.baxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.carpet.baxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.baxis import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/carpet/hoverlabel/__init__.py b/plotly/graph_objs/carpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/carpet/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/carpet/hoverlabel/_font.py b/plotly/graph_objs/carpet/hoverlabel/_font.py new file mode 100644 index 0000000000..6bf5bafa6a --- /dev/null +++ b/plotly/graph_objs/carpet/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'carpet.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.carpet.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.carpet.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.carpet.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.carpet.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/__init__.py b/plotly/graph_objs/choropleth/__init__.py new file mode 100644 index 0000000000..836539c709 --- /dev/null +++ b/plotly/graph_objs/choropleth/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.choropleth import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.choropleth import selected +from ._marker import Marker +from plotly.graph_objs.choropleth import marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.choropleth import hoverlabel +from ._colorbar import ColorBar +from plotly.graph_objs.choropleth import colorbar diff --git a/plotly/graph_objs/choropleth/_colorbar.py b/plotly/graph_objs/choropleth/_colorbar.py new file mode 100644 index 0000000000..0f633a66fd --- /dev/null +++ b/plotly/graph_objs/choropleth/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.choropleth.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.choropleth.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.choropleth.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.choropleth.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.choropleth.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.choropleth.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.choropleth.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.choropleth.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/_hoverlabel.py b/plotly/graph_objs/choropleth/_hoverlabel.py new file mode 100644 index 0000000000..36aff30194 --- /dev/null +++ b/plotly/graph_objs/choropleth/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.choropleth.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.choropleth.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/_marker.py b/plotly/graph_objs/choropleth/_marker.py new file mode 100644 index 0000000000..9e184df6fb --- /dev/null +++ b/plotly/graph_objs/choropleth/_marker.py @@ -0,0 +1,169 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.choropleth.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.choropleth.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the locations. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + line + plotly.graph_objs.choropleth.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the locations. + opacitysrc + Sets the source reference on plot.ly for opacity . + """ + + def __init__( + self, arg=None, line=None, opacity=None, opacitysrc=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.Marker + line + plotly.graph_objs.choropleth.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the locations. + opacitysrc + Sets the source reference on plot.ly for opacity . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.Marker +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/_selected.py b/plotly/graph_objs/choropleth/_selected.py new file mode 100644 index 0000000000..ce9ea676e9 --- /dev/null +++ b/plotly/graph_objs/choropleth/_selected.py @@ -0,0 +1,99 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.choropleth.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + opacity + Sets the marker opacity of selected points. + + Returns + ------- + plotly.graph_objs.choropleth.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.choropleth.selected.Marker instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.Selected + marker + plotly.graph_objs.choropleth.selected.Marker instance + or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.Selected +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/_stream.py b/plotly/graph_objs/choropleth/_stream.py new file mode 100644 index 0000000000..17202bffbe --- /dev/null +++ b/plotly/graph_objs/choropleth/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.Stream +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/_unselected.py b/plotly/graph_objs/choropleth/_unselected.py new file mode 100644 index 0000000000..02fc7b0998 --- /dev/null +++ b/plotly/graph_objs/choropleth/_unselected.py @@ -0,0 +1,100 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.choropleth.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.choropleth.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.choropleth.unselected.Marker instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.Unselected + marker + plotly.graph_objs.choropleth.unselected.Marker instance + or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/colorbar/__init__.py b/plotly/graph_objs/choropleth/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/choropleth/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/choropleth/colorbar/_tickfont.py b/plotly/graph_objs/choropleth/colorbar/_tickfont.py new file mode 100644 index 0000000000..1e552b6057 --- /dev/null +++ b/plotly/graph_objs/choropleth/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/colorbar/_tickformatstop.py b/plotly/graph_objs/choropleth/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..1bdb9de463 --- /dev/null +++ b/plotly/graph_objs/choropleth/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/colorbar/_titlefont.py b/plotly/graph_objs/choropleth/colorbar/_titlefont.py new file mode 100644 index 0000000000..f4bd82390b --- /dev/null +++ b/plotly/graph_objs/choropleth/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/hoverlabel/__init__.py b/plotly/graph_objs/choropleth/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/choropleth/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/choropleth/hoverlabel/_font.py b/plotly/graph_objs/choropleth/hoverlabel/_font.py new file mode 100644 index 0000000000..81d96e86e8 --- /dev/null +++ b/plotly/graph_objs/choropleth/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/marker/__init__.py b/plotly/graph_objs/choropleth/marker/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/choropleth/marker/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/choropleth/marker/_line.py b/plotly/graph_objs/choropleth/marker/_line.py new file mode 100644 index 0000000000..012e979c05 --- /dev/null +++ b/plotly/graph_objs/choropleth/marker/_line.py @@ -0,0 +1,232 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.choropleth.marker.Line + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/selected/__init__.py b/plotly/graph_objs/choropleth/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/choropleth/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/choropleth/selected/_marker.py b/plotly/graph_objs/choropleth/selected/_marker.py new file mode 100644 index 0000000000..3e18ffadc0 --- /dev/null +++ b/plotly/graph_objs/choropleth/selected/_marker.py @@ -0,0 +1,92 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + opacity + Sets the marker opacity of selected points. + """ + + def __init__(self, arg=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.selected.Marker + opacity + Sets the marker opacity of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/choropleth/unselected/__init__.py b/plotly/graph_objs/choropleth/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/choropleth/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/choropleth/unselected/_marker.py b/plotly/graph_objs/choropleth/unselected/_marker.py new file mode 100644 index 0000000000..ca89f4dd91 --- /dev/null +++ b/plotly/graph_objs/choropleth/unselected/_marker.py @@ -0,0 +1,97 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'choropleth.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.choropleth.unselected.Marker + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.choropleth.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.choropleth.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.choropleth.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/__init__.py b/plotly/graph_objs/cone/__init__.py new file mode 100644 index 0000000000..b2469854e0 --- /dev/null +++ b/plotly/graph_objs/cone/__init__.py @@ -0,0 +1,7 @@ +from ._stream import Stream +from ._lightposition import Lightposition +from ._lighting import Lighting +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.cone import hoverlabel +from ._colorbar import ColorBar +from plotly.graph_objs.cone import colorbar diff --git a/plotly/graph_objs/cone/_colorbar.py b/plotly/graph_objs/cone/_colorbar.py new file mode 100644 index 0000000000..d5a529047e --- /dev/null +++ b/plotly/graph_objs/cone/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.cone.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.cone.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.cone.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.cone.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.cone.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.cone.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.cone.colorbar.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.cone.colorbar.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.cone.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/_hoverlabel.py b/plotly/graph_objs/cone/_hoverlabel.py new file mode 100644 index 0000000000..54b940bb91 --- /dev/null +++ b/plotly/graph_objs/cone/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.cone.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.cone.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.cone.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/_lighting.py b/plotly/graph_objs/cone/_lighting.py new file mode 100644 index 0000000000..412ef79f3f --- /dev/null +++ b/plotly/graph_objs/cone/_lighting.py @@ -0,0 +1,292 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lighting(BaseTraceHierarchyType): + + # ambient + # ------- + @property + def ambient(self): + """ + Ambient light increases overall color visibility but can wash + out the image. + + The 'ambient' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['ambient'] + + @ambient.setter + def ambient(self, val): + self['ambient'] = val + + # diffuse + # ------- + @property + def diffuse(self): + """ + Represents the extent that incident rays are reflected in a + range of angles. + + The 'diffuse' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['diffuse'] + + @diffuse.setter + def diffuse(self, val): + self['diffuse'] = val + + # facenormalsepsilon + # ------------------ + @property + def facenormalsepsilon(self): + """ + Epsilon for face normals calculation avoids math issues arising + from degenerate geometry. + + The 'facenormalsepsilon' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['facenormalsepsilon'] + + @facenormalsepsilon.setter + def facenormalsepsilon(self, val): + self['facenormalsepsilon'] = val + + # fresnel + # ------- + @property + def fresnel(self): + """ + Represents the reflectance as a dependency of the viewing + angle; e.g. paper is reflective when viewing it from the edge + of the paper (almost 90 degrees), causing shine. + + The 'fresnel' property is a number and may be specified as: + - An int or float in the interval [0, 5] + + Returns + ------- + int|float + """ + return self['fresnel'] + + @fresnel.setter + def fresnel(self, val): + self['fresnel'] = val + + # roughness + # --------- + @property + def roughness(self): + """ + Alters specular reflection; the rougher the surface, the wider + and less contrasty the shine. + + The 'roughness' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['roughness'] + + @roughness.setter + def roughness(self, val): + self['roughness'] = val + + # specular + # -------- + @property + def specular(self): + """ + Represents the level that incident rays are reflected in a + single direction, causing shine. + + The 'specular' property is a number and may be specified as: + - An int or float in the interval [0, 2] + + Returns + ------- + int|float + """ + return self['specular'] + + @specular.setter + def specular(self, val): + self['specular'] = val + + # vertexnormalsepsilon + # -------------------- + @property + def vertexnormalsepsilon(self): + """ + Epsilon for vertex normals calculation avoids math issues + arising from degenerate geometry. + + The 'vertexnormalsepsilon' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['vertexnormalsepsilon'] + + @vertexnormalsepsilon.setter + def vertexnormalsepsilon(self, val): + self['vertexnormalsepsilon'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids math issues + arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids math + issues arising from degenerate geometry. + """ + + def __init__( + self, + arg=None, + ambient=None, + diffuse=None, + facenormalsepsilon=None, + fresnel=None, + roughness=None, + specular=None, + vertexnormalsepsilon=None, + **kwargs + ): + """ + Construct a new Lighting object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.Lighting + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids math issues + arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids math + issues arising from degenerate geometry. + + Returns + ------- + Lighting + """ + super(Lighting, self).__init__('lighting') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.Lighting +constructor must be a dict or +an instance of plotly.graph_objs.cone.Lighting""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone import (lighting as v_lighting) + + # Initialize validators + # --------------------- + self._validators['ambient'] = v_lighting.AmbientValidator() + self._validators['diffuse'] = v_lighting.DiffuseValidator() + self._validators['facenormalsepsilon' + ] = v_lighting.FacenormalsepsilonValidator() + self._validators['fresnel'] = v_lighting.FresnelValidator() + self._validators['roughness'] = v_lighting.RoughnessValidator() + self._validators['specular'] = v_lighting.SpecularValidator() + self._validators['vertexnormalsepsilon' + ] = v_lighting.VertexnormalsepsilonValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('ambient', None) + self.ambient = ambient if ambient is not None else v + v = arg.pop('diffuse', None) + self.diffuse = diffuse if diffuse is not None else v + v = arg.pop('facenormalsepsilon', None) + self.facenormalsepsilon = facenormalsepsilon if facenormalsepsilon is not None else v + v = arg.pop('fresnel', None) + self.fresnel = fresnel if fresnel is not None else v + v = arg.pop('roughness', None) + self.roughness = roughness if roughness is not None else v + v = arg.pop('specular', None) + self.specular = specular if specular is not None else v + v = arg.pop('vertexnormalsepsilon', None) + self.vertexnormalsepsilon = vertexnormalsepsilon if vertexnormalsepsilon is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/_lightposition.py b/plotly/graph_objs/cone/_lightposition.py new file mode 100644 index 0000000000..20f53aaba3 --- /dev/null +++ b/plotly/graph_objs/cone/_lightposition.py @@ -0,0 +1,151 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lightposition(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Numeric vector, representing the X coordinate for each vertex. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Numeric vector, representing the Y coordinate for each vertex. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Numeric vector, representing the Z coordinate for each vertex. + + The 'z' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Lightposition object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.Lightposition + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + + Returns + ------- + Lightposition + """ + super(Lightposition, self).__init__('lightposition') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.Lightposition +constructor must be a dict or +an instance of plotly.graph_objs.cone.Lightposition""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone import (lightposition as v_lightposition) + + # Initialize validators + # --------------------- + self._validators['x'] = v_lightposition.XValidator() + self._validators['y'] = v_lightposition.YValidator() + self._validators['z'] = v_lightposition.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/_stream.py b/plotly/graph_objs/cone/_stream.py new file mode 100644 index 0000000000..4bd7996a5e --- /dev/null +++ b/plotly/graph_objs/cone/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.Stream +constructor must be a dict or +an instance of plotly.graph_objs.cone.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/colorbar/__init__.py b/plotly/graph_objs/cone/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/cone/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/cone/colorbar/_tickfont.py b/plotly/graph_objs/cone/colorbar/_tickfont.py new file mode 100644 index 0000000000..432719205b --- /dev/null +++ b/plotly/graph_objs/cone/colorbar/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.cone.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone.colorbar import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/colorbar/_tickformatstop.py b/plotly/graph_objs/cone/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..c228ccf1c1 --- /dev/null +++ b/plotly/graph_objs/cone/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.cone.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.cone.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/colorbar/_titlefont.py b/plotly/graph_objs/cone/colorbar/_titlefont.py new file mode 100644 index 0000000000..f55d22e53f --- /dev/null +++ b/plotly/graph_objs/cone/colorbar/_titlefont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.cone.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.cone.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone.colorbar import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/cone/hoverlabel/__init__.py b/plotly/graph_objs/cone/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/cone/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/cone/hoverlabel/_font.py b/plotly/graph_objs/cone/hoverlabel/_font.py new file mode 100644 index 0000000000..16828edd84 --- /dev/null +++ b/plotly/graph_objs/cone/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'cone.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.cone.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.cone.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.cone.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.cone.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/__init__.py b/plotly/graph_objs/contour/__init__.py new file mode 100644 index 0000000000..73dadc1219 --- /dev/null +++ b/plotly/graph_objs/contour/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.contour import hoverlabel +from ._contours import Contours +from plotly.graph_objs.contour import contours +from ._colorbar import ColorBar +from plotly.graph_objs.contour import colorbar diff --git a/plotly/graph_objs/contour/_colorbar.py b/plotly/graph_objs/contour/_colorbar.py new file mode 100644 index 0000000000..d53a487f0f --- /dev/null +++ b/plotly/graph_objs/contour/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.contour.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contour.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.contour.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.contour.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.contour.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contour.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.contour.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contour.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.contour.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.contour.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/_contours.py b/plotly/graph_objs/contour/_contours.py new file mode 100644 index 0000000000..cf80fbea7d --- /dev/null +++ b/plotly/graph_objs/contour/_contours.py @@ -0,0 +1,499 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Contours(BaseTraceHierarchyType): + + # coloring + # -------- + @property + def coloring(self): + """ + Determines the coloring method showing the contour values. If + *fill*, coloring is done evenly between each contour level If + *heatmap*, a heatmap gradient coloring is applied between each + contour level. If *lines*, coloring is done on the contour + lines. If *none*, no coloring is applied on this trace. + + The 'coloring' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fill', 'heatmap', 'lines', 'none'] + + Returns + ------- + Any + """ + return self['coloring'] + + @coloring.setter + def coloring(self, val): + self['coloring'] = val + + # end + # --- + @property + def end(self): + """ + Sets the end contour level value. Must be more than + `contours.start` + + The 'end' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # labelfont + # --------- + @property + def labelfont(self): + """ + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + The 'labelfont' property is an instance of Labelfont + that may be specified as: + - An instance of plotly.graph_objs.contour.contours.Labelfont + - A dict of string/value properties that will be passed + to the Labelfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contour.contours.Labelfont + """ + return self['labelfont'] + + @labelfont.setter + def labelfont(self, val): + self['labelfont'] = val + + # labelformat + # ----------- + @property + def labelformat(self): + """ + Sets the contour label formatting rule using d3 formatting + mini-language which is very similar to Python, see: https://git + hub.com/d3/d3-format/blob/master/README.md#locale_format. + + The 'labelformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelformat'] + + @labelformat.setter + def labelformat(self, val): + self['labelformat'] = val + + # operation + # --------- + @property + def operation(self): + """ + Sets the constraint operation. *=* keeps regions equal to + `value` *<* and *<=* keep regions less than `value` *>* and + *>=* keep regions greater than `value` *[]*, *()*, *[)*, and + *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, + *](*, *)[* keep regions outside `value[0]` to value[1]` Open + vs. closed intervals make no difference to constraint display, + but all versions are allowed for consistency with filter + transforms. + + The 'operation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', + ')(', '](', ')['] + + Returns + ------- + Any + """ + return self['operation'] + + @operation.setter + def operation(self, val): + self['operation'] = val + + # showlabels + # ---------- + @property + def showlabels(self): + """ + Determines whether to label the contour lines with their + values. + + The 'showlabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlabels'] + + @showlabels.setter + def showlabels(self, val): + self['showlabels'] = val + + # showlines + # --------- + @property + def showlines(self): + """ + Determines whether or not the contour lines are drawn. Has an + effect only if `contours.coloring` is set to *fill*. + + The 'showlines' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlines'] + + @showlines.setter + def showlines(self, val): + self['showlines'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step between each contour level. Must be positive. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting contour level value. Must be less than + `contours.end` + + The 'start' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # type + # ---- + @property + def type(self): + """ + If `levels`, the data is represented as a contour plot with + multiple levels displayed. If `constraint`, the data is + represented as constraints with the invalid region shaded as + specified by the `operation` and `value` parameters. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['levels', 'constraint'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value or values of the constraint boundary. When + `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of + two numbers where the first is the lower bound and the second + is the upper bound. + + The 'value' property accepts values of any type + + Returns + ------- + Any + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *heatmap*, a heatmap gradient coloring + is applied between each contour level. If *lines*, + coloring is done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + """ + + def __init__( + self, + arg=None, + coloring=None, + end=None, + labelfont=None, + labelformat=None, + operation=None, + showlabels=None, + showlines=None, + size=None, + start=None, + type=None, + value=None, + **kwargs + ): + """ + Construct a new Contours object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contour.Contours + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *heatmap*, a heatmap gradient coloring + is applied between each contour level. If *lines*, + coloring is done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + + Returns + ------- + Contours + """ + super(Contours, self).__init__('contours') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.Contours +constructor must be a dict or +an instance of plotly.graph_objs.contour.Contours""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour import (contours as v_contours) + + # Initialize validators + # --------------------- + self._validators['coloring'] = v_contours.ColoringValidator() + self._validators['end'] = v_contours.EndValidator() + self._validators['labelfont'] = v_contours.LabelfontValidator() + self._validators['labelformat'] = v_contours.LabelformatValidator() + self._validators['operation'] = v_contours.OperationValidator() + self._validators['showlabels'] = v_contours.ShowlabelsValidator() + self._validators['showlines'] = v_contours.ShowlinesValidator() + self._validators['size'] = v_contours.SizeValidator() + self._validators['start'] = v_contours.StartValidator() + self._validators['type'] = v_contours.TypeValidator() + self._validators['value'] = v_contours.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('coloring', None) + self.coloring = coloring if coloring is not None else v + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('labelfont', None) + self.labelfont = labelfont if labelfont is not None else v + v = arg.pop('labelformat', None) + self.labelformat = labelformat if labelformat is not None else v + v = arg.pop('operation', None) + self.operation = operation if operation is not None else v + v = arg.pop('showlabels', None) + self.showlabels = showlabels if showlabels is not None else v + v = arg.pop('showlines', None) + self.showlines = showlines if showlines is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/_hoverlabel.py b/plotly/graph_objs/contour/_hoverlabel.py new file mode 100644 index 0000000000..c675d527d8 --- /dev/null +++ b/plotly/graph_objs/contour/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.contour.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.contour.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contour.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.contour.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/_line.py b/plotly/graph_objs/contour/_line.py new file mode 100644 index 0000000000..77b0f9fb42 --- /dev/null +++ b/plotly/graph_objs/contour/_line.py @@ -0,0 +1,237 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Sets the amount of smoothing for the contour lines, where *0* + corresponds to no smoothing. + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contour.Line + color + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.Line +constructor must be a dict or +an instance of plotly.graph_objs.contour.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/_stream.py b/plotly/graph_objs/contour/_stream.py new file mode 100644 index 0000000000..7d71407289 --- /dev/null +++ b/plotly/graph_objs/contour/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contour.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.Stream +constructor must be a dict or +an instance of plotly.graph_objs.contour.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/colorbar/__init__.py b/plotly/graph_objs/contour/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/contour/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/contour/colorbar/_tickfont.py b/plotly/graph_objs/contour/colorbar/_tickfont.py new file mode 100644 index 0000000000..b9c1ef5dee --- /dev/null +++ b/plotly/graph_objs/contour/colorbar/_tickfont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contour.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.contour.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour.colorbar import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/colorbar/_tickformatstop.py b/plotly/graph_objs/contour/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..c2a587f9da --- /dev/null +++ b/plotly/graph_objs/contour/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contour.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.contour.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/colorbar/_titlefont.py b/plotly/graph_objs/contour/colorbar/_titlefont.py new file mode 100644 index 0000000000..fd79bdd13c --- /dev/null +++ b/plotly/graph_objs/contour/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contour.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.contour.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/contours/__init__.py b/plotly/graph_objs/contour/contours/__init__.py new file mode 100644 index 0000000000..4729349bff --- /dev/null +++ b/plotly/graph_objs/contour/contours/__init__.py @@ -0,0 +1 @@ +from ._labelfont import Labelfont diff --git a/plotly/graph_objs/contour/contours/_labelfont.py b/plotly/graph_objs/contour/contours/_labelfont.py new file mode 100644 index 0000000000..fb8f02f73a --- /dev/null +++ b/plotly/graph_objs/contour/contours/_labelfont.py @@ -0,0 +1,222 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Labelfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Labelfont object + + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contour.contours.Labelfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Labelfont + """ + super(Labelfont, self).__init__('labelfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.contours.Labelfont +constructor must be a dict or +an instance of plotly.graph_objs.contour.contours.Labelfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour.contours import ( + labelfont as v_labelfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_labelfont.ColorValidator() + self._validators['family'] = v_labelfont.FamilyValidator() + self._validators['size'] = v_labelfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contour/hoverlabel/__init__.py b/plotly/graph_objs/contour/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/contour/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/contour/hoverlabel/_font.py b/plotly/graph_objs/contour/hoverlabel/_font.py new file mode 100644 index 0000000000..fa308bb37b --- /dev/null +++ b/plotly/graph_objs/contour/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contour.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contour.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contour.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.contour.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.contour.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/__init__.py b/plotly/graph_objs/contourcarpet/__init__.py new file mode 100644 index 0000000000..5c794e002a --- /dev/null +++ b/plotly/graph_objs/contourcarpet/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.contourcarpet import hoverlabel +from ._contours import Contours +from plotly.graph_objs.contourcarpet import contours +from ._colorbar import ColorBar +from plotly.graph_objs.contourcarpet import colorbar diff --git a/plotly/graph_objs/contourcarpet/_colorbar.py b/plotly/graph_objs/contourcarpet/_colorbar.py new file mode 100644 index 0000000000..4dcd541e9e --- /dev/null +++ b/plotly/graph_objs/contourcarpet/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contourcarpet.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.contourcarpet.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.contourcarpet.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contourcarpet.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.contourcarpet.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contourcarpet.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.contourcarpet.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/_contours.py b/plotly/graph_objs/contourcarpet/_contours.py new file mode 100644 index 0000000000..73e223921a --- /dev/null +++ b/plotly/graph_objs/contourcarpet/_contours.py @@ -0,0 +1,496 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Contours(BaseTraceHierarchyType): + + # coloring + # -------- + @property + def coloring(self): + """ + Determines the coloring method showing the contour values. If + *fill*, coloring is done evenly between each contour level If + *lines*, coloring is done on the contour lines. If *none*, no + coloring is applied on this trace. + + The 'coloring' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fill', 'lines', 'none'] + + Returns + ------- + Any + """ + return self['coloring'] + + @coloring.setter + def coloring(self, val): + self['coloring'] = val + + # end + # --- + @property + def end(self): + """ + Sets the end contour level value. Must be more than + `contours.start` + + The 'end' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # labelfont + # --------- + @property + def labelfont(self): + """ + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + The 'labelfont' property is an instance of Labelfont + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.contours.Labelfont + - A dict of string/value properties that will be passed + to the Labelfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.contourcarpet.contours.Labelfont + """ + return self['labelfont'] + + @labelfont.setter + def labelfont(self, val): + self['labelfont'] = val + + # labelformat + # ----------- + @property + def labelformat(self): + """ + Sets the contour label formatting rule using d3 formatting + mini-language which is very similar to Python, see: https://git + hub.com/d3/d3-format/blob/master/README.md#locale_format. + + The 'labelformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelformat'] + + @labelformat.setter + def labelformat(self, val): + self['labelformat'] = val + + # operation + # --------- + @property + def operation(self): + """ + Sets the constraint operation. *=* keeps regions equal to + `value` *<* and *<=* keep regions less than `value` *>* and + *>=* keep regions greater than `value` *[]*, *()*, *[)*, and + *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, + *](*, *)[* keep regions outside `value[0]` to value[1]` Open + vs. closed intervals make no difference to constraint display, + but all versions are allowed for consistency with filter + transforms. + + The 'operation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', + ')(', '](', ')['] + + Returns + ------- + Any + """ + return self['operation'] + + @operation.setter + def operation(self, val): + self['operation'] = val + + # showlabels + # ---------- + @property + def showlabels(self): + """ + Determines whether to label the contour lines with their + values. + + The 'showlabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlabels'] + + @showlabels.setter + def showlabels(self, val): + self['showlabels'] = val + + # showlines + # --------- + @property + def showlines(self): + """ + Determines whether or not the contour lines are drawn. Has an + effect only if `contours.coloring` is set to *fill*. + + The 'showlines' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlines'] + + @showlines.setter + def showlines(self, val): + self['showlines'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step between each contour level. Must be positive. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting contour level value. Must be less than + `contours.end` + + The 'start' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # type + # ---- + @property + def type(self): + """ + If `levels`, the data is represented as a contour plot with + multiple levels displayed. If `constraint`, the data is + represented as constraints with the invalid region shaded as + specified by the `operation` and `value` parameters. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['levels', 'constraint'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value or values of the constraint boundary. When + `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of + two numbers where the first is the lower bound and the second + is the upper bound. + + The 'value' property accepts values of any type + + Returns + ------- + Any + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *lines*, coloring is done on the + contour lines. If *none*, no coloring is applied on + this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + """ + + def __init__( + self, + arg=None, + coloring=None, + end=None, + labelfont=None, + labelformat=None, + operation=None, + showlabels=None, + showlines=None, + size=None, + start=None, + type=None, + value=None, + **kwargs + ): + """ + Construct a new Contours object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contourcarpet.Contours + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *lines*, coloring is done on the + contour lines. If *none*, no coloring is applied on + this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + + Returns + ------- + Contours + """ + super(Contours, self).__init__('contours') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.Contours +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.Contours""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet import (contours as v_contours) + + # Initialize validators + # --------------------- + self._validators['coloring'] = v_contours.ColoringValidator() + self._validators['end'] = v_contours.EndValidator() + self._validators['labelfont'] = v_contours.LabelfontValidator() + self._validators['labelformat'] = v_contours.LabelformatValidator() + self._validators['operation'] = v_contours.OperationValidator() + self._validators['showlabels'] = v_contours.ShowlabelsValidator() + self._validators['showlines'] = v_contours.ShowlinesValidator() + self._validators['size'] = v_contours.SizeValidator() + self._validators['start'] = v_contours.StartValidator() + self._validators['type'] = v_contours.TypeValidator() + self._validators['value'] = v_contours.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('coloring', None) + self.coloring = coloring if coloring is not None else v + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('labelfont', None) + self.labelfont = labelfont if labelfont is not None else v + v = arg.pop('labelformat', None) + self.labelformat = labelformat if labelformat is not None else v + v = arg.pop('operation', None) + self.operation = operation if operation is not None else v + v = arg.pop('showlabels', None) + self.showlabels = showlabels if showlabels is not None else v + v = arg.pop('showlines', None) + self.showlines = showlines if showlines is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/_hoverlabel.py b/plotly/graph_objs/contourcarpet/_hoverlabel.py new file mode 100644 index 0000000000..bc4295c5f2 --- /dev/null +++ b/plotly/graph_objs/contourcarpet/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.contourcarpet.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.contourcarpet.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/_line.py b/plotly/graph_objs/contourcarpet/_line.py new file mode 100644 index 0000000000..91b9768f61 --- /dev/null +++ b/plotly/graph_objs/contourcarpet/_line.py @@ -0,0 +1,237 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour level. Has no if + `contours.coloring` is set to *lines*. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Sets the amount of smoothing for the contour lines, where *0* + corresponds to no smoothing. + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour level. Has no if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contourcarpet.Line + color + Sets the color of the contour level. Has no if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.Line +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/_stream.py b/plotly/graph_objs/contourcarpet/_stream.py new file mode 100644 index 0000000000..2d6c08fa7b --- /dev/null +++ b/plotly/graph_objs/contourcarpet/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.contourcarpet.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.Stream +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/colorbar/__init__.py b/plotly/graph_objs/contourcarpet/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/contourcarpet/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/contourcarpet/colorbar/_tickfont.py b/plotly/graph_objs/contourcarpet/colorbar/_tickfont.py new file mode 100644 index 0000000000..14f91bb71b --- /dev/null +++ b/plotly/graph_objs/contourcarpet/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/colorbar/_tickformatstop.py b/plotly/graph_objs/contourcarpet/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..94ed42f28a --- /dev/null +++ b/plotly/graph_objs/contourcarpet/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/colorbar/_titlefont.py b/plotly/graph_objs/contourcarpet/colorbar/_titlefont.py new file mode 100644 index 0000000000..e4d2ecc520 --- /dev/null +++ b/plotly/graph_objs/contourcarpet/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/contours/__init__.py b/plotly/graph_objs/contourcarpet/contours/__init__.py new file mode 100644 index 0000000000..4729349bff --- /dev/null +++ b/plotly/graph_objs/contourcarpet/contours/__init__.py @@ -0,0 +1 @@ +from ._labelfont import Labelfont diff --git a/plotly/graph_objs/contourcarpet/contours/_labelfont.py b/plotly/graph_objs/contourcarpet/contours/_labelfont.py new file mode 100644 index 0000000000..dc21966d3f --- /dev/null +++ b/plotly/graph_objs/contourcarpet/contours/_labelfont.py @@ -0,0 +1,222 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Labelfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Labelfont object + + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.contours.Labelfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Labelfont + """ + super(Labelfont, self).__init__('labelfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.contours.Labelfont +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.contours.Labelfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet.contours import ( + labelfont as v_labelfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_labelfont.ColorValidator() + self._validators['family'] = v_labelfont.FamilyValidator() + self._validators['size'] = v_labelfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/contourcarpet/hoverlabel/__init__.py b/plotly/graph_objs/contourcarpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/contourcarpet/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/contourcarpet/hoverlabel/_font.py b/plotly/graph_objs/contourcarpet/hoverlabel/_font.py new file mode 100644 index 0000000000..797387241d --- /dev/null +++ b/plotly/graph_objs/contourcarpet/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'contourcarpet.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.contourcarpet.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.contourcarpet.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.contourcarpet.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.contourcarpet.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/graph_objs.py b/plotly/graph_objs/graph_objs.py index b7a21604d9..60189f9431 100644 --- a/plotly/graph_objs/graph_objs.py +++ b/plotly/graph_objs/graph_objs.py @@ -1,2054 +1 @@ -""" -graph_objs -========== - -A module that understands plotly language and can manage the json -structures. This module defines two base classes: PlotlyList and PlotlyDict. -The former inherits from `list` and the latter inherits from `dict`. and is -A third structure, PlotlyTrace, is also considered a base class for all -subclassing 'trace' objects like Scatter, Box, Bar, etc. It is also not meant -to instantiated by users. - -Goals of this module: ---------------------- - -* A dict/list with the same entries as a PlotlyDict/PlotlyList should look -exactly the same once a call is made to plot. - -* Only mutate object structure when users ASK for it. (some magic now...) - -* It should always be possible to get a dict/list JSON representation from a -graph_objs object and it should always be possible to make a graph_objs object -from a dict/list JSON representation. - -""" -from __future__ import absolute_import - -import copy -import re -import warnings -from collections import OrderedDict - -import six - -from plotly import exceptions, graph_reference -from plotly.graph_objs import graph_objs_tools - -_subplot_regex = re.compile(r'(?P\d+$)') - - -class PlotlyBase(object): - """ - Base object for PlotlyList and PlotlyDict. - - """ - _name = None - _parent = None - _parent_key = None - - def _get_path(self): - """ - Get a tuple of the str keys and int indices for this object's path. - - :return: (tuple) - - """ - path = [] - parents = self._get_parents() - parents.reverse() - children = [self] + parents[:-1] - for parent, child in zip(parents, children): - path.append(child._parent_key) - path.reverse() - return tuple(path) - - def _get_parents(self): - """ - Get a list of all the parent objects above this one. - - :return: (list[PlotlyBase]) - - """ - parents = [] - parent = self._parent - while parent is not None: - parents.append(parent) - parent = parent._parent - parents.reverse() - return parents - - def _get_parent_object_names(self): - """ - Get a list of the names of the parent objects above this one. - - :return: (list[str]) - - """ - parents = self._get_parents() - return [parent._name for parent in parents] - - def _get_class_name(self): - """For convenience. See `graph_reference.object_name_to_class_name`.""" - return graph_reference.object_name_to_class_name(self._name) - - def help(self, return_help=False): - """ - Print a help string for this object. - - :param (bool) return_help: Return help string instead of prining? - :return: (None|str) Optionally can return help string. - - """ - object_name = self._name - path = self._get_path() - parent_object_names = self._get_parent_object_names() - help_string = graph_objs_tools.get_help(object_name, path, - parent_object_names) - if return_help: - return help_string - print(help_string) - - def to_graph_objs(self, **kwargs): - """Everything is cast into graph_objs. Here for backwards compat.""" - pass - - def validate(self): - """Everything is *always* validated now. Keep for backwards compat.""" - pass - - -class PlotlyList(list, PlotlyBase): - """ - Base class for list-like Plotly objects. - - """ - _name = None - - def __init__(self, *args, **kwargs): - _raise = kwargs.get('_raise', True) - if self._name is None: - self.__dict__['_name'] = kwargs.pop('_name', None) - self.__dict__['_parent'] = kwargs.get('_parent') - self.__dict__['_parent_key'] = kwargs.get('_parent_key') - - if self._name is None: - raise exceptions.PlotlyError( - "PlotlyList is a base class. It's shouldn't be instantiated." - ) - - if args and isinstance(args[0], dict): - note = ( - "Just like a `list`, `{name}` must be instantiated " - "with a *single* collection.\n" - "In other words these are OK:\n" - ">>> {name}()\n" - ">>> {name}([])\n" - ">>> {name}([dict()])\n" - ">>> {name}([dict(), dict()])\n" - "However, these don't make sense:\n" - ">>> {name}(dict())\n" - ">>> {name}(dict(), dict())" - .format(name=self._get_class_name()) - ) - raise exceptions.PlotlyListEntryError(self, [0], notes=[note]) - - super(PlotlyList, self).__init__() - - for index, value in enumerate(list(*args)): - value = self._value_to_graph_object(index, value, _raise=_raise) - - if isinstance(value, PlotlyBase): - self.append(value) - - def __setitem__(self, index, value, _raise=True): - """Override to enforce validation.""" - if not isinstance(index, int): - if _raise: - index_type = type(index) - raise TypeError('Index must be int, not {}'.format(index_type)) - return - - if index >= len(self): - raise IndexError(index) - - value = self._value_to_graph_object(index, value, _raise=_raise) - if isinstance(value, (PlotlyDict, PlotlyList)): - super(PlotlyList, self).__setitem__(index, value) - - def __setattr__(self, key, value): - raise exceptions.PlotlyError('Setting attributes on a PlotlyList is ' - 'not allowed') - - def __iadd__(self, other): - """Defines the `+=` operator, which we map to extend.""" - self.extend(other) - return self - - def __copy__(self): - - # TODO: https://github.com/plotly/python-api/issues/291 - return GraphObjectFactory.create(self._name, _parent=self._parent, - _parent_key=self._parent_key, *self) - - def __deepcopy__(self, memodict={}): - - # TODO: https://github.com/plotly/python-api/issues/291 - return self.__copy__() - - def _value_to_graph_object(self, index, value, _raise=True): - """ - Attempt to change the given value into a graph object. - - If _raise is False, this won't raise. If the entry can't be converted, - `None` is returned, meaning the caller should ignore the value or - discard it as a failed conversion. - - :param (dict) value: A dict to be converted into a graph object. - :param (bool) _raise: If False, ignore bad values instead of raising. - :return: (PlotlyBase|None) The graph object or possibly `None`. - - """ - if not isinstance(value, dict): - if _raise: - path = self._get_path() + (index, ) - raise exceptions.PlotlyListEntryError(self, path) - else: - return - - items = graph_reference.ARRAYS[self._name]['items'] - for i, item in enumerate(items, 1): - try: - return GraphObjectFactory.create(item, _raise=_raise, - _parent=self, - _parent_key=index, **value) - except exceptions.PlotlyGraphObjectError: - if i == len(items) and _raise: - raise - - def append(self, value): - """Override to enforce validation.""" - index = len(self) # used for error messages - value = self._value_to_graph_object(index, value) - super(PlotlyList, self).append(value) - - def extend(self, iterable): - """Override to enforce validation.""" - for value in iterable: - index = len(self) - value = self._value_to_graph_object(index, value) - super(PlotlyList, self).append(value) - - def insert(self, index, value): - """Override to enforce validation.""" - value = self._value_to_graph_object(index, value) - super(PlotlyList, self).insert(index, value) - - def update(self, changes, make_copies=False): - """ - Update current list with changed_list, which must be iterable. - - :param (dict|list[dict]) changes: - :param (bool) make_copies: - - Because mutable objects contain references to their values, updating - multiple items in a list will cause the items to all reference the same - original set of objects. To change this behavior add - `make_copies=True` which makes deep copies of the update items and - therefore break references. - - """ - if isinstance(changes, dict): - changes = [changes] - for index in range(len(self)): - try: - update = changes[index % len(changes)] - except ZeroDivisionError: - pass - else: - if make_copies: - self[index].update(copy.deepcopy(update)) - else: - self[index].update(update) - - def strip_style(self): - """Strip style by calling `stip_style` on children items.""" - for plotly_dict in self: - plotly_dict.strip_style() - - def get_data(self, flatten=False): - """ - Returns the JSON for the plot with non-data elements stripped. - - :param (bool) flatten: {'a': {'b': ''}} --> {'a.b': ''} - :returns: (dict|list) Depending on (flat|unflat) - - """ - l = list() - for plotly_dict in self: - l += [plotly_dict.get_data(flatten=flatten)] - del_indicies = [index for index, item in enumerate(self) - if len(item) == 0] - del_ct = 0 - for index in del_indicies: - del self[index - del_ct] - del_ct += 1 - - if flatten: - d = {} - for i, e in enumerate(l): - for k, v in e.items(): - key = "{0}.{1}".format(i, k) - d[key] = v - return d - else: - return l - - def get_ordered(self, **kwargs): - """All children are already validated. Just use get_ordered on them.""" - return [child.get_ordered() for child in self] - - def to_string(self, level=0, indent=4, eol='\n', - pretty=True, max_chars=80): - """Get formatted string by calling `to_string` on children items.""" - if not len(self): - return "{name}()".format(name=self._get_class_name()) - string = "{name}([{eol}{indent}".format( - name=self._get_class_name(), - eol=eol, - indent=' ' * indent * (level + 1)) - for index, entry in enumerate(self): - string += entry.to_string(level=level+1, - indent=indent, - eol=eol, - pretty=pretty, - max_chars=max_chars) - if index < len(self) - 1: - string += ",{eol}{indent}".format( - eol=eol, - indent=' ' * indent * (level + 1)) - string += ( - "{eol}{indent}])").format(eol=eol, indent=' ' * indent * level) - return string - - def force_clean(self, **kwargs): - """Remove empty/None values by calling `force_clean()` on children.""" - for entry in self: - entry.force_clean() - del_indicies = [index for index, item in enumerate(self) - if len(item) == 0] - del_ct = 0 - for index in del_indicies: - del self[index - del_ct] - del_ct += 1 - - -class PlotlyDict(dict, PlotlyBase): - """ - Base class for dict-like Plotly objects. - - """ - _name = None - _parent_key = None - _valid_attributes = None - _deprecated_attributes = None - _subplot_attributes = None - - def __init__(self, *args, **kwargs): - - _raise = kwargs.pop('_raise', True) - if self._name is None: - self.__dict__['_name'] = kwargs.pop('_name', None) - self.__dict__['_parent'] = kwargs.pop('_parent', None) - self.__dict__['_parent_key'] = kwargs.pop('_parent_key', None) - - if self._name is None: - raise exceptions.PlotlyError( - "PlotlyDict is a base class. It's shouldn't be instantiated." - ) - - super(PlotlyDict, self).__init__() - - if self._name in graph_reference.TRACE_NAMES: - self['type'] = self._name - - # force key-value pairs to go through validation - d = {key: val for key, val in dict(*args, **kwargs).items()} - for key, val in d.items(): - self.__setitem__(key, val, _raise=_raise) - - def __dir__(self): - """Dynamically return the existing and possible attributes.""" - return sorted(list(self._get_valid_attributes())) - - def __getitem__(self, key): - """Calls __missing__ when key is not found. May mutate object.""" - if key not in self: - self.__missing__(key) - return super(PlotlyDict, self).__getitem__(key) - - def __setattr__(self, key, value): - """Maps __setattr__ onto __setitem__""" - self.__setitem__(key, value) - - def __setitem__(self, key, value, _raise=True): - """Validates/Converts values which should be Graph Objects.""" - if not isinstance(key, six.string_types): - if _raise: - raise TypeError('Key must be string, not {}'.format(type(key))) - return - - if key.endswith('src'): - if key in self._get_valid_attributes(): - value = graph_objs_tools.assign_id_to_src(key, value) - return super(PlotlyDict, self).__setitem__(key, value) - - subplot_key = self._get_subplot_key(key) - if subplot_key is not None: - value = self._value_to_graph_object(subplot_key, value, - _raise=_raise) - if isinstance(value, (PlotlyDict, PlotlyList)): - return super(PlotlyDict, self).__setitem__(key, value) - - if key not in self._get_valid_attributes(): - - if key in self._get_deprecated_attributes(): - warnings.warn( - "Oops! '{attribute}' has been deprecated in " - "'{object_name}'\nThis may still work, but you should " - "update your code when possible.\n\n" - "Run `.help('{attribute}')` for more information." - .format(attribute=key, object_name=self._name) - ) - - # this means deprecated attrs get set *as-is*! - return super(PlotlyDict, self).__setitem__(key, value) - else: - if _raise: - path = self._get_path() + (key, ) - raise exceptions.PlotlyDictKeyError(self, path) - return - - if self._get_attribute_role(key) == 'object': - value = self._value_to_graph_object(key, value, _raise=_raise) - if not isinstance(value, (PlotlyDict, PlotlyList)): - return - - super(PlotlyDict, self).__setitem__(key, value) - - def __getattr__(self, key): - """Python only calls this when key is missing!""" - try: - return self.__getitem__(key) - except KeyError: - raise AttributeError(key) - - def __copy__(self): - - # TODO: https://github.com/plotly/python-api/issues/291 - return GraphObjectFactory.create(self._name, _parent=self.parent, - _parent_key=self._parent_key, **self) - - def __deepcopy__(self, memodict={}): - - # TODO: https://github.com/plotly/python-api/issues/291 - return self.__copy__() - - def __missing__(self, key): - """Mimics defaultdict. This is called from __getitem__ when key DNE.""" - if key in self._get_valid_attributes(): - if self._get_attribute_role(key) == 'object': - value = GraphObjectFactory.create(key, _parent=self, - _parent_key=key) - return super(PlotlyDict, self).__setitem__(key, value) - - subplot_key = self._get_subplot_key(key) - if subplot_key is not None: - value = GraphObjectFactory.create(subplot_key, _parent=self, - _parent_key=key) - super(PlotlyDict, self).__setitem__(key, value) - - def _get_attribute_role(self, key, value=None): - """See `graph_reference.get_role`.""" - object_name = self._name - parent_object_names = self._get_parent_object_names() - return graph_reference.get_role( - object_name, key, value=value, - parent_object_names=parent_object_names - ) - - def _get_valid_attributes(self): - """See `graph_reference.get_valid_attributes`.""" - if self._valid_attributes is None: - parent_object_names = self._get_parent_object_names() - valid_attributes = graph_reference.get_valid_attributes( - self._name, parent_object_names - ) - self.__dict__['_valid_attributes'] = valid_attributes - return self._valid_attributes - - def _get_deprecated_attributes(self): - """See `graph_reference.get_deprecated_attributes`.""" - if self._deprecated_attributes is None: - parent_object_names = self._get_parent_object_names() - deprecated_attributes = graph_reference.get_deprecated_attributes( - self._name, parent_object_names - ) - self.__dict__['_deprecated_attributes'] = deprecated_attributes - return self._deprecated_attributes - - def _get_subplot_attributes(self): - """See `graph_reference.get_subplot_attributes`.""" - if self._subplot_attributes is None: - parent_object_names = self._get_parent_object_names() - subplot_attributes = graph_reference.get_subplot_attributes( - self._name, parent_object_names - ) - self.__dict__['_subplot_attributes'] = subplot_attributes - return self._subplot_attributes - - def _get_subplot_key(self, key): - """Some keys can have appended integers, this handles that.""" - match = _subplot_regex.search(key) - if match: - root_key = key[:match.start()] - if (root_key in self._get_subplot_attributes() and - not match.group('digits').startswith('0')): - return root_key - - def _value_to_graph_object(self, key, value, _raise=True): - """ - Attempt to convert value to graph object. - - :param (str|unicode) key: Should be an object_name from GRAPH_REFERENCE - :param (dict) value: This will fail if it's not a dict. - :param (bool) _raise: Flag to prevent inappropriate erring. - - :return: (PlotlyList|PlotlyDict|None) `None` if `_raise` and failure. - - """ - if key in graph_reference.ARRAYS: - val_types = (list, ) - else: - val_types = (dict, ) - - if not isinstance(value, val_types): - if _raise: - path = self._get_path() + (key, ) - raise exceptions.PlotlyDictValueError(self, path) - else: - return - - # this can be `None` when `_raise == False` - return GraphObjectFactory.create(key, value, _raise=_raise, - _parent=self, _parent_key=key) - - def help(self, attribute=None, return_help=False): - """ - Print help string for this object or an attribute of this object. - - :param (str) attribute: A valid attribute string for this object. - :param (bool) return_help: Return help_string instead of printing it? - :return: (None|str) - - """ - if not attribute: - return super(PlotlyDict, self).help(return_help=return_help) - - object_name = self._name - path = self._get_path() - parent_object_names = self._get_parent_object_names() - help_string = graph_objs_tools.get_help(object_name, path, - parent_object_names, attribute) - - if return_help: - return help_string - print(help_string) - - def update(self, dict1=None, **dict2): - """ - Update current dict with dict1 and then dict2. - - This recursively updates the structure of the original dictionary-like - object with the new entries in the second and third objects. This - allows users to update with large, nested structures. - - Note, because the dict2 packs up all the keyword arguments, you can - specify the changes as a list of keyword arguments. - - Examples: - # update with dict - obj = Layout(title='my title', xaxis=XAxis(range=[0,1], domain=[0,1])) - update_dict = dict(title='new title', xaxis=dict(domain=[0,.8])) - obj.update(update_dict) - obj - {'title': 'new title', 'xaxis': {'range': [0,1], 'domain': [0,.8]}} - - # update with list of keyword arguments - obj = Layout(title='my title', xaxis=XAxis(range=[0,1], domain=[0,1])) - obj.update(title='new title', xaxis=dict(domain=[0,.8])) - obj - {'title': 'new title', 'xaxis': {'range': [0,1], 'domain': [0,.8]}} - - This 'fully' supports duck-typing in that the call signature is - identical, however this differs slightly from the normal update - method provided by Python's dictionaries. - - """ - if dict1 is not None: - for key, val in list(dict1.items()): - if key in self: - if isinstance(self[key], (PlotlyDict, PlotlyList)): - self[key].update(val) - else: - self[key] = val - else: - self[key] = val - - if len(dict2): - for key, val in list(dict2.items()): - if key in self: - if isinstance(self[key], (PlotlyDict, PlotlyList)): - self[key].update(val) - else: - self[key] = val - else: - self[key] = val - - def strip_style(self): - """ - Recursively strip style from the current representation. - - All PlotlyDicts and PlotlyLists are guaranteed to survive the - stripping process, though they made be left empty. This is allowable. - - Keys that will be stripped in this process are tagged with - `'type': 'style'` in graph_objs_meta.json. Note that a key tagged as - style, but with an array as a value may still be considered data. - - """ - keys = list(self.keys()) - for key in keys: - if isinstance(self[key], (PlotlyDict, PlotlyList)): - self[key].strip_style() - else: - if self._get_attribute_role(key, value=self[key]) == 'style': - del self[key] - - # this is for backwards compat when we updated graph reference. - elif self._name == 'layout' and key == 'autosize': - del self[key] - - def get_data(self, flatten=False): - """Returns the JSON for the plot with non-data elements stripped.""" - d = dict() - for key, val in list(self.items()): - if isinstance(val, (PlotlyDict, PlotlyList)): - sub_data = val.get_data(flatten=flatten) - if flatten: - for sub_key, sub_val in sub_data.items(): - key_string = "{0}.{1}".format(key, sub_key) - d[key_string] = sub_val - else: - d[key] = sub_data - else: - if self._get_attribute_role(key, value=val) == 'data': - d[key] = val - - # we use the name to help make data frames - if self._name in graph_reference.TRACE_NAMES and key == 'name': - d[key] = val - keys = list(d.keys()) - for key in keys: - if isinstance(d[key], (dict, list)): - if len(d[key]) == 0: - del d[key] - return d - - def get_ordered(self, **kwargs): - """Return a predictable, OrderedDict version of self.""" - keys = sorted(self.keys(), key=graph_objs_tools.sort_keys) - ordered = OrderedDict() - for key in keys: - if isinstance(self[key], PlotlyBase): - ordered[key] = self[key].get_ordered() - else: - ordered[key] = self[key] - return ordered - - def to_string(self, level=0, indent=4, eol='\n', - pretty=True, max_chars=80): - """ - Returns a formatted string showing graph_obj constructors. - - :param (int) level: The number of indentations to start with. - :param (int) indent: The indentation amount. - :param (str) eol: The end of line character(s). - :param (bool) pretty: Curtail long list output with a '..' ? - :param (int) max_chars: The max characters per line. - - Example: - - print(obj.to_string()) - - """ - if not len(self): - return "{name}()".format(name=self._get_class_name()) - string = "{name}(".format(name=self._get_class_name()) - if self._name in graph_reference.TRACE_NAMES: - keys = [key for key in self.keys() if key != 'type'] - else: - keys = self.keys() - - keys = sorted(keys, key=graph_objs_tools.sort_keys) - num_keys = len(keys) - - for index, key in enumerate(keys, 1): - string += "{eol}{indent}{key}=".format( - eol=eol, - indent=' ' * indent * (level+1), - key=key) - if isinstance(self[key], PlotlyBase): - string += self[key].to_string(level=level+1, - indent=indent, - eol=eol, - pretty=pretty, - max_chars=max_chars) - else: - if pretty: # curtail representation if too many chars - max_len = (max_chars - - indent*(level + 1) - - len(key + "=") - - len(eol)) - if index < num_keys: - max_len -= len(',') # remember the comma! - if isinstance(self[key], list): - s = "[]" - for iii, entry in enumerate(self[key], 1): - if iii < len(self[key]): - s_sub = graph_objs_tools.curtail_val_repr( - entry, - max_chars=max_len - len(s), - add_delim=True - ) - else: - s_sub = graph_objs_tools.curtail_val_repr( - entry, - max_chars=max_len - len(s), - add_delim=False - ) - s = s[:-1] + s_sub + s[-1] - if len(s) == max_len: - break - string += s - else: - string += graph_objs_tools.curtail_val_repr( - self[key], max_len) - else: # they want it all! - string += repr(self[key]) - if index < num_keys: - string += "," - string += "{eol}{indent})".format(eol=eol, indent=' ' * indent * level) - return string - - def force_clean(self, **kwargs): - """Recursively remove empty/None values.""" - keys = list(self.keys()) - for key in keys: - try: - self[key].force_clean() - except AttributeError: - pass - if isinstance(self[key], (dict, list)): - if len(self[key]) == 0: - del self[key] # clears empty collections! - elif self[key] is None: - del self[key] - - -class GraphObjectFactory(object): - """GraphObject creation in this module should run through this factory.""" - - @staticmethod - def create(object_name, *args, **kwargs): - """ - Create a graph object from the OBJECTS dict by name, args, and kwargs. - - :param (str) object_name: A valid object name from OBJECTS. - :param args: Arguments to pass to class constructor. - :param kwargs: Keyword arguments to pass to class constructor. - - :return: (PlotlyList|PlotlyDict) The instantiated graph object. - - """ - is_array = object_name in graph_reference.ARRAYS - is_object = object_name in graph_reference.OBJECTS - if not (is_array or is_object): - raise exceptions.PlotlyError( - "'{}' is not a valid object name.".format(object_name) - ) - - # We patch Figure and Data, so they actually require the subclass. - class_name = graph_reference.OBJECT_NAME_TO_CLASS_NAME.get(object_name) - if class_name in ['Figure', 'Data', 'Frames']: - return globals()[class_name](*args, **kwargs) - else: - kwargs['_name'] = object_name - if is_array: - return PlotlyList(*args, **kwargs) - else: - return PlotlyDict(*args, **kwargs) - - -# AUTO-GENERATED BELOW. DO NOT EDIT! See makefile. - - -class AngularAxis(PlotlyDict): - """ - Valid attributes for 'angularaxis' at path [] under parents (): - - ['categoryarray', 'categoryarraysrc', 'categoryorder', 'color', - 'direction', 'domain', 'dtick', 'endpadding', 'exponentformat', - 'gridcolor', 'gridwidth', 'hoverformat', 'layer', 'linecolor', - 'linewidth', 'nticks', 'period', 'range', 'rotation', - 'separatethousands', 'showexponent', 'showgrid', 'showline', - 'showticklabels', 'showtickprefix', 'showticksuffix', 'thetaunit', - 'tick0', 'tickangle', 'tickcolor', 'tickfont', 'tickformat', - 'tickformatstops', 'ticklen', 'tickmode', 'tickorientation', - 'tickprefix', 'ticks', 'ticksuffix', 'ticktext', 'ticktextsrc', - 'tickvals', 'tickvalssrc', 'tickwidth', 'type', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'angularaxis' - - -class Annotation(PlotlyDict): - """ - Valid attributes for 'annotation' at path [] under parents (): - - ['align', 'arrowcolor', 'arrowhead', 'arrowside', 'arrowsize', - 'arrowwidth', 'ax', 'axref', 'ay', 'ayref', 'bgcolor', 'bordercolor', - 'borderpad', 'borderwidth', 'captureevents', 'clicktoshow', 'font', - 'height', 'hoverlabel', 'hovertext', 'opacity', 'ref', 'showarrow', - 'standoff', 'startarrowhead', 'startarrowsize', 'startstandoff', - 'text', 'textangle', 'valign', 'visible', 'width', 'x', 'xanchor', - 'xclick', 'xref', 'xshift', 'y', 'yanchor', 'yclick', 'yref', 'yshift', - 'z'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'annotation' - - -class Annotations(PlotlyList): - """ - Valid items for 'annotations' at path [] under parents (): - ['Annotation'] - - """ - _name = 'annotations' - - -class Area(PlotlyDict): - """ - Valid attributes for 'area' at path [] under parents (): - - ['customdata', 'customdatasrc', 'hoverinfo', 'hoverinfosrc', - 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'marker', 'name', - 'opacity', 'r', 'rsrc', 'selectedpoints', 'showlegend', 'stream', 't', - 'tsrc', 'type', 'uid', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'area' - - -class Bar(PlotlyDict): - """ - Valid attributes for 'bar' at path [] under parents (): - - ['bardir', 'base', 'basesrc', 'cliponaxis', 'constraintext', - 'customdata', 'customdatasrc', 'dx', 'dy', 'error_x', 'error_y', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hovertext', 'hovertextsrc', - 'ids', 'idssrc', 'insidetextfont', 'legendgroup', 'marker', 'name', - 'offset', 'offsetsrc', 'opacity', 'orientation', 'outsidetextfont', - 'r', 'rsrc', 'selected', 'selectedpoints', 'showlegend', 'stream', 't', - 'text', 'textfont', 'textposition', 'textpositionsrc', 'textsrc', - 'tsrc', 'type', 'uid', 'unselected', 'visible', 'width', 'widthsrc', - 'x', 'x0', 'xaxis', 'xcalendar', 'xsrc', 'y', 'y0', 'yaxis', - 'ycalendar', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'bar' - - -class Box(PlotlyDict): - """ - Valid attributes for 'box' at path [] under parents (): - - ['boxmean', 'boxpoints', 'customdata', 'customdatasrc', 'fillcolor', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hoveron', 'ids', 'idssrc', - 'jitter', 'legendgroup', 'line', 'marker', 'name', 'notched', - 'notchwidth', 'opacity', 'orientation', 'pointpos', 'selected', - 'selectedpoints', 'showlegend', 'stream', 'text', 'textsrc', 'type', - 'uid', 'unselected', 'visible', 'whiskerwidth', 'x', 'x0', 'xaxis', - 'xcalendar', 'xsrc', 'y', 'y0', 'yaxis', 'ycalendar', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'box' - - -class Candlestick(PlotlyDict): - """ - Valid attributes for 'candlestick' at path [] under parents (): - - ['close', 'closesrc', 'customdata', 'customdatasrc', 'decreasing', - 'high', 'highsrc', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', - 'idssrc', 'increasing', 'legendgroup', 'line', 'low', 'lowsrc', 'name', - 'opacity', 'open', 'opensrc', 'selectedpoints', 'showlegend', 'stream', - 'text', 'textsrc', 'type', 'uid', 'visible', 'whiskerwidth', 'x', - 'xaxis', 'xcalendar', 'xsrc', 'yaxis'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'candlestick' - - -class Carpet(PlotlyDict): - """ - Valid attributes for 'carpet' at path [] under parents (): - - ['a', 'a0', 'aaxis', 'asrc', 'b', 'b0', 'baxis', 'bsrc', 'carpet', - 'cheaterslope', 'color', 'customdata', 'customdatasrc', 'da', 'db', - 'font', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', - 'legendgroup', 'name', 'opacity', 'selectedpoints', 'showlegend', - 'stream', 'type', 'uid', 'visible', 'x', 'xaxis', 'xsrc', 'y', 'yaxis', - 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'carpet' - - -class Choropleth(PlotlyDict): - """ - Valid attributes for 'choropleth' at path [] under parents (): - - ['autocolorscale', 'colorbar', 'colorscale', 'customdata', - 'customdatasrc', 'geo', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', - 'ids', 'idssrc', 'legendgroup', 'locationmode', 'locations', - 'locationssrc', 'marker', 'name', 'opacity', 'reversescale', - 'selected', 'selectedpoints', 'showlegend', 'showscale', 'stream', - 'text', 'textsrc', 'type', 'uid', 'unselected', 'visible', 'z', - 'zauto', 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'choropleth' - - -class ColorBar(PlotlyDict): - """ - Valid attributes for 'colorbar' at path [] under parents (): - - ['bgcolor', 'bordercolor', 'borderwidth', 'dtick', 'exponentformat', - 'len', 'lenmode', 'nticks', 'outlinecolor', 'outlinewidth', - 'separatethousands', 'showexponent', 'showticklabels', - 'showtickprefix', 'showticksuffix', 'thickness', 'thicknessmode', - 'tick0', 'tickangle', 'tickcolor', 'tickfont', 'tickformat', - 'tickformatstops', 'ticklen', 'tickmode', 'tickprefix', 'ticks', - 'ticksuffix', 'ticktext', 'ticktextsrc', 'tickvals', 'tickvalssrc', - 'tickwidth', 'title', 'titlefont', 'titleside', 'x', 'xanchor', 'xpad', - 'y', 'yanchor', 'ypad'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'colorbar' - - -class Contour(PlotlyDict): - """ - Valid attributes for 'contour' at path [] under parents (): - - ['autocolorscale', 'autocontour', 'colorbar', 'colorscale', - 'connectgaps', 'contours', 'customdata', 'customdatasrc', 'dx', 'dy', - 'fillcolor', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', - 'idssrc', 'legendgroup', 'line', 'name', 'ncontours', 'opacity', - 'reversescale', 'selectedpoints', 'showlegend', 'showscale', 'stream', - 'text', 'textsrc', 'transpose', 'type', 'uid', 'visible', 'x', 'x0', - 'xaxis', 'xcalendar', 'xsrc', 'xtype', 'y', 'y0', 'yaxis', 'ycalendar', - 'ysrc', 'ytype', 'z', 'zauto', 'zhoverformat', 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'contour' - - -class Contourcarpet(PlotlyDict): - """ - Valid attributes for 'contourcarpet' at path [] under parents (): - - ['a', 'a0', 'asrc', 'atype', 'autocolorscale', 'autocontour', 'b', - 'b0', 'bsrc', 'btype', 'carpet', 'colorbar', 'colorscale', 'contours', - 'customdata', 'customdatasrc', 'da', 'db', 'fillcolor', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'line', - 'name', 'ncontours', 'opacity', 'reversescale', 'selectedpoints', - 'showlegend', 'showscale', 'stream', 'text', 'textsrc', 'transpose', - 'type', 'uid', 'visible', 'xaxis', 'yaxis', 'z', 'zauto', 'zmax', - 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'contourcarpet' - - -class Contours(PlotlyDict): - """ - Valid attributes for 'contours' at path [] under parents (): - - ['coloring', 'end', 'labelfont', 'labelformat', 'operation', - 'showlabels', 'showlines', 'size', 'start', 'type', 'value', 'x', 'y', - 'z'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'contours' - - -class Data(PlotlyList): - """ - Valid items for 'data' at path [] under parents (): - ['Area', 'Bar', 'Box', 'Candlestick', 'Carpet', 'Choropleth', - 'Contour', 'Contourcarpet', 'Heatmap', 'Heatmapgl', 'Histogram', - 'Histogram2d', 'Histogram2dcontour', 'Mesh3d', 'Ohlc', 'Parcoords', - 'Pie', 'Pointcloud', 'Sankey', 'Scatter', 'Scatter3d', 'Scattercarpet', - 'Scattergeo', 'Scattergl', 'Scattermapbox', 'Scatterpolar', - 'Scatterpolargl', 'Scatterternary', 'Splom', 'Surface', 'Table', - 'Violin'] - - """ - _name = 'data' - - def _value_to_graph_object(self, index, value, _raise=True): - - if not isinstance(value, dict): - if _raise: - notes = ['Entry should subclass dict.'] - path = self._get_path() + (index, ) - raise exceptions.PlotlyListEntryError(self, path, - notes=notes) - else: - return - - item = value.get('type', 'scatter') - if item not in graph_reference.ARRAYS['data']['items']: - if _raise: - path = self._get_path() + (0, ) - raise exceptions.PlotlyDataTypeError(self, path) - - return GraphObjectFactory.create(item, _raise=_raise, - _parent=self, - _parent_key=index, **value) - - def get_data(self, flatten=False): - """ - Returns the JSON for the plot with non-data elements stripped. - - :param (bool) flatten: {'a': {'b': ''}} --> {'a.b': ''} - :returns: (dict|list) Depending on (flat|unflat) - - """ - if flatten: - data = [v.get_data(flatten=flatten) for v in self] - d = {} - taken_names = [] - for i, trace in enumerate(data): - - # we want to give the traces helpful names - # however, we need to be sure they're unique too... - trace_name = trace.pop('name', 'trace_{0}'.format(i)) - if trace_name in taken_names: - j = 1 - new_trace_name = "{0}_{1}".format(trace_name, j) - while new_trace_name in taken_names: - new_trace_name = ( - "{0}_{1}".format(trace_name, j) - ) - j += 1 - trace_name = new_trace_name - taken_names.append(trace_name) - - # finish up the dot-concatenation - for k, v in trace.items(): - key = "{0}.{1}".format(trace_name, k) - d[key] = v - return d - else: - return super(Data, self).get_data(flatten=flatten) - - -class ErrorX(PlotlyDict): - """ - Valid attributes for 'error_x' at path [] under parents (): - - ['array', 'arrayminus', 'arrayminussrc', 'arraysrc', 'color', - 'copy_ystyle', 'copy_zstyle', 'opacity', 'symmetric', 'thickness', - 'traceref', 'tracerefminus', 'type', 'value', 'valueminus', 'visible', - 'width'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'error_x' - - -class ErrorY(PlotlyDict): - """ - Valid attributes for 'error_y' at path [] under parents (): - - ['array', 'arrayminus', 'arrayminussrc', 'arraysrc', 'color', - 'copy_zstyle', 'opacity', 'symmetric', 'thickness', 'traceref', - 'tracerefminus', 'type', 'value', 'valueminus', 'visible', 'width'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'error_y' - - -class ErrorZ(PlotlyDict): - """ - Valid attributes for 'error_z' at path [] under parents (): - - ['array', 'arrayminus', 'arrayminussrc', 'arraysrc', 'color', - 'opacity', 'symmetric', 'thickness', 'traceref', 'tracerefminus', - 'type', 'value', 'valueminus', 'visible', 'width'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'error_z' - - -class Figure(PlotlyDict): - """ - Valid attributes for 'figure' at path [] under parents (): - - ['data', 'frames', 'layout'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'figure' - - def __init__(self, *args, **kwargs): - super(Figure, self).__init__(*args, **kwargs) - if 'data' not in self: - self.data = Data(_parent=self, _parent_key='data') - - def get_data(self, flatten=False): - """ - Returns the JSON for the plot with non-data elements stripped. - - Flattening may increase the utility of the result. - - :param (bool) flatten: {'a': {'b': ''}} --> {'a.b': ''} - :returns: (dict|list) Depending on (flat|unflat) - - """ - return self.data.get_data(flatten=flatten) - - def to_dataframe(self): - """ - Create a dataframe with trace names and keys as column names. - - :return: (DataFrame) - - """ - data = self.get_data(flatten=True) - from pandas import DataFrame, Series - return DataFrame( - dict([(k, Series(v)) for k, v in data.items()])) - - def print_grid(self): - """ - Print a visual layout of the figure's axes arrangement. - - This is only valid for figures that are created - with plotly.tools.make_subplots. - - """ - try: - grid_str = self.__dict__['_grid_str'] - except AttributeError: - raise Exception("Use plotly.tools.make_subplots " - "to create a subplot grid.") - print(grid_str) - - def append_trace(self, trace, row, col): - """ - Add a trace to your figure bound to axes at the row, col index. - - The row, col index is generated from figures created with - plotly.tools.make_subplots and can be viewed with - Figure.print_grid. - - :param (dict) trace: The data trace to be bound. - :param (int) row: Subplot row index (see Figure.print_grid). - :param (int) col: Subplot column index (see Figure.print_grid). - - Example: - # stack two subplots vertically - fig = tools.make_subplots(rows=2) - - This is the format of your plot grid: - [ (1,1) x1,y1 ] - [ (2,1) x2,y2 ] - - fig.append_trace(Scatter(x=[1,2,3], y=[2,1,2]), 1, 1) - fig.append_trace(Scatter(x=[1,2,3], y=[2,1,2]), 2, 1) - - """ - try: - grid_ref = self._grid_ref - except AttributeError: - raise Exception("In order to use Figure.append_trace, " - "you must first use " - "plotly.tools.make_subplots " - "to create a subplot grid.") - if row <= 0: - raise Exception("Row value is out of range. " - "Note: the starting cell is (1, 1)") - if col <= 0: - raise Exception("Col value is out of range. " - "Note: the starting cell is (1, 1)") - try: - ref = grid_ref[row-1][col-1] - except IndexError: - raise Exception("The (row, col) pair sent is out of " - "range. Use Figure.print_grid to view the " - "subplot grid. ") - if 'scene' in ref[0]: - trace['scene'] = ref[0] - if ref[0] not in self['layout']: - raise Exception("Something went wrong. " - "The scene object for ({r},{c}) " - "subplot cell " - "got deleted.".format(r=row, c=col)) - else: - xaxis_key = "xaxis{ref}".format(ref=ref[0][1:]) - yaxis_key = "yaxis{ref}".format(ref=ref[1][1:]) - if (xaxis_key not in self['layout'] - or yaxis_key not in self['layout']): - raise Exception("Something went wrong. " - "An axis object for ({r},{c}) subplot " - "cell got deleted." - .format(r=row, c=col)) - trace['xaxis'] = ref[0] - trace['yaxis'] = ref[1] - self['data'] += [trace] - - -class Font(PlotlyDict): - """ - Valid attributes for 'font' at path [] under parents (): - - ['color', 'colorsrc', 'family', 'familysrc', 'size', 'sizesrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'font' - - -class Frames(PlotlyList): - """ - Valid items for 'frames' at path [] under parents (): - ['dict'] - - """ - _name = 'frames' - - def _value_to_graph_object(self, index, value, _raise=True): - if isinstance(value, six.string_types): - return value - return super(Frames, self)._value_to_graph_object(index, value, - _raise=_raise) - - def to_string(self, level=0, indent=4, eol='\n', - pretty=True, max_chars=80): - """Get formatted string by calling `to_string` on children items.""" - if not len(self): - return "{name}()".format(name=self._get_class_name()) - string = "{name}([{eol}{indent}".format( - name=self._get_class_name(), - eol=eol, - indent=' ' * indent * (level + 1)) - for index, entry in enumerate(self): - if isinstance(entry, six.string_types): - string += repr(entry) - else: - string += entry.to_string(level=level+1, - indent=indent, - eol=eol, - pretty=pretty, - max_chars=max_chars) - if index < len(self) - 1: - string += ",{eol}{indent}".format( - eol=eol, - indent=' ' * indent * (level + 1)) - string += ( - "{eol}{indent}])").format(eol=eol, indent=' ' * indent * level) - return string - - -class Heatmap(PlotlyDict): - """ - Valid attributes for 'heatmap' at path [] under parents (): - - ['autocolorscale', 'colorbar', 'colorscale', 'connectgaps', - 'customdata', 'customdatasrc', 'dx', 'dy', 'hoverinfo', 'hoverinfosrc', - 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'name', 'opacity', - 'reversescale', 'selectedpoints', 'showlegend', 'showscale', 'stream', - 'text', 'textsrc', 'transpose', 'type', 'uid', 'visible', 'x', 'x0', - 'xaxis', 'xcalendar', 'xgap', 'xsrc', 'xtype', 'y', 'y0', 'yaxis', - 'ycalendar', 'ygap', 'ysrc', 'ytype', 'z', 'zauto', 'zhoverformat', - 'zmax', 'zmin', 'zsmooth', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'heatmap' - - -class Heatmapgl(PlotlyDict): - """ - Valid attributes for 'heatmapgl' at path [] under parents (): - - ['autocolorscale', 'colorbar', 'colorscale', 'customdata', - 'customdatasrc', 'dx', 'dy', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', - 'ids', 'idssrc', 'legendgroup', 'name', 'opacity', 'reversescale', - 'selectedpoints', 'showlegend', 'showscale', 'stream', 'text', - 'textsrc', 'transpose', 'type', 'uid', 'visible', 'x', 'x0', 'xaxis', - 'xsrc', 'xtype', 'y', 'y0', 'yaxis', 'ysrc', 'ytype', 'z', 'zauto', - 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'heatmapgl' - - -class Histogram(PlotlyDict): - """ - Valid attributes for 'histogram' at path [] under parents (): - - ['autobinx', 'autobiny', 'bardir', 'cumulative', 'customdata', - 'customdatasrc', 'error_x', 'error_y', 'histfunc', 'histnorm', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', - 'legendgroup', 'marker', 'name', 'nbinsx', 'nbinsy', 'opacity', - 'orientation', 'selected', 'selectedpoints', 'showlegend', 'stream', - 'text', 'textsrc', 'type', 'uid', 'unselected', 'visible', 'x', - 'xaxis', 'xbins', 'xcalendar', 'xsrc', 'y', 'yaxis', 'ybins', - 'ycalendar', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'histogram' - - -class Histogram2d(PlotlyDict): - """ - Valid attributes for 'histogram2d' at path [] under parents (): - - ['autobinx', 'autobiny', 'autocolorscale', 'colorbar', 'colorscale', - 'customdata', 'customdatasrc', 'histfunc', 'histnorm', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'marker', - 'name', 'nbinsx', 'nbinsy', 'opacity', 'reversescale', - 'selectedpoints', 'showlegend', 'showscale', 'stream', 'type', 'uid', - 'visible', 'x', 'xaxis', 'xbins', 'xcalendar', 'xgap', 'xsrc', 'y', - 'yaxis', 'ybins', 'ycalendar', 'ygap', 'ysrc', 'z', 'zauto', - 'zhoverformat', 'zmax', 'zmin', 'zsmooth', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'histogram2d' - - -class Histogram2dContour(PlotlyDict): - """ - Valid attributes for 'histogram2dcontour' at path [] under parents (): - - ['autobinx', 'autobiny', 'autocolorscale', 'autocontour', 'colorbar', - 'colorscale', 'contours', 'customdata', 'customdatasrc', 'histfunc', - 'histnorm', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', - 'legendgroup', 'line', 'marker', 'name', 'nbinsx', 'nbinsy', - 'ncontours', 'opacity', 'reversescale', 'selectedpoints', 'showlegend', - 'showscale', 'stream', 'type', 'uid', 'visible', 'x', 'xaxis', 'xbins', - 'xcalendar', 'xsrc', 'y', 'yaxis', 'ybins', 'ycalendar', 'ysrc', 'z', - 'zauto', 'zhoverformat', 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'histogram2dcontour' - - -class Histogram2dcontour(PlotlyDict): - """ - Valid attributes for 'histogram2dcontour' at path [] under parents (): - - ['autobinx', 'autobiny', 'autocolorscale', 'autocontour', 'colorbar', - 'colorscale', 'contours', 'customdata', 'customdatasrc', 'histfunc', - 'histnorm', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', - 'legendgroup', 'line', 'marker', 'name', 'nbinsx', 'nbinsy', - 'ncontours', 'opacity', 'reversescale', 'selectedpoints', 'showlegend', - 'showscale', 'stream', 'type', 'uid', 'visible', 'x', 'xaxis', 'xbins', - 'xcalendar', 'xsrc', 'y', 'yaxis', 'ybins', 'ycalendar', 'ysrc', 'z', - 'zauto', 'zhoverformat', 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'histogram2dcontour' - - -class Layout(PlotlyDict): - """ - Valid attributes for 'layout' at path [] under parents (): - - ['angularaxis', 'annotations', 'autosize', 'bargap', 'bargroupgap', - 'barmode', 'barnorm', 'boxgap', 'boxgroupgap', 'boxmode', 'calendar', - 'colorway', 'datarevision', 'direction', 'dragmode', 'font', 'geo', - 'grid', 'height', 'hiddenlabels', 'hiddenlabelssrc', 'hidesources', - 'hoverdistance', 'hoverlabel', 'hovermode', 'images', 'legend', - 'mapbox', 'margin', 'orientation', 'paper_bgcolor', 'plot_bgcolor', - 'polar', 'radialaxis', 'scene', 'selectdirection', 'separators', - 'shapes', 'showlegend', 'sliders', 'spikedistance', 'ternary', 'title', - 'titlefont', 'updatemenus', 'violingap', 'violingroupgap', - 'violinmode', 'width', 'xaxis', 'yaxis'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'layout' - - -class Legend(PlotlyDict): - """ - Valid attributes for 'legend' at path [] under parents (): - - ['bgcolor', 'bordercolor', 'borderwidth', 'font', 'orientation', - 'tracegroupgap', 'traceorder', 'x', 'xanchor', 'y', 'yanchor'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'legend' - - -class Line(PlotlyDict): - """ - Valid attributes for 'line' at path [] under parents (): - - ['autocolorscale', 'cauto', 'cmax', 'cmin', 'color', 'colorbar', - 'colorscale', 'colorsrc', 'dash', 'outliercolor', 'outlierwidth', - 'reversescale', 'shape', 'showscale', 'simplify', 'smoothing', 'width', - 'widthsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'line' - - -class Margin(PlotlyDict): - """ - Valid attributes for 'margin' at path [] under parents (): - - ['autoexpand', 'b', 'l', 'pad', 'r', 't'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'margin' - - -class Marker(PlotlyDict): - """ - Valid attributes for 'marker' at path [] under parents (): - - ['autocolorscale', 'blend', 'border', 'cauto', 'cmax', 'cmin', 'color', - 'colorbar', 'colors', 'colorscale', 'colorsrc', 'colorssrc', - 'gradient', 'line', 'maxdisplayed', 'opacity', 'opacitysrc', - 'outliercolor', 'reversescale', 'showscale', 'size', 'sizemax', - 'sizemin', 'sizemode', 'sizeref', 'sizesrc', 'symbol', 'symbolsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'marker' - - -class Mesh3d(PlotlyDict): - """ - Valid attributes for 'mesh3d' at path [] under parents (): - - ['alphahull', 'autocolorscale', 'cauto', 'cmax', 'cmin', 'color', - 'colorbar', 'colorscale', 'contour', 'customdata', 'customdatasrc', - 'delaunayaxis', 'facecolor', 'facecolorsrc', 'flatshading', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'i', 'ids', 'idssrc', - 'intensity', 'intensitysrc', 'isrc', 'j', 'jsrc', 'k', 'ksrc', - 'legendgroup', 'lighting', 'lightposition', 'name', 'opacity', - 'reversescale', 'scene', 'selectedpoints', 'showlegend', 'showscale', - 'stream', 'text', 'textsrc', 'type', 'uid', 'vertexcolor', - 'vertexcolorsrc', 'visible', 'x', 'xcalendar', 'xsrc', 'y', - 'ycalendar', 'ysrc', 'z', 'zcalendar', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'mesh3d' - - -class Ohlc(PlotlyDict): - """ - Valid attributes for 'ohlc' at path [] under parents (): - - ['close', 'closesrc', 'customdata', 'customdatasrc', 'decreasing', - 'high', 'highsrc', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', - 'idssrc', 'increasing', 'legendgroup', 'line', 'low', 'lowsrc', 'name', - 'opacity', 'open', 'opensrc', 'selectedpoints', 'showlegend', 'stream', - 'text', 'textsrc', 'tickwidth', 'type', 'uid', 'visible', 'x', 'xaxis', - 'xcalendar', 'xsrc', 'yaxis'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'ohlc' - - -class Parcoords(PlotlyDict): - """ - Valid attributes for 'parcoords' at path [] under parents (): - - ['customdata', 'customdatasrc', 'dimensions', 'domain', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'labelfont', - 'legendgroup', 'line', 'name', 'opacity', 'rangefont', - 'selectedpoints', 'showlegend', 'stream', 'tickfont', 'type', 'uid', - 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'parcoords' - - -class Pie(PlotlyDict): - """ - Valid attributes for 'pie' at path [] under parents (): - - ['customdata', 'customdatasrc', 'direction', 'dlabel', 'domain', - 'hole', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hovertext', - 'hovertextsrc', 'ids', 'idssrc', 'insidetextfont', 'label0', 'labels', - 'labelssrc', 'legendgroup', 'marker', 'name', 'opacity', - 'outsidetextfont', 'pull', 'pullsrc', 'rotation', 'scalegroup', - 'selectedpoints', 'showlegend', 'sort', 'stream', 'text', 'textfont', - 'textinfo', 'textposition', 'textpositionsrc', 'textsrc', 'type', - 'uid', 'values', 'valuessrc', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'pie' - - -class Pointcloud(PlotlyDict): - """ - Valid attributes for 'pointcloud' at path [] under parents (): - - ['customdata', 'customdatasrc', 'hoverinfo', 'hoverinfosrc', - 'hoverlabel', 'ids', 'idssrc', 'indices', 'indicessrc', 'legendgroup', - 'marker', 'name', 'opacity', 'selectedpoints', 'showlegend', 'stream', - 'text', 'textsrc', 'type', 'uid', 'visible', 'x', 'xaxis', 'xbounds', - 'xboundssrc', 'xsrc', 'xy', 'xysrc', 'y', 'yaxis', 'ybounds', - 'yboundssrc', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'pointcloud' - - -class RadialAxis(PlotlyDict): - """ - Valid attributes for 'radialaxis' at path [] under parents (): - - ['angle', 'autorange', 'calendar', 'categoryarray', 'categoryarraysrc', - 'categoryorder', 'color', 'domain', 'dtick', 'endpadding', - 'exponentformat', 'gridcolor', 'gridwidth', 'hoverformat', 'layer', - 'linecolor', 'linewidth', 'nticks', 'orientation', 'range', - 'rangemode', 'separatethousands', 'showexponent', 'showgrid', - 'showline', 'showticklabels', 'showtickprefix', 'showticksuffix', - 'side', 'tick0', 'tickangle', 'tickcolor', 'tickfont', 'tickformat', - 'tickformatstops', 'ticklen', 'tickmode', 'tickorientation', - 'tickprefix', 'ticks', 'ticksuffix', 'ticktext', 'ticktextsrc', - 'tickvals', 'tickvalssrc', 'tickwidth', 'title', 'titlefont', 'type', - 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'radialaxis' - - -class Sankey(PlotlyDict): - """ - Valid attributes for 'sankey' at path [] under parents (): - - ['arrangement', 'customdata', 'customdatasrc', 'domain', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'link', - 'name', 'node', 'opacity', 'orientation', 'selectedpoints', - 'showlegend', 'stream', 'textfont', 'type', 'uid', 'valueformat', - 'valuesuffix', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'sankey' - - -class Scatter(PlotlyDict): - """ - Valid attributes for 'scatter' at path [] under parents (): - - ['cliponaxis', 'connectgaps', 'customdata', 'customdatasrc', 'dx', - 'dy', 'error_x', 'error_y', 'fill', 'fillcolor', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'hoveron', 'hovertext', 'hovertextsrc', - 'ids', 'idssrc', 'legendgroup', 'line', 'marker', 'mode', 'name', - 'opacity', 'r', 'rsrc', 'selected', 'selectedpoints', 'showlegend', - 'stream', 't', 'text', 'textfont', 'textposition', 'textpositionsrc', - 'textsrc', 'tsrc', 'type', 'uid', 'unselected', 'visible', 'x', 'x0', - 'xaxis', 'xcalendar', 'xsrc', 'y', 'y0', 'yaxis', 'ycalendar', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scatter' - - -class Scatter3d(PlotlyDict): - """ - Valid attributes for 'scatter3d' at path [] under parents (): - - ['connectgaps', 'customdata', 'customdatasrc', 'error_x', 'error_y', - 'error_z', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hovertext', - 'hovertextsrc', 'ids', 'idssrc', 'legendgroup', 'line', 'marker', - 'mode', 'name', 'opacity', 'projection', 'scene', 'selectedpoints', - 'showlegend', 'stream', 'surfaceaxis', 'surfacecolor', 'text', - 'textfont', 'textposition', 'textpositionsrc', 'textsrc', 'type', - 'uid', 'visible', 'x', 'xcalendar', 'xsrc', 'y', 'ycalendar', 'ysrc', - 'z', 'zcalendar', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scatter3d' - - -class Scattercarpet(PlotlyDict): - """ - Valid attributes for 'scattercarpet' at path [] under parents (): - - ['a', 'asrc', 'b', 'bsrc', 'carpet', 'connectgaps', 'customdata', - 'customdatasrc', 'fill', 'fillcolor', 'hoverinfo', 'hoverinfosrc', - 'hoverlabel', 'hoveron', 'ids', 'idssrc', 'legendgroup', 'line', - 'marker', 'mode', 'name', 'opacity', 'selected', 'selectedpoints', - 'showlegend', 'stream', 'text', 'textfont', 'textposition', - 'textpositionsrc', 'textsrc', 'type', 'uid', 'unselected', 'visible', - 'xaxis', 'yaxis'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scattercarpet' - - -class Scattergeo(PlotlyDict): - """ - Valid attributes for 'scattergeo' at path [] under parents (): - - ['connectgaps', 'customdata', 'customdatasrc', 'fill', 'fillcolor', - 'geo', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hovertext', - 'hovertextsrc', 'ids', 'idssrc', 'lat', 'latsrc', 'legendgroup', - 'line', 'locationmode', 'locations', 'locationssrc', 'lon', 'lonsrc', - 'marker', 'mode', 'name', 'opacity', 'selected', 'selectedpoints', - 'showlegend', 'stream', 'text', 'textfont', 'textposition', - 'textpositionsrc', 'textsrc', 'type', 'uid', 'unselected', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scattergeo' - - -class Scattergl(PlotlyDict): - """ - Valid attributes for 'scattergl' at path [] under parents (): - - ['connectgaps', 'customdata', 'customdatasrc', 'dx', 'dy', 'error_x', - 'error_y', 'fill', 'fillcolor', 'hoverinfo', 'hoverinfosrc', - 'hoverlabel', 'hoveron', 'ids', 'idssrc', 'legendgroup', 'line', - 'marker', 'mode', 'name', 'opacity', 'selected', 'selectedpoints', - 'showlegend', 'stream', 'text', 'textsrc', 'type', 'uid', 'unselected', - 'visible', 'x', 'x0', 'xaxis', 'xcalendar', 'xsrc', 'y', 'y0', 'yaxis', - 'ycalendar', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scattergl' - - -class Scattermapbox(PlotlyDict): - """ - Valid attributes for 'scattermapbox' at path [] under parents (): - - ['connectgaps', 'customdata', 'customdatasrc', 'fill', 'fillcolor', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hovertext', 'hovertextsrc', - 'ids', 'idssrc', 'lat', 'latsrc', 'legendgroup', 'line', 'lon', - 'lonsrc', 'marker', 'mode', 'name', 'opacity', 'selected', - 'selectedpoints', 'showlegend', 'stream', 'subplot', 'text', - 'textfont', 'textposition', 'textsrc', 'type', 'uid', 'unselected', - 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scattermapbox' - - -class Scatterpolar(PlotlyDict): - """ - Valid attributes for 'scatterpolar' at path [] under parents (): - - ['cliponaxis', 'connectgaps', 'customdata', 'customdatasrc', 'fill', - 'fillcolor', 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hoveron', - 'hovertext', 'hovertextsrc', 'ids', 'idssrc', 'legendgroup', 'line', - 'marker', 'mode', 'name', 'opacity', 'r', 'rsrc', 'selected', - 'selectedpoints', 'showlegend', 'stream', 'subplot', 'text', - 'textfont', 'textposition', 'textpositionsrc', 'textsrc', 'theta', - 'thetasrc', 'thetaunit', 'type', 'uid', 'unselected', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scatterpolar' - - -class Scatterpolargl(PlotlyDict): - """ - Valid attributes for 'scatterpolargl' at path [] under parents (): - - ['connectgaps', 'customdata', 'customdatasrc', 'fill', 'fillcolor', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hoveron', 'ids', 'idssrc', - 'legendgroup', 'line', 'marker', 'mode', 'name', 'opacity', 'r', - 'rsrc', 'selected', 'selectedpoints', 'showlegend', 'stream', - 'subplot', 'text', 'textsrc', 'theta', 'thetasrc', 'thetaunit', 'type', - 'uid', 'unselected', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scatterpolargl' - - -class Scatterternary(PlotlyDict): - """ - Valid attributes for 'scatterternary' at path [] under parents (): - - ['a', 'asrc', 'b', 'bsrc', 'c', 'cliponaxis', 'connectgaps', 'csrc', - 'customdata', 'customdatasrc', 'fill', 'fillcolor', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'hoveron', 'hovertext', 'hovertextsrc', - 'ids', 'idssrc', 'legendgroup', 'line', 'marker', 'mode', 'name', - 'opacity', 'selected', 'selectedpoints', 'showlegend', 'stream', - 'subplot', 'sum', 'text', 'textfont', 'textposition', - 'textpositionsrc', 'textsrc', 'type', 'uid', 'unselected', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scatterternary' - - -class Scene(PlotlyDict): - """ - Valid attributes for 'scene' at path [] under parents (): - - ['annotations', 'aspectmode', 'aspectratio', 'bgcolor', 'camera', - 'cameraposition', 'domain', 'dragmode', 'hovermode', 'xaxis', 'yaxis', - 'zaxis'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'scene' - - -class Splom(PlotlyDict): - """ - Valid attributes for 'splom' at path [] under parents (): - - ['customdata', 'customdatasrc', 'diagonal', 'dimensions', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'legendgroup', 'marker', - 'name', 'opacity', 'selected', 'selectedpoints', 'showlegend', - 'showlowerhalf', 'showupperhalf', 'stream', 'text', 'textsrc', 'type', - 'uid', 'unselected', 'visible', 'xaxes', 'yaxes'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'splom' - - -class Stream(PlotlyDict): - """ - Valid attributes for 'stream' at path [] under parents (): - - ['maxpoints', 'token'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'stream' - - -class Surface(PlotlyDict): - """ - Valid attributes for 'surface' at path [] under parents (): - - ['autocolorscale', 'cauto', 'cmax', 'cmin', 'colorbar', 'colorscale', - 'contours', 'customdata', 'customdatasrc', 'hidesurface', 'hoverinfo', - 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', 'legendgroup', - 'lighting', 'lightposition', 'name', 'opacity', 'reversescale', - 'scene', 'selectedpoints', 'showlegend', 'showscale', 'stream', - 'surfacecolor', 'surfacecolorsrc', 'text', 'textsrc', 'type', 'uid', - 'visible', 'x', 'xcalendar', 'xsrc', 'y', 'ycalendar', 'ysrc', 'z', - 'zauto', 'zcalendar', 'zmax', 'zmin', 'zsrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'surface' - - -class Table(PlotlyDict): - """ - Valid attributes for 'table' at path [] under parents (): - - ['cells', 'columnorder', 'columnordersrc', 'columnwidth', - 'columnwidthsrc', 'customdata', 'customdatasrc', 'domain', 'header', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'ids', 'idssrc', - 'legendgroup', 'name', 'opacity', 'selectedpoints', 'showlegend', - 'stream', 'type', 'uid', 'visible'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'table' - - -class Trace(dict): - pass - - -class Violin(PlotlyDict): - """ - Valid attributes for 'violin' at path [] under parents (): - - ['bandwidth', 'box', 'customdata', 'customdatasrc', 'fillcolor', - 'hoverinfo', 'hoverinfosrc', 'hoverlabel', 'hoveron', 'ids', 'idssrc', - 'jitter', 'legendgroup', 'line', 'marker', 'meanline', 'name', - 'opacity', 'orientation', 'pointpos', 'points', 'scalegroup', - 'scalemode', 'selected', 'selectedpoints', 'showlegend', 'side', - 'span', 'spanmode', 'stream', 'text', 'textsrc', 'type', 'uid', - 'unselected', 'visible', 'x', 'x0', 'xaxis', 'xsrc', 'y', 'y0', - 'yaxis', 'ysrc'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'violin' - - -class XAxis(PlotlyDict): - """ - Valid attributes for 'xaxis' at path [] under parents (): - - ['anchor', 'automargin', 'autorange', 'autotick', 'backgroundcolor', - 'calendar', 'categoryarray', 'categoryarraysrc', 'categoryorder', - 'color', 'constrain', 'constraintoward', 'domain', 'dtick', - 'exponentformat', 'fixedrange', 'gridcolor', 'gridwidth', - 'hoverformat', 'layer', 'linecolor', 'linewidth', 'mirror', 'nticks', - 'overlaying', 'position', 'range', 'rangemode', 'rangeselector', - 'rangeslider', 'scaleanchor', 'scaleratio', 'separatethousands', - 'showaxeslabels', 'showbackground', 'showexponent', 'showgrid', - 'showline', 'showspikes', 'showticklabels', 'showtickprefix', - 'showticksuffix', 'side', 'spikecolor', 'spikedash', 'spikemode', - 'spikesides', 'spikesnap', 'spikethickness', 'tick0', 'tickangle', - 'tickcolor', 'tickfont', 'tickformat', 'tickformatstops', 'ticklen', - 'tickmode', 'tickprefix', 'ticks', 'ticksuffix', 'ticktext', - 'ticktextsrc', 'tickvals', 'tickvalssrc', 'tickwidth', 'title', - 'titlefont', 'type', 'visible', 'zeroline', 'zerolinecolor', - 'zerolinewidth'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'xaxis' - - -class XBins(PlotlyDict): - """ - Valid attributes for 'xbins' at path [] under parents (): - - ['end', 'size', 'start'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'xbins' - - -class YAxis(PlotlyDict): - """ - Valid attributes for 'yaxis' at path [] under parents (): - - ['anchor', 'automargin', 'autorange', 'autotick', 'backgroundcolor', - 'calendar', 'categoryarray', 'categoryarraysrc', 'categoryorder', - 'color', 'constrain', 'constraintoward', 'domain', 'dtick', - 'exponentformat', 'fixedrange', 'gridcolor', 'gridwidth', - 'hoverformat', 'layer', 'linecolor', 'linewidth', 'mirror', 'nticks', - 'overlaying', 'position', 'range', 'rangemode', 'scaleanchor', - 'scaleratio', 'separatethousands', 'showaxeslabels', 'showbackground', - 'showexponent', 'showgrid', 'showline', 'showspikes', 'showticklabels', - 'showtickprefix', 'showticksuffix', 'side', 'spikecolor', 'spikedash', - 'spikemode', 'spikesides', 'spikesnap', 'spikethickness', 'tick0', - 'tickangle', 'tickcolor', 'tickfont', 'tickformat', 'tickformatstops', - 'ticklen', 'tickmode', 'tickprefix', 'ticks', 'ticksuffix', 'ticktext', - 'ticktextsrc', 'tickvals', 'tickvalssrc', 'tickwidth', 'title', - 'titlefont', 'type', 'visible', 'zeroline', 'zerolinecolor', - 'zerolinewidth'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'yaxis' - - -class YBins(PlotlyDict): - """ - Valid attributes for 'ybins' at path [] under parents (): - - ['end', 'size', 'start'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'ybins' - - -class ZAxis(PlotlyDict): - """ - Valid attributes for 'zaxis' at path [] under parents (): - - ['autorange', 'backgroundcolor', 'calendar', 'categoryarray', - 'categoryarraysrc', 'categoryorder', 'color', 'dtick', - 'exponentformat', 'gridcolor', 'gridwidth', 'hoverformat', 'linecolor', - 'linewidth', 'mirror', 'nticks', 'range', 'rangemode', - 'separatethousands', 'showaxeslabels', 'showbackground', - 'showexponent', 'showgrid', 'showline', 'showspikes', 'showticklabels', - 'showtickprefix', 'showticksuffix', 'spikecolor', 'spikesides', - 'spikethickness', 'tick0', 'tickangle', 'tickcolor', 'tickfont', - 'tickformat', 'tickformatstops', 'ticklen', 'tickmode', 'tickprefix', - 'ticks', 'ticksuffix', 'ticktext', 'ticktextsrc', 'tickvals', - 'tickvalssrc', 'tickwidth', 'title', 'titlefont', 'type', 'visible', - 'zeroline', 'zerolinecolor', 'zerolinewidth'] - - Run `.help('attribute')` on any of the above. - '' is the object at [] - - """ - _name = 'zaxis' - -__all__ = [cls for cls in graph_reference.CLASSES.keys() if cls in globals()] +from plotly.graph_objs import * diff --git a/plotly/graph_objs/graph_objs_tools.py b/plotly/graph_objs/graph_objs_tools.py deleted file mode 100644 index fdd4cf7130..0000000000 --- a/plotly/graph_objs/graph_objs_tools.py +++ /dev/null @@ -1,270 +0,0 @@ -from __future__ import absolute_import -import textwrap -import six - -from plotly import exceptions, graph_reference - -# Define line and tab size for help text! -LINE_SIZE = 76 -TAB_SIZE = 4 - - -def get_help(object_name, path=(), parent_object_names=(), attribute=None): - """ - Returns a help string for a graph object. - - :param (str) object_name: An object name from GRAPH_REFERENCE - :param (tuple[str]) path: The path within a `figure` object. - :param parent_object_names: An iterable of names of this object's parents. - :param (str|None) attribute: An attribute of given . - :return: (str) A printable string to show to users. - - """ - if object_name in graph_reference.ARRAYS: - help_string = _list_help(object_name, path, parent_object_names) - else: - if attribute: - help_string = _dict_attribute_help(object_name, path, - parent_object_names, attribute) - else: - help_string = _dict_object_help(object_name, path, - parent_object_names) - return help_string.expandtabs(TAB_SIZE) - - -def _list_help(object_name, path=(), parent_object_names=()): - """See get_help().""" - items = graph_reference.ARRAYS[object_name]['items'] - items_classes = set() - for item in items: - if item in graph_reference.OBJECT_NAME_TO_CLASS_NAME: - items_classes.add(graph_reference.string_to_class_name(item)) - else: - # There are no lists objects which can contain list entries. - items_classes.add('dict') - items_classes = list(items_classes) - items_classes.sort() - lines = textwrap.wrap(repr(items_classes), width=LINE_SIZE-TAB_SIZE-1) - - help_dict = { - 'object_name': object_name, - 'path_string': '[' + ']['.join(repr(k) for k in path) + ']', - 'parent_object_names': parent_object_names, - 'items_string': '\t' + '\n\t'.join(lines) - } - - return ( - "Valid items for '{object_name}' at path {path_string} under parents " - "{parent_object_names}:\n{items_string}\n".format(**help_dict) - ) - - -def _dict_object_help(object_name, path, parent_object_names): - """See get_help().""" - attributes = list( - graph_reference.get_valid_attributes(object_name, parent_object_names)) - attributes.sort() - lines = textwrap.wrap(repr(list(attributes)), width=LINE_SIZE-TAB_SIZE-1) - - help_dict = { - 'object_name': object_name, - 'path_string': '[' + ']['.join(repr(k) for k in path) + ']', - 'parent_object_names': parent_object_names, - 'attributes_string': '\t' + '\n\t'.join(lines) - } - - return ( - "Valid attributes for '{object_name}' at path {path_string} under " - "parents {parent_object_names}:\n\n{attributes_string}\n\n" - "Run `<{object_name}-object>.help('attribute')` on any of the above.\n" - "'<{object_name}-object>' is the object at {path_string}" - .format(**help_dict) - ) - - -def _dict_attribute_help(object_name, path, parent_object_names, attribute): - """ - Get general help information or information on a specific attribute. - - See get_help(). - - :param (str|unicode) attribute: The attribute we'll get info for. - - """ - help_dict = { - 'object_name': object_name, - 'path_string': '[' + ']['.join(repr(k) for k in path) + ']', - 'parent_object_names': parent_object_names, - 'attribute': attribute - } - - valid_attributes = graph_reference.get_valid_attributes( - object_name, parent_object_names - ) - - help_string = ( - "Current path: {path_string}\n" - "Current parent object_names: {parent_object_names}\n\n") - - if attribute not in valid_attributes: - help_string += "'{attribute}' is not allowed here.\n" - return help_string.format(**help_dict) - - attributes_dicts = graph_reference.get_attributes_dicts( - object_name, parent_object_names - ) - - attribute_definitions = [] - additional_definition = None - meta_keys = graph_reference.GRAPH_REFERENCE['defs']['metaKeys'] - trace_names = graph_reference.TRACE_NAMES - for key, attribute_dict in attributes_dicts.items(): - if attribute in attribute_dict: - if object_name in trace_names and attribute == 'type': - d = {'role': 'info'} - else: - d = {k: v for k, v in attribute_dict[attribute].items() - if k in meta_keys and not k.startswith('_')} - elif attribute in attribute_dict.get('_deprecated', {}): - deprecate_attribute_dict = attribute_dict['_deprecated'][attribute] - d = {k: v for k, v in deprecate_attribute_dict.items() - if k in meta_keys and not k.startswith('_')} - d['deprecated'] = True - else: - continue - - if key == 'additional_attributes': - additional_definition = d - continue - - new_definition = True - for item in attribute_definitions: - if item['definition'] == d: - item['paths'].append(key) - new_definition = False - if new_definition: - attribute_definitions.append({'paths': [key], 'definition': d}) - - if attribute_definitions: - help_string += ("With the current parents, '{attribute}' can be " - "used as follows:\n\n") - - help_string = help_string.format(**help_dict) - - for item in attribute_definitions: - valid_parents_objects_names = [ - graph_reference.attribute_path_to_object_names(definition_path) - for definition_path in item['paths'] - ] - - if len(valid_parents_objects_names) == 1: - valid_parent_objects_names = valid_parents_objects_names[0] - help_string += 'Under {}:\n\n'.format( - str(valid_parent_objects_names) - ) - else: - help_string += 'Under any of:\n\t\t* {}\n\n'.format( - '\n\t\t* '.join(str(tup) for tup in valid_parents_objects_names) - ) - - for meta_key, val in sorted(item['definition'].items()): - help_string += '\t{}: '.format(meta_key) - if meta_key == 'description': - - # TODO: https://github.com/plotly/streambed/issues/3950 - if isinstance(val, list) and attribute == 'showline': - val = val[0] - - lines = textwrap.wrap(val, width=LINE_SIZE-1) - help_string += '\n\t\t'.join(lines) - else: - help_string += '{}'.format(val) - help_string += '\n' - help_string += '\n\n' - - if additional_definition: - help_string += 'Additionally:\n\n' - for item in sorted(additional_definition.items()): - help_string += '\t{}: {}\n'.format(*item) - help_string += '\n' - - return help_string - - -def curtail_val_repr(val, max_chars, add_delim=False): - """ - Used mostly by the `to_string` function on Graph Objects to pretty print. - - Limit the number of characters of output, but keep the representation - pretty. - - :param (*) val: The `repr(val)` result is what gets curtailed. - :param (int) max_chars: Max number of chars which may be returned. - :param (bool) add_delim: Used if a value is *not* the last in an iterable. - :return: (str) - - """ - delim = ", " - end = ".." - if isinstance(val, six.string_types): - if max_chars <= len("'" + end + "'"): - return ' ' * max_chars - elif add_delim and max_chars <= len("'" + end + "'") + len(delim): - return "'" + end + "'" + ' ' * (max_chars - len("'" + end + "'")) - else: - if max_chars <= len(end): - return ' ' * max_chars - elif add_delim and max_chars <= len(end) + len(delim): - return end + ' ' * (max_chars - len(end)) - if add_delim: - max_chars -= len(delim) - r = repr(val) - if len(r) > max_chars: - if isinstance(val, six.string_types): - # TODO: can we assume this ends in "'" - r = r[:max_chars - len(end + "'")] + end + "'" - elif (isinstance(val, list) and - max_chars >= len("[{end}]".format(end=end))): - r = r[:max_chars - len(end + ']')] + end + ']' - else: - r = r[:max_chars - len(end)] + end - if add_delim: - r += delim - return r - - -def assign_id_to_src(src_name, src_value): - if isinstance(src_value, six.string_types): - src_id = src_value - else: - try: - src_id = src_value.id - except: - err = ("{0} does not have an `id` property. " - "{1} needs to be assigned to either an " - "object with an `id` (like a " - "plotly.grid_objs.Column) or a string. " - "The `id` is a unique identifier " - "assigned by the Plotly webserver " - "to this grid column.") - src_value_str = str(src_value) - err = err.format(src_name, src_value_str) - raise exceptions.InputError(err) - - if src_id == '': - err = exceptions.COLUMN_NOT_YET_UPLOADED_MESSAGE - err.format(column_name=src_value.name, reference=src_name) - raise exceptions.InputError(err) - return src_id - - -def sort_keys(key): - """ - Temporary function. See https://github.com/plotly/python-api/issues/290. - - :param (str|unicode) key: The attribute we're sorting on. - :return: (bool, str|unicode) The naturally-sortable tuple. - - """ - is_special = key in 'rtxyz' - return not is_special, key diff --git a/plotly/graph_objs/heatmap/__init__.py b/plotly/graph_objs/heatmap/__init__.py new file mode 100644 index 0000000000..f6c2af194e --- /dev/null +++ b/plotly/graph_objs/heatmap/__init__.py @@ -0,0 +1,5 @@ +from ._stream import Stream +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.heatmap import hoverlabel +from ._colorbar import ColorBar +from plotly.graph_objs.heatmap import colorbar diff --git a/plotly/graph_objs/heatmap/_colorbar.py b/plotly/graph_objs/heatmap/_colorbar.py new file mode 100644 index 0000000000..0a51c987f9 --- /dev/null +++ b/plotly/graph_objs/heatmap/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.heatmap.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.heatmap.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.heatmap.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.heatmap.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.heatmap.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.heatmap.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmap.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmap.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmap.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/_hoverlabel.py b/plotly/graph_objs/heatmap/_hoverlabel.py new file mode 100644 index 0000000000..65cb797963 --- /dev/null +++ b/plotly/graph_objs/heatmap/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.heatmap.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.heatmap.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmap.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/_stream.py b/plotly/graph_objs/heatmap/_stream.py new file mode 100644 index 0000000000..e6e66040c8 --- /dev/null +++ b/plotly/graph_objs/heatmap/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmap.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.Stream +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/colorbar/__init__.py b/plotly/graph_objs/heatmap/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/heatmap/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/heatmap/colorbar/_tickfont.py b/plotly/graph_objs/heatmap/colorbar/_tickfont.py new file mode 100644 index 0000000000..dad87ac8f0 --- /dev/null +++ b/plotly/graph_objs/heatmap/colorbar/_tickfont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmap.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap.colorbar import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/colorbar/_tickformatstop.py b/plotly/graph_objs/heatmap/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..880d3d1f29 --- /dev/null +++ b/plotly/graph_objs/heatmap/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmap.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/colorbar/_titlefont.py b/plotly/graph_objs/heatmap/colorbar/_titlefont.py new file mode 100644 index 0000000000..2a4a22cd45 --- /dev/null +++ b/plotly/graph_objs/heatmap/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmap.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmap/hoverlabel/__init__.py b/plotly/graph_objs/heatmap/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/heatmap/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/heatmap/hoverlabel/_font.py b/plotly/graph_objs/heatmap/hoverlabel/_font.py new file mode 100644 index 0000000000..6825c2ac42 --- /dev/null +++ b/plotly/graph_objs/heatmap/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmap.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmap.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmap.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.heatmap.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmap.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/__init__.py b/plotly/graph_objs/heatmapgl/__init__.py new file mode 100644 index 0000000000..2ed0469664 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/__init__.py @@ -0,0 +1,5 @@ +from ._stream import Stream +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.heatmapgl import hoverlabel +from ._colorbar import ColorBar +from plotly.graph_objs.heatmapgl import colorbar diff --git a/plotly/graph_objs/heatmapgl/_colorbar.py b/plotly/graph_objs/heatmapgl/_colorbar.py new file mode 100644 index 0000000000..4ef442a55a --- /dev/null +++ b/plotly/graph_objs/heatmapgl/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.heatmapgl.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.heatmapgl.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.heatmapgl.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.heatmapgl.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmapgl.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmapgl.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmapgl.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/_hoverlabel.py b/plotly/graph_objs/heatmapgl/_hoverlabel.py new file mode 100644 index 0000000000..e2e9b056c0 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.heatmapgl.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.heatmapgl.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmapgl.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/_stream.py b/plotly/graph_objs/heatmapgl/_stream.py new file mode 100644 index 0000000000..34d6d72ed8 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.heatmapgl.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.Stream +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/colorbar/__init__.py b/plotly/graph_objs/heatmapgl/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/heatmapgl/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/heatmapgl/colorbar/_tickfont.py b/plotly/graph_objs/heatmapgl/colorbar/_tickfont.py new file mode 100644 index 0000000000..f70d689091 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmapgl.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/colorbar/_tickformatstop.py b/plotly/graph_objs/heatmapgl/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..be9754578b --- /dev/null +++ b/plotly/graph_objs/heatmapgl/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmapgl.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/colorbar/_titlefont.py b/plotly/graph_objs/heatmapgl/colorbar/_titlefont.py new file mode 100644 index 0000000000..982f0634b6 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmapgl.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/heatmapgl/hoverlabel/__init__.py b/plotly/graph_objs/heatmapgl/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/heatmapgl/hoverlabel/_font.py b/plotly/graph_objs/heatmapgl/hoverlabel/_font.py new file mode 100644 index 0000000000..28022d8d62 --- /dev/null +++ b/plotly/graph_objs/heatmapgl/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'heatmapgl.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.heatmapgl.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.heatmapgl.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.heatmapgl.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.heatmapgl.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/__init__.py b/plotly/graph_objs/histogram/__init__.py new file mode 100644 index 0000000000..75c8795ac9 --- /dev/null +++ b/plotly/graph_objs/histogram/__init__.py @@ -0,0 +1,14 @@ +from ._ybins import YBins +from ._xbins import XBins +from ._unselected import Unselected +from plotly.graph_objs.histogram import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.histogram import selected +from ._marker import Marker +from plotly.graph_objs.histogram import marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.histogram import hoverlabel +from ._error_y import ErrorY +from ._error_x import ErrorX +from ._cumulative import Cumulative diff --git a/plotly/graph_objs/histogram/_cumulative.py b/plotly/graph_objs/histogram/_cumulative.py new file mode 100644 index 0000000000..2f5803c1e2 --- /dev/null +++ b/plotly/graph_objs/histogram/_cumulative.py @@ -0,0 +1,200 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Cumulative(BaseTraceHierarchyType): + + # currentbin + # ---------- + @property + def currentbin(self): + """ + Only applies if cumulative is enabled. Sets whether the current + bin is included, excluded, or has half of its value included in + the current cumulative value. *include* is the default for + compatibility with various other tools, however it introduces a + half-bin bias to the results. *exclude* makes the opposite + half-bin bias, and *half* removes it. + + The 'currentbin' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['include', 'exclude', 'half'] + + Returns + ------- + Any + """ + return self['currentbin'] + + @currentbin.setter + def currentbin(self, val): + self['currentbin'] = val + + # direction + # --------- + @property + def direction(self): + """ + Only applies if cumulative is enabled. If *increasing* + (default) we sum all prior bins, so the result increases from + left to right. If *decreasing* we sum later bins so the result + decreases from left to right. + + The 'direction' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['increasing', 'decreasing'] + + Returns + ------- + Any + """ + return self['direction'] + + @direction.setter + def direction(self, val): + self['direction'] = val + + # enabled + # ------- + @property + def enabled(self): + """ + If true, display the cumulative distribution by summing the + binned values. Use the `direction` and `centralbin` attributes + to tune the accumulation method. Note: in this mode, the + *density* `histnorm` settings behave the same as their + equivalents without *density*: ** and *density* both rise to + the number of data points, and *probability* and *probability + density* both rise to the number of sample points. + + The 'enabled' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['enabled'] + + @enabled.setter + def enabled(self, val): + self['enabled'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + currentbin + Only applies if cumulative is enabled. Sets whether the + current bin is included, excluded, or has half of its + value included in the current cumulative value. + *include* is the default for compatibility with various + other tools, however it introduces a half-bin bias to + the results. *exclude* makes the opposite half-bin + bias, and *half* removes it. + direction + Only applies if cumulative is enabled. If *increasing* + (default) we sum all prior bins, so the result + increases from left to right. If *decreasing* we sum + later bins so the result decreases from left to right. + enabled + If true, display the cumulative distribution by summing + the binned values. Use the `direction` and `centralbin` + attributes to tune the accumulation method. Note: in + this mode, the *density* `histnorm` settings behave the + same as their equivalents without *density*: ** and + *density* both rise to the number of data points, and + *probability* and *probability density* both rise to + the number of sample points. + """ + + def __init__( + self, + arg=None, + currentbin=None, + direction=None, + enabled=None, + **kwargs + ): + """ + Construct a new Cumulative object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Cumulative + currentbin + Only applies if cumulative is enabled. Sets whether the + current bin is included, excluded, or has half of its + value included in the current cumulative value. + *include* is the default for compatibility with various + other tools, however it introduces a half-bin bias to + the results. *exclude* makes the opposite half-bin + bias, and *half* removes it. + direction + Only applies if cumulative is enabled. If *increasing* + (default) we sum all prior bins, so the result + increases from left to right. If *decreasing* we sum + later bins so the result decreases from left to right. + enabled + If true, display the cumulative distribution by summing + the binned values. Use the `direction` and `centralbin` + attributes to tune the accumulation method. Note: in + this mode, the *density* `histnorm` settings behave the + same as their equivalents without *density*: ** and + *density* both rise to the number of data points, and + *probability* and *probability density* both rise to + the number of sample points. + + Returns + ------- + Cumulative + """ + super(Cumulative, self).__init__('cumulative') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Cumulative +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Cumulative""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (cumulative as v_cumulative) + + # Initialize validators + # --------------------- + self._validators['currentbin'] = v_cumulative.CurrentbinValidator() + self._validators['direction'] = v_cumulative.DirectionValidator() + self._validators['enabled'] = v_cumulative.EnabledValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('currentbin', None) + self.currentbin = currentbin if currentbin is not None else v + v = arg.pop('direction', None) + self.direction = direction if direction is not None else v + v = arg.pop('enabled', None) + self.enabled = enabled if enabled is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_error_x.py b/plotly/graph_objs/histogram/_error_x.py new file mode 100644 index 0000000000..653176bda7 --- /dev/null +++ b/plotly/graph_objs/histogram/_error_x.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorX(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_ystyle + # ----------- + @property + def copy_ystyle(self): + """ + The 'copy_ystyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_ystyle'] + + @copy_ystyle.setter + def copy_ystyle(self, val): + self['copy_ystyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_ystyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorX object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.ErrorX + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorX + """ + super(ErrorX, self).__init__('error_x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.ErrorX +constructor must be a dict or +an instance of plotly.graph_objs.histogram.ErrorX""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (error_x as v_error_x) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_x.ArrayValidator() + self._validators['arrayminus'] = v_error_x.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_x.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_x.ArraysrcValidator() + self._validators['color'] = v_error_x.ColorValidator() + self._validators['copy_ystyle'] = v_error_x.CopyYstyleValidator() + self._validators['symmetric'] = v_error_x.SymmetricValidator() + self._validators['thickness'] = v_error_x.ThicknessValidator() + self._validators['traceref'] = v_error_x.TracerefValidator() + self._validators['tracerefminus'] = v_error_x.TracerefminusValidator() + self._validators['type'] = v_error_x.TypeValidator() + self._validators['value'] = v_error_x.ValueValidator() + self._validators['valueminus'] = v_error_x.ValueminusValidator() + self._validators['visible'] = v_error_x.VisibleValidator() + self._validators['width'] = v_error_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_ystyle', None) + self.copy_ystyle = copy_ystyle if copy_ystyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_error_y.py b/plotly/graph_objs/histogram/_error_y.py new file mode 100644 index 0000000000..a013973559 --- /dev/null +++ b/plotly/graph_objs/histogram/_error_y.py @@ -0,0 +1,561 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorY(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorY object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.ErrorY + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorY + """ + super(ErrorY, self).__init__('error_y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.ErrorY +constructor must be a dict or +an instance of plotly.graph_objs.histogram.ErrorY""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (error_y as v_error_y) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_y.ArrayValidator() + self._validators['arrayminus'] = v_error_y.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_y.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_y.ArraysrcValidator() + self._validators['color'] = v_error_y.ColorValidator() + self._validators['symmetric'] = v_error_y.SymmetricValidator() + self._validators['thickness'] = v_error_y.ThicknessValidator() + self._validators['traceref'] = v_error_y.TracerefValidator() + self._validators['tracerefminus'] = v_error_y.TracerefminusValidator() + self._validators['type'] = v_error_y.TypeValidator() + self._validators['value'] = v_error_y.ValueValidator() + self._validators['valueminus'] = v_error_y.ValueminusValidator() + self._validators['visible'] = v_error_y.VisibleValidator() + self._validators['width'] = v_error_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_hoverlabel.py b/plotly/graph_objs/histogram/_hoverlabel.py new file mode 100644 index 0000000000..065ddf309f --- /dev/null +++ b/plotly/graph_objs/histogram/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.histogram.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.histogram.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_marker.py b/plotly/graph_objs/histogram/_marker.py new file mode 100644 index 0000000000..a066f3f247 --- /dev/null +++ b/plotly/graph_objs/histogram/_marker.py @@ -0,0 +1,876 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to histogram.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.histogram.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.histogram.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.histogram.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.histogram.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the bars. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.histogram.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.histogram.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.histogram.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.histogram.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Marker +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_selected.py b/plotly/graph_objs/histogram/_selected.py new file mode 100644 index 0000000000..802d31b8a1 --- /dev/null +++ b/plotly/graph_objs/histogram/_selected.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.histogram.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + + Returns + ------- + plotly.graph_objs.histogram.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.histogram.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.histogram.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.histogram.selected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.histogram.selected.Textfont instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Selected + marker + plotly.graph_objs.histogram.selected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.histogram.selected.Textfont instance + or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Selected +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_stream.py b/plotly/graph_objs/histogram/_stream.py new file mode 100644 index 0000000000..a53cbb67e5 --- /dev/null +++ b/plotly/graph_objs/histogram/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Stream +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_unselected.py b/plotly/graph_objs/histogram/_unselected.py new file mode 100644 index 0000000000..cd4472d84d --- /dev/null +++ b/plotly/graph_objs/histogram/_unselected.py @@ -0,0 +1,139 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.histogram.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.histogram.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.histogram.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.histogram.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.histogram.unselected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.histogram.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.Unselected + marker + plotly.graph_objs.histogram.unselected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.histogram.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.histogram.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_xbins.py b/plotly/graph_objs/histogram/_xbins.py new file mode 100644 index 0000000000..2c82bd63ec --- /dev/null +++ b/plotly/graph_objs/histogram/_xbins.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class XBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the x axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each x axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the x axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new XBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.XBins + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + XBins + """ + super(XBins, self).__init__('xbins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.XBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram.XBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (xbins as v_xbins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_xbins.EndValidator() + self._validators['size'] = v_xbins.SizeValidator() + self._validators['start'] = v_xbins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/_ybins.py b/plotly/graph_objs/histogram/_ybins.py new file mode 100644 index 0000000000..c66136d4ca --- /dev/null +++ b/plotly/graph_objs/histogram/_ybins.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class YBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the y axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each y axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the y axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new YBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.YBins + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + YBins + """ + super(YBins, self).__init__('ybins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.YBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram.YBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram import (ybins as v_ybins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_ybins.EndValidator() + self._validators['size'] = v_ybins.SizeValidator() + self._validators['start'] = v_ybins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/hoverlabel/__init__.py b/plotly/graph_objs/histogram/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/histogram/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/histogram/hoverlabel/_font.py b/plotly/graph_objs/histogram/hoverlabel/_font.py new file mode 100644 index 0000000000..2c2d515044 --- /dev/null +++ b/plotly/graph_objs/histogram/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.histogram.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/marker/__init__.py b/plotly/graph_objs/histogram/marker/__init__.py new file mode 100644 index 0000000000..3c2c7eac9b --- /dev/null +++ b/plotly/graph_objs/histogram/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.histogram.marker import colorbar diff --git a/plotly/graph_objs/histogram/marker/_colorbar.py b/plotly/graph_objs/histogram/marker/_colorbar.py new file mode 100644 index 0000000000..ef0fe42780 --- /dev/null +++ b/plotly/graph_objs/histogram/marker/_colorbar.py @@ -0,0 +1,1736 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.histogram.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.histogram.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.histogram.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.histogram.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.histogram.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/marker/_line.py b/plotly/graph_objs/histogram/marker/_line.py new file mode 100644 index 0000000000..70f66b710d --- /dev/null +++ b/plotly/graph_objs/histogram/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to histogram.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.histogram.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/marker/colorbar/__init__.py b/plotly/graph_objs/histogram/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/histogram/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/histogram/marker/colorbar/_tickfont.py b/plotly/graph_objs/histogram/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..26ea204bef --- /dev/null +++ b/plotly/graph_objs/histogram/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/histogram/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..7d133ad1e8 --- /dev/null +++ b/plotly/graph_objs/histogram/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram.marker.color + bar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.histogram.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/marker/colorbar/_titlefont.py b/plotly/graph_objs/histogram/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..1c1805ca5d --- /dev/null +++ b/plotly/graph_objs/histogram/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.histogram.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/selected/__init__.py b/plotly/graph_objs/histogram/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/histogram/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/histogram/selected/_marker.py b/plotly/graph_objs/histogram/selected/_marker.py new file mode 100644 index 0000000000..fa12e7359d --- /dev/null +++ b/plotly/graph_objs/histogram/selected/_marker.py @@ -0,0 +1,158 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + """ + + def __init__(self, arg=None, color=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.histogram.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/selected/_textfont.py b/plotly/graph_objs/histogram/selected/_textfont.py new file mode 100644 index 0000000000..703980936b --- /dev/null +++ b/plotly/graph_objs/histogram/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/unselected/__init__.py b/plotly/graph_objs/histogram/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/histogram/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/histogram/unselected/_marker.py b/plotly/graph_objs/histogram/unselected/_marker.py new file mode 100644 index 0000000000..7420133018 --- /dev/null +++ b/plotly/graph_objs/histogram/unselected/_marker.py @@ -0,0 +1,164 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, opacity=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.histogram.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram/unselected/_textfont.py b/plotly/graph_objs/histogram/unselected/_textfont.py new file mode 100644 index 0000000000..82a779a18a --- /dev/null +++ b/plotly/graph_objs/histogram/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/__init__.py b/plotly/graph_objs/histogram2d/__init__.py new file mode 100644 index 0000000000..8bb12d1ad6 --- /dev/null +++ b/plotly/graph_objs/histogram2d/__init__.py @@ -0,0 +1,8 @@ +from ._ybins import YBins +from ._xbins import XBins +from ._stream import Stream +from ._marker import Marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.histogram2d import hoverlabel +from ._colorbar import ColorBar +from plotly.graph_objs.histogram2d import colorbar diff --git a/plotly/graph_objs/histogram2d/_colorbar.py b/plotly/graph_objs/histogram2d/_colorbar.py new file mode 100644 index 0000000000..743470b1ed --- /dev/null +++ b/plotly/graph_objs/histogram2d/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram2d.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.histogram2d.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.histogram2d.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram2d.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2d.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2d.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/_hoverlabel.py b/plotly/graph_objs/histogram2d/_hoverlabel.py new file mode 100644 index 0000000000..2522d71208 --- /dev/null +++ b/plotly/graph_objs/histogram2d/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.histogram2d.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.histogram2d.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/_marker.py b/plotly/graph_objs/histogram2d/_marker.py new file mode 100644 index 0000000000..f115e8f76c --- /dev/null +++ b/plotly/graph_objs/histogram2d/_marker.py @@ -0,0 +1,118 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the aggregation data. + + The 'color' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color . + """ + + def __init__(self, arg=None, color=None, colorsrc=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.Marker + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.Marker +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/_stream.py b/plotly/graph_objs/histogram2d/_stream.py new file mode 100644 index 0000000000..cd8e8cb6e6 --- /dev/null +++ b/plotly/graph_objs/histogram2d/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.Stream +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/_xbins.py b/plotly/graph_objs/histogram2d/_xbins.py new file mode 100644 index 0000000000..7a2b119294 --- /dev/null +++ b/plotly/graph_objs/histogram2d/_xbins.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class XBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the x axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each x axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the x axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new XBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.XBins + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + XBins + """ + super(XBins, self).__init__('xbins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.XBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.XBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (xbins as v_xbins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_xbins.EndValidator() + self._validators['size'] = v_xbins.SizeValidator() + self._validators['start'] = v_xbins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/_ybins.py b/plotly/graph_objs/histogram2d/_ybins.py new file mode 100644 index 0000000000..f97ce2291d --- /dev/null +++ b/plotly/graph_objs/histogram2d/_ybins.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class YBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the y axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each y axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the y axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new YBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2d.YBins + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + YBins + """ + super(YBins, self).__init__('ybins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.YBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.YBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d import (ybins as v_ybins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_ybins.EndValidator() + self._validators['size'] = v_ybins.SizeValidator() + self._validators['start'] = v_ybins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/colorbar/__init__.py b/plotly/graph_objs/histogram2d/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/histogram2d/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/histogram2d/colorbar/_tickfont.py b/plotly/graph_objs/histogram2d/colorbar/_tickfont.py new file mode 100644 index 0000000000..941aaba4f9 --- /dev/null +++ b/plotly/graph_objs/histogram2d/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2d.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/colorbar/_tickformatstop.py b/plotly/graph_objs/histogram2d/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..60b302be24 --- /dev/null +++ b/plotly/graph_objs/histogram2d/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2d.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/colorbar/_titlefont.py b/plotly/graph_objs/histogram2d/colorbar/_titlefont.py new file mode 100644 index 0000000000..f269eb9923 --- /dev/null +++ b/plotly/graph_objs/histogram2d/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2d.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2d/hoverlabel/__init__.py b/plotly/graph_objs/histogram2d/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/histogram2d/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/histogram2d/hoverlabel/_font.py b/plotly/graph_objs/histogram2d/hoverlabel/_font.py new file mode 100644 index 0000000000..2d4dd8b7ff --- /dev/null +++ b/plotly/graph_objs/histogram2d/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2d.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2d.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2d.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.histogram2d.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2d.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/__init__.py b/plotly/graph_objs/histogram2dcontour/__init__.py new file mode 100644 index 0000000000..3cfeee14b4 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/__init__.py @@ -0,0 +1,11 @@ +from ._ybins import YBins +from ._xbins import XBins +from ._stream import Stream +from ._marker import Marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.histogram2dcontour import hoverlabel +from ._contours import Contours +from plotly.graph_objs.histogram2dcontour import contours +from ._colorbar import ColorBar +from plotly.graph_objs.histogram2dcontour import colorbar diff --git a/plotly/graph_objs/histogram2dcontour/_colorbar.py b/plotly/graph_objs/histogram2dcontour/_colorbar.py new file mode 100644 index 0000000000..dccdc7c992 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram2dcontour.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.histogram2dcontour.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.histogram2dcontour.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram2dcontour.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2dcontour.colorbar.Tickforma + tstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2dcontour.colorbar.Tickforma + tstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_contours.py b/plotly/graph_objs/histogram2dcontour/_contours.py new file mode 100644 index 0000000000..8393f3907c --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_contours.py @@ -0,0 +1,502 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Contours(BaseTraceHierarchyType): + + # coloring + # -------- + @property + def coloring(self): + """ + Determines the coloring method showing the contour values. If + *fill*, coloring is done evenly between each contour level If + *heatmap*, a heatmap gradient coloring is applied between each + contour level. If *lines*, coloring is done on the contour + lines. If *none*, no coloring is applied on this trace. + + The 'coloring' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fill', 'heatmap', 'lines', 'none'] + + Returns + ------- + Any + """ + return self['coloring'] + + @coloring.setter + def coloring(self, val): + self['coloring'] = val + + # end + # --- + @property + def end(self): + """ + Sets the end contour level value. Must be more than + `contours.start` + + The 'end' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # labelfont + # --------- + @property + def labelfont(self): + """ + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + The 'labelfont' property is an instance of Labelfont + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.contours.Labelfont + - A dict of string/value properties that will be passed + to the Labelfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.histogram2dcontour.contours.Labelfont + """ + return self['labelfont'] + + @labelfont.setter + def labelfont(self, val): + self['labelfont'] = val + + # labelformat + # ----------- + @property + def labelformat(self): + """ + Sets the contour label formatting rule using d3 formatting + mini-language which is very similar to Python, see: https://git + hub.com/d3/d3-format/blob/master/README.md#locale_format. + + The 'labelformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['labelformat'] + + @labelformat.setter + def labelformat(self, val): + self['labelformat'] = val + + # operation + # --------- + @property + def operation(self): + """ + Sets the constraint operation. *=* keeps regions equal to + `value` *<* and *<=* keep regions less than `value` *>* and + *>=* keep regions greater than `value` *[]*, *()*, *[)*, and + *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, + *](*, *)[* keep regions outside `value[0]` to value[1]` Open + vs. closed intervals make no difference to constraint display, + but all versions are allowed for consistency with filter + transforms. + + The 'operation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', + ')(', '](', ')['] + + Returns + ------- + Any + """ + return self['operation'] + + @operation.setter + def operation(self, val): + self['operation'] = val + + # showlabels + # ---------- + @property + def showlabels(self): + """ + Determines whether to label the contour lines with their + values. + + The 'showlabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlabels'] + + @showlabels.setter + def showlabels(self, val): + self['showlabels'] = val + + # showlines + # --------- + @property + def showlines(self): + """ + Determines whether or not the contour lines are drawn. Has an + effect only if `contours.coloring` is set to *fill*. + + The 'showlines' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlines'] + + @showlines.setter + def showlines(self, val): + self['showlines'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step between each contour level. Must be positive. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting contour level value. Must be less than + `contours.end` + + The 'start' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # type + # ---- + @property + def type(self): + """ + If `levels`, the data is represented as a contour plot with + multiple levels displayed. If `constraint`, the data is + represented as constraints with the invalid region shaded as + specified by the `operation` and `value` parameters. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['levels', 'constraint'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value or values of the constraint boundary. When + `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of + two numbers where the first is the lower bound and the second + is the upper bound. + + The 'value' property accepts values of any type + + Returns + ------- + Any + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *heatmap*, a heatmap gradient coloring + is applied between each contour level. If *lines*, + coloring is done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + """ + + def __init__( + self, + arg=None, + coloring=None, + end=None, + labelfont=None, + labelformat=None, + operation=None, + showlabels=None, + showlines=None, + size=None, + start=None, + type=None, + value=None, + **kwargs + ): + """ + Construct a new Contours object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.Contours + coloring + Determines the coloring method showing the contour + values. If *fill*, coloring is done evenly between each + contour level If *heatmap*, a heatmap gradient coloring + is applied between each contour level. If *lines*, + coloring is done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more than + `contours.start` + labelfont + Sets the font used for labeling the contour levels. The + default color comes from the lines, if shown. The + default family and size come from `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar to + Python, see: https://github.com/d3/d3-format/blob/maste + r/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps regions equal + to `value` *<* and *<=* keep regions less than `value` + *>* and *>=* keep regions greater than `value` *[]*, + *()*, *[)*, and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions outside + `value[0]` to value[1]` Open vs. closed intervals make + no difference to constraint display, but all versions + are allowed for consistency with filter transforms. + showlabels + Determines whether to label the contour lines with + their values. + showlines + Determines whether or not the contour lines are drawn. + Has an effect only if `contours.coloring` is set to + *fill*. + size + Sets the step between each contour level. Must be + positive. + start + Sets the starting contour level value. Must be less + than `contours.end` + type + If `levels`, the data is represented as a contour plot + with multiple levels displayed. If `constraint`, the + data is represented as constraints with the invalid + region shaded as specified by the `operation` and + `value` parameters. + value + Sets the value or values of the constraint boundary. + When `operation` is set to one of the comparison values + (=,<,>=,>,<=) *value* is expected to be a number. When + `operation` is set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected to be an + array of two numbers where the first is the lower bound + and the second is the upper bound. + + Returns + ------- + Contours + """ + super(Contours, self).__init__('contours') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.Contours +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.Contours""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import ( + contours as v_contours + ) + + # Initialize validators + # --------------------- + self._validators['coloring'] = v_contours.ColoringValidator() + self._validators['end'] = v_contours.EndValidator() + self._validators['labelfont'] = v_contours.LabelfontValidator() + self._validators['labelformat'] = v_contours.LabelformatValidator() + self._validators['operation'] = v_contours.OperationValidator() + self._validators['showlabels'] = v_contours.ShowlabelsValidator() + self._validators['showlines'] = v_contours.ShowlinesValidator() + self._validators['size'] = v_contours.SizeValidator() + self._validators['start'] = v_contours.StartValidator() + self._validators['type'] = v_contours.TypeValidator() + self._validators['value'] = v_contours.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('coloring', None) + self.coloring = coloring if coloring is not None else v + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('labelfont', None) + self.labelfont = labelfont if labelfont is not None else v + v = arg.pop('labelformat', None) + self.labelformat = labelformat if labelformat is not None else v + v = arg.pop('operation', None) + self.operation = operation if operation is not None else v + v = arg.pop('showlabels', None) + self.showlabels = showlabels if showlabels is not None else v + v = arg.pop('showlines', None) + self.showlines = showlines if showlines is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_hoverlabel.py b/plotly/graph_objs/histogram2dcontour/_hoverlabel.py new file mode 100644 index 0000000000..5d2a72c805 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.histogram2dcontour.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.histogram2dcontour.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_line.py b/plotly/graph_objs/histogram2dcontour/_line.py new file mode 100644 index 0000000000..4813167abd --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_line.py @@ -0,0 +1,238 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Sets the amount of smoothing for the contour lines, where *0* + corresponds to no smoothing. + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.Line + color + Sets the color of the contour level. Has no effect if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour lines, + where *0* corresponds to no smoothing. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.Line +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_marker.py b/plotly/graph_objs/histogram2dcontour/_marker.py new file mode 100644 index 0000000000..6305946e5b --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_marker.py @@ -0,0 +1,119 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the aggregation data. + + The 'color' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color . + """ + + def __init__(self, arg=None, color=None, colorsrc=None, **kwargs): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.Marker + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.Marker +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_stream.py b/plotly/graph_objs/histogram2dcontour/_stream.py new file mode 100644 index 0000000000..b5b8d40ef5 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_stream.py @@ -0,0 +1,132 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.Stream +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_xbins.py b/plotly/graph_objs/histogram2dcontour/_xbins.py new file mode 100644 index 0000000000..a9043323cf --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_xbins.py @@ -0,0 +1,143 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class XBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the x axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each x axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the x axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new XBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.XBins + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins. + + Returns + ------- + XBins + """ + super(XBins, self).__init__('xbins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.XBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.XBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import (xbins as v_xbins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_xbins.EndValidator() + self._validators['size'] = v_xbins.SizeValidator() + self._validators['start'] = v_xbins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/_ybins.py b/plotly/graph_objs/histogram2dcontour/_ybins.py new file mode 100644 index 0000000000..f8ad03ae69 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/_ybins.py @@ -0,0 +1,143 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class YBins(BaseTraceHierarchyType): + + # end + # --- + @property + def end(self): + """ + Sets the end value for the y axis bins. + + The 'end' property accepts values of any type + + Returns + ------- + Any + """ + return self['end'] + + @end.setter + def end(self, val): + self['end'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the step in-between value each y axis bin. + + The 'size' property accepts values of any type + + Returns + ------- + Any + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # start + # ----- + @property + def start(self): + """ + Sets the starting value for the y axis bins. + + The 'start' property accepts values of any type + + Returns + ------- + Any + """ + return self['start'] + + @start.setter + def start(self, val): + self['start'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + """ + + def __init__(self, arg=None, end=None, size=None, start=None, **kwargs): + """ + Construct a new YBins object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.YBins + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins. + + Returns + ------- + YBins + """ + super(YBins, self).__init__('ybins') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.YBins +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.YBins""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour import (ybins as v_ybins) + + # Initialize validators + # --------------------- + self._validators['end'] = v_ybins.EndValidator() + self._validators['size'] = v_ybins.SizeValidator() + self._validators['start'] = v_ybins.StartValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('end', None) + self.end = end if end is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('start', None) + self.start = start if start is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/colorbar/__init__.py b/plotly/graph_objs/histogram2dcontour/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/histogram2dcontour/colorbar/_tickfont.py b/plotly/graph_objs/histogram2dcontour/colorbar/_tickfont.py new file mode 100644 index 0000000000..4729ed8f30 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/colorbar/_tickformatstop.py b/plotly/graph_objs/histogram2dcontour/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..12130c8ca6 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.histogram2dcontour.col + orbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/colorbar/_titlefont.py b/plotly/graph_objs/histogram2dcontour/colorbar/_titlefont.py new file mode 100644 index 0000000000..dd64d8725c --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/contours/__init__.py b/plotly/graph_objs/histogram2dcontour/contours/__init__.py new file mode 100644 index 0000000000..4729349bff --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/contours/__init__.py @@ -0,0 +1 @@ +from ._labelfont import Labelfont diff --git a/plotly/graph_objs/histogram2dcontour/contours/_labelfont.py b/plotly/graph_objs/histogram2dcontour/contours/_labelfont.py new file mode 100644 index 0000000000..c41fd30089 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/contours/_labelfont.py @@ -0,0 +1,222 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Labelfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Labelfont object + + Sets the font used for labeling the contour levels. The default + color comes from the lines, if shown. The default family and + size come from `layout.font`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.contours.Labelfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Labelfont + """ + super(Labelfont, self).__init__('labelfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.contours.Labelfont +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.contours.Labelfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour.contours import ( + labelfont as v_labelfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_labelfont.ColorValidator() + self._validators['family'] = v_labelfont.FamilyValidator() + self._validators['size'] = v_labelfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/histogram2dcontour/hoverlabel/__init__.py b/plotly/graph_objs/histogram2dcontour/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/histogram2dcontour/hoverlabel/_font.py b/plotly/graph_objs/histogram2dcontour/hoverlabel/_font.py new file mode 100644 index 0000000000..0abde63551 --- /dev/null +++ b/plotly/graph_objs/histogram2dcontour/hoverlabel/_font.py @@ -0,0 +1,314 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'histogram2dcontour.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.histogram2dcontour.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.histogram2dcontour.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.histogram2dcontour.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.histogram2dcontour.hoverlabel import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/__init__.py b/plotly/graph_objs/layout/__init__.py new file mode 100644 index 0000000000..e0d9a7a098 --- /dev/null +++ b/plotly/graph_objs/layout/__init__.py @@ -0,0 +1,34 @@ +from ._yaxis import YAxis +from plotly.graph_objs.layout import yaxis +from ._xaxis import XAxis +from plotly.graph_objs.layout import xaxis +from ._updatemenu import Updatemenu +from plotly.graph_objs.layout import updatemenu +from ._titlefont import Titlefont +from ._ternary import Ternary +from plotly.graph_objs.layout import ternary +from ._slider import Slider +from plotly.graph_objs.layout import slider +from ._shape import Shape +from plotly.graph_objs.layout import shape +from ._scene import Scene +from plotly.graph_objs.layout import scene +from ._radialaxis import RadialAxis +from ._polar import Polar +from plotly.graph_objs.layout import polar +from ._margin import Margin +from ._mapbox import Mapbox +from plotly.graph_objs.layout import mapbox +from ._legend import Legend +from plotly.graph_objs.layout import legend +from ._image import Image +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.layout import hoverlabel +from ._grid import Grid +from plotly.graph_objs.layout import grid +from ._geo import Geo +from plotly.graph_objs.layout import geo +from ._font import Font +from ._annotation import Annotation +from plotly.graph_objs.layout import annotation +from ._angularaxis import AngularAxis diff --git a/plotly/graph_objs/layout/_angularaxis.py b/plotly/graph_objs/layout/_angularaxis.py new file mode 100644 index 0000000000..5733970847 --- /dev/null +++ b/plotly/graph_objs/layout/_angularaxis.py @@ -0,0 +1,411 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class AngularAxis(BaseLayoutHierarchyType): + + # domain + # ------ + @property + def domain(self): + """ + Polar chart subplots are not supported yet. This key has + currently no effect. + + The 'domain' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'domain[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'domain[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # endpadding + # ---------- + @property + def endpadding(self): + """ + The 'endpadding' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['endpadding'] + + @endpadding.setter + def endpadding(self, val): + self['endpadding'] = val + + # range + # ----- + @property + def range(self): + """ + Defines the start and end point of this angular axis. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property is a number and may be specified as: + - An int or float + (1) The 'range[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not the line bounding this angular axis + will be shown on the figure. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the angular axis ticks will feature + tick labels. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the color of the tick lines on this angular axis. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the length of the tick lines on this angular axis. + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickorientation + # --------------- + @property + def tickorientation(self): + """ + Sets the orientation (from the paper perspective) of the + angular axis tick labels. + + The 'tickorientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['horizontal', 'vertical'] + + Returns + ------- + Any + """ + return self['tickorientation'] + + @tickorientation.setter + def tickorientation(self, val): + self['tickorientation'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets the length of the tick lines on this angular axis. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this axis will be visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + domain + Polar chart subplots are not supported yet. This key + has currently no effect. + endpadding + + range + Defines the start and end point of this angular axis. + showline + Determines whether or not the line bounding this + angular axis will be shown on the figure. + showticklabels + Determines whether or not the angular axis ticks will + feature tick labels. + tickcolor + Sets the color of the tick lines on this angular axis. + ticklen + Sets the length of the tick lines on this angular axis. + tickorientation + Sets the orientation (from the paper perspective) of + the angular axis tick labels. + ticksuffix + Sets the length of the tick lines on this angular axis. + visible + Determines whether or not this axis will be visible. + """ + + def __init__( + self, + arg=None, + domain=None, + endpadding=None, + range=None, + showline=None, + showticklabels=None, + tickcolor=None, + ticklen=None, + tickorientation=None, + ticksuffix=None, + visible=None, + **kwargs + ): + """ + Construct a new AngularAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.AngularAxis + domain + Polar chart subplots are not supported yet. This key + has currently no effect. + endpadding + + range + Defines the start and end point of this angular axis. + showline + Determines whether or not the line bounding this + angular axis will be shown on the figure. + showticklabels + Determines whether or not the angular axis ticks will + feature tick labels. + tickcolor + Sets the color of the tick lines on this angular axis. + ticklen + Sets the length of the tick lines on this angular axis. + tickorientation + Sets the orientation (from the paper perspective) of + the angular axis tick labels. + ticksuffix + Sets the length of the tick lines on this angular axis. + visible + Determines whether or not this axis will be visible. + + Returns + ------- + AngularAxis + """ + super(AngularAxis, self).__init__('angularaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.AngularAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.AngularAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (angularaxis as v_angularaxis) + + # Initialize validators + # --------------------- + self._validators['domain'] = v_angularaxis.DomainValidator() + self._validators['endpadding'] = v_angularaxis.EndpaddingValidator() + self._validators['range'] = v_angularaxis.RangeValidator() + self._validators['showline'] = v_angularaxis.ShowlineValidator() + self._validators['showticklabels' + ] = v_angularaxis.ShowticklabelsValidator() + self._validators['tickcolor'] = v_angularaxis.TickcolorValidator() + self._validators['ticklen'] = v_angularaxis.TicklenValidator() + self._validators['tickorientation' + ] = v_angularaxis.TickorientationValidator() + self._validators['ticksuffix'] = v_angularaxis.TicksuffixValidator() + self._validators['visible'] = v_angularaxis.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('endpadding', None) + self.endpadding = endpadding if endpadding is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickorientation', None) + self.tickorientation = tickorientation if tickorientation is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_annotation.py b/plotly/graph_objs/layout/_annotation.py new file mode 100644 index 0000000000..7a2d1650c9 --- /dev/null +++ b/plotly/graph_objs/layout/_annotation.py @@ -0,0 +1,1755 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Annotation(BaseLayoutHierarchyType): + + # align + # ----- + @property + def align(self): + """ + Sets the horizontal alignment of the `text` within the box. Has + an effect only if `text` spans more two or more lines (i.e. + `text` contains one or more
HTML tags) or if an explicit + width is set to override the text width. + + The 'align' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['align'] + + @align.setter + def align(self, val): + self['align'] = val + + # arrowcolor + # ---------- + @property + def arrowcolor(self): + """ + Sets the color of the annotation arrow. + + The 'arrowcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['arrowcolor'] + + @arrowcolor.setter + def arrowcolor(self, val): + self['arrowcolor'] = val + + # arrowhead + # --------- + @property + def arrowhead(self): + """ + Sets the end annotation arrow head style. + + The 'arrowhead' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 8] + + Returns + ------- + int + """ + return self['arrowhead'] + + @arrowhead.setter + def arrowhead(self, val): + self['arrowhead'] = val + + # arrowside + # --------- + @property + def arrowside(self): + """ + Sets the annotation arrow head position. + + The 'arrowside' property is a flaglist and may be specified + as a string containing: + - Any combination of ['end', 'start'] joined with '+' characters + (e.g. 'end+start') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['arrowside'] + + @arrowside.setter + def arrowside(self, val): + self['arrowside'] = val + + # arrowsize + # --------- + @property + def arrowsize(self): + """ + Sets the size of the end annotation arrow head, relative to + `arrowwidth`. A value of 1 (default) gives a head about 3x as + wide as the line. + + The 'arrowsize' property is a number and may be specified as: + - An int or float in the interval [0.3, inf] + + Returns + ------- + int|float + """ + return self['arrowsize'] + + @arrowsize.setter + def arrowsize(self, val): + self['arrowsize'] = val + + # arrowwidth + # ---------- + @property + def arrowwidth(self): + """ + Sets the width (in px) of annotation arrow line. + + The 'arrowwidth' property is a number and may be specified as: + - An int or float in the interval [0.1, inf] + + Returns + ------- + int|float + """ + return self['arrowwidth'] + + @arrowwidth.setter + def arrowwidth(self, val): + self['arrowwidth'] = val + + # ax + # -- + @property + def ax(self): + """ + Sets the x component of the arrow tail about the arrow head. If + `axref` is `pixel`, a positive (negative) component + corresponds to an arrow pointing from right to left (left to + right). If `axref` is an axis, this is an absolute value on + that axis, like `x`, NOT a relative value. + + The 'ax' property accepts values of any type + + Returns + ------- + Any + """ + return self['ax'] + + @ax.setter + def ax(self, val): + self['ax'] = val + + # axref + # ----- + @property + def axref(self): + """ + Indicates in what terms the tail of the annotation (ax,ay) is + specified. If `pixel`, `ax` is a relative offset in pixels + from `x`. If set to an x axis id (e.g. *x* or *x2*), `ax` is + specified in the same terms as that axis. This is useful for + trendline annotations which should continue to indicate the + correct trend when zoomed. + + The 'axref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['pixel'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['axref'] + + @axref.setter + def axref(self, val): + self['axref'] = val + + # ay + # -- + @property + def ay(self): + """ + Sets the y component of the arrow tail about the arrow head. If + `ayref` is `pixel`, a positive (negative) component + corresponds to an arrow pointing from bottom to top (top to + bottom). If `ayref` is an axis, this is an absolute value on + that axis, like `y`, NOT a relative value. + + The 'ay' property accepts values of any type + + Returns + ------- + Any + """ + return self['ay'] + + @ay.setter + def ay(self, val): + self['ay'] = val + + # ayref + # ----- + @property + def ayref(self): + """ + Indicates in what terms the tail of the annotation (ax,ay) is + specified. If `pixel`, `ay` is a relative offset in pixels + from `y`. If set to a y axis id (e.g. *y* or *y2*), `ay` is + specified in the same terms as that axis. This is useful for + trendline annotations which should continue to indicate the + correct trend when zoomed. + + The 'ayref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['pixel'] + - A string that matches one of the following regular expressions: + ['^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['ayref'] + + @ayref.setter + def ayref(self, val): + self['ayref'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the annotation. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the annotation `text`. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderpad + # --------- + @property + def borderpad(self): + """ + Sets the padding (in px) between the `text` and the enclosing + border. + + The 'borderpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderpad'] + + @borderpad.setter + def borderpad(self, val): + self['borderpad'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the annotation + `text`. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # captureevents + # ------------- + @property + def captureevents(self): + """ + Determines whether the annotation text box captures mouse move + and click events, or allows those events to pass through to + data points in the plot that may be behind the annotation. By + default `captureevents` is *false* unless `hovertext` is + provided. If you use the event `plotly_clickannotation` without + `hovertext` you must explicitly enable `captureevents`. + + The 'captureevents' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['captureevents'] + + @captureevents.setter + def captureevents(self, val): + self['captureevents'] = val + + # clicktoshow + # ----------- + @property + def clicktoshow(self): + """ + Makes this annotation respond to clicks on the plot. If you + click a data point that exactly matches the `x` and `y` values + of this annotation, and it is hidden (visible: false), it will + appear. In *onoff* mode, you must click the same point again to + make it disappear, so if you click multiple points, you can + show multiple annotations. In *onout* mode, a click anywhere + else in the plot (on another data point or not) will hide this + annotation. If you need to show/hide this annotation in + response to different `x` or `y` values, you can set `xclick` + and/or `yclick`. This is useful for example to label the side + of a bar. To label markers though, `standoff` is preferred over + `xclick` and `yclick`. + + The 'clicktoshow' property is an enumeration that may be specified as: + - One of the following enumeration values: + [False, 'onoff', 'onout'] + + Returns + ------- + Any + """ + return self['clicktoshow'] + + @clicktoshow.setter + def clicktoshow(self, val): + self['clicktoshow'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the annotation text font. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.annotation.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.annotation.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # height + # ------ + @property + def height(self): + """ + Sets an explicit height for the text box. null (default) lets + the text set the box height. Taller text will be clipped. + + The 'height' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['height'] + + @height.setter + def height(self, val): + self['height'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.layout.annotation.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover label. + By default uses the annotation's `bgcolor` made + opaque, or white if it was transparent. + bordercolor + Sets the border color of the hover label. By + default uses either dark grey or white, for + maximum contrast with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses + the global hover font and size, with color from + `hoverlabel.bordercolor`. + + Returns + ------- + plotly.graph_objs.layout.annotation.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets text to appear when hovering over this annotation. If + omitted or blank, no hover label will appear. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the annotation (text + arrow). + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # showarrow + # --------- + @property + def showarrow(self): + """ + Determines whether or not the annotation is drawn with an + arrow. If *true*, `text` is placed near the arrow's tail. If + *false*, `text` lines up with the `x` and `y` provided. + + The 'showarrow' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showarrow'] + + @showarrow.setter + def showarrow(self, val): + self['showarrow'] = val + + # standoff + # -------- + @property + def standoff(self): + """ + Sets a distance, in pixels, to move the end arrowhead away from + the position it is pointing at, for example to point at the + edge of a marker independent of zoom. Note that this shortens + the arrow from the `ax` / `ay` vector, in contrast to `xshift` + / `yshift` which moves everything by this amount. + + The 'standoff' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['standoff'] + + @standoff.setter + def standoff(self, val): + self['standoff'] = val + + # startarrowhead + # -------------- + @property + def startarrowhead(self): + """ + Sets the start annotation arrow head style. + + The 'startarrowhead' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 8] + + Returns + ------- + int + """ + return self['startarrowhead'] + + @startarrowhead.setter + def startarrowhead(self, val): + self['startarrowhead'] = val + + # startarrowsize + # -------------- + @property + def startarrowsize(self): + """ + Sets the size of the start annotation arrow head, relative to + `arrowwidth`. A value of 1 (default) gives a head about 3x as + wide as the line. + + The 'startarrowsize' property is a number and may be specified as: + - An int or float in the interval [0.3, inf] + + Returns + ------- + int|float + """ + return self['startarrowsize'] + + @startarrowsize.setter + def startarrowsize(self, val): + self['startarrowsize'] = val + + # startstandoff + # ------------- + @property + def startstandoff(self): + """ + Sets a distance, in pixels, to move the start arrowhead away + from the position it is pointing at, for example to point at + the edge of a marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, in contrast to + `xshift` / `yshift` which moves everything by this amount. + + The 'startstandoff' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['startstandoff'] + + @startstandoff.setter + def startstandoff(self, val): + self['startstandoff'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text associated with this annotation. Plotly uses a + subset of HTML tags to do things like newline (
), bold + (), italics (), hyperlinks (). + Tags , , are also supported. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textangle + # --------- + @property + def textangle(self): + """ + Sets the angle at which the `text` is drawn with respect to the + horizontal. + + The 'textangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['textangle'] + + @textangle.setter + def textangle(self, val): + self['textangle'] = val + + # valign + # ------ + @property + def valign(self): + """ + Sets the vertical alignment of the `text` within the box. Has + an effect only if an explicit height is set to override the + text height. + + The 'valign' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['valign'] + + @valign.setter + def valign(self, val): + self['valign'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this annotation is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets an explicit width for the text box. null (default) lets + the text set the box width. Wider text will be clipped. There + is no automatic wrapping; use
to start a new line. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # x + # - + @property + def x(self): + """ + Sets the annotation's x position. If the axis `type` is *log*, + then you must take the log of your desired range. If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'x' property accepts values of any type + + Returns + ------- + Any + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the text box's horizontal position anchor This anchor + binds the `x` position to the *left*, *center* or *right* of + the annotation. For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the right-most portion of + the annotation lines up with the right-most edge of the + plotting area. If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is an arrow, + whereas for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xclick + # ------ + @property + def xclick(self): + """ + Toggle this annotation when clicking a data point whose `x` + value is `xclick` rather than the annotation's `x` value. + + The 'xclick' property accepts values of any type + + Returns + ------- + Any + """ + return self['xclick'] + + @xclick.setter + def xclick(self, val): + self['xclick'] = val + + # xref + # ---- + @property + def xref(self): + """ + Sets the annotation's x coordinate axis. If set to an x axis id + (e.g. *x* or *x2*), the `x` position refers to an x coordinate + If set to *paper*, the `x` position refers to the distance from + the left side of the plotting area in normalized coordinates + where 0 (1) corresponds to the left (right) side. + + The 'xref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['xref'] + + @xref.setter + def xref(self, val): + self['xref'] = val + + # xshift + # ------ + @property + def xshift(self): + """ + Shifts the position of the whole annotation and arrow to the + right (positive) or left (negative) by this many pixels. + + The 'xshift' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['xshift'] + + @xshift.setter + def xshift(self, val): + self['xshift'] = val + + # y + # - + @property + def y(self): + """ + Sets the annotation's y position. If the axis `type` is *log*, + then you must take the log of your desired range. If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'y' property accepts values of any type + + Returns + ------- + Any + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the text box's vertical position anchor This anchor binds + the `y` position to the *top*, *middle* or *bottom* of the + annotation. For example, if `y` is set to 1, `yref` to *paper* + and `yanchor` to *top* then the top-most portion of the + annotation lines up with the top-most edge of the plotting + area. If *auto*, the anchor is equivalent to *middle* for data- + referenced annotations or if there is an arrow, whereas for + paper-referenced with no arrow, the anchor picked corresponds + to the closest side. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # yclick + # ------ + @property + def yclick(self): + """ + Toggle this annotation when clicking a data point whose `y` + value is `yclick` rather than the annotation's `y` value. + + The 'yclick' property accepts values of any type + + Returns + ------- + Any + """ + return self['yclick'] + + @yclick.setter + def yclick(self, val): + self['yclick'] = val + + # yref + # ---- + @property + def yref(self): + """ + Sets the annotation's y coordinate axis. If set to an y axis id + (e.g. *y* or *y2*), the `y` position refers to an y coordinate + If set to *paper*, the `y` position refers to the distance from + the bottom of the plotting area in normalized coordinates where + 0 (1) corresponds to the bottom (top). + + The 'yref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['yref'] + + @yref.setter + def yref(self, val): + self['yref'] = val + + # yshift + # ------ + @property + def yshift(self): + """ + Shifts the position of the whole annotation and arrow up + (positive) or down (negative) by this many pixels. + + The 'yshift' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['yshift'] + + @yshift.setter + def yshift(self, val): + self['yshift'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + arrowwidth + Sets the width (in px) of annotation arrow line. + ax + Sets the x component of the arrow tail about the arrow + head. If `axref` is `pixel`, a positive (negative) + component corresponds to an arrow pointing from right + to left (left to right). If `axref` is an axis, this is + an absolute value on that axis, like `x`, NOT a + relative value. + axref + Indicates in what terms the tail of the annotation + (ax,ay) is specified. If `pixel`, `ax` is a relative + offset in pixels from `x`. If set to an x axis id + (e.g. *x* or *x2*), `ax` is specified in the same + terms as that axis. This is useful for trendline + annotations which should continue to indicate the + correct trend when zoomed. + ay + Sets the y component of the arrow tail about the arrow + head. If `ayref` is `pixel`, a positive (negative) + component corresponds to an arrow pointing from bottom + to top (top to bottom). If `ayref` is an axis, this is + an absolute value on that axis, like `y`, NOT a + relative value. + ayref + Indicates in what terms the tail of the annotation + (ax,ay) is specified. If `pixel`, `ay` is a relative + offset in pixels from `y`. If set to a y axis id (e.g. + *y* or *y2*), `ay` is specified in the same terms as + that axis. This is useful for trendline annotations + which should continue to indicate the correct trend + when zoomed. + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the annotation + `text`. + borderpad + Sets the padding (in px) between the `text` and the + enclosing border. + borderwidth + Sets the width (in px) of the border enclosing the + annotation `text`. + captureevents + Determines whether the annotation text box captures + mouse move and click events, or allows those events to + pass through to data points in the plot that may be + behind the annotation. By default `captureevents` is + *false* unless `hovertext` is provided. If you use the + event `plotly_clickannotation` without `hovertext` you + must explicitly enable `captureevents`. + clicktoshow + Makes this annotation respond to clicks on the plot. If + you click a data point that exactly matches the `x` and + `y` values of this annotation, and it is hidden + (visible: false), it will appear. In *onoff* mode, you + must click the same point again to make it disappear, + so if you click multiple points, you can show multiple + annotations. In *onout* mode, a click anywhere else in + the plot (on another data point or not) will hide this + annotation. If you need to show/hide this annotation in + response to different `x` or `y` values, you can set + `xclick` and/or `yclick`. This is useful for example to + label the side of a bar. To label markers though, + `standoff` is preferred over `xclick` and `yclick`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. Taller text + will be clipped. + hoverlabel + plotly.graph_objs.layout.annotation.Hoverlabel instance + or dict with compatible properties + hovertext + Sets text to appear when hovering over this annotation. + If omitted or blank, no hover label will appear. + opacity + Sets the opacity of the annotation (text + arrow). + showarrow + Determines whether or not the annotation is drawn with + an arrow. If *true*, `text` is placed near the arrow's + tail. If *false*, `text` lines up with the `x` and `y` + provided. + standoff + Sets a distance, in pixels, to move the end arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + startstandoff + Sets a distance, in pixels, to move the start arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. Plotly + uses a subset of HTML tags to do things like newline + (
), bold (), italics (), hyperlinks + (). Tags , , + are also supported. + textangle + Sets the angle at which the `text` is drawn with + respect to the horizontal. + valign + Sets the vertical alignment of the `text` within the + box. Has an effect only if an explicit height is set to + override the text height. + visible + Determines whether or not this annotation is visible. + width + Sets an explicit width for the text box. null (default) + lets the text set the box width. Wider text will be + clipped. There is no automatic wrapping; use
to + start a new line. + x + Sets the annotation's x position. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + xanchor + Sets the text box's horizontal position anchor This + anchor binds the `x` position to the *left*, *center* + or *right* of the annotation. For example, if `x` is + set to 1, `xref` to *paper* and `xanchor` to *right* + then the right-most portion of the annotation lines up + with the right-most edge of the plotting area. If + *auto*, the anchor is equivalent to *center* for data- + referenced annotations or if there is an arrow, whereas + for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + xclick + Toggle this annotation when clicking a data point whose + `x` value is `xclick` rather than the annotation's `x` + value. + xref + Sets the annotation's x coordinate axis. If set to an x + axis id (e.g. *x* or *x2*), the `x` position refers to + an x coordinate If set to *paper*, the `x` position + refers to the distance from the left side of the + plotting area in normalized coordinates where 0 (1) + corresponds to the left (right) side. + xshift + Shifts the position of the whole annotation and arrow + to the right (positive) or left (negative) by this many + pixels. + y + Sets the annotation's y position. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + yanchor + Sets the text box's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the annotation. For example, if `y` is set + to 1, `yref` to *paper* and `yanchor` to *top* then the + top-most portion of the annotation lines up with the + top-most edge of the plotting area. If *auto*, the + anchor is equivalent to *middle* for data-referenced + annotations or if there is an arrow, whereas for paper- + referenced with no arrow, the anchor picked corresponds + to the closest side. + yclick + Toggle this annotation when clicking a data point whose + `y` value is `yclick` rather than the annotation's `y` + value. + yref + Sets the annotation's y coordinate axis. If set to an y + axis id (e.g. *y* or *y2*), the `y` position refers to + an y coordinate If set to *paper*, the `y` position + refers to the distance from the bottom of the plotting + area in normalized coordinates where 0 (1) corresponds + to the bottom (top). + yshift + Shifts the position of the whole annotation and arrow + up (positive) or down (negative) by this many pixels. + """ + + def __init__( + self, + arg=None, + align=None, + arrowcolor=None, + arrowhead=None, + arrowside=None, + arrowsize=None, + arrowwidth=None, + ax=None, + axref=None, + ay=None, + ayref=None, + bgcolor=None, + bordercolor=None, + borderpad=None, + borderwidth=None, + captureevents=None, + clicktoshow=None, + font=None, + height=None, + hoverlabel=None, + hovertext=None, + opacity=None, + showarrow=None, + standoff=None, + startarrowhead=None, + startarrowsize=None, + startstandoff=None, + text=None, + textangle=None, + valign=None, + visible=None, + width=None, + x=None, + xanchor=None, + xclick=None, + xref=None, + xshift=None, + y=None, + yanchor=None, + yclick=None, + yref=None, + yshift=None, + **kwargs + ): + """ + Construct a new Annotation object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Annotation + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + arrowwidth + Sets the width (in px) of annotation arrow line. + ax + Sets the x component of the arrow tail about the arrow + head. If `axref` is `pixel`, a positive (negative) + component corresponds to an arrow pointing from right + to left (left to right). If `axref` is an axis, this is + an absolute value on that axis, like `x`, NOT a + relative value. + axref + Indicates in what terms the tail of the annotation + (ax,ay) is specified. If `pixel`, `ax` is a relative + offset in pixels from `x`. If set to an x axis id + (e.g. *x* or *x2*), `ax` is specified in the same + terms as that axis. This is useful for trendline + annotations which should continue to indicate the + correct trend when zoomed. + ay + Sets the y component of the arrow tail about the arrow + head. If `ayref` is `pixel`, a positive (negative) + component corresponds to an arrow pointing from bottom + to top (top to bottom). If `ayref` is an axis, this is + an absolute value on that axis, like `y`, NOT a + relative value. + ayref + Indicates in what terms the tail of the annotation + (ax,ay) is specified. If `pixel`, `ay` is a relative + offset in pixels from `y`. If set to a y axis id (e.g. + *y* or *y2*), `ay` is specified in the same terms as + that axis. This is useful for trendline annotations + which should continue to indicate the correct trend + when zoomed. + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the annotation + `text`. + borderpad + Sets the padding (in px) between the `text` and the + enclosing border. + borderwidth + Sets the width (in px) of the border enclosing the + annotation `text`. + captureevents + Determines whether the annotation text box captures + mouse move and click events, or allows those events to + pass through to data points in the plot that may be + behind the annotation. By default `captureevents` is + *false* unless `hovertext` is provided. If you use the + event `plotly_clickannotation` without `hovertext` you + must explicitly enable `captureevents`. + clicktoshow + Makes this annotation respond to clicks on the plot. If + you click a data point that exactly matches the `x` and + `y` values of this annotation, and it is hidden + (visible: false), it will appear. In *onoff* mode, you + must click the same point again to make it disappear, + so if you click multiple points, you can show multiple + annotations. In *onout* mode, a click anywhere else in + the plot (on another data point or not) will hide this + annotation. If you need to show/hide this annotation in + response to different `x` or `y` values, you can set + `xclick` and/or `yclick`. This is useful for example to + label the side of a bar. To label markers though, + `standoff` is preferred over `xclick` and `yclick`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. Taller text + will be clipped. + hoverlabel + plotly.graph_objs.layout.annotation.Hoverlabel instance + or dict with compatible properties + hovertext + Sets text to appear when hovering over this annotation. + If omitted or blank, no hover label will appear. + opacity + Sets the opacity of the annotation (text + arrow). + showarrow + Determines whether or not the annotation is drawn with + an arrow. If *true*, `text` is placed near the arrow's + tail. If *false*, `text` lines up with the `x` and `y` + provided. + standoff + Sets a distance, in pixels, to move the end arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + startstandoff + Sets a distance, in pixels, to move the start arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. Plotly + uses a subset of HTML tags to do things like newline + (
), bold (), italics (), hyperlinks + (). Tags , , + are also supported. + textangle + Sets the angle at which the `text` is drawn with + respect to the horizontal. + valign + Sets the vertical alignment of the `text` within the + box. Has an effect only if an explicit height is set to + override the text height. + visible + Determines whether or not this annotation is visible. + width + Sets an explicit width for the text box. null (default) + lets the text set the box width. Wider text will be + clipped. There is no automatic wrapping; use
to + start a new line. + x + Sets the annotation's x position. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + xanchor + Sets the text box's horizontal position anchor This + anchor binds the `x` position to the *left*, *center* + or *right* of the annotation. For example, if `x` is + set to 1, `xref` to *paper* and `xanchor` to *right* + then the right-most portion of the annotation lines up + with the right-most edge of the plotting area. If + *auto*, the anchor is equivalent to *center* for data- + referenced annotations or if there is an arrow, whereas + for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + xclick + Toggle this annotation when clicking a data point whose + `x` value is `xclick` rather than the annotation's `x` + value. + xref + Sets the annotation's x coordinate axis. If set to an x + axis id (e.g. *x* or *x2*), the `x` position refers to + an x coordinate If set to *paper*, the `x` position + refers to the distance from the left side of the + plotting area in normalized coordinates where 0 (1) + corresponds to the left (right) side. + xshift + Shifts the position of the whole annotation and arrow + to the right (positive) or left (negative) by this many + pixels. + y + Sets the annotation's y position. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + yanchor + Sets the text box's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the annotation. For example, if `y` is set + to 1, `yref` to *paper* and `yanchor` to *top* then the + top-most portion of the annotation lines up with the + top-most edge of the plotting area. If *auto*, the + anchor is equivalent to *middle* for data-referenced + annotations or if there is an arrow, whereas for paper- + referenced with no arrow, the anchor picked corresponds + to the closest side. + yclick + Toggle this annotation when clicking a data point whose + `y` value is `yclick` rather than the annotation's `y` + value. + yref + Sets the annotation's y coordinate axis. If set to an y + axis id (e.g. *y* or *y2*), the `y` position refers to + an y coordinate If set to *paper*, the `y` position + refers to the distance from the bottom of the plotting + area in normalized coordinates where 0 (1) corresponds + to the bottom (top). + yshift + Shifts the position of the whole annotation and arrow + up (positive) or down (negative) by this many pixels. + + Returns + ------- + Annotation + """ + super(Annotation, self).__init__('annotations') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Annotation +constructor must be a dict or +an instance of plotly.graph_objs.layout.Annotation""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (annotation as v_annotation) + + # Initialize validators + # --------------------- + self._validators['align'] = v_annotation.AlignValidator() + self._validators['arrowcolor'] = v_annotation.ArrowcolorValidator() + self._validators['arrowhead'] = v_annotation.ArrowheadValidator() + self._validators['arrowside'] = v_annotation.ArrowsideValidator() + self._validators['arrowsize'] = v_annotation.ArrowsizeValidator() + self._validators['arrowwidth'] = v_annotation.ArrowwidthValidator() + self._validators['ax'] = v_annotation.AxValidator() + self._validators['axref'] = v_annotation.AxrefValidator() + self._validators['ay'] = v_annotation.AyValidator() + self._validators['ayref'] = v_annotation.AyrefValidator() + self._validators['bgcolor'] = v_annotation.BgcolorValidator() + self._validators['bordercolor'] = v_annotation.BordercolorValidator() + self._validators['borderpad'] = v_annotation.BorderpadValidator() + self._validators['borderwidth'] = v_annotation.BorderwidthValidator() + self._validators['captureevents' + ] = v_annotation.CaptureeventsValidator() + self._validators['clicktoshow'] = v_annotation.ClicktoshowValidator() + self._validators['font'] = v_annotation.FontValidator() + self._validators['height'] = v_annotation.HeightValidator() + self._validators['hoverlabel'] = v_annotation.HoverlabelValidator() + self._validators['hovertext'] = v_annotation.HovertextValidator() + self._validators['opacity'] = v_annotation.OpacityValidator() + self._validators['showarrow'] = v_annotation.ShowarrowValidator() + self._validators['standoff'] = v_annotation.StandoffValidator() + self._validators['startarrowhead' + ] = v_annotation.StartarrowheadValidator() + self._validators['startarrowsize' + ] = v_annotation.StartarrowsizeValidator() + self._validators['startstandoff' + ] = v_annotation.StartstandoffValidator() + self._validators['text'] = v_annotation.TextValidator() + self._validators['textangle'] = v_annotation.TextangleValidator() + self._validators['valign'] = v_annotation.ValignValidator() + self._validators['visible'] = v_annotation.VisibleValidator() + self._validators['width'] = v_annotation.WidthValidator() + self._validators['x'] = v_annotation.XValidator() + self._validators['xanchor'] = v_annotation.XanchorValidator() + self._validators['xclick'] = v_annotation.XclickValidator() + self._validators['xref'] = v_annotation.XrefValidator() + self._validators['xshift'] = v_annotation.XshiftValidator() + self._validators['y'] = v_annotation.YValidator() + self._validators['yanchor'] = v_annotation.YanchorValidator() + self._validators['yclick'] = v_annotation.YclickValidator() + self._validators['yref'] = v_annotation.YrefValidator() + self._validators['yshift'] = v_annotation.YshiftValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('align', None) + self.align = align if align is not None else v + v = arg.pop('arrowcolor', None) + self.arrowcolor = arrowcolor if arrowcolor is not None else v + v = arg.pop('arrowhead', None) + self.arrowhead = arrowhead if arrowhead is not None else v + v = arg.pop('arrowside', None) + self.arrowside = arrowside if arrowside is not None else v + v = arg.pop('arrowsize', None) + self.arrowsize = arrowsize if arrowsize is not None else v + v = arg.pop('arrowwidth', None) + self.arrowwidth = arrowwidth if arrowwidth is not None else v + v = arg.pop('ax', None) + self.ax = ax if ax is not None else v + v = arg.pop('axref', None) + self.axref = axref if axref is not None else v + v = arg.pop('ay', None) + self.ay = ay if ay is not None else v + v = arg.pop('ayref', None) + self.ayref = ayref if ayref is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderpad', None) + self.borderpad = borderpad if borderpad is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('captureevents', None) + self.captureevents = captureevents if captureevents is not None else v + v = arg.pop('clicktoshow', None) + self.clicktoshow = clicktoshow if clicktoshow is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('height', None) + self.height = height if height is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('showarrow', None) + self.showarrow = showarrow if showarrow is not None else v + v = arg.pop('standoff', None) + self.standoff = standoff if standoff is not None else v + v = arg.pop('startarrowhead', None) + self.startarrowhead = startarrowhead if startarrowhead is not None else v + v = arg.pop('startarrowsize', None) + self.startarrowsize = startarrowsize if startarrowsize is not None else v + v = arg.pop('startstandoff', None) + self.startstandoff = startstandoff if startstandoff is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textangle', None) + self.textangle = textangle if textangle is not None else v + v = arg.pop('valign', None) + self.valign = valign if valign is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xclick', None) + self.xclick = xclick if xclick is not None else v + v = arg.pop('xref', None) + self.xref = xref if xref is not None else v + v = arg.pop('xshift', None) + self.xshift = xshift if xshift is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('yclick', None) + self.yclick = yclick if yclick is not None else v + v = arg.pop('yref', None) + self.yref = yref if yref is not None else v + v = arg.pop('yshift', None) + self.yshift = yshift if yshift is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_font.py b/plotly/graph_objs/layout/_font.py new file mode 100644 index 0000000000..2553d4a8ed --- /dev/null +++ b/plotly/graph_objs/layout/_font.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the global font. Note that fonts used in traces and other + layout components inherit from the global font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_geo.py b/plotly/graph_objs/layout/_geo.py new file mode 100644 index 0000000000..46016b1e4e --- /dev/null +++ b/plotly/graph_objs/layout/_geo.py @@ -0,0 +1,1357 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Geo(BaseLayoutHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Set the background color of the map + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # center + # ------ + @property + def center(self): + """ + The 'center' property is an instance of Center + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.Center + - A dict of string/value properties that will be passed + to the Center constructor + + Supported dict properties: + + lat + Sets the latitude of the map's center. For all + projection types, the map's latitude center + lies at the middle of the latitude range by + default. + lon + Sets the longitude of the map's center. By + default, the map's longitude center lies at the + middle of the longitude range for scoped + projection and above `projection.rotation.lon` + otherwise. + + Returns + ------- + plotly.graph_objs.layout.geo.Center + """ + return self['center'] + + @center.setter + def center(self, val): + self['center'] = val + + # coastlinecolor + # -------------- + @property + def coastlinecolor(self): + """ + Sets the coastline color. + + The 'coastlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['coastlinecolor'] + + @coastlinecolor.setter + def coastlinecolor(self, val): + self['coastlinecolor'] = val + + # coastlinewidth + # -------------- + @property + def coastlinewidth(self): + """ + Sets the coastline stroke width (in px). + + The 'coastlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['coastlinewidth'] + + @coastlinewidth.setter + def coastlinewidth(self, val): + self['coastlinewidth'] = val + + # countrycolor + # ------------ + @property + def countrycolor(self): + """ + Sets line color of the country boundaries. + + The 'countrycolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['countrycolor'] + + @countrycolor.setter + def countrycolor(self, val): + self['countrycolor'] = val + + # countrywidth + # ------------ + @property + def countrywidth(self): + """ + Sets line width (in px) of the country boundaries. + + The 'countrywidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['countrywidth'] + + @countrywidth.setter + def countrywidth(self, val): + self['countrywidth'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this geo subplot . + Note that geo subplots are constrained by + domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y + domain, but not both. + row + If there is a layout grid, use the domain for + this row in the grid for this geo subplot . + Note that geo subplots are constrained by + domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y + domain, but not both. + x + Sets the horizontal domain of this geo subplot + (in plot fraction). Note that geo subplots are + constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both. + y + Sets the vertical domain of this geo subplot + (in plot fraction). Note that geo subplots are + constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both. + + Returns + ------- + plotly.graph_objs.layout.geo.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # framecolor + # ---------- + @property + def framecolor(self): + """ + Sets the color the frame. + + The 'framecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['framecolor'] + + @framecolor.setter + def framecolor(self, val): + self['framecolor'] = val + + # framewidth + # ---------- + @property + def framewidth(self): + """ + Sets the stroke width (in px) of the frame. + + The 'framewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['framewidth'] + + @framewidth.setter + def framewidth(self, val): + self['framewidth'] = val + + # lakecolor + # --------- + @property + def lakecolor(self): + """ + Sets the color of the lakes. + + The 'lakecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['lakecolor'] + + @lakecolor.setter + def lakecolor(self, val): + self['lakecolor'] = val + + # landcolor + # --------- + @property + def landcolor(self): + """ + Sets the land mass color. + + The 'landcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['landcolor'] + + @landcolor.setter + def landcolor(self, val): + self['landcolor'] = val + + # lataxis + # ------- + @property + def lataxis(self): + """ + The 'lataxis' property is an instance of Lataxis + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.Lataxis + - A dict of string/value properties that will be passed + to the Lataxis constructor + + Supported dict properties: + + dtick + Sets the graticule's longitude/latitude tick + step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets + the map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the + map. + tick0 + Sets the graticule's starting tick + longitude/latitude. + + Returns + ------- + plotly.graph_objs.layout.geo.Lataxis + """ + return self['lataxis'] + + @lataxis.setter + def lataxis(self, val): + self['lataxis'] = val + + # lonaxis + # ------- + @property + def lonaxis(self): + """ + The 'lonaxis' property is an instance of Lonaxis + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.Lonaxis + - A dict of string/value properties that will be passed + to the Lonaxis constructor + + Supported dict properties: + + dtick + Sets the graticule's longitude/latitude tick + step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets + the map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the + map. + tick0 + Sets the graticule's starting tick + longitude/latitude. + + Returns + ------- + plotly.graph_objs.layout.geo.Lonaxis + """ + return self['lonaxis'] + + @lonaxis.setter + def lonaxis(self, val): + self['lonaxis'] = val + + # oceancolor + # ---------- + @property + def oceancolor(self): + """ + Sets the ocean color + + The 'oceancolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['oceancolor'] + + @oceancolor.setter + def oceancolor(self, val): + self['oceancolor'] = val + + # projection + # ---------- + @property + def projection(self): + """ + The 'projection' property is an instance of Projection + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.Projection + - A dict of string/value properties that will be passed + to the Projection constructor + + Supported dict properties: + + parallels + For conic projection types only. Sets the + parallels (tangent, secant) where the cone + intersects the sphere. + rotation + plotly.graph_objs.layout.geo.projection.Rotatio + n instance or dict with compatible properties + scale + Zooms in or out on the map view. A scale of *1* + corresponds to the largest zoom level that fits + the map's lon and lat ranges. + type + Sets the projection type. + + Returns + ------- + plotly.graph_objs.layout.geo.Projection + """ + return self['projection'] + + @projection.setter + def projection(self, val): + self['projection'] = val + + # resolution + # ---------- + @property + def resolution(self): + """ + Sets the resolution of the base layers. The values have units + of km/mm e.g. 110 corresponds to a scale ratio of + 1:110,000,000. + + The 'resolution' property is an enumeration that may be specified as: + - One of the following enumeration values: + [110, 50] + + Returns + ------- + Any + """ + return self['resolution'] + + @resolution.setter + def resolution(self, val): + self['resolution'] = val + + # rivercolor + # ---------- + @property + def rivercolor(self): + """ + Sets color of the rivers. + + The 'rivercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['rivercolor'] + + @rivercolor.setter + def rivercolor(self, val): + self['rivercolor'] = val + + # riverwidth + # ---------- + @property + def riverwidth(self): + """ + Sets the stroke width (in px) of the rivers. + + The 'riverwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['riverwidth'] + + @riverwidth.setter + def riverwidth(self, val): + self['riverwidth'] = val + + # scope + # ----- + @property + def scope(self): + """ + Set the scope of the map. + + The 'scope' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['world', 'usa', 'europe', 'asia', 'africa', 'north + america', 'south america'] + + Returns + ------- + Any + """ + return self['scope'] + + @scope.setter + def scope(self, val): + self['scope'] = val + + # showcoastlines + # -------------- + @property + def showcoastlines(self): + """ + Sets whether or not the coastlines are drawn. + + The 'showcoastlines' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showcoastlines'] + + @showcoastlines.setter + def showcoastlines(self, val): + self['showcoastlines'] = val + + # showcountries + # ------------- + @property + def showcountries(self): + """ + Sets whether or not country boundaries are drawn. + + The 'showcountries' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showcountries'] + + @showcountries.setter + def showcountries(self, val): + self['showcountries'] = val + + # showframe + # --------- + @property + def showframe(self): + """ + Sets whether or not a frame is drawn around the map. + + The 'showframe' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showframe'] + + @showframe.setter + def showframe(self, val): + self['showframe'] = val + + # showlakes + # --------- + @property + def showlakes(self): + """ + Sets whether or not lakes are drawn. + + The 'showlakes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showlakes'] + + @showlakes.setter + def showlakes(self, val): + self['showlakes'] = val + + # showland + # -------- + @property + def showland(self): + """ + Sets whether or not land masses are filled in color. + + The 'showland' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showland'] + + @showland.setter + def showland(self, val): + self['showland'] = val + + # showocean + # --------- + @property + def showocean(self): + """ + Sets whether or not oceans are filled in color. + + The 'showocean' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showocean'] + + @showocean.setter + def showocean(self, val): + self['showocean'] = val + + # showrivers + # ---------- + @property + def showrivers(self): + """ + Sets whether or not rivers are drawn. + + The 'showrivers' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showrivers'] + + @showrivers.setter + def showrivers(self, val): + self['showrivers'] = val + + # showsubunits + # ------------ + @property + def showsubunits(self): + """ + Sets whether or not boundaries of subunits within countries + (e.g. states, provinces) are drawn. + + The 'showsubunits' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showsubunits'] + + @showsubunits.setter + def showsubunits(self, val): + self['showsubunits'] = val + + # subunitcolor + # ------------ + @property + def subunitcolor(self): + """ + Sets the color of the subunits boundaries. + + The 'subunitcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['subunitcolor'] + + @subunitcolor.setter + def subunitcolor(self, val): + self['subunitcolor'] = val + + # subunitwidth + # ------------ + @property + def subunitwidth(self): + """ + Sets the stroke width (in px) of the subunits boundaries. + + The 'subunitwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['subunitwidth'] + + @subunitwidth.setter + def subunitwidth(self, val): + self['subunitwidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Set the background color of the map + center + plotly.graph_objs.layout.geo.Center instance or dict + with compatible properties + coastlinecolor + Sets the coastline color. + coastlinewidth + Sets the coastline stroke width (in px). + countrycolor + Sets line color of the country boundaries. + countrywidth + Sets line width (in px) of the country boundaries. + domain + plotly.graph_objs.layout.geo.Domain instance or dict + with compatible properties + framecolor + Sets the color the frame. + framewidth + Sets the stroke width (in px) of the frame. + lakecolor + Sets the color of the lakes. + landcolor + Sets the land mass color. + lataxis + plotly.graph_objs.layout.geo.Lataxis instance or dict + with compatible properties + lonaxis + plotly.graph_objs.layout.geo.Lonaxis instance or dict + with compatible properties + oceancolor + Sets the ocean color + projection + plotly.graph_objs.layout.geo.Projection instance or + dict with compatible properties + resolution + Sets the resolution of the base layers. The values have + units of km/mm e.g. 110 corresponds to a scale ratio of + 1:110,000,000. + rivercolor + Sets color of the rivers. + riverwidth + Sets the stroke width (in px) of the rivers. + scope + Set the scope of the map. + showcoastlines + Sets whether or not the coastlines are drawn. + showcountries + Sets whether or not country boundaries are drawn. + showframe + Sets whether or not a frame is drawn around the map. + showlakes + Sets whether or not lakes are drawn. + showland + Sets whether or not land masses are filled in color. + showocean + Sets whether or not oceans are filled in color. + showrivers + Sets whether or not rivers are drawn. + showsubunits + Sets whether or not boundaries of subunits within + countries (e.g. states, provinces) are drawn. + subunitcolor + Sets the color of the subunits boundaries. + subunitwidth + Sets the stroke width (in px) of the subunits + boundaries. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + center=None, + coastlinecolor=None, + coastlinewidth=None, + countrycolor=None, + countrywidth=None, + domain=None, + framecolor=None, + framewidth=None, + lakecolor=None, + landcolor=None, + lataxis=None, + lonaxis=None, + oceancolor=None, + projection=None, + resolution=None, + rivercolor=None, + riverwidth=None, + scope=None, + showcoastlines=None, + showcountries=None, + showframe=None, + showlakes=None, + showland=None, + showocean=None, + showrivers=None, + showsubunits=None, + subunitcolor=None, + subunitwidth=None, + **kwargs + ): + """ + Construct a new Geo object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Geo + bgcolor + Set the background color of the map + center + plotly.graph_objs.layout.geo.Center instance or dict + with compatible properties + coastlinecolor + Sets the coastline color. + coastlinewidth + Sets the coastline stroke width (in px). + countrycolor + Sets line color of the country boundaries. + countrywidth + Sets line width (in px) of the country boundaries. + domain + plotly.graph_objs.layout.geo.Domain instance or dict + with compatible properties + framecolor + Sets the color the frame. + framewidth + Sets the stroke width (in px) of the frame. + lakecolor + Sets the color of the lakes. + landcolor + Sets the land mass color. + lataxis + plotly.graph_objs.layout.geo.Lataxis instance or dict + with compatible properties + lonaxis + plotly.graph_objs.layout.geo.Lonaxis instance or dict + with compatible properties + oceancolor + Sets the ocean color + projection + plotly.graph_objs.layout.geo.Projection instance or + dict with compatible properties + resolution + Sets the resolution of the base layers. The values have + units of km/mm e.g. 110 corresponds to a scale ratio of + 1:110,000,000. + rivercolor + Sets color of the rivers. + riverwidth + Sets the stroke width (in px) of the rivers. + scope + Set the scope of the map. + showcoastlines + Sets whether or not the coastlines are drawn. + showcountries + Sets whether or not country boundaries are drawn. + showframe + Sets whether or not a frame is drawn around the map. + showlakes + Sets whether or not lakes are drawn. + showland + Sets whether or not land masses are filled in color. + showocean + Sets whether or not oceans are filled in color. + showrivers + Sets whether or not rivers are drawn. + showsubunits + Sets whether or not boundaries of subunits within + countries (e.g. states, provinces) are drawn. + subunitcolor + Sets the color of the subunits boundaries. + subunitwidth + Sets the stroke width (in px) of the subunits + boundaries. + + Returns + ------- + Geo + """ + super(Geo, self).__init__('geo') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Geo +constructor must be a dict or +an instance of plotly.graph_objs.layout.Geo""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (geo as v_geo) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_geo.BgcolorValidator() + self._validators['center'] = v_geo.CenterValidator() + self._validators['coastlinecolor'] = v_geo.CoastlinecolorValidator() + self._validators['coastlinewidth'] = v_geo.CoastlinewidthValidator() + self._validators['countrycolor'] = v_geo.CountrycolorValidator() + self._validators['countrywidth'] = v_geo.CountrywidthValidator() + self._validators['domain'] = v_geo.DomainValidator() + self._validators['framecolor'] = v_geo.FramecolorValidator() + self._validators['framewidth'] = v_geo.FramewidthValidator() + self._validators['lakecolor'] = v_geo.LakecolorValidator() + self._validators['landcolor'] = v_geo.LandcolorValidator() + self._validators['lataxis'] = v_geo.LataxisValidator() + self._validators['lonaxis'] = v_geo.LonaxisValidator() + self._validators['oceancolor'] = v_geo.OceancolorValidator() + self._validators['projection'] = v_geo.ProjectionValidator() + self._validators['resolution'] = v_geo.ResolutionValidator() + self._validators['rivercolor'] = v_geo.RivercolorValidator() + self._validators['riverwidth'] = v_geo.RiverwidthValidator() + self._validators['scope'] = v_geo.ScopeValidator() + self._validators['showcoastlines'] = v_geo.ShowcoastlinesValidator() + self._validators['showcountries'] = v_geo.ShowcountriesValidator() + self._validators['showframe'] = v_geo.ShowframeValidator() + self._validators['showlakes'] = v_geo.ShowlakesValidator() + self._validators['showland'] = v_geo.ShowlandValidator() + self._validators['showocean'] = v_geo.ShowoceanValidator() + self._validators['showrivers'] = v_geo.ShowriversValidator() + self._validators['showsubunits'] = v_geo.ShowsubunitsValidator() + self._validators['subunitcolor'] = v_geo.SubunitcolorValidator() + self._validators['subunitwidth'] = v_geo.SubunitwidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('center', None) + self.center = center if center is not None else v + v = arg.pop('coastlinecolor', None) + self.coastlinecolor = coastlinecolor if coastlinecolor is not None else v + v = arg.pop('coastlinewidth', None) + self.coastlinewidth = coastlinewidth if coastlinewidth is not None else v + v = arg.pop('countrycolor', None) + self.countrycolor = countrycolor if countrycolor is not None else v + v = arg.pop('countrywidth', None) + self.countrywidth = countrywidth if countrywidth is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('framecolor', None) + self.framecolor = framecolor if framecolor is not None else v + v = arg.pop('framewidth', None) + self.framewidth = framewidth if framewidth is not None else v + v = arg.pop('lakecolor', None) + self.lakecolor = lakecolor if lakecolor is not None else v + v = arg.pop('landcolor', None) + self.landcolor = landcolor if landcolor is not None else v + v = arg.pop('lataxis', None) + self.lataxis = lataxis if lataxis is not None else v + v = arg.pop('lonaxis', None) + self.lonaxis = lonaxis if lonaxis is not None else v + v = arg.pop('oceancolor', None) + self.oceancolor = oceancolor if oceancolor is not None else v + v = arg.pop('projection', None) + self.projection = projection if projection is not None else v + v = arg.pop('resolution', None) + self.resolution = resolution if resolution is not None else v + v = arg.pop('rivercolor', None) + self.rivercolor = rivercolor if rivercolor is not None else v + v = arg.pop('riverwidth', None) + self.riverwidth = riverwidth if riverwidth is not None else v + v = arg.pop('scope', None) + self.scope = scope if scope is not None else v + v = arg.pop('showcoastlines', None) + self.showcoastlines = showcoastlines if showcoastlines is not None else v + v = arg.pop('showcountries', None) + self.showcountries = showcountries if showcountries is not None else v + v = arg.pop('showframe', None) + self.showframe = showframe if showframe is not None else v + v = arg.pop('showlakes', None) + self.showlakes = showlakes if showlakes is not None else v + v = arg.pop('showland', None) + self.showland = showland if showland is not None else v + v = arg.pop('showocean', None) + self.showocean = showocean if showocean is not None else v + v = arg.pop('showrivers', None) + self.showrivers = showrivers if showrivers is not None else v + v = arg.pop('showsubunits', None) + self.showsubunits = showsubunits if showsubunits is not None else v + v = arg.pop('subunitcolor', None) + self.subunitcolor = subunitcolor if subunitcolor is not None else v + v = arg.pop('subunitwidth', None) + self.subunitwidth = subunitwidth if subunitwidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_grid.py b/plotly/graph_objs/layout/_grid.py new file mode 100644 index 0000000000..b3d4be0092 --- /dev/null +++ b/plotly/graph_objs/layout/_grid.py @@ -0,0 +1,573 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Grid(BaseLayoutHierarchyType): + + # columns + # ------- + @property + def columns(self): + """ + The number of columns in the grid. If you provide a 2D + `subplots` array, the length of its longest row is used as the + default. If you give an `xaxes` array, its length is used as + the default. But it's also possible to have a different length, + if you want to leave a row at the end for non-cartesian + subplots. + + The 'columns' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['columns'] + + @columns.setter + def columns(self, val): + self['columns'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.grid.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + x + Sets the horizontal domain of this grid subplot + (in plot fraction). The first and last cells + end exactly at the domain edges, with no grout + around the edges. + y + Sets the vertical domain of this grid subplot + (in plot fraction). The first and last cells + end exactly at the domain edges, with no grout + around the edges. + + Returns + ------- + plotly.graph_objs.layout.grid.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # pattern + # ------- + @property + def pattern(self): + """ + If no `subplots`, `xaxes`, or `yaxes` are given but we do have + `rows` and `columns`, we can generate defaults using + consecutive axis IDs, in two ways: *coupled* gives one x axis + per column and one y axis per row. *independent* uses a new xy + pair for each cell, left-to-right across each row then + iterating rows according to `roworder`. + + The 'pattern' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['independent', 'coupled'] + + Returns + ------- + Any + """ + return self['pattern'] + + @pattern.setter + def pattern(self, val): + self['pattern'] = val + + # roworder + # -------- + @property + def roworder(self): + """ + Is the first row the top or the bottom? Note that columns are + always enumerated from left to right. + + The 'roworder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top to bottom', 'bottom to top'] + + Returns + ------- + Any + """ + return self['roworder'] + + @roworder.setter + def roworder(self, val): + self['roworder'] = val + + # rows + # ---- + @property + def rows(self): + """ + The number of rows in the grid. If you provide a 2D `subplots` + array or a `yaxes` array, its length is used as the default. + But it's also possible to have a different length, if you want + to leave a row at the end for non-cartesian subplots. + + The 'rows' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['rows'] + + @rows.setter + def rows(self, val): + self['rows'] = val + + # subplots + # -------- + @property + def subplots(self): + """ + Used for freeform grids, where some axes may be shared across + subplots but others are not. Each entry should be a cartesian + subplot id, like *xy* or *x3y2*, or ** to leave that cell + empty. You may reuse x axes within the same column, and y axes + within the same row. Non-cartesian subplots and traces that + support `domain` can place themselves in this grid separately + using the `gridcell` attribute. + + The 'subplots' property is an info array that may be specified as a + list or tuple of up to 1 elements where: + + (0) The 'subplots[0]' property is an enumeration that may be specified as: + - One of the following enumeration values: + [''] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + list + """ + return self['subplots'] + + @subplots.setter + def subplots(self, val): + self['subplots'] = val + + # xaxes + # ----- + @property + def xaxes(self): + """ + Used with `yaxes` when the x and y axes are shared across + columns and rows. Each entry should be an x axis id like *x*, + *x2*, etc., or ** to not put an x axis in that column. Entries + other than ** must be unique. Ignored if `subplots` is present. + If missing but `yaxes` is present, will generate consecutive + IDs. + + The 'xaxes' property is an info array that may be specified as a + list or tuple of up to 1 elements where: + + (0) The 'xaxes[0]' property is an enumeration that may be specified as: + - One of the following enumeration values: + [''] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + list + """ + return self['xaxes'] + + @xaxes.setter + def xaxes(self, val): + self['xaxes'] = val + + # xgap + # ---- + @property + def xgap(self): + """ + Horizontal space between grid cells, expressed as a fraction of + the total width available to one cell. Defaults to 0.1 for + coupled-axes grids and 0.2 for independent grids. + + The 'xgap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['xgap'] + + @xgap.setter + def xgap(self, val): + self['xgap'] = val + + # xside + # ----- + @property + def xside(self): + """ + Sets where the x axis labels and titles go. *bottom* means the + very bottom of the grid. *bottom plot* is the lowest plot that + each x axis is used in. *top* and *top plot* are similar. + + The 'xside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['bottom', 'bottom plot', 'top plot', 'top'] + + Returns + ------- + Any + """ + return self['xside'] + + @xside.setter + def xside(self, val): + self['xside'] = val + + # yaxes + # ----- + @property + def yaxes(self): + """ + Used with `yaxes` when the x and y axes are shared across + columns and rows. Each entry should be an y axis id like *y*, + *y2*, etc., or ** to not put a y axis in that row. Entries + other than ** must be unique. Ignored if `subplots` is present. + If missing but `xaxes` is present, will generate consecutive + IDs. + + The 'yaxes' property is an info array that may be specified as a + list or tuple of up to 1 elements where: + + (0) The 'yaxes[0]' property is an enumeration that may be specified as: + - One of the following enumeration values: + [''] + - A string that matches one of the following regular expressions: + ['^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + list + """ + return self['yaxes'] + + @yaxes.setter + def yaxes(self, val): + self['yaxes'] = val + + # ygap + # ---- + @property + def ygap(self): + """ + Vertical space between grid cells, expressed as a fraction of + the total height available to one cell. Defaults to 0.1 for + coupled-axes grids and 0.3 for independent grids. + + The 'ygap' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['ygap'] + + @ygap.setter + def ygap(self, val): + self['ygap'] = val + + # yside + # ----- + @property + def yside(self): + """ + Sets where the y axis labels and titles go. *left* means the + very left edge of the grid. *left plot* is the leftmost plot + that each y axis is used in. *right* and *right plot* are + similar. + + The 'yside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'left plot', 'right plot', 'right'] + + Returns + ------- + Any + """ + return self['yside'] + + @yside.setter + def yside(self, val): + self['yside'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + columns + The number of columns in the grid. If you provide a 2D + `subplots` array, the length of its longest row is used + as the default. If you give an `xaxes` array, its + length is used as the default. But it's also possible + to have a different length, if you want to leave a row + at the end for non-cartesian subplots. + domain + plotly.graph_objs.layout.grid.Domain instance or dict + with compatible properties + pattern + If no `subplots`, `xaxes`, or `yaxes` are given but we + do have `rows` and `columns`, we can generate defaults + using consecutive axis IDs, in two ways: *coupled* + gives one x axis per column and one y axis per row. + *independent* uses a new xy pair for each cell, left- + to-right across each row then iterating rows according + to `roworder`. + roworder + Is the first row the top or the bottom? Note that + columns are always enumerated from left to right. + rows + The number of rows in the grid. If you provide a 2D + `subplots` array or a `yaxes` array, its length is used + as the default. But it's also possible to have a + different length, if you want to leave a row at the end + for non-cartesian subplots. + subplots + Used for freeform grids, where some axes may be shared + across subplots but others are not. Each entry should + be a cartesian subplot id, like *xy* or *x3y2*, or ** + to leave that cell empty. You may reuse x axes within + the same column, and y axes within the same row. Non- + cartesian subplots and traces that support `domain` can + place themselves in this grid separately using the + `gridcell` attribute. + xaxes + Used with `yaxes` when the x and y axes are shared + across columns and rows. Each entry should be an x axis + id like *x*, *x2*, etc., or ** to not put an x axis in + that column. Entries other than ** must be unique. + Ignored if `subplots` is present. If missing but + `yaxes` is present, will generate consecutive IDs. + xgap + Horizontal space between grid cells, expressed as a + fraction of the total width available to one cell. + Defaults to 0.1 for coupled-axes grids and 0.2 for + independent grids. + xside + Sets where the x axis labels and titles go. *bottom* + means the very bottom of the grid. *bottom plot* is the + lowest plot that each x axis is used in. *top* and *top + plot* are similar. + yaxes + Used with `yaxes` when the x and y axes are shared + across columns and rows. Each entry should be an y axis + id like *y*, *y2*, etc., or ** to not put a y axis in + that row. Entries other than ** must be unique. Ignored + if `subplots` is present. If missing but `xaxes` is + present, will generate consecutive IDs. + ygap + Vertical space between grid cells, expressed as a + fraction of the total height available to one cell. + Defaults to 0.1 for coupled-axes grids and 0.3 for + independent grids. + yside + Sets where the y axis labels and titles go. *left* + means the very left edge of the grid. *left plot* is + the leftmost plot that each y axis is used in. *right* + and *right plot* are similar. + """ + + def __init__( + self, + arg=None, + columns=None, + domain=None, + pattern=None, + roworder=None, + rows=None, + subplots=None, + xaxes=None, + xgap=None, + xside=None, + yaxes=None, + ygap=None, + yside=None, + **kwargs + ): + """ + Construct a new Grid object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Grid + columns + The number of columns in the grid. If you provide a 2D + `subplots` array, the length of its longest row is used + as the default. If you give an `xaxes` array, its + length is used as the default. But it's also possible + to have a different length, if you want to leave a row + at the end for non-cartesian subplots. + domain + plotly.graph_objs.layout.grid.Domain instance or dict + with compatible properties + pattern + If no `subplots`, `xaxes`, or `yaxes` are given but we + do have `rows` and `columns`, we can generate defaults + using consecutive axis IDs, in two ways: *coupled* + gives one x axis per column and one y axis per row. + *independent* uses a new xy pair for each cell, left- + to-right across each row then iterating rows according + to `roworder`. + roworder + Is the first row the top or the bottom? Note that + columns are always enumerated from left to right. + rows + The number of rows in the grid. If you provide a 2D + `subplots` array or a `yaxes` array, its length is used + as the default. But it's also possible to have a + different length, if you want to leave a row at the end + for non-cartesian subplots. + subplots + Used for freeform grids, where some axes may be shared + across subplots but others are not. Each entry should + be a cartesian subplot id, like *xy* or *x3y2*, or ** + to leave that cell empty. You may reuse x axes within + the same column, and y axes within the same row. Non- + cartesian subplots and traces that support `domain` can + place themselves in this grid separately using the + `gridcell` attribute. + xaxes + Used with `yaxes` when the x and y axes are shared + across columns and rows. Each entry should be an x axis + id like *x*, *x2*, etc., or ** to not put an x axis in + that column. Entries other than ** must be unique. + Ignored if `subplots` is present. If missing but + `yaxes` is present, will generate consecutive IDs. + xgap + Horizontal space between grid cells, expressed as a + fraction of the total width available to one cell. + Defaults to 0.1 for coupled-axes grids and 0.2 for + independent grids. + xside + Sets where the x axis labels and titles go. *bottom* + means the very bottom of the grid. *bottom plot* is the + lowest plot that each x axis is used in. *top* and *top + plot* are similar. + yaxes + Used with `yaxes` when the x and y axes are shared + across columns and rows. Each entry should be an y axis + id like *y*, *y2*, etc., or ** to not put a y axis in + that row. Entries other than ** must be unique. Ignored + if `subplots` is present. If missing but `xaxes` is + present, will generate consecutive IDs. + ygap + Vertical space between grid cells, expressed as a + fraction of the total height available to one cell. + Defaults to 0.1 for coupled-axes grids and 0.3 for + independent grids. + yside + Sets where the y axis labels and titles go. *left* + means the very left edge of the grid. *left plot* is + the leftmost plot that each y axis is used in. *right* + and *right plot* are similar. + + Returns + ------- + Grid + """ + super(Grid, self).__init__('grid') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Grid +constructor must be a dict or +an instance of plotly.graph_objs.layout.Grid""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (grid as v_grid) + + # Initialize validators + # --------------------- + self._validators['columns'] = v_grid.ColumnsValidator() + self._validators['domain'] = v_grid.DomainValidator() + self._validators['pattern'] = v_grid.PatternValidator() + self._validators['roworder'] = v_grid.RoworderValidator() + self._validators['rows'] = v_grid.RowsValidator() + self._validators['subplots'] = v_grid.SubplotsValidator() + self._validators['xaxes'] = v_grid.XaxesValidator() + self._validators['xgap'] = v_grid.XgapValidator() + self._validators['xside'] = v_grid.XsideValidator() + self._validators['yaxes'] = v_grid.YaxesValidator() + self._validators['ygap'] = v_grid.YgapValidator() + self._validators['yside'] = v_grid.YsideValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('columns', None) + self.columns = columns if columns is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('pattern', None) + self.pattern = pattern if pattern is not None else v + v = arg.pop('roworder', None) + self.roworder = roworder if roworder is not None else v + v = arg.pop('rows', None) + self.rows = rows if rows is not None else v + v = arg.pop('subplots', None) + self.subplots = subplots if subplots is not None else v + v = arg.pop('xaxes', None) + self.xaxes = xaxes if xaxes is not None else v + v = arg.pop('xgap', None) + self.xgap = xgap if xgap is not None else v + v = arg.pop('xside', None) + self.xside = xside if xside is not None else v + v = arg.pop('yaxes', None) + self.yaxes = yaxes if yaxes is not None else v + v = arg.pop('ygap', None) + self.ygap = ygap if ygap is not None else v + v = arg.pop('yside', None) + self.yside = yside if yside is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_hoverlabel.py b/plotly/graph_objs/layout/_hoverlabel.py new file mode 100644 index 0000000000..9673015e6f --- /dev/null +++ b/plotly/graph_objs/layout/_hoverlabel.py @@ -0,0 +1,304 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Hoverlabel(BaseLayoutHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of all hover labels on graph + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of all hover labels on graph. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the default hover label font used by all traces on the + graph. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the default length (in number of characters) of the trace + name in the hover labels for all traces. -1 shows the whole + name regardless of length. 0-3 shows the first 0-3 characters, + and an integer >3 will show the whole name if it is less than + that many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + + Returns + ------- + int + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of all hover labels on graph + bordercolor + Sets the border color of all hover labels on graph. + font + Sets the default hover label font used by all traces on + the graph. + namelength + Sets the default length (in number of characters) of + the trace name in the hover labels for all traces. -1 + shows the whole name regardless of length. 0-3 shows + the first 0-3 characters, and an integer >3 will show + the whole name if it is less than that many characters, + but if it is longer, will truncate to `namelength - 3` + characters and add an ellipsis. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + font=None, + namelength=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Hoverlabel + bgcolor + Sets the background color of all hover labels on graph + bordercolor + Sets the border color of all hover labels on graph. + font + Sets the default hover label font used by all traces on + the graph. + namelength + Sets the default length (in number of characters) of + the trace name in the hover labels for all traces. -1 + shows the whole name regardless of length. 0-3 shows + the first 0-3 characters, and an integer >3 will show + the whole name if it is less than that many characters, + but if it is longer, will truncate to `namelength - 3` + characters and add an ellipsis. + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.layout.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_image.py b/plotly/graph_objs/layout/_image.py new file mode 100644 index 0000000000..2c36d9c153 --- /dev/null +++ b/plotly/graph_objs/layout/_image.py @@ -0,0 +1,514 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Image(BaseLayoutHierarchyType): + + # layer + # ----- + @property + def layer(self): + """ + Specifies whether images are drawn below or above traces. When + `xref` and `yref` are both set to `paper`, image is drawn below + the entire plot area. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['below', 'above'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the image. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # sizex + # ----- + @property + def sizex(self): + """ + Sets the image container size horizontally. The image will be + sized based on the `position` value. When `xref` is set to + `paper`, units are sized relative to the plot width. + + The 'sizex' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizex'] + + @sizex.setter + def sizex(self, val): + self['sizex'] = val + + # sizey + # ----- + @property + def sizey(self): + """ + Sets the image container size vertically. The image will be + sized based on the `position` value. When `yref` is set to + `paper`, units are sized relative to the plot height. + + The 'sizey' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizey'] + + @sizey.setter + def sizey(self, val): + self['sizey'] = val + + # sizing + # ------ + @property + def sizing(self): + """ + Specifies which dimension of the image to constrain. + + The 'sizing' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fill', 'contain', 'stretch'] + + Returns + ------- + Any + """ + return self['sizing'] + + @sizing.setter + def sizing(self, val): + self['sizing'] = val + + # source + # ------ + @property + def source(self): + """ + Specifies the URL of the image to be used. The URL must be + accessible from the domain where the plot code is run, and can + be either relative or absolute. + + The 'source' property is an image URI that may be specified as: + - A remote image URI string + (e.g. 'http://www.somewhere.com/image.png') + - A data URI image string + (e.g. 'data:image/png;base64,iVBORw0KGgoAAAANSU') + - A PIL.Image.Image object which will be immediately converted + to a data URI image string + See http://pillow.readthedocs.io/en/latest/reference/Image.html + + Returns + ------- + str + """ + return self['source'] + + @source.setter + def source(self, val): + self['source'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this image is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the image's x position. When `xref` is set to `paper`, + units are sized relative to the plot height. See `xref` for + more info + + The 'x' property accepts values of any type + + Returns + ------- + Any + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the anchor for the x position + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xref + # ---- + @property + def xref(self): + """ + Sets the images's x coordinate axis. If set to a x axis id + (e.g. *x* or *x2*), the `x` position refers to an x data + coordinate If set to *paper*, the `x` position refers to the + distance from the left of plot in normalized coordinates where + *0* (*1*) corresponds to the left (right). + + The 'xref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['xref'] + + @xref.setter + def xref(self, val): + self['xref'] = val + + # y + # - + @property + def y(self): + """ + Sets the image's y position. When `yref` is set to `paper`, + units are sized relative to the plot height. See `yref` for + more info + + The 'y' property accepts values of any type + + Returns + ------- + Any + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the anchor for the y position. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # yref + # ---- + @property + def yref(self): + """ + Sets the images's y coordinate axis. If set to a y axis id + (e.g. *y* or *y2*), the `y` position refers to a y data + coordinate. If set to *paper*, the `y` position refers to the + distance from the bottom of the plot in normalized coordinates + where *0* (*1*) corresponds to the bottom (top). + + The 'yref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['yref'] + + @yref.setter + def yref(self, val): + self['yref'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + layer + Specifies whether images are drawn below or above + traces. When `xref` and `yref` are both set to `paper`, + image is drawn below the entire plot area. + opacity + Sets the opacity of the image. + sizex + Sets the image container size horizontally. The image + will be sized based on the `position` value. When + `xref` is set to `paper`, units are sized relative to + the plot width. + sizey + Sets the image container size vertically. The image + will be sized based on the `position` value. When + `yref` is set to `paper`, units are sized relative to + the plot height. + sizing + Specifies which dimension of the image to constrain. + source + Specifies the URL of the image to be used. The URL must + be accessible from the domain where the plot code is + run, and can be either relative or absolute. + visible + Determines whether or not this image is visible. + x + Sets the image's x position. When `xref` is set to + `paper`, units are sized relative to the plot height. + See `xref` for more info + xanchor + Sets the anchor for the x position + xref + Sets the images's x coordinate axis. If set to a x axis + id (e.g. *x* or *x2*), the `x` position refers to an x + data coordinate If set to *paper*, the `x` position + refers to the distance from the left of plot in + normalized coordinates where *0* (*1*) corresponds to + the left (right). + y + Sets the image's y position. When `yref` is set to + `paper`, units are sized relative to the plot height. + See `yref` for more info + yanchor + Sets the anchor for the y position. + yref + Sets the images's y coordinate axis. If set to a y axis + id (e.g. *y* or *y2*), the `y` position refers to a y + data coordinate. If set to *paper*, the `y` position + refers to the distance from the bottom of the plot in + normalized coordinates where *0* (*1*) corresponds to + the bottom (top). + """ + + def __init__( + self, + arg=None, + layer=None, + opacity=None, + sizex=None, + sizey=None, + sizing=None, + source=None, + visible=None, + x=None, + xanchor=None, + xref=None, + y=None, + yanchor=None, + yref=None, + **kwargs + ): + """ + Construct a new Image object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Image + layer + Specifies whether images are drawn below or above + traces. When `xref` and `yref` are both set to `paper`, + image is drawn below the entire plot area. + opacity + Sets the opacity of the image. + sizex + Sets the image container size horizontally. The image + will be sized based on the `position` value. When + `xref` is set to `paper`, units are sized relative to + the plot width. + sizey + Sets the image container size vertically. The image + will be sized based on the `position` value. When + `yref` is set to `paper`, units are sized relative to + the plot height. + sizing + Specifies which dimension of the image to constrain. + source + Specifies the URL of the image to be used. The URL must + be accessible from the domain where the plot code is + run, and can be either relative or absolute. + visible + Determines whether or not this image is visible. + x + Sets the image's x position. When `xref` is set to + `paper`, units are sized relative to the plot height. + See `xref` for more info + xanchor + Sets the anchor for the x position + xref + Sets the images's x coordinate axis. If set to a x axis + id (e.g. *x* or *x2*), the `x` position refers to an x + data coordinate If set to *paper*, the `x` position + refers to the distance from the left of plot in + normalized coordinates where *0* (*1*) corresponds to + the left (right). + y + Sets the image's y position. When `yref` is set to + `paper`, units are sized relative to the plot height. + See `yref` for more info + yanchor + Sets the anchor for the y position. + yref + Sets the images's y coordinate axis. If set to a y axis + id (e.g. *y* or *y2*), the `y` position refers to a y + data coordinate. If set to *paper*, the `y` position + refers to the distance from the bottom of the plot in + normalized coordinates where *0* (*1*) corresponds to + the bottom (top). + + Returns + ------- + Image + """ + super(Image, self).__init__('images') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Image +constructor must be a dict or +an instance of plotly.graph_objs.layout.Image""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (image as v_image) + + # Initialize validators + # --------------------- + self._validators['layer'] = v_image.LayerValidator() + self._validators['opacity'] = v_image.OpacityValidator() + self._validators['sizex'] = v_image.SizexValidator() + self._validators['sizey'] = v_image.SizeyValidator() + self._validators['sizing'] = v_image.SizingValidator() + self._validators['source'] = v_image.SourceValidator() + self._validators['visible'] = v_image.VisibleValidator() + self._validators['x'] = v_image.XValidator() + self._validators['xanchor'] = v_image.XanchorValidator() + self._validators['xref'] = v_image.XrefValidator() + self._validators['y'] = v_image.YValidator() + self._validators['yanchor'] = v_image.YanchorValidator() + self._validators['yref'] = v_image.YrefValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('sizex', None) + self.sizex = sizex if sizex is not None else v + v = arg.pop('sizey', None) + self.sizey = sizey if sizey is not None else v + v = arg.pop('sizing', None) + self.sizing = sizing if sizing is not None else v + v = arg.pop('source', None) + self.source = source if source is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xref', None) + self.xref = xref if xref is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('yref', None) + self.yref = yref if yref is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_legend.py b/plotly/graph_objs/layout/_legend.py new file mode 100644 index 0000000000..93dad91387 --- /dev/null +++ b/plotly/graph_objs/layout/_legend.py @@ -0,0 +1,526 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Legend(BaseLayoutHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the legend background color. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the legend. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the legend. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used to text the legend items. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.legend.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.legend.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation of the legend. + + The 'orientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['v', 'h'] + + Returns + ------- + Any + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # tracegroupgap + # ------------- + @property + def tracegroupgap(self): + """ + Sets the amount of vertical space (in px) between legend + groups. + + The 'tracegroupgap' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tracegroupgap'] + + @tracegroupgap.setter + def tracegroupgap(self, val): + self['tracegroupgap'] = val + + # traceorder + # ---------- + @property + def traceorder(self): + """ + Determines the order at which the legend items are displayed. + If *normal*, the items are displayed top-to-bottom in the same + order as the input data. If *reversed*, the items are displayed + in the opposite order as *normal*. If *grouped*, the items are + displayed in groups (when a trace `legendgroup` is provided). + if *grouped+reversed*, the items are displayed in the opposite + order as *grouped*. + + The 'traceorder' property is a flaglist and may be specified + as a string containing: + - Any combination of ['reversed', 'grouped'] joined with '+' characters + (e.g. 'reversed+grouped') + OR exactly one of ['normal'] (e.g. 'normal') + + Returns + ------- + Any + """ + return self['traceorder'] + + @traceorder.setter + def traceorder(self, val): + self['traceorder'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position (in normalized coordinates) of the legend. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the legend's horizontal position anchor. This anchor binds + the `x` position to the *left*, *center* or *right* of the + legend. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position (in normalized coordinates) of the legend. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the legend's vertical position anchor This anchor binds + the `y` position to the *top*, *middle* or *bottom* of the + legend. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the legend background color. + bordercolor + Sets the color of the border enclosing the legend. + borderwidth + Sets the width (in px) of the border enclosing the + legend. + font + Sets the font used to text the legend items. + orientation + Sets the orientation of the legend. + tracegroupgap + Sets the amount of vertical space (in px) between + legend groups. + traceorder + Determines the order at which the legend items are + displayed. If *normal*, the items are displayed top-to- + bottom in the same order as the input data. If + *reversed*, the items are displayed in the opposite + order as *normal*. If *grouped*, the items are + displayed in groups (when a trace `legendgroup` is + provided). if *grouped+reversed*, the items are + displayed in the opposite order as *grouped*. + x + Sets the x position (in normalized coordinates) of the + legend. + xanchor + Sets the legend's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the legend. + y + Sets the y position (in normalized coordinates) of the + legend. + yanchor + Sets the legend's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or + *bottom* of the legend. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + font=None, + orientation=None, + tracegroupgap=None, + traceorder=None, + x=None, + xanchor=None, + y=None, + yanchor=None, + **kwargs + ): + """ + Construct a new Legend object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Legend + bgcolor + Sets the legend background color. + bordercolor + Sets the color of the border enclosing the legend. + borderwidth + Sets the width (in px) of the border enclosing the + legend. + font + Sets the font used to text the legend items. + orientation + Sets the orientation of the legend. + tracegroupgap + Sets the amount of vertical space (in px) between + legend groups. + traceorder + Determines the order at which the legend items are + displayed. If *normal*, the items are displayed top-to- + bottom in the same order as the input data. If + *reversed*, the items are displayed in the opposite + order as *normal*. If *grouped*, the items are + displayed in groups (when a trace `legendgroup` is + provided). if *grouped+reversed*, the items are + displayed in the opposite order as *grouped*. + x + Sets the x position (in normalized coordinates) of the + legend. + xanchor + Sets the legend's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the legend. + y + Sets the y position (in normalized coordinates) of the + legend. + yanchor + Sets the legend's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or + *bottom* of the legend. + + Returns + ------- + Legend + """ + super(Legend, self).__init__('legend') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Legend +constructor must be a dict or +an instance of plotly.graph_objs.layout.Legend""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (legend as v_legend) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_legend.BgcolorValidator() + self._validators['bordercolor'] = v_legend.BordercolorValidator() + self._validators['borderwidth'] = v_legend.BorderwidthValidator() + self._validators['font'] = v_legend.FontValidator() + self._validators['orientation'] = v_legend.OrientationValidator() + self._validators['tracegroupgap'] = v_legend.TracegroupgapValidator() + self._validators['traceorder'] = v_legend.TraceorderValidator() + self._validators['x'] = v_legend.XValidator() + self._validators['xanchor'] = v_legend.XanchorValidator() + self._validators['y'] = v_legend.YValidator() + self._validators['yanchor'] = v_legend.YanchorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('tracegroupgap', None) + self.tracegroupgap = tracegroupgap if tracegroupgap is not None else v + v = arg.pop('traceorder', None) + self.traceorder = traceorder if traceorder is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_mapbox.py b/plotly/graph_objs/layout/_mapbox.py new file mode 100644 index 0000000000..1ad493b255 --- /dev/null +++ b/plotly/graph_objs/layout/_mapbox.py @@ -0,0 +1,390 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Mapbox(BaseLayoutHierarchyType): + + # accesstoken + # ----------- + @property + def accesstoken(self): + """ + Sets the mapbox access token to be used for this mapbox map. + Alternatively, the mapbox access token can be set in the + configuration options under `mapboxAccessToken`. + + The 'accesstoken' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['accesstoken'] + + @accesstoken.setter + def accesstoken(self, val): + self['accesstoken'] = val + + # bearing + # ------- + @property + def bearing(self): + """ + Sets the bearing angle of the map (in degrees counter-clockwise + from North). + + The 'bearing' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['bearing'] + + @bearing.setter + def bearing(self, val): + self['bearing'] = val + + # center + # ------ + @property + def center(self): + """ + The 'center' property is an instance of Center + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.Center + - A dict of string/value properties that will be passed + to the Center constructor + + Supported dict properties: + + lat + Sets the latitude of the center of the map (in + degrees North). + lon + Sets the longitude of the center of the map (in + degrees East). + + Returns + ------- + plotly.graph_objs.layout.mapbox.Center + """ + return self['center'] + + @center.setter + def center(self, val): + self['center'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this mapbox subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this mapbox subplot . + x + Sets the horizontal domain of this mapbox + subplot (in plot fraction). + y + Sets the vertical domain of this mapbox subplot + (in plot fraction). + + Returns + ------- + plotly.graph_objs.layout.mapbox.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # layers + # ------ + @property + def layers(self): + """ + The 'layers' property is a tuple of instances of + Layer that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.mapbox.Layer + - A list or tuple of dicts of string/value properties that + will be passed to the Layer constructor + + Supported dict properties: + + below + Determines if the layer will be inserted before + the layer with the specified ID. If omitted or + set to '', the layer will be inserted above + every existing layer. + circle + plotly.graph_objs.layout.mapbox.layer.Circle + instance or dict with compatible properties + color + Sets the primary layer color. If `type` is + *circle*, color corresponds to the circle color + If `type` is *line*, color corresponds to the + line color If `type` is *fill*, color + corresponds to the fill color If `type` is + *symbol*, color corresponds to the icon color + fill + plotly.graph_objs.layout.mapbox.layer.Fill + instance or dict with compatible properties + line + plotly.graph_objs.layout.mapbox.layer.Line + instance or dict with compatible properties + opacity + Sets the opacity of the layer. + source + Sets the source data for this layer. Source can + be either a URL, a geojson object (with + `sourcetype` set to *geojson*) or an array of + tile URLS (with `sourcetype` set to *vector*). + sourcelayer + Specifies the layer to use from a vector tile + source. Required for *vector* source type that + supports multiple layers. + sourcetype + Sets the source type for this layer. Support + for *raster*, *image* and *video* source types + is coming soon. + symbol + plotly.graph_objs.layout.mapbox.layer.Symbol + instance or dict with compatible properties + type + Sets the layer type. Support for *raster*, + *background* types is coming soon. Note that + *line* and *fill* are not compatible with Point + GeoJSON geometries. + + Returns + ------- + tuple[plotly.graph_objs.layout.mapbox.Layer] + """ + return self['layers'] + + @layers.setter + def layers(self, val): + self['layers'] = val + + # pitch + # ----- + @property + def pitch(self): + """ + Sets the pitch angle of the map (in degrees, where *0* means + perpendicular to the surface of the map). + + The 'pitch' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['pitch'] + + @pitch.setter + def pitch(self, val): + self['pitch'] = val + + # style + # ----- + @property + def style(self): + """ + Sets the Mapbox map style. Either input one of the default + Mapbox style names or the URL to a custom style or a valid + Mapbox style JSON. + + The 'style' property accepts values of any type + + Returns + ------- + Any + """ + return self['style'] + + @style.setter + def style(self, val): + self['style'] = val + + # zoom + # ---- + @property + def zoom(self): + """ + Sets the zoom level of the map. + + The 'zoom' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zoom'] + + @zoom.setter + def zoom(self, val): + self['zoom'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + accesstoken + Sets the mapbox access token to be used for this mapbox + map. Alternatively, the mapbox access token can be set + in the configuration options under `mapboxAccessToken`. + bearing + Sets the bearing angle of the map (in degrees counter- + clockwise from North). + center + plotly.graph_objs.layout.mapbox.Center instance or dict + with compatible properties + domain + plotly.graph_objs.layout.mapbox.Domain instance or dict + with compatible properties + layers + plotly.graph_objs.layout.mapbox.Layer instance or dict + with compatible properties + pitch + Sets the pitch angle of the map (in degrees, where *0* + means perpendicular to the surface of the map). + style + Sets the Mapbox map style. Either input one of the + default Mapbox style names or the URL to a custom style + or a valid Mapbox style JSON. + zoom + Sets the zoom level of the map. + """ + + def __init__( + self, + arg=None, + accesstoken=None, + bearing=None, + center=None, + domain=None, + layers=None, + pitch=None, + style=None, + zoom=None, + **kwargs + ): + """ + Construct a new Mapbox object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Mapbox + accesstoken + Sets the mapbox access token to be used for this mapbox + map. Alternatively, the mapbox access token can be set + in the configuration options under `mapboxAccessToken`. + bearing + Sets the bearing angle of the map (in degrees counter- + clockwise from North). + center + plotly.graph_objs.layout.mapbox.Center instance or dict + with compatible properties + domain + plotly.graph_objs.layout.mapbox.Domain instance or dict + with compatible properties + layers + plotly.graph_objs.layout.mapbox.Layer instance or dict + with compatible properties + pitch + Sets the pitch angle of the map (in degrees, where *0* + means perpendicular to the surface of the map). + style + Sets the Mapbox map style. Either input one of the + default Mapbox style names or the URL to a custom style + or a valid Mapbox style JSON. + zoom + Sets the zoom level of the map. + + Returns + ------- + Mapbox + """ + super(Mapbox, self).__init__('mapbox') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Mapbox +constructor must be a dict or +an instance of plotly.graph_objs.layout.Mapbox""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (mapbox as v_mapbox) + + # Initialize validators + # --------------------- + self._validators['accesstoken'] = v_mapbox.AccesstokenValidator() + self._validators['bearing'] = v_mapbox.BearingValidator() + self._validators['center'] = v_mapbox.CenterValidator() + self._validators['domain'] = v_mapbox.DomainValidator() + self._validators['layers'] = v_mapbox.LayersValidator() + self._validators['pitch'] = v_mapbox.PitchValidator() + self._validators['style'] = v_mapbox.StyleValidator() + self._validators['zoom'] = v_mapbox.ZoomValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('accesstoken', None) + self.accesstoken = accesstoken if accesstoken is not None else v + v = arg.pop('bearing', None) + self.bearing = bearing if bearing is not None else v + v = arg.pop('center', None) + self.center = center if center is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('layers', None) + self.layers = layers if layers is not None else v + v = arg.pop('pitch', None) + self.pitch = pitch if pitch is not None else v + v = arg.pop('style', None) + self.style = style if style is not None else v + v = arg.pop('zoom', None) + self.zoom = zoom if zoom is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_margin.py b/plotly/graph_objs/layout/_margin.py new file mode 100644 index 0000000000..a81ee03493 --- /dev/null +++ b/plotly/graph_objs/layout/_margin.py @@ -0,0 +1,237 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Margin(BaseLayoutHierarchyType): + + # autoexpand + # ---------- + @property + def autoexpand(self): + """ + The 'autoexpand' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autoexpand'] + + @autoexpand.setter + def autoexpand(self, val): + self['autoexpand'] = val + + # b + # - + @property + def b(self): + """ + Sets the bottom margin (in px). + + The 'b' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # l + # - + @property + def l(self): + """ + Sets the left margin (in px). + + The 'l' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['l'] + + @l.setter + def l(self, val): + self['l'] = val + + # pad + # --- + @property + def pad(self): + """ + Sets the amount of padding (in px) between the plotting area + and the axis lines + + The 'pad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['pad'] + + @pad.setter + def pad(self, val): + self['pad'] = val + + # r + # - + @property + def r(self): + """ + Sets the right margin (in px). + + The 'r' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # t + # - + @property + def t(self): + """ + Sets the top margin (in px). + + The 't' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autoexpand + + b + Sets the bottom margin (in px). + l + Sets the left margin (in px). + pad + Sets the amount of padding (in px) between the plotting + area and the axis lines + r + Sets the right margin (in px). + t + Sets the top margin (in px). + """ + + def __init__( + self, + arg=None, + autoexpand=None, + b=None, + l=None, + pad=None, + r=None, + t=None, + **kwargs + ): + """ + Construct a new Margin object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Margin + autoexpand + + b + Sets the bottom margin (in px). + l + Sets the left margin (in px). + pad + Sets the amount of padding (in px) between the plotting + area and the axis lines + r + Sets the right margin (in px). + t + Sets the top margin (in px). + + Returns + ------- + Margin + """ + super(Margin, self).__init__('margin') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Margin +constructor must be a dict or +an instance of plotly.graph_objs.layout.Margin""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (margin as v_margin) + + # Initialize validators + # --------------------- + self._validators['autoexpand'] = v_margin.AutoexpandValidator() + self._validators['b'] = v_margin.BValidator() + self._validators['l'] = v_margin.LValidator() + self._validators['pad'] = v_margin.PadValidator() + self._validators['r'] = v_margin.RValidator() + self._validators['t'] = v_margin.TValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autoexpand', None) + self.autoexpand = autoexpand if autoexpand is not None else v + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('l', None) + self.l = l if l is not None else v + v = arg.pop('pad', None) + self.pad = pad if pad is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_polar.py b/plotly/graph_objs/layout/_polar.py new file mode 100644 index 0000000000..fd399723dc --- /dev/null +++ b/plotly/graph_objs/layout/_polar.py @@ -0,0 +1,778 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Polar(BaseLayoutHierarchyType): + + # angularaxis + # ----------- + @property + def angularaxis(self): + """ + The 'angularaxis' property is an instance of AngularAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.AngularAxis + - A dict of string/value properties that will be passed + to the AngularAxis constructor + + Supported dict properties: + + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + direction + Sets the direction corresponding to positive + angles. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + period + Set the angular period. Has an effect only when + `angularaxis.type` is *category*. + rotation + Sets that start position (in degrees) of the + angular axis By default, polar subplots with + `direction` set to *counterclockwise* get a + `rotation` of *0* which corresponds to due East + (like what mathematicians prefer). In turn, + polar with `direction` set to *clockwise* get a + rotation of *90* which corresponds to due North + (like on a compass), + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thetaunit + Sets the format unit of the formatted *theta* + values. Has an effect only when + `angularaxis.type` is *linear*. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.angularaxis.Tick + formatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + type + Sets the angular axis type. If *linear*, set + `thetaunit` to determine the unit in which axis + value are shown. If *category, use `period` to + set the number of integer coordinates around + polar axis. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + + Returns + ------- + plotly.graph_objs.layout.polar.AngularAxis + """ + return self['angularaxis'] + + @angularaxis.setter + def angularaxis(self, val): + self['angularaxis'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Set the background color of the subplot + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this polar subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this polar subplot . + x + Sets the horizontal domain of this polar + subplot (in plot fraction). + y + Sets the vertical domain of this polar subplot + (in plot fraction). + + Returns + ------- + plotly.graph_objs.layout.polar.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # radialaxis + # ---------- + @property + def radialaxis(self): + """ + The 'radialaxis' property is an instance of RadialAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.RadialAxis + - A dict of string/value properties that will be passed + to the RadialAxis constructor + + Supported dict properties: + + angle + Sets the angle (in degrees) from which the + radial axis is drawn. Note that by default, + radial axis line on the theta=0 line + corresponds to a line pointing right (like what + mathematicians prefer). Defaults to the first + `polar.sector` angle. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, + the range is non-negative, regardless of the + input data. If *normal*, the range is computed + in relation to the extrema of the input data + (same behavior as for cartesian axes). + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines on which side of radial axis line + the tick and tick labels appear. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.radialaxis.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + + Returns + ------- + plotly.graph_objs.layout.polar.RadialAxis + """ + return self['radialaxis'] + + @radialaxis.setter + def radialaxis(self, val): + self['radialaxis'] = val + + # sector + # ------ + @property + def sector(self): + """ + Sets angular span of this polar subplot with two angles (in + degrees). Sector are assumed to be spanned in the + counterclockwise direction with *0* corresponding to rightmost + limit of the polar subplot. + + The 'sector' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'sector[0]' property is a number and may be specified as: + - An int or float + (1) The 'sector[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['sector'] + + @sector.setter + def sector(self, val): + self['sector'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + angularaxis + plotly.graph_objs.layout.polar.AngularAxis instance or + dict with compatible properties + bgcolor + Set the background color of the subplot + domain + plotly.graph_objs.layout.polar.Domain instance or dict + with compatible properties + radialaxis + plotly.graph_objs.layout.polar.RadialAxis instance or + dict with compatible properties + sector + Sets angular span of this polar subplot with two angles + (in degrees). Sector are assumed to be spanned in the + counterclockwise direction with *0* corresponding to + rightmost limit of the polar subplot. + """ + + def __init__( + self, + arg=None, + angularaxis=None, + bgcolor=None, + domain=None, + radialaxis=None, + sector=None, + **kwargs + ): + """ + Construct a new Polar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Polar + angularaxis + plotly.graph_objs.layout.polar.AngularAxis instance or + dict with compatible properties + bgcolor + Set the background color of the subplot + domain + plotly.graph_objs.layout.polar.Domain instance or dict + with compatible properties + radialaxis + plotly.graph_objs.layout.polar.RadialAxis instance or + dict with compatible properties + sector + Sets angular span of this polar subplot with two angles + (in degrees). Sector are assumed to be spanned in the + counterclockwise direction with *0* corresponding to + rightmost limit of the polar subplot. + + Returns + ------- + Polar + """ + super(Polar, self).__init__('polar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Polar +constructor must be a dict or +an instance of plotly.graph_objs.layout.Polar""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (polar as v_polar) + + # Initialize validators + # --------------------- + self._validators['angularaxis'] = v_polar.AngularAxisValidator() + self._validators['bgcolor'] = v_polar.BgcolorValidator() + self._validators['domain'] = v_polar.DomainValidator() + self._validators['radialaxis'] = v_polar.RadialAxisValidator() + self._validators['sector'] = v_polar.SectorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('angularaxis', None) + self.angularaxis = angularaxis if angularaxis is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('radialaxis', None) + self.radialaxis = radialaxis if radialaxis is not None else v + v = arg.pop('sector', None) + self.sector = sector if sector is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_radialaxis.py b/plotly/graph_objs/layout/_radialaxis.py new file mode 100644 index 0000000000..c6184fa429 --- /dev/null +++ b/plotly/graph_objs/layout/_radialaxis.py @@ -0,0 +1,442 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class RadialAxis(BaseLayoutHierarchyType): + + # domain + # ------ + @property + def domain(self): + """ + Polar chart subplots are not supported yet. This key has + currently no effect. + + The 'domain' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'domain[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'domain[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # endpadding + # ---------- + @property + def endpadding(self): + """ + The 'endpadding' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['endpadding'] + + @endpadding.setter + def endpadding(self, val): + self['endpadding'] = val + + # orientation + # ----------- + @property + def orientation(self): + """ + Sets the orientation (an angle with respect to the origin) of + the radial axis. + + The 'orientation' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['orientation'] + + @orientation.setter + def orientation(self, val): + self['orientation'] = val + + # range + # ----- + @property + def range(self): + """ + Defines the start and end point of this radial axis. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property is a number and may be specified as: + - An int or float + (1) The 'range[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not the line bounding this radial axis + will be shown on the figure. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the radial axis ticks will feature + tick labels. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the color of the tick lines on this radial axis. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the length of the tick lines on this radial axis. + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickorientation + # --------------- + @property + def tickorientation(self): + """ + Sets the orientation (from the paper perspective) of the radial + axis tick labels. + + The 'tickorientation' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['horizontal', 'vertical'] + + Returns + ------- + Any + """ + return self['tickorientation'] + + @tickorientation.setter + def tickorientation(self, val): + self['tickorientation'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets the length of the tick lines on this radial axis. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this axis will be visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + domain + Polar chart subplots are not supported yet. This key + has currently no effect. + endpadding + + orientation + Sets the orientation (an angle with respect to the + origin) of the radial axis. + range + Defines the start and end point of this radial axis. + showline + Determines whether or not the line bounding this radial + axis will be shown on the figure. + showticklabels + Determines whether or not the radial axis ticks will + feature tick labels. + tickcolor + Sets the color of the tick lines on this radial axis. + ticklen + Sets the length of the tick lines on this radial axis. + tickorientation + Sets the orientation (from the paper perspective) of + the radial axis tick labels. + ticksuffix + Sets the length of the tick lines on this radial axis. + visible + Determines whether or not this axis will be visible. + """ + + def __init__( + self, + arg=None, + domain=None, + endpadding=None, + orientation=None, + range=None, + showline=None, + showticklabels=None, + tickcolor=None, + ticklen=None, + tickorientation=None, + ticksuffix=None, + visible=None, + **kwargs + ): + """ + Construct a new RadialAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.RadialAxis + domain + Polar chart subplots are not supported yet. This key + has currently no effect. + endpadding + + orientation + Sets the orientation (an angle with respect to the + origin) of the radial axis. + range + Defines the start and end point of this radial axis. + showline + Determines whether or not the line bounding this radial + axis will be shown on the figure. + showticklabels + Determines whether or not the radial axis ticks will + feature tick labels. + tickcolor + Sets the color of the tick lines on this radial axis. + ticklen + Sets the length of the tick lines on this radial axis. + tickorientation + Sets the orientation (from the paper perspective) of + the radial axis tick labels. + ticksuffix + Sets the length of the tick lines on this radial axis. + visible + Determines whether or not this axis will be visible. + + Returns + ------- + RadialAxis + """ + super(RadialAxis, self).__init__('radialaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.RadialAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.RadialAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (radialaxis as v_radialaxis) + + # Initialize validators + # --------------------- + self._validators['domain'] = v_radialaxis.DomainValidator() + self._validators['endpadding'] = v_radialaxis.EndpaddingValidator() + self._validators['orientation'] = v_radialaxis.OrientationValidator() + self._validators['range'] = v_radialaxis.RangeValidator() + self._validators['showline'] = v_radialaxis.ShowlineValidator() + self._validators['showticklabels' + ] = v_radialaxis.ShowticklabelsValidator() + self._validators['tickcolor'] = v_radialaxis.TickcolorValidator() + self._validators['ticklen'] = v_radialaxis.TicklenValidator() + self._validators['tickorientation' + ] = v_radialaxis.TickorientationValidator() + self._validators['ticksuffix'] = v_radialaxis.TicksuffixValidator() + self._validators['visible'] = v_radialaxis.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('endpadding', None) + self.endpadding = endpadding if endpadding is not None else v + v = arg.pop('orientation', None) + self.orientation = orientation if orientation is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickorientation', None) + self.tickorientation = tickorientation if tickorientation is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_scene.py b/plotly/graph_objs/layout/_scene.py new file mode 100644 index 0000000000..f8b736935c --- /dev/null +++ b/plotly/graph_objs/layout/_scene.py @@ -0,0 +1,1487 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Scene(BaseLayoutHierarchyType): + + # annotations + # ----------- + @property + def annotations(self): + """ + The 'annotations' property is a tuple of instances of + Annotation that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.scene.Annotation + - A list or tuple of dicts of string/value properties that + will be passed to the Annotation constructor + + Supported dict properties: + + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + arrowwidth + Sets the width (in px) of annotation arrow + line. + ax + Sets the x component of the arrow tail about + the arrow head (in pixels). + ay + Sets the y component of the arrow tail about + the arrow head (in pixels). + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the + annotation `text`. + borderpad + Sets the padding (in px) between the `text` and + the enclosing border. + borderwidth + Sets the width (in px) of the border enclosing + the annotation `text`. + captureevents + Determines whether the annotation text box + captures mouse move and click events, or allows + those events to pass through to data points in + the plot that may be behind the annotation. By + default `captureevents` is *false* unless + `hovertext` is provided. If you use the event + `plotly_clickannotation` without `hovertext` + you must explicitly enable `captureevents`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. + Taller text will be clipped. + hoverlabel + plotly.graph_objs.layout.scene.annotation.Hover + label instance or dict with compatible + properties + hovertext + Sets text to appear when hovering over this + annotation. If omitted or blank, no hover label + will appear. + opacity + Sets the opacity of the annotation (text + + arrow). + showarrow + Determines whether or not the annotation is + drawn with an arrow. If *true*, `text` is + placed near the arrow's tail. If *false*, + `text` lines up with the `x` and `y` provided. + standoff + Sets a distance, in pixels, to move the end + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow + head, relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + startstandoff + Sets a distance, in pixels, to move the start + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. + Plotly uses a subset of HTML tags to do things + like newline (
), bold (), italics + (), hyperlinks (). + Tags , , are also + supported. + textangle + Sets the angle at which the `text` is drawn + with respect to the horizontal. + valign + Sets the vertical alignment of the `text` + within the box. Has an effect only if an + explicit height is set to override the text + height. + visible + Determines whether or not this annotation is + visible. + width + Sets an explicit width for the text box. null + (default) lets the text set the box width. + Wider text will be clipped. There is no + automatic wrapping; use
to start a new + line. + x + Sets the annotation's x position. + xanchor + Sets the text box's horizontal position anchor + This anchor binds the `x` position to the + *left*, *center* or *right* of the annotation. + For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the + right-most portion of the annotation lines up + with the right-most edge of the plotting area. + If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + xshift + Shifts the position of the whole annotation and + arrow to the right (positive) or left + (negative) by this many pixels. + y + Sets the annotation's y position. + yanchor + Sets the text box's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the annotation. + For example, if `y` is set to 1, `yref` to + *paper* and `yanchor` to *top* then the top- + most portion of the annotation lines up with + the top-most edge of the plotting area. If + *auto*, the anchor is equivalent to *middle* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + yshift + Shifts the position of the whole annotation and + arrow up (positive) or down (negative) by this + many pixels. + z + Sets the annotation's z position. + + Returns + ------- + tuple[plotly.graph_objs.layout.scene.Annotation] + """ + return self['annotations'] + + @annotations.setter + def annotations(self, val): + self['annotations'] = val + + # aspectmode + # ---------- + @property + def aspectmode(self): + """ + If *cube*, this scene's axes are drawn as a cube, regardless of + the axes' ranges. If *data*, this scene's axes are drawn in + proportion with the axes' ranges. If *manual*, this scene's + axes are drawn in proportion with the input of *aspectratio* + (the default behavior if *aspectratio* is provided). If *auto*, + this scene's axes are drawn using the results of *data* except + when one axis is more than four times the size of the two + others, where in that case the results of *cube* are used. + + The 'aspectmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'cube', 'data', 'manual'] + + Returns + ------- + Any + """ + return self['aspectmode'] + + @aspectmode.setter + def aspectmode(self, val): + self['aspectmode'] = val + + # aspectratio + # ----------- + @property + def aspectratio(self): + """ + Sets this scene's axis aspectratio. + + The 'aspectratio' property is an instance of Aspectratio + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.Aspectratio + - A dict of string/value properties that will be passed + to the Aspectratio constructor + + Supported dict properties: + + x + + y + + z + + Returns + ------- + plotly.graph_objs.layout.scene.Aspectratio + """ + return self['aspectratio'] + + @aspectratio.setter + def aspectratio(self, val): + self['aspectratio'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # camera + # ------ + @property + def camera(self): + """ + The 'camera' property is an instance of Camera + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.Camera + - A dict of string/value properties that will be passed + to the Camera constructor + + Supported dict properties: + + center + Sets the (x,y,z) components of the 'center' + camera vector This vector determines the + translation (x,y,z) space about the center of + this scene. By default, there is no such + translation. + eye + Sets the (x,y,z) components of the 'eye' camera + vector. This vector determines the view point + about the origin of this scene. + up + Sets the (x,y,z) components of the 'up' camera + vector. This vector determines the up direction + of this scene with respect to the page. The + default is *{x: 0, y: 0, z: 1}* which means + that the z axis points up. + + Returns + ------- + plotly.graph_objs.layout.scene.Camera + """ + return self['camera'] + + @camera.setter + def camera(self, val): + self['camera'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this scene subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this scene subplot . + x + Sets the horizontal domain of this scene + subplot (in plot fraction). + y + Sets the vertical domain of this scene subplot + (in plot fraction). + + Returns + ------- + plotly.graph_objs.layout.scene.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # dragmode + # -------- + @property + def dragmode(self): + """ + Determines the mode of drag interactions for this scene. + + The 'dragmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['orbit', 'turntable', 'zoom', 'pan', False] + + Returns + ------- + Any + """ + return self['dragmode'] + + @dragmode.setter + def dragmode(self, val): + self['dragmode'] = val + + # hovermode + # --------- + @property + def hovermode(self): + """ + Determines the mode of hover interactions for this scene. + + The 'hovermode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['closest', False] + + Returns + ------- + Any + """ + return self['hovermode'] + + @hovermode.setter + def hovermode(self, val): + self['hovermode'] = val + + # xaxis + # ----- + @property + def xaxis(self): + """ + The 'xaxis' property is an instance of XAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.XAxis + - A dict of string/value properties that will be passed + to the XAxis constructor + + Supported dict properties: + + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.xaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + plotly.graph_objs.layout.scene.XAxis + """ + return self['xaxis'] + + @xaxis.setter + def xaxis(self, val): + self['xaxis'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + The 'yaxis' property is an instance of YAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.YAxis + - A dict of string/value properties that will be passed + to the YAxis constructor + + Supported dict properties: + + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.yaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + plotly.graph_objs.layout.scene.YAxis + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # zaxis + # ----- + @property + def zaxis(self): + """ + The 'zaxis' property is an instance of ZAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.ZAxis + - A dict of string/value properties that will be passed + to the ZAxis constructor + + Supported dict properties: + + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.zaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + plotly.graph_objs.layout.scene.ZAxis + """ + return self['zaxis'] + + @zaxis.setter + def zaxis(self, val): + self['zaxis'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + annotations + plotly.graph_objs.layout.scene.Annotation instance or + dict with compatible properties + aspectmode + If *cube*, this scene's axes are drawn as a cube, + regardless of the axes' ranges. If *data*, this scene's + axes are drawn in proportion with the axes' ranges. If + *manual*, this scene's axes are drawn in proportion + with the input of *aspectratio* (the default behavior + if *aspectratio* is provided). If *auto*, this scene's + axes are drawn using the results of *data* except when + one axis is more than four times the size of the two + others, where in that case the results of *cube* are + used. + aspectratio + Sets this scene's axis aspectratio. + bgcolor + + camera + plotly.graph_objs.layout.scene.Camera instance or dict + with compatible properties + domain + plotly.graph_objs.layout.scene.Domain instance or dict + with compatible properties + dragmode + Determines the mode of drag interactions for this + scene. + hovermode + Determines the mode of hover interactions for this + scene. + xaxis + plotly.graph_objs.layout.scene.XAxis instance or dict + with compatible properties + yaxis + plotly.graph_objs.layout.scene.YAxis instance or dict + with compatible properties + zaxis + plotly.graph_objs.layout.scene.ZAxis instance or dict + with compatible properties + """ + + def __init__( + self, + arg=None, + annotations=None, + aspectmode=None, + aspectratio=None, + bgcolor=None, + camera=None, + domain=None, + dragmode=None, + hovermode=None, + xaxis=None, + yaxis=None, + zaxis=None, + **kwargs + ): + """ + Construct a new Scene object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Scene + annotations + plotly.graph_objs.layout.scene.Annotation instance or + dict with compatible properties + aspectmode + If *cube*, this scene's axes are drawn as a cube, + regardless of the axes' ranges. If *data*, this scene's + axes are drawn in proportion with the axes' ranges. If + *manual*, this scene's axes are drawn in proportion + with the input of *aspectratio* (the default behavior + if *aspectratio* is provided). If *auto*, this scene's + axes are drawn using the results of *data* except when + one axis is more than four times the size of the two + others, where in that case the results of *cube* are + used. + aspectratio + Sets this scene's axis aspectratio. + bgcolor + + camera + plotly.graph_objs.layout.scene.Camera instance or dict + with compatible properties + domain + plotly.graph_objs.layout.scene.Domain instance or dict + with compatible properties + dragmode + Determines the mode of drag interactions for this + scene. + hovermode + Determines the mode of hover interactions for this + scene. + xaxis + plotly.graph_objs.layout.scene.XAxis instance or dict + with compatible properties + yaxis + plotly.graph_objs.layout.scene.YAxis instance or dict + with compatible properties + zaxis + plotly.graph_objs.layout.scene.ZAxis instance or dict + with compatible properties + + Returns + ------- + Scene + """ + super(Scene, self).__init__('scene') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Scene +constructor must be a dict or +an instance of plotly.graph_objs.layout.Scene""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (scene as v_scene) + + # Initialize validators + # --------------------- + self._validators['annotations'] = v_scene.AnnotationsValidator() + self._validators['aspectmode'] = v_scene.AspectmodeValidator() + self._validators['aspectratio'] = v_scene.AspectratioValidator() + self._validators['bgcolor'] = v_scene.BgcolorValidator() + self._validators['camera'] = v_scene.CameraValidator() + self._validators['domain'] = v_scene.DomainValidator() + self._validators['dragmode'] = v_scene.DragmodeValidator() + self._validators['hovermode'] = v_scene.HovermodeValidator() + self._validators['xaxis'] = v_scene.XAxisValidator() + self._validators['yaxis'] = v_scene.YAxisValidator() + self._validators['zaxis'] = v_scene.ZAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('annotations', None) + self.annotations = annotations if annotations is not None else v + v = arg.pop('aspectmode', None) + self.aspectmode = aspectmode if aspectmode is not None else v + v = arg.pop('aspectratio', None) + self.aspectratio = aspectratio if aspectratio is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('camera', None) + self.camera = camera if camera is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('dragmode', None) + self.dragmode = dragmode if dragmode is not None else v + v = arg.pop('hovermode', None) + self.hovermode = hovermode if hovermode is not None else v + v = arg.pop('xaxis', None) + self.xaxis = xaxis if xaxis is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + v = arg.pop('zaxis', None) + self.zaxis = zaxis if zaxis is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_shape.py b/plotly/graph_objs/layout/_shape.py new file mode 100644 index 0000000000..b4dcfa2fbf --- /dev/null +++ b/plotly/graph_objs/layout/_shape.py @@ -0,0 +1,818 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Shape(BaseLayoutHierarchyType): + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the color filling the shape's interior. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # layer + # ----- + @property + def layer(self): + """ + Specifies whether shapes are drawn below or above traces. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['below', 'above'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.layout.shape.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.layout.shape.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the shape. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # path + # ---- + @property + def path(self): + """ + For `type` *path* - a valid SVG path with the pixel values + replaced by data values in `xsizemode`/`ysizemode` being + *scaled* and taken unmodified as pixels relative to `xanchor` + and `yanchor` in case of *pixel* size mode. There are a few + restrictions / quirks only absolute instructions, not relative. + So the allowed segments are: M, L, H, V, Q, C, T, S, and Z arcs + (A) are not allowed because radius rx and ry are relative. In + the future we could consider supporting relative commands, but + we would have to decide on how to handle date and log axes. + Note that even as is, Q and C Bezier paths that are smooth on + linear axes may not be smooth on log, and vice versa. no + chained "polybezier" commands - specify the segment type for + each one. On category axes, values are numbers scaled to the + serial numbers of categories because using the categories + themselves there would be no way to describe fractional + positions On data axes: because space and T are both normal + components of path strings, we can't use either to separate + date from time parts. Therefore we'll use underscore for this + purpose: 2015-02-21_13:45:56.789 + + The 'path' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['path'] + + @path.setter + def path(self, val): + self['path'] = val + + # type + # ---- + @property + def type(self): + """ + Specifies the shape type to be drawn. If *line*, a line is + drawn from (`x0`,`y0`) to (`x1`,`y1`) with respect to the axes' + sizing mode. If *circle*, a circle is drawn from + ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius (|(`x0`+`x1`)/2 - + `x0`|, |(`y0`+`y1`)/2 -`y0`)|) with respect to the axes' sizing + mode. If *rect*, a rectangle is drawn linking (`x0`,`y0`), + (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) with respect + to the axes' sizing mode. If *path*, draw a custom SVG path + using `path`. with respect to the axes' sizing mode. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['circle', 'rect', 'path', 'line'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this shape is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x0 + # -- + @property + def x0(self): + """ + Sets the shape's starting x position. See `type` and + `xsizemode` for more info. + + The 'x0' property accepts values of any type + + Returns + ------- + Any + """ + return self['x0'] + + @x0.setter + def x0(self, val): + self['x0'] = val + + # x1 + # -- + @property + def x1(self): + """ + Sets the shape's end x position. See `type` and `xsizemode` for + more info. + + The 'x1' property accepts values of any type + + Returns + ------- + Any + """ + return self['x1'] + + @x1.setter + def x1(self, val): + self['x1'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Only relevant in conjunction with `xsizemode` set to *pixel*. + Specifies the anchor point on the x axis to which `x0`, `x1` + and x coordinates within `path` are relative to. E.g. useful to + attach a pixel sized shape to a certain data value. No effect + when `xsizemode` not set to *pixel*. + + The 'xanchor' property accepts values of any type + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xref + # ---- + @property + def xref(self): + """ + Sets the shape's x coordinate axis. If set to an x axis id + (e.g. *x* or *x2*), the `x` position refers to an x coordinate. + If set to *paper*, the `x` position refers to the distance from + the left side of the plotting area in normalized coordinates + where *0* (*1*) corresponds to the left (right) side. If the + axis `type` is *log*, then you must take the log of your + desired range. If the axis `type` is *date*, then you must + convert the date to unix time in milliseconds. + + The 'xref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['xref'] + + @xref.setter + def xref(self, val): + self['xref'] = val + + # xsizemode + # --------- + @property + def xsizemode(self): + """ + Sets the shapes's sizing mode along the x axis. If set to + *scaled*, `x0`, `x1` and x coordinates within `path` refer to + data values on the x axis or a fraction of the plot area's + width (`xref` set to *paper*). If set to *pixel*, `xanchor` + specifies the x position in terms of data or plot fraction but + `x0`, `x1` and x coordinates within `path` are pixels relative + to `xanchor`. This way, the shape can have a fixed width while + maintaining a position relative to data or plot fraction. + + The 'xsizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['scaled', 'pixel'] + + Returns + ------- + Any + """ + return self['xsizemode'] + + @xsizemode.setter + def xsizemode(self, val): + self['xsizemode'] = val + + # y0 + # -- + @property + def y0(self): + """ + Sets the shape's starting y position. See `type` and + `ysizemode` for more info. + + The 'y0' property accepts values of any type + + Returns + ------- + Any + """ + return self['y0'] + + @y0.setter + def y0(self, val): + self['y0'] = val + + # y1 + # -- + @property + def y1(self): + """ + Sets the shape's end y position. See `type` and `ysizemode` for + more info. + + The 'y1' property accepts values of any type + + Returns + ------- + Any + """ + return self['y1'] + + @y1.setter + def y1(self, val): + self['y1'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Only relevant in conjunction with `ysizemode` set to *pixel*. + Specifies the anchor point on the y axis to which `y0`, `y1` + and y coordinates within `path` are relative to. E.g. useful to + attach a pixel sized shape to a certain data value. No effect + when `ysizemode` not set to *pixel*. + + The 'yanchor' property accepts values of any type + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # yref + # ---- + @property + def yref(self): + """ + Sets the annotation's y coordinate axis. If set to an y axis id + (e.g. *y* or *y2*), the `y` position refers to an y coordinate + If set to *paper*, the `y` position refers to the distance from + the bottom of the plotting area in normalized coordinates where + *0* (*1*) corresponds to the bottom (top). + + The 'yref' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['paper'] + - A string that matches one of the following regular expressions: + ['^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['yref'] + + @yref.setter + def yref(self, val): + self['yref'] = val + + # ysizemode + # --------- + @property + def ysizemode(self): + """ + Sets the shapes's sizing mode along the y axis. If set to + *scaled*, `y0`, `y1` and y coordinates within `path` refer to + data values on the y axis or a fraction of the plot area's + height (`yref` set to *paper*). If set to *pixel*, `yanchor` + specifies the y position in terms of data or plot fraction but + `y0`, `y1` and y coordinates within `path` are pixels relative + to `yanchor`. This way, the shape can have a fixed height while + maintaining a position relative to data or plot fraction. + + The 'ysizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['scaled', 'pixel'] + + Returns + ------- + Any + """ + return self['ysizemode'] + + @ysizemode.setter + def ysizemode(self, val): + self['ysizemode'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + fillcolor + Sets the color filling the shape's interior. + layer + Specifies whether shapes are drawn below or above + traces. + line + plotly.graph_objs.layout.shape.Line instance or dict + with compatible properties + opacity + Sets the opacity of the shape. + path + For `type` *path* - a valid SVG path with the pixel + values replaced by data values in + `xsizemode`/`ysizemode` being *scaled* and taken + unmodified as pixels relative to `xanchor` and + `yanchor` in case of *pixel* size mode. There are a few + restrictions / quirks only absolute instructions, not + relative. So the allowed segments are: M, L, H, V, Q, + C, T, S, and Z arcs (A) are not allowed because radius + rx and ry are relative. In the future we could consider + supporting relative commands, but we would have to + decide on how to handle date and log axes. Note that + even as is, Q and C Bezier paths that are smooth on + linear axes may not be smooth on log, and vice versa. + no chained "polybezier" commands - specify the segment + type for each one. On category axes, values are numbers + scaled to the serial numbers of categories because + using the categories themselves there would be no way + to describe fractional positions On data axes: because + space and T are both normal components of path strings, + we can't use either to separate date from time parts. + Therefore we'll use underscore for this purpose: + 2015-02-21_13:45:56.789 + type + Specifies the shape type to be drawn. If *line*, a line + is drawn from (`x0`,`y0`) to (`x1`,`y1`) with respect + to the axes' sizing mode. If *circle*, a circle is + drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius + (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) with + respect to the axes' sizing mode. If *rect*, a + rectangle is drawn linking (`x0`,`y0`), (`x1`,`y0`), + (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) with respect to + the axes' sizing mode. If *path*, draw a custom SVG + path using `path`. with respect to the axes' sizing + mode. + visible + Determines whether or not this shape is visible. + x0 + Sets the shape's starting x position. See `type` and + `xsizemode` for more info. + x1 + Sets the shape's end x position. See `type` and + `xsizemode` for more info. + xanchor + Only relevant in conjunction with `xsizemode` set to + *pixel*. Specifies the anchor point on the x axis to + which `x0`, `x1` and x coordinates within `path` are + relative to. E.g. useful to attach a pixel sized shape + to a certain data value. No effect when `xsizemode` not + set to *pixel*. + xref + Sets the shape's x coordinate axis. If set to an x axis + id (e.g. *x* or *x2*), the `x` position refers to an x + coordinate. If set to *paper*, the `x` position refers + to the distance from the left side of the plotting area + in normalized coordinates where *0* (*1*) corresponds + to the left (right) side. If the axis `type` is *log*, + then you must take the log of your desired range. If + the axis `type` is *date*, then you must convert the + date to unix time in milliseconds. + xsizemode + Sets the shapes's sizing mode along the x axis. If set + to *scaled*, `x0`, `x1` and x coordinates within `path` + refer to data values on the x axis or a fraction of the + plot area's width (`xref` set to *paper*). If set to + *pixel*, `xanchor` specifies the x position in terms of + data or plot fraction but `x0`, `x1` and x coordinates + within `path` are pixels relative to `xanchor`. This + way, the shape can have a fixed width while maintaining + a position relative to data or plot fraction. + y0 + Sets the shape's starting y position. See `type` and + `ysizemode` for more info. + y1 + Sets the shape's end y position. See `type` and + `ysizemode` for more info. + yanchor + Only relevant in conjunction with `ysizemode` set to + *pixel*. Specifies the anchor point on the y axis to + which `y0`, `y1` and y coordinates within `path` are + relative to. E.g. useful to attach a pixel sized shape + to a certain data value. No effect when `ysizemode` not + set to *pixel*. + yref + Sets the annotation's y coordinate axis. If set to an y + axis id (e.g. *y* or *y2*), the `y` position refers to + an y coordinate If set to *paper*, the `y` position + refers to the distance from the bottom of the plotting + area in normalized coordinates where *0* (*1*) + corresponds to the bottom (top). + ysizemode + Sets the shapes's sizing mode along the y axis. If set + to *scaled*, `y0`, `y1` and y coordinates within `path` + refer to data values on the y axis or a fraction of the + plot area's height (`yref` set to *paper*). If set to + *pixel*, `yanchor` specifies the y position in terms of + data or plot fraction but `y0`, `y1` and y coordinates + within `path` are pixels relative to `yanchor`. This + way, the shape can have a fixed height while + maintaining a position relative to data or plot + fraction. + """ + + def __init__( + self, + arg=None, + fillcolor=None, + layer=None, + line=None, + opacity=None, + path=None, + type=None, + visible=None, + x0=None, + x1=None, + xanchor=None, + xref=None, + xsizemode=None, + y0=None, + y1=None, + yanchor=None, + yref=None, + ysizemode=None, + **kwargs + ): + """ + Construct a new Shape object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Shape + fillcolor + Sets the color filling the shape's interior. + layer + Specifies whether shapes are drawn below or above + traces. + line + plotly.graph_objs.layout.shape.Line instance or dict + with compatible properties + opacity + Sets the opacity of the shape. + path + For `type` *path* - a valid SVG path with the pixel + values replaced by data values in + `xsizemode`/`ysizemode` being *scaled* and taken + unmodified as pixels relative to `xanchor` and + `yanchor` in case of *pixel* size mode. There are a few + restrictions / quirks only absolute instructions, not + relative. So the allowed segments are: M, L, H, V, Q, + C, T, S, and Z arcs (A) are not allowed because radius + rx and ry are relative. In the future we could consider + supporting relative commands, but we would have to + decide on how to handle date and log axes. Note that + even as is, Q and C Bezier paths that are smooth on + linear axes may not be smooth on log, and vice versa. + no chained "polybezier" commands - specify the segment + type for each one. On category axes, values are numbers + scaled to the serial numbers of categories because + using the categories themselves there would be no way + to describe fractional positions On data axes: because + space and T are both normal components of path strings, + we can't use either to separate date from time parts. + Therefore we'll use underscore for this purpose: + 2015-02-21_13:45:56.789 + type + Specifies the shape type to be drawn. If *line*, a line + is drawn from (`x0`,`y0`) to (`x1`,`y1`) with respect + to the axes' sizing mode. If *circle*, a circle is + drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius + (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) with + respect to the axes' sizing mode. If *rect*, a + rectangle is drawn linking (`x0`,`y0`), (`x1`,`y0`), + (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) with respect to + the axes' sizing mode. If *path*, draw a custom SVG + path using `path`. with respect to the axes' sizing + mode. + visible + Determines whether or not this shape is visible. + x0 + Sets the shape's starting x position. See `type` and + `xsizemode` for more info. + x1 + Sets the shape's end x position. See `type` and + `xsizemode` for more info. + xanchor + Only relevant in conjunction with `xsizemode` set to + *pixel*. Specifies the anchor point on the x axis to + which `x0`, `x1` and x coordinates within `path` are + relative to. E.g. useful to attach a pixel sized shape + to a certain data value. No effect when `xsizemode` not + set to *pixel*. + xref + Sets the shape's x coordinate axis. If set to an x axis + id (e.g. *x* or *x2*), the `x` position refers to an x + coordinate. If set to *paper*, the `x` position refers + to the distance from the left side of the plotting area + in normalized coordinates where *0* (*1*) corresponds + to the left (right) side. If the axis `type` is *log*, + then you must take the log of your desired range. If + the axis `type` is *date*, then you must convert the + date to unix time in milliseconds. + xsizemode + Sets the shapes's sizing mode along the x axis. If set + to *scaled*, `x0`, `x1` and x coordinates within `path` + refer to data values on the x axis or a fraction of the + plot area's width (`xref` set to *paper*). If set to + *pixel*, `xanchor` specifies the x position in terms of + data or plot fraction but `x0`, `x1` and x coordinates + within `path` are pixels relative to `xanchor`. This + way, the shape can have a fixed width while maintaining + a position relative to data or plot fraction. + y0 + Sets the shape's starting y position. See `type` and + `ysizemode` for more info. + y1 + Sets the shape's end y position. See `type` and + `ysizemode` for more info. + yanchor + Only relevant in conjunction with `ysizemode` set to + *pixel*. Specifies the anchor point on the y axis to + which `y0`, `y1` and y coordinates within `path` are + relative to. E.g. useful to attach a pixel sized shape + to a certain data value. No effect when `ysizemode` not + set to *pixel*. + yref + Sets the annotation's y coordinate axis. If set to an y + axis id (e.g. *y* or *y2*), the `y` position refers to + an y coordinate If set to *paper*, the `y` position + refers to the distance from the bottom of the plotting + area in normalized coordinates where *0* (*1*) + corresponds to the bottom (top). + ysizemode + Sets the shapes's sizing mode along the y axis. If set + to *scaled*, `y0`, `y1` and y coordinates within `path` + refer to data values on the y axis or a fraction of the + plot area's height (`yref` set to *paper*). If set to + *pixel*, `yanchor` specifies the y position in terms of + data or plot fraction but `y0`, `y1` and y coordinates + within `path` are pixels relative to `yanchor`. This + way, the shape can have a fixed height while + maintaining a position relative to data or plot + fraction. + + Returns + ------- + Shape + """ + super(Shape, self).__init__('shapes') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Shape +constructor must be a dict or +an instance of plotly.graph_objs.layout.Shape""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (shape as v_shape) + + # Initialize validators + # --------------------- + self._validators['fillcolor'] = v_shape.FillcolorValidator() + self._validators['layer'] = v_shape.LayerValidator() + self._validators['line'] = v_shape.LineValidator() + self._validators['opacity'] = v_shape.OpacityValidator() + self._validators['path'] = v_shape.PathValidator() + self._validators['type'] = v_shape.TypeValidator() + self._validators['visible'] = v_shape.VisibleValidator() + self._validators['x0'] = v_shape.X0Validator() + self._validators['x1'] = v_shape.X1Validator() + self._validators['xanchor'] = v_shape.XanchorValidator() + self._validators['xref'] = v_shape.XrefValidator() + self._validators['xsizemode'] = v_shape.XsizemodeValidator() + self._validators['y0'] = v_shape.Y0Validator() + self._validators['y1'] = v_shape.Y1Validator() + self._validators['yanchor'] = v_shape.YanchorValidator() + self._validators['yref'] = v_shape.YrefValidator() + self._validators['ysizemode'] = v_shape.YsizemodeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('path', None) + self.path = path if path is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x0', None) + self.x0 = x0 if x0 is not None else v + v = arg.pop('x1', None) + self.x1 = x1 if x1 is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xref', None) + self.xref = xref if xref is not None else v + v = arg.pop('xsizemode', None) + self.xsizemode = xsizemode if xsizemode is not None else v + v = arg.pop('y0', None) + self.y0 = y0 if y0 is not None else v + v = arg.pop('y1', None) + self.y1 = y1 if y1 is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('yref', None) + self.yref = yref if yref is not None else v + v = arg.pop('ysizemode', None) + self.ysizemode = ysizemode if ysizemode is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_slider.py b/plotly/graph_objs/layout/_slider.py new file mode 100644 index 0000000000..077f0a26df --- /dev/null +++ b/plotly/graph_objs/layout/_slider.py @@ -0,0 +1,961 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Slider(BaseLayoutHierarchyType): + + # active + # ------ + @property + def active(self): + """ + Determines which button (by index starting from 0) is + considered active. + + The 'active' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['active'] + + @active.setter + def active(self, val): + self['active'] = val + + # activebgcolor + # ------------- + @property + def activebgcolor(self): + """ + Sets the background color of the slider grip while dragging. + + The 'activebgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['activebgcolor'] + + @activebgcolor.setter + def activebgcolor(self, val): + self['activebgcolor'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the slider. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the slider. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the slider. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # currentvalue + # ------------ + @property + def currentvalue(self): + """ + The 'currentvalue' property is an instance of Currentvalue + that may be specified as: + - An instance of plotly.graph_objs.layout.slider.Currentvalue + - A dict of string/value properties that will be passed + to the Currentvalue constructor + + Supported dict properties: + + font + Sets the font of the current value label text. + offset + The amount of space, in pixels, between the + current value label and the slider. + prefix + When currentvalue.visible is true, this sets + the prefix of the label. + suffix + When currentvalue.visible is true, this sets + the suffix of the label. + visible + Shows the currently-selected value above the + slider. + xanchor + The alignment of the value readout relative to + the length of the slider. + + Returns + ------- + plotly.graph_objs.layout.slider.Currentvalue + """ + return self['currentvalue'] + + @currentvalue.setter + def currentvalue(self, val): + self['currentvalue'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font of the slider step labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.slider.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.slider.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the slider This measure excludes the padding + of both ends. That is, the slider's length is this length minus + the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this slider length is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # minorticklen + # ------------ + @property + def minorticklen(self): + """ + Sets the length in pixels of minor step tick marks + + The 'minorticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['minorticklen'] + + @minorticklen.setter + def minorticklen(self, val): + self['minorticklen'] = val + + # pad + # --- + @property + def pad(self): + """ + Set the padding of the slider component along each side. + + The 'pad' property is an instance of Pad + that may be specified as: + - An instance of plotly.graph_objs.layout.slider.Pad + - A dict of string/value properties that will be passed + to the Pad constructor + + Supported dict properties: + + b + The amount of padding (in px) along the bottom + of the component. + l + The amount of padding (in px) on the left side + of the component. + r + The amount of padding (in px) on the right side + of the component. + t + The amount of padding (in px) along the top of + the component. + + Returns + ------- + plotly.graph_objs.layout.slider.Pad + """ + return self['pad'] + + @pad.setter + def pad(self, val): + self['pad'] = val + + # steps + # ----- + @property + def steps(self): + """ + The 'steps' property is a tuple of instances of + Step that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.slider.Step + - A list or tuple of dicts of string/value properties that + will be passed to the Step constructor + + Supported dict properties: + + args + Sets the arguments values to be passed to the + Plotly method set in `method` on slide. + execute + When true, the API method is executed. When + false, all other behaviors are the same and + command execution is skipped. This may be + useful when hooking into, for example, the + `plotly_sliderchange` method and executing the + API command manually without losing the benefit + of the slider automatically binding to the + state of the plot through the specification of + `method` and `args`. + label + Sets the text label to appear on the slider + method + Sets the Plotly method to be called when the + slider value is changed. If the `skip` method + is used, the API slider will function as normal + but will perform no API calls and will not bind + automatically to state updates. This may be + used to create a component interface and attach + to slider events manually via JavaScript. + value + Sets the value of the slider step, used to + refer to the step programatically. Defaults to + the slider label if not provided. + + Returns + ------- + tuple[plotly.graph_objs.layout.slider.Step] + """ + return self['steps'] + + @steps.setter + def steps(self, val): + self['steps'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the color of the border enclosing the slider. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the length in pixels of step tick marks + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # transition + # ---------- + @property + def transition(self): + """ + The 'transition' property is an instance of Transition + that may be specified as: + - An instance of plotly.graph_objs.layout.slider.Transition + - A dict of string/value properties that will be passed + to the Transition constructor + + Supported dict properties: + + duration + Sets the duration of the slider transition + easing + Sets the easing function of the slider + transition + + Returns + ------- + plotly.graph_objs.layout.slider.Transition + """ + return self['transition'] + + @transition.setter + def transition(self, val): + self['transition'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not the slider is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position (in normalized coordinates) of the slider. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the slider's horizontal position anchor. This anchor binds + the `x` position to the *left*, *center* or *right* of the + range selector. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position (in normalized coordinates) of the slider. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the slider's vertical position anchor This anchor binds + the `y` position to the *top*, *middle* or *bottom* of the + range selector. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + active + Determines which button (by index starting from 0) is + considered active. + activebgcolor + Sets the background color of the slider grip while + dragging. + bgcolor + Sets the background color of the slider. + bordercolor + Sets the color of the border enclosing the slider. + borderwidth + Sets the width (in px) of the border enclosing the + slider. + currentvalue + plotly.graph_objs.layout.slider.Currentvalue instance + or dict with compatible properties + font + Sets the font of the slider step labels. + len + Sets the length of the slider This measure excludes the + padding of both ends. That is, the slider's length is + this length minus the padding on both ends. + lenmode + Determines whether this slider length is set in units + of plot *fraction* or in *pixels. Use `len` to set the + value. + minorticklen + Sets the length in pixels of minor step tick marks + pad + Set the padding of the slider component along each + side. + steps + plotly.graph_objs.layout.slider.Step instance or dict + with compatible properties + tickcolor + Sets the color of the border enclosing the slider. + ticklen + Sets the length in pixels of step tick marks + tickwidth + Sets the tick width (in px). + transition + plotly.graph_objs.layout.slider.Transition instance or + dict with compatible properties + visible + Determines whether or not the slider is visible. + x + Sets the x position (in normalized coordinates) of the + slider. + xanchor + Sets the slider's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + slider. + yanchor + Sets the slider's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + """ + + def __init__( + self, + arg=None, + active=None, + activebgcolor=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + currentvalue=None, + font=None, + len=None, + lenmode=None, + minorticklen=None, + pad=None, + steps=None, + tickcolor=None, + ticklen=None, + tickwidth=None, + transition=None, + visible=None, + x=None, + xanchor=None, + y=None, + yanchor=None, + **kwargs + ): + """ + Construct a new Slider object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Slider + active + Determines which button (by index starting from 0) is + considered active. + activebgcolor + Sets the background color of the slider grip while + dragging. + bgcolor + Sets the background color of the slider. + bordercolor + Sets the color of the border enclosing the slider. + borderwidth + Sets the width (in px) of the border enclosing the + slider. + currentvalue + plotly.graph_objs.layout.slider.Currentvalue instance + or dict with compatible properties + font + Sets the font of the slider step labels. + len + Sets the length of the slider This measure excludes the + padding of both ends. That is, the slider's length is + this length minus the padding on both ends. + lenmode + Determines whether this slider length is set in units + of plot *fraction* or in *pixels. Use `len` to set the + value. + minorticklen + Sets the length in pixels of minor step tick marks + pad + Set the padding of the slider component along each + side. + steps + plotly.graph_objs.layout.slider.Step instance or dict + with compatible properties + tickcolor + Sets the color of the border enclosing the slider. + ticklen + Sets the length in pixels of step tick marks + tickwidth + Sets the tick width (in px). + transition + plotly.graph_objs.layout.slider.Transition instance or + dict with compatible properties + visible + Determines whether or not the slider is visible. + x + Sets the x position (in normalized coordinates) of the + slider. + xanchor + Sets the slider's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + slider. + yanchor + Sets the slider's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + + Returns + ------- + Slider + """ + super(Slider, self).__init__('sliders') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Slider +constructor must be a dict or +an instance of plotly.graph_objs.layout.Slider""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (slider as v_slider) + + # Initialize validators + # --------------------- + self._validators['active'] = v_slider.ActiveValidator() + self._validators['activebgcolor'] = v_slider.ActivebgcolorValidator() + self._validators['bgcolor'] = v_slider.BgcolorValidator() + self._validators['bordercolor'] = v_slider.BordercolorValidator() + self._validators['borderwidth'] = v_slider.BorderwidthValidator() + self._validators['currentvalue'] = v_slider.CurrentvalueValidator() + self._validators['font'] = v_slider.FontValidator() + self._validators['len'] = v_slider.LenValidator() + self._validators['lenmode'] = v_slider.LenmodeValidator() + self._validators['minorticklen'] = v_slider.MinorticklenValidator() + self._validators['pad'] = v_slider.PadValidator() + self._validators['steps'] = v_slider.StepsValidator() + self._validators['tickcolor'] = v_slider.TickcolorValidator() + self._validators['ticklen'] = v_slider.TicklenValidator() + self._validators['tickwidth'] = v_slider.TickwidthValidator() + self._validators['transition'] = v_slider.TransitionValidator() + self._validators['visible'] = v_slider.VisibleValidator() + self._validators['x'] = v_slider.XValidator() + self._validators['xanchor'] = v_slider.XanchorValidator() + self._validators['y'] = v_slider.YValidator() + self._validators['yanchor'] = v_slider.YanchorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('active', None) + self.active = active if active is not None else v + v = arg.pop('activebgcolor', None) + self.activebgcolor = activebgcolor if activebgcolor is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('currentvalue', None) + self.currentvalue = currentvalue if currentvalue is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('minorticklen', None) + self.minorticklen = minorticklen if minorticklen is not None else v + v = arg.pop('pad', None) + self.pad = pad if pad is not None else v + v = arg.pop('steps', None) + self.steps = steps if steps is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('transition', None) + self.transition = transition if transition is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_ternary.py b/plotly/graph_objs/layout/_ternary.py new file mode 100644 index 0000000000..0635cb03c8 --- /dev/null +++ b/plotly/graph_objs/layout/_ternary.py @@ -0,0 +1,879 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Ternary(BaseLayoutHierarchyType): + + # aaxis + # ----- + @property + def aaxis(self): + """ + The 'aaxis' property is an instance of Aaxis + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.Aaxis + - A dict of string/value properties that will be passed + to the Aaxis constructor + + Supported dict properties: + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.aaxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + plotly.graph_objs.layout.ternary.Aaxis + """ + return self['aaxis'] + + @aaxis.setter + def aaxis(self, val): + self['aaxis'] = val + + # baxis + # ----- + @property + def baxis(self): + """ + The 'baxis' property is an instance of Baxis + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.Baxis + - A dict of string/value properties that will be passed + to the Baxis constructor + + Supported dict properties: + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.baxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + plotly.graph_objs.layout.ternary.Baxis + """ + return self['baxis'] + + @baxis.setter + def baxis(self, val): + self['baxis'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Set the background color of the subplot + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # caxis + # ----- + @property + def caxis(self): + """ + The 'caxis' property is an instance of Caxis + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.Caxis + - A dict of string/value properties that will be passed + to the Caxis constructor + + Supported dict properties: + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.caxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + plotly.graph_objs.layout.ternary.Caxis + """ + return self['caxis'] + + @caxis.setter + def caxis(self, val): + self['caxis'] = val + + # domain + # ------ + @property + def domain(self): + """ + The 'domain' property is an instance of Domain + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.Domain + - A dict of string/value properties that will be passed + to the Domain constructor + + Supported dict properties: + + column + If there is a layout grid, use the domain for + this column in the grid for this ternary + subplot . + row + If there is a layout grid, use the domain for + this row in the grid for this ternary subplot . + x + Sets the horizontal domain of this ternary + subplot (in plot fraction). + y + Sets the vertical domain of this ternary + subplot (in plot fraction). + + Returns + ------- + plotly.graph_objs.layout.ternary.Domain + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # sum + # --- + @property + def sum(self): + """ + The number each triplet should sum to, and the maximum range of + each axis + + The 'sum' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sum'] + + @sum.setter + def sum(self, val): + self['sum'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + aaxis + plotly.graph_objs.layout.ternary.Aaxis instance or dict + with compatible properties + baxis + plotly.graph_objs.layout.ternary.Baxis instance or dict + with compatible properties + bgcolor + Set the background color of the subplot + caxis + plotly.graph_objs.layout.ternary.Caxis instance or dict + with compatible properties + domain + plotly.graph_objs.layout.ternary.Domain instance or + dict with compatible properties + sum + The number each triplet should sum to, and the maximum + range of each axis + """ + + def __init__( + self, + arg=None, + aaxis=None, + baxis=None, + bgcolor=None, + caxis=None, + domain=None, + sum=None, + **kwargs + ): + """ + Construct a new Ternary object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Ternary + aaxis + plotly.graph_objs.layout.ternary.Aaxis instance or dict + with compatible properties + baxis + plotly.graph_objs.layout.ternary.Baxis instance or dict + with compatible properties + bgcolor + Set the background color of the subplot + caxis + plotly.graph_objs.layout.ternary.Caxis instance or dict + with compatible properties + domain + plotly.graph_objs.layout.ternary.Domain instance or + dict with compatible properties + sum + The number each triplet should sum to, and the maximum + range of each axis + + Returns + ------- + Ternary + """ + super(Ternary, self).__init__('ternary') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Ternary +constructor must be a dict or +an instance of plotly.graph_objs.layout.Ternary""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (ternary as v_ternary) + + # Initialize validators + # --------------------- + self._validators['aaxis'] = v_ternary.AaxisValidator() + self._validators['baxis'] = v_ternary.BaxisValidator() + self._validators['bgcolor'] = v_ternary.BgcolorValidator() + self._validators['caxis'] = v_ternary.CaxisValidator() + self._validators['domain'] = v_ternary.DomainValidator() + self._validators['sum'] = v_ternary.SumValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('aaxis', None) + self.aaxis = aaxis if aaxis is not None else v + v = arg.pop('baxis', None) + self.baxis = baxis if baxis is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('caxis', None) + self.caxis = caxis if caxis is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('sum', None) + self.sum = sum if sum is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_titlefont.py b/plotly/graph_objs/layout/_titlefont.py new file mode 100644 index 0000000000..05d2f9a543 --- /dev/null +++ b/plotly/graph_objs/layout/_titlefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets the title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_updatemenu.py b/plotly/graph_objs/layout/_updatemenu.py new file mode 100644 index 0000000000..3982ae7302 --- /dev/null +++ b/plotly/graph_objs/layout/_updatemenu.py @@ -0,0 +1,685 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Updatemenu(BaseLayoutHierarchyType): + + # active + # ------ + @property + def active(self): + """ + Determines which button (by index starting from 0) is + considered active. + + The 'active' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + + Returns + ------- + int + """ + return self['active'] + + @active.setter + def active(self, val): + self['active'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the update menu buttons. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the update menu. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the update menu. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # buttons + # ------- + @property + def buttons(self): + """ + The 'buttons' property is a tuple of instances of + Button that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.updatemenu.Button + - A list or tuple of dicts of string/value properties that + will be passed to the Button constructor + + Supported dict properties: + + args + Sets the arguments values to be passed to the + Plotly method set in `method` on click. + execute + When true, the API method is executed. When + false, all other behaviors are the same and + command execution is skipped. This may be + useful when hooking into, for example, the + `plotly_buttonclicked` method and executing the + API command manually without losing the benefit + of the updatemenu automatically binding to the + state of the plot through the specification of + `method` and `args`. + label + Sets the text label to appear on the button. + method + Sets the Plotly method to be called on click. + If the `skip` method is used, the API + updatemenu will function as normal but will + perform no API calls and will not bind + automatically to state updates. This may be + used to create a component interface and attach + to updatemenu events manually via JavaScript. + + Returns + ------- + tuple[plotly.graph_objs.layout.updatemenu.Button] + """ + return self['buttons'] + + @buttons.setter + def buttons(self, val): + self['buttons'] = val + + # direction + # --------- + @property + def direction(self): + """ + Determines the direction in which the buttons are laid out, + whether in a dropdown menu or a row/column of buttons. For + `left` and `up`, the buttons will still appear in left-to-right + or top-to-bottom order respectively. + + The 'direction' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'right', 'up', 'down'] + + Returns + ------- + Any + """ + return self['direction'] + + @direction.setter + def direction(self, val): + self['direction'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font of the update menu button text. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.updatemenu.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.updatemenu.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # pad + # --- + @property + def pad(self): + """ + Sets the padding around the buttons or dropdown menu. + + The 'pad' property is an instance of Pad + that may be specified as: + - An instance of plotly.graph_objs.layout.updatemenu.Pad + - A dict of string/value properties that will be passed + to the Pad constructor + + Supported dict properties: + + b + The amount of padding (in px) along the bottom + of the component. + l + The amount of padding (in px) on the left side + of the component. + r + The amount of padding (in px) on the right side + of the component. + t + The amount of padding (in px) along the top of + the component. + + Returns + ------- + plotly.graph_objs.layout.updatemenu.Pad + """ + return self['pad'] + + @pad.setter + def pad(self, val): + self['pad'] = val + + # showactive + # ---------- + @property + def showactive(self): + """ + Highlights active dropdown item or active button if true. + + The 'showactive' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showactive'] + + @showactive.setter + def showactive(self, val): + self['showactive'] = val + + # type + # ---- + @property + def type(self): + """ + Determines whether the buttons are accessible via a dropdown + menu or whether the buttons are stacked horizontally or + vertically + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['dropdown', 'buttons'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not the update menu is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position (in normalized coordinates) of the update + menu. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the update menu's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the range selector. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position (in normalized coordinates) of the update + menu. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the update menu's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the range selector. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + active + Determines which button (by index starting from 0) is + considered active. + bgcolor + Sets the background color of the update menu buttons. + bordercolor + Sets the color of the border enclosing the update menu. + borderwidth + Sets the width (in px) of the border enclosing the + update menu. + buttons + plotly.graph_objs.layout.updatemenu.Button instance or + dict with compatible properties + direction + Determines the direction in which the buttons are laid + out, whether in a dropdown menu or a row/column of + buttons. For `left` and `up`, the buttons will still + appear in left-to-right or top-to-bottom order + respectively. + font + Sets the font of the update menu button text. + pad + Sets the padding around the buttons or dropdown menu. + showactive + Highlights active dropdown item or active button if + true. + type + Determines whether the buttons are accessible via a + dropdown menu or whether the buttons are stacked + horizontally or vertically + visible + Determines whether or not the update menu is visible. + x + Sets the x position (in normalized coordinates) of the + update menu. + xanchor + Sets the update menu's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + update menu. + yanchor + Sets the update menu's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + """ + + def __init__( + self, + arg=None, + active=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + buttons=None, + direction=None, + font=None, + pad=None, + showactive=None, + type=None, + visible=None, + x=None, + xanchor=None, + y=None, + yanchor=None, + **kwargs + ): + """ + Construct a new Updatemenu object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.Updatemenu + active + Determines which button (by index starting from 0) is + considered active. + bgcolor + Sets the background color of the update menu buttons. + bordercolor + Sets the color of the border enclosing the update menu. + borderwidth + Sets the width (in px) of the border enclosing the + update menu. + buttons + plotly.graph_objs.layout.updatemenu.Button instance or + dict with compatible properties + direction + Determines the direction in which the buttons are laid + out, whether in a dropdown menu or a row/column of + buttons. For `left` and `up`, the buttons will still + appear in left-to-right or top-to-bottom order + respectively. + font + Sets the font of the update menu button text. + pad + Sets the padding around the buttons or dropdown menu. + showactive + Highlights active dropdown item or active button if + true. + type + Determines whether the buttons are accessible via a + dropdown menu or whether the buttons are stacked + horizontally or vertically + visible + Determines whether or not the update menu is visible. + x + Sets the x position (in normalized coordinates) of the + update menu. + xanchor + Sets the update menu's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + update menu. + yanchor + Sets the update menu's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + + Returns + ------- + Updatemenu + """ + super(Updatemenu, self).__init__('updatemenus') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.Updatemenu +constructor must be a dict or +an instance of plotly.graph_objs.layout.Updatemenu""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (updatemenu as v_updatemenu) + + # Initialize validators + # --------------------- + self._validators['active'] = v_updatemenu.ActiveValidator() + self._validators['bgcolor'] = v_updatemenu.BgcolorValidator() + self._validators['bordercolor'] = v_updatemenu.BordercolorValidator() + self._validators['borderwidth'] = v_updatemenu.BorderwidthValidator() + self._validators['buttons'] = v_updatemenu.ButtonsValidator() + self._validators['direction'] = v_updatemenu.DirectionValidator() + self._validators['font'] = v_updatemenu.FontValidator() + self._validators['pad'] = v_updatemenu.PadValidator() + self._validators['showactive'] = v_updatemenu.ShowactiveValidator() + self._validators['type'] = v_updatemenu.TypeValidator() + self._validators['visible'] = v_updatemenu.VisibleValidator() + self._validators['x'] = v_updatemenu.XValidator() + self._validators['xanchor'] = v_updatemenu.XanchorValidator() + self._validators['y'] = v_updatemenu.YValidator() + self._validators['yanchor'] = v_updatemenu.YanchorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('active', None) + self.active = active if active is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('buttons', None) + self.buttons = buttons if buttons is not None else v + v = arg.pop('direction', None) + self.direction = direction if direction is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('pad', None) + self.pad = pad if pad is not None else v + v = arg.pop('showactive', None) + self.showactive = showactive if showactive is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_xaxis.py b/plotly/graph_objs/layout/_xaxis.py new file mode 100644 index 0000000000..ed203305bd --- /dev/null +++ b/plotly/graph_objs/layout/_xaxis.py @@ -0,0 +1,2913 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class XAxis(BaseLayoutHierarchyType): + + # anchor + # ------ + @property + def anchor(self): + """ + If set to an opposite-letter axis id (e.g. `x2`, `y`), this + axis is bound to the corresponding opposite-letter axis. If set + to *free*, this axis' position is determined by `position`. + + The 'anchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['free'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['anchor'] + + @anchor.setter + def anchor(self, val): + self['anchor'] = val + + # automargin + # ---------- + @property + def automargin(self): + """ + Determines whether long tick labels automatically grow the + figure margins. + + The 'automargin' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['automargin'] + + @automargin.setter + def automargin(self, val): + self['automargin'] = val + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # constrain + # --------- + @property + def constrain(self): + """ + If this axis needs to be compressed (either due to its own + `scaleanchor` and `scaleratio` or those of the other axis), + determines how that happens: by increasing the *range* + (default), or by decreasing the *domain*. + + The 'constrain' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['range', 'domain'] + + Returns + ------- + Any + """ + return self['constrain'] + + @constrain.setter + def constrain(self, val): + self['constrain'] = val + + # constraintoward + # --------------- + @property + def constraintoward(self): + """ + If this axis needs to be compressed (either due to its own + `scaleanchor` and `scaleratio` or those of the other axis), + determines which direction we push the originally specified + plot area. Options are *left*, *center* (default), and *right* + for x axes, and *top*, *middle* (default), and *bottom* for y + axes. + + The 'constraintoward' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['constraintoward'] + + @constraintoward.setter + def constraintoward(self, val): + self['constraintoward'] = val + + # domain + # ------ + @property + def domain(self): + """ + Sets the domain of this axis (in plot fraction). + + The 'domain' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'domain[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'domain[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # fixedrange + # ---------- + @property + def fixedrange(self): + """ + Determines whether or not this axis is zoom-able. If true, then + zoom is disabled. + + The 'fixedrange' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['fixedrange'] + + @fixedrange.setter + def fixedrange(self, val): + self['fixedrange'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # mirror + # ------ + @property + def mirror(self): + """ + Determines if the axis lines or/and ticks are mirrored to the + opposite side of the plotting area. If *true*, the axis lines + are mirrored. If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If *all*, axis + lines are mirrored on all shared-axes subplots. If *allticks*, + axis lines and ticks are mirrored on all shared-axes subplots. + + The 'mirror' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'ticks', False, 'all', 'allticks'] + + Returns + ------- + Any + """ + return self['mirror'] + + @mirror.setter + def mirror(self, val): + self['mirror'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # overlaying + # ---------- + @property + def overlaying(self): + """ + If set a same-letter axis id, this axis is overlaid on top of + the corresponding same-letter axis. If *false*, this axis does + not overlay any same-letter axes. + + The 'overlaying' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['free'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['overlaying'] + + @overlaying.setter + def overlaying(self, val): + self['overlaying'] = val + + # position + # -------- + @property + def position(self): + """ + Sets the position of this axis in the plotting space (in + normalized coordinates). Only has an effect if `anchor` is set + to *free*. + + The 'position' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['position'] + + @position.setter + def position(self, val): + self['position'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # rangeselector + # ------------- + @property + def rangeselector(self): + """ + The 'rangeselector' property is an instance of Rangeselector + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.Rangeselector + - A dict of string/value properties that will be passed + to the Rangeselector constructor + + Supported dict properties: + + activecolor + Sets the background color of the active range + selector button. + bgcolor + Sets the background color of the range selector + buttons. + bordercolor + Sets the color of the border enclosing the + range selector. + borderwidth + Sets the width (in px) of the border enclosing + the range selector. + buttons + Sets the specifications for each buttons. By + default, a range selector comes with no + buttons. + font + Sets the font of the range selector button + text. + visible + Determines whether or not this range selector + is visible. Note that range selectors are only + available for x axes of `type` set to or auto- + typed to *date*. + x + Sets the x position (in normalized coordinates) + of the range selector. + xanchor + Sets the range selector's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the range selector. + yanchor + Sets the range selector's vertical position + anchor This anchor binds the `y` position to + the *top*, *middle* or *bottom* of the range + selector. + + Returns + ------- + plotly.graph_objs.layout.xaxis.Rangeselector + """ + return self['rangeselector'] + + @rangeselector.setter + def rangeselector(self, val): + self['rangeselector'] = val + + # rangeslider + # ----------- + @property + def rangeslider(self): + """ + The 'rangeslider' property is an instance of Rangeslider + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.Rangeslider + - A dict of string/value properties that will be passed + to the Rangeslider constructor + + Supported dict properties: + + autorange + Determines whether or not the range slider + range is computed in relation to the input + data. If `range` is provided, then `autorange` + is set to *false*. + bgcolor + Sets the background color of the range slider. + bordercolor + Sets the border color of the range slider. + borderwidth + Sets the border color of the range slider. + range + Sets the range of the range slider. If not set, + defaults to the full xaxis range. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + thickness + The height of the range slider as a fraction of + the total plot area height. + visible + Determines whether or not the range slider will + be visible. If visible, perpendicular axes will + be set to `fixedrange` + yaxis + plotly.graph_objs.layout.xaxis.rangeslider.YAxi + s instance or dict with compatible properties + + Returns + ------- + plotly.graph_objs.layout.xaxis.Rangeslider + """ + return self['rangeslider'] + + @rangeslider.setter + def rangeslider(self, val): + self['rangeslider'] = val + + # scaleanchor + # ----------- + @property + def scaleanchor(self): + """ + If set to another axis id (e.g. `x2`, `y`), the range of this + axis changes together with the range of the corresponding axis + such that the scale of pixels per unit is in a constant ratio. + Both axes are still zoomable, but when you zoom one, the other + will zoom the same amount, keeping a fixed midpoint. + `constrain` and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, + xaxis2: {scaleanchor: *y*}` but you can only link axes of the + same `type`. The linked axis can have the opposite letter (to + constrain the aspect ratio) or the same letter (to match scales + across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the last + constraint encountered will be ignored to avoid possible + inconsistent constraints via `scaleratio`. + + The 'scaleanchor' property is an enumeration that may be specified as: + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['scaleanchor'] + + @scaleanchor.setter + def scaleanchor(self, val): + self['scaleanchor'] = val + + # scaleratio + # ---------- + @property + def scaleratio(self): + """ + If this axis is linked to another by `scaleanchor`, this + determines the pixel to unit scale ratio. For example, if this + value is 10, then every unit on this axis spans 10 times the + number of pixels as a unit on the linked axis. Use this for + example to create an elevation profile where the vertical scale + is exaggerated a fixed amount with respect to the horizontal. + + The 'scaleratio' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['scaleratio'] + + @scaleratio.setter + def scaleratio(self, val): + self['scaleratio'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showspikes + # ---------- + @property + def showspikes(self): + """ + Determines whether or not spikes (aka droplines) are drawn for + this axis. Note: This only takes affect when hovermode = + closest + + The 'showspikes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showspikes'] + + @showspikes.setter + def showspikes(self, val): + self['showspikes'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # side + # ---- + @property + def side(self): + """ + Determines whether a x (y) axis is positioned at the *bottom* + (*left*) or *top* (*right*) of the plotting area. + + The 'side' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'bottom', 'left', 'right'] + + Returns + ------- + Any + """ + return self['side'] + + @side.setter + def side(self, val): + self['side'] = val + + # spikecolor + # ---------- + @property + def spikecolor(self): + """ + Sets the spike color. If undefined, will use the series color + + The 'spikecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['spikecolor'] + + @spikecolor.setter + def spikecolor(self, val): + self['spikecolor'] = val + + # spikedash + # --------- + @property + def spikedash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'spikedash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['spikedash'] + + @spikedash.setter + def spikedash(self, val): + self['spikedash'] = val + + # spikemode + # --------- + @property + def spikemode(self): + """ + Determines the drawing mode for the spike line If *toaxis*, the + line is drawn from the data point to the axis the series is + plotted on. If *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If *marker*, then a marker + dot is drawn on the axis the series is plotted on + + The 'spikemode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['toaxis', 'across', 'marker'] joined with '+' characters + (e.g. 'toaxis+across') + + Returns + ------- + Any + """ + return self['spikemode'] + + @spikemode.setter + def spikemode(self, val): + self['spikemode'] = val + + # spikesnap + # --------- + @property + def spikesnap(self): + """ + Determines whether spikelines are stuck to the cursor or to the + closest datapoints. + + The 'spikesnap' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['data', 'cursor'] + + Returns + ------- + Any + """ + return self['spikesnap'] + + @spikesnap.setter + def spikesnap(self, val): + self['spikesnap'] = val + + # spikethickness + # -------------- + @property + def spikethickness(self): + """ + Sets the width (in px) of the zero line. + + The 'spikethickness' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['spikethickness'] + + @spikethickness.setter + def spikethickness(self, val): + self['spikethickness'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.xaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.xaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.xaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.xaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # zeroline + # -------- + @property + def zeroline(self): + """ + Determines whether or not a line is drawn at along the 0 value + of this axis. If *true*, the zero line is drawn on top of the + grid lines. + + The 'zeroline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zeroline'] + + @zeroline.setter + def zeroline(self, val): + self['zeroline'] = val + + # zerolinecolor + # ------------- + @property + def zerolinecolor(self): + """ + Sets the line color of the zero line. + + The 'zerolinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['zerolinecolor'] + + @zerolinecolor.setter + def zerolinecolor(self, val): + self['zerolinecolor'] = val + + # zerolinewidth + # ------------- + @property + def zerolinewidth(self): + """ + Sets the width (in px) of the zero line. + + The 'zerolinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zerolinewidth'] + + @zerolinewidth.setter + def zerolinewidth(self, val): + self['zerolinewidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + anchor + If set to an opposite-letter axis id (e.g. `x2`, `y`), + this axis is bound to the corresponding opposite-letter + axis. If set to *free*, this axis' position is + determined by `position`. + automargin + Determines whether long tick labels automatically grow + the figure margins. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + constrain + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines how that happens: by increasing + the *range* (default), or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines which direction we push the + originally specified plot area. Options are *left*, + *center* (default), and *right* for x axes, and *top*, + *middle* (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot fraction). + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + overlaying + If set a same-letter axis id, this axis is overlaid on + top of the corresponding same-letter axis. If *false*, + this axis does not overlay any same-letter axes. + position + Sets the position of this axis in the plotting space + (in normalized coordinates). Only has an effect if + `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + rangeselector + plotly.graph_objs.layout.xaxis.Rangeselector instance + or dict with compatible properties + rangeslider + plotly.graph_objs.layout.xaxis.Rangeslider instance or + dict with compatible properties + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the range + of this axis changes together with the range of the + corresponding axis such that the scale of pixels per + unit is in a constant ratio. Both axes are still + zoomable, but when you zoom one, the other will zoom + the same amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you + can only link axes of the same `type`. The linked axis + can have the opposite letter (to constrain the aspect + ratio) or the same letter (to match scales across + subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the + last constraint encountered will be ignored to avoid + possible inconsistent constraints via `scaleratio`. + scaleratio + If this axis is linked to another by `scaleanchor`, + this determines the pixel to unit scale ratio. For + example, if this value is 10, then every unit on this + axis spans 10 times the number of pixels as a unit on + the linked axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Determines whether or not spikes (aka droplines) are + drawn for this axis. Note: This only takes affect when + hovermode = closest + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned at the + *bottom* (*left*) or *top* (*right*) of the plotting + area. + spikecolor + Sets the spike color. If undefined, will use the series + color + spikedash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line If + *toaxis*, the line is drawn from the data point to the + axis the series is plotted on. If *across*, the line + is drawn across the entire plot area, and supercedes + *toaxis*. If *marker*, then a marker dot is drawn on + the axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the cursor + or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.xaxis.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + """ + + def __init__( + self, + arg=None, + anchor=None, + automargin=None, + autorange=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + constrain=None, + constraintoward=None, + domain=None, + dtick=None, + exponentformat=None, + fixedrange=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + mirror=None, + nticks=None, + overlaying=None, + position=None, + range=None, + rangemode=None, + rangeselector=None, + rangeslider=None, + scaleanchor=None, + scaleratio=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showspikes=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + side=None, + spikecolor=None, + spikedash=None, + spikemode=None, + spikesnap=None, + spikethickness=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + zeroline=None, + zerolinecolor=None, + zerolinewidth=None, + **kwargs + ): + """ + Construct a new XAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.XAxis + anchor + If set to an opposite-letter axis id (e.g. `x2`, `y`), + this axis is bound to the corresponding opposite-letter + axis. If set to *free*, this axis' position is + determined by `position`. + automargin + Determines whether long tick labels automatically grow + the figure margins. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + constrain + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines how that happens: by increasing + the *range* (default), or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines which direction we push the + originally specified plot area. Options are *left*, + *center* (default), and *right* for x axes, and *top*, + *middle* (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot fraction). + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + overlaying + If set a same-letter axis id, this axis is overlaid on + top of the corresponding same-letter axis. If *false*, + this axis does not overlay any same-letter axes. + position + Sets the position of this axis in the plotting space + (in normalized coordinates). Only has an effect if + `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + rangeselector + plotly.graph_objs.layout.xaxis.Rangeselector instance + or dict with compatible properties + rangeslider + plotly.graph_objs.layout.xaxis.Rangeslider instance or + dict with compatible properties + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the range + of this axis changes together with the range of the + corresponding axis such that the scale of pixels per + unit is in a constant ratio. Both axes are still + zoomable, but when you zoom one, the other will zoom + the same amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you + can only link axes of the same `type`. The linked axis + can have the opposite letter (to constrain the aspect + ratio) or the same letter (to match scales across + subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the + last constraint encountered will be ignored to avoid + possible inconsistent constraints via `scaleratio`. + scaleratio + If this axis is linked to another by `scaleanchor`, + this determines the pixel to unit scale ratio. For + example, if this value is 10, then every unit on this + axis spans 10 times the number of pixels as a unit on + the linked axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Determines whether or not spikes (aka droplines) are + drawn for this axis. Note: This only takes affect when + hovermode = closest + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned at the + *bottom* (*left*) or *top* (*right*) of the plotting + area. + spikecolor + Sets the spike color. If undefined, will use the series + color + spikedash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line If + *toaxis*, the line is drawn from the data point to the + axis the series is plotted on. If *across*, the line + is drawn across the entire plot area, and supercedes + *toaxis*. If *marker*, then a marker dot is drawn on + the axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the cursor + or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.xaxis.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + XAxis + """ + super(XAxis, self).__init__('xaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.XAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.XAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (xaxis as v_xaxis) + + # Initialize validators + # --------------------- + self._validators['anchor'] = v_xaxis.AnchorValidator() + self._validators['automargin'] = v_xaxis.AutomarginValidator() + self._validators['autorange'] = v_xaxis.AutorangeValidator() + self._validators['calendar'] = v_xaxis.CalendarValidator() + self._validators['categoryarray'] = v_xaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_xaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_xaxis.CategoryorderValidator() + self._validators['color'] = v_xaxis.ColorValidator() + self._validators['constrain'] = v_xaxis.ConstrainValidator() + self._validators['constraintoward' + ] = v_xaxis.ConstraintowardValidator() + self._validators['domain'] = v_xaxis.DomainValidator() + self._validators['dtick'] = v_xaxis.DtickValidator() + self._validators['exponentformat'] = v_xaxis.ExponentformatValidator() + self._validators['fixedrange'] = v_xaxis.FixedrangeValidator() + self._validators['gridcolor'] = v_xaxis.GridcolorValidator() + self._validators['gridwidth'] = v_xaxis.GridwidthValidator() + self._validators['hoverformat'] = v_xaxis.HoverformatValidator() + self._validators['layer'] = v_xaxis.LayerValidator() + self._validators['linecolor'] = v_xaxis.LinecolorValidator() + self._validators['linewidth'] = v_xaxis.LinewidthValidator() + self._validators['mirror'] = v_xaxis.MirrorValidator() + self._validators['nticks'] = v_xaxis.NticksValidator() + self._validators['overlaying'] = v_xaxis.OverlayingValidator() + self._validators['position'] = v_xaxis.PositionValidator() + self._validators['range'] = v_xaxis.RangeValidator() + self._validators['rangemode'] = v_xaxis.RangemodeValidator() + self._validators['rangeselector'] = v_xaxis.RangeselectorValidator() + self._validators['rangeslider'] = v_xaxis.RangesliderValidator() + self._validators['scaleanchor'] = v_xaxis.ScaleanchorValidator() + self._validators['scaleratio'] = v_xaxis.ScaleratioValidator() + self._validators['separatethousands' + ] = v_xaxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_xaxis.ShowexponentValidator() + self._validators['showgrid'] = v_xaxis.ShowgridValidator() + self._validators['showline'] = v_xaxis.ShowlineValidator() + self._validators['showspikes'] = v_xaxis.ShowspikesValidator() + self._validators['showticklabels'] = v_xaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_xaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_xaxis.ShowticksuffixValidator() + self._validators['side'] = v_xaxis.SideValidator() + self._validators['spikecolor'] = v_xaxis.SpikecolorValidator() + self._validators['spikedash'] = v_xaxis.SpikedashValidator() + self._validators['spikemode'] = v_xaxis.SpikemodeValidator() + self._validators['spikesnap'] = v_xaxis.SpikesnapValidator() + self._validators['spikethickness'] = v_xaxis.SpikethicknessValidator() + self._validators['tick0'] = v_xaxis.Tick0Validator() + self._validators['tickangle'] = v_xaxis.TickangleValidator() + self._validators['tickcolor'] = v_xaxis.TickcolorValidator() + self._validators['tickfont'] = v_xaxis.TickfontValidator() + self._validators['tickformat'] = v_xaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_xaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_xaxis.TicklenValidator() + self._validators['tickmode'] = v_xaxis.TickmodeValidator() + self._validators['tickprefix'] = v_xaxis.TickprefixValidator() + self._validators['ticks'] = v_xaxis.TicksValidator() + self._validators['ticksuffix'] = v_xaxis.TicksuffixValidator() + self._validators['ticktext'] = v_xaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_xaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_xaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_xaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_xaxis.TickwidthValidator() + self._validators['title'] = v_xaxis.TitleValidator() + self._validators['titlefont'] = v_xaxis.TitlefontValidator() + self._validators['type'] = v_xaxis.TypeValidator() + self._validators['visible'] = v_xaxis.VisibleValidator() + self._validators['zeroline'] = v_xaxis.ZerolineValidator() + self._validators['zerolinecolor'] = v_xaxis.ZerolinecolorValidator() + self._validators['zerolinewidth'] = v_xaxis.ZerolinewidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('anchor', None) + self.anchor = anchor if anchor is not None else v + v = arg.pop('automargin', None) + self.automargin = automargin if automargin is not None else v + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('constrain', None) + self.constrain = constrain if constrain is not None else v + v = arg.pop('constraintoward', None) + self.constraintoward = constraintoward if constraintoward is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('fixedrange', None) + self.fixedrange = fixedrange if fixedrange is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('mirror', None) + self.mirror = mirror if mirror is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('overlaying', None) + self.overlaying = overlaying if overlaying is not None else v + v = arg.pop('position', None) + self.position = position if position is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('rangeselector', None) + self.rangeselector = rangeselector if rangeselector is not None else v + v = arg.pop('rangeslider', None) + self.rangeslider = rangeslider if rangeslider is not None else v + v = arg.pop('scaleanchor', None) + self.scaleanchor = scaleanchor if scaleanchor is not None else v + v = arg.pop('scaleratio', None) + self.scaleratio = scaleratio if scaleratio is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showspikes', None) + self.showspikes = showspikes if showspikes is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('side', None) + self.side = side if side is not None else v + v = arg.pop('spikecolor', None) + self.spikecolor = spikecolor if spikecolor is not None else v + v = arg.pop('spikedash', None) + self.spikedash = spikedash if spikedash is not None else v + v = arg.pop('spikemode', None) + self.spikemode = spikemode if spikemode is not None else v + v = arg.pop('spikesnap', None) + self.spikesnap = spikesnap if spikesnap is not None else v + v = arg.pop('spikethickness', None) + self.spikethickness = spikethickness if spikethickness is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('zeroline', None) + self.zeroline = zeroline if zeroline is not None else v + v = arg.pop('zerolinecolor', None) + self.zerolinecolor = zerolinecolor if zerolinecolor is not None else v + v = arg.pop('zerolinewidth', None) + self.zerolinewidth = zerolinewidth if zerolinewidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/_yaxis.py b/plotly/graph_objs/layout/_yaxis.py new file mode 100644 index 0000000000..86ac1cf1c3 --- /dev/null +++ b/plotly/graph_objs/layout/_yaxis.py @@ -0,0 +1,2772 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class YAxis(BaseLayoutHierarchyType): + + # anchor + # ------ + @property + def anchor(self): + """ + If set to an opposite-letter axis id (e.g. `x2`, `y`), this + axis is bound to the corresponding opposite-letter axis. If set + to *free*, this axis' position is determined by `position`. + + The 'anchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['free'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['anchor'] + + @anchor.setter + def anchor(self, val): + self['anchor'] = val + + # automargin + # ---------- + @property + def automargin(self): + """ + Determines whether long tick labels automatically grow the + figure margins. + + The 'automargin' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['automargin'] + + @automargin.setter + def automargin(self, val): + self['automargin'] = val + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # constrain + # --------- + @property + def constrain(self): + """ + If this axis needs to be compressed (either due to its own + `scaleanchor` and `scaleratio` or those of the other axis), + determines how that happens: by increasing the *range* + (default), or by decreasing the *domain*. + + The 'constrain' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['range', 'domain'] + + Returns + ------- + Any + """ + return self['constrain'] + + @constrain.setter + def constrain(self, val): + self['constrain'] = val + + # constraintoward + # --------------- + @property + def constraintoward(self): + """ + If this axis needs to be compressed (either due to its own + `scaleanchor` and `scaleratio` or those of the other axis), + determines which direction we push the originally specified + plot area. Options are *left*, *center* (default), and *right* + for x axes, and *top*, *middle* (default), and *bottom* for y + axes. + + The 'constraintoward' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['constraintoward'] + + @constraintoward.setter + def constraintoward(self, val): + self['constraintoward'] = val + + # domain + # ------ + @property + def domain(self): + """ + Sets the domain of this axis (in plot fraction). + + The 'domain' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'domain[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'domain[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['domain'] + + @domain.setter + def domain(self, val): + self['domain'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # fixedrange + # ---------- + @property + def fixedrange(self): + """ + Determines whether or not this axis is zoom-able. If true, then + zoom is disabled. + + The 'fixedrange' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['fixedrange'] + + @fixedrange.setter + def fixedrange(self, val): + self['fixedrange'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # mirror + # ------ + @property + def mirror(self): + """ + Determines if the axis lines or/and ticks are mirrored to the + opposite side of the plotting area. If *true*, the axis lines + are mirrored. If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If *all*, axis + lines are mirrored on all shared-axes subplots. If *allticks*, + axis lines and ticks are mirrored on all shared-axes subplots. + + The 'mirror' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'ticks', False, 'all', 'allticks'] + + Returns + ------- + Any + """ + return self['mirror'] + + @mirror.setter + def mirror(self, val): + self['mirror'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # overlaying + # ---------- + @property + def overlaying(self): + """ + If set a same-letter axis id, this axis is overlaid on top of + the corresponding same-letter axis. If *false*, this axis does + not overlay any same-letter axes. + + The 'overlaying' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['free'] + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['overlaying'] + + @overlaying.setter + def overlaying(self, val): + self['overlaying'] = val + + # position + # -------- + @property + def position(self): + """ + Sets the position of this axis in the plotting space (in + normalized coordinates). Only has an effect if `anchor` is set + to *free*. + + The 'position' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['position'] + + @position.setter + def position(self, val): + self['position'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # scaleanchor + # ----------- + @property + def scaleanchor(self): + """ + If set to another axis id (e.g. `x2`, `y`), the range of this + axis changes together with the range of the corresponding axis + such that the scale of pixels per unit is in a constant ratio. + Both axes are still zoomable, but when you zoom one, the other + will zoom the same amount, keeping a fixed midpoint. + `constrain` and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, + xaxis2: {scaleanchor: *y*}` but you can only link axes of the + same `type`. The linked axis can have the opposite letter (to + constrain the aspect ratio) or the same letter (to match scales + across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the last + constraint encountered will be ignored to avoid possible + inconsistent constraints via `scaleratio`. + + The 'scaleanchor' property is an enumeration that may be specified as: + - A string that matches one of the following regular expressions: + ['^x([2-9]|[1-9][0-9]+)?$', '^y([2-9]|[1-9][0-9]+)?$'] + + Returns + ------- + Any + """ + return self['scaleanchor'] + + @scaleanchor.setter + def scaleanchor(self, val): + self['scaleanchor'] = val + + # scaleratio + # ---------- + @property + def scaleratio(self): + """ + If this axis is linked to another by `scaleanchor`, this + determines the pixel to unit scale ratio. For example, if this + value is 10, then every unit on this axis spans 10 times the + number of pixels as a unit on the linked axis. Use this for + example to create an elevation profile where the vertical scale + is exaggerated a fixed amount with respect to the horizontal. + + The 'scaleratio' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['scaleratio'] + + @scaleratio.setter + def scaleratio(self, val): + self['scaleratio'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showspikes + # ---------- + @property + def showspikes(self): + """ + Determines whether or not spikes (aka droplines) are drawn for + this axis. Note: This only takes affect when hovermode = + closest + + The 'showspikes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showspikes'] + + @showspikes.setter + def showspikes(self, val): + self['showspikes'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # side + # ---- + @property + def side(self): + """ + Determines whether a x (y) axis is positioned at the *bottom* + (*left*) or *top* (*right*) of the plotting area. + + The 'side' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'bottom', 'left', 'right'] + + Returns + ------- + Any + """ + return self['side'] + + @side.setter + def side(self, val): + self['side'] = val + + # spikecolor + # ---------- + @property + def spikecolor(self): + """ + Sets the spike color. If undefined, will use the series color + + The 'spikecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['spikecolor'] + + @spikecolor.setter + def spikecolor(self, val): + self['spikecolor'] = val + + # spikedash + # --------- + @property + def spikedash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'spikedash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['spikedash'] + + @spikedash.setter + def spikedash(self, val): + self['spikedash'] = val + + # spikemode + # --------- + @property + def spikemode(self): + """ + Determines the drawing mode for the spike line If *toaxis*, the + line is drawn from the data point to the axis the series is + plotted on. If *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If *marker*, then a marker + dot is drawn on the axis the series is plotted on + + The 'spikemode' property is a flaglist and may be specified + as a string containing: + - Any combination of ['toaxis', 'across', 'marker'] joined with '+' characters + (e.g. 'toaxis+across') + + Returns + ------- + Any + """ + return self['spikemode'] + + @spikemode.setter + def spikemode(self, val): + self['spikemode'] = val + + # spikesnap + # --------- + @property + def spikesnap(self): + """ + Determines whether spikelines are stuck to the cursor or to the + closest datapoints. + + The 'spikesnap' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['data', 'cursor'] + + Returns + ------- + Any + """ + return self['spikesnap'] + + @spikesnap.setter + def spikesnap(self, val): + self['spikesnap'] = val + + # spikethickness + # -------------- + @property + def spikethickness(self): + """ + Sets the width (in px) of the zero line. + + The 'spikethickness' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['spikethickness'] + + @spikethickness.setter + def spikethickness(self, val): + self['spikethickness'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.yaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.yaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.yaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.yaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.yaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.yaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # zeroline + # -------- + @property + def zeroline(self): + """ + Determines whether or not a line is drawn at along the 0 value + of this axis. If *true*, the zero line is drawn on top of the + grid lines. + + The 'zeroline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zeroline'] + + @zeroline.setter + def zeroline(self, val): + self['zeroline'] = val + + # zerolinecolor + # ------------- + @property + def zerolinecolor(self): + """ + Sets the line color of the zero line. + + The 'zerolinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['zerolinecolor'] + + @zerolinecolor.setter + def zerolinecolor(self, val): + self['zerolinecolor'] = val + + # zerolinewidth + # ------------- + @property + def zerolinewidth(self): + """ + Sets the width (in px) of the zero line. + + The 'zerolinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zerolinewidth'] + + @zerolinewidth.setter + def zerolinewidth(self, val): + self['zerolinewidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + anchor + If set to an opposite-letter axis id (e.g. `x2`, `y`), + this axis is bound to the corresponding opposite-letter + axis. If set to *free*, this axis' position is + determined by `position`. + automargin + Determines whether long tick labels automatically grow + the figure margins. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + constrain + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines how that happens: by increasing + the *range* (default), or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines which direction we push the + originally specified plot area. Options are *left*, + *center* (default), and *right* for x axes, and *top*, + *middle* (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot fraction). + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + overlaying + If set a same-letter axis id, this axis is overlaid on + top of the corresponding same-letter axis. If *false*, + this axis does not overlay any same-letter axes. + position + Sets the position of this axis in the plotting space + (in normalized coordinates). Only has an effect if + `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the range + of this axis changes together with the range of the + corresponding axis such that the scale of pixels per + unit is in a constant ratio. Both axes are still + zoomable, but when you zoom one, the other will zoom + the same amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you + can only link axes of the same `type`. The linked axis + can have the opposite letter (to constrain the aspect + ratio) or the same letter (to match scales across + subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the + last constraint encountered will be ignored to avoid + possible inconsistent constraints via `scaleratio`. + scaleratio + If this axis is linked to another by `scaleanchor`, + this determines the pixel to unit scale ratio. For + example, if this value is 10, then every unit on this + axis spans 10 times the number of pixels as a unit on + the linked axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Determines whether or not spikes (aka droplines) are + drawn for this axis. Note: This only takes affect when + hovermode = closest + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned at the + *bottom* (*left*) or *top* (*right*) of the plotting + area. + spikecolor + Sets the spike color. If undefined, will use the series + color + spikedash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line If + *toaxis*, the line is drawn from the data point to the + axis the series is plotted on. If *across*, the line + is drawn across the entire plot area, and supercedes + *toaxis*. If *marker*, then a marker dot is drawn on + the axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the cursor + or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.yaxis.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + """ + + def __init__( + self, + arg=None, + anchor=None, + automargin=None, + autorange=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + constrain=None, + constraintoward=None, + domain=None, + dtick=None, + exponentformat=None, + fixedrange=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + mirror=None, + nticks=None, + overlaying=None, + position=None, + range=None, + rangemode=None, + scaleanchor=None, + scaleratio=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showspikes=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + side=None, + spikecolor=None, + spikedash=None, + spikemode=None, + spikesnap=None, + spikethickness=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + zeroline=None, + zerolinecolor=None, + zerolinewidth=None, + **kwargs + ): + """ + Construct a new YAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.YAxis + anchor + If set to an opposite-letter axis id (e.g. `x2`, `y`), + this axis is bound to the corresponding opposite-letter + axis. If set to *free*, this axis' position is + determined by `position`. + automargin + Determines whether long tick labels automatically grow + the figure margins. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + constrain + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines how that happens: by increasing + the *range* (default), or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due to its + own `scaleanchor` and `scaleratio` or those of the + other axis), determines which direction we push the + originally specified plot area. Options are *left*, + *center* (default), and *right* for x axes, and *top*, + *middle* (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot fraction). + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom-able. If + true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + overlaying + If set a same-letter axis id, this axis is overlaid on + top of the corresponding same-letter axis. If *false*, + this axis does not overlay any same-letter axes. + position + Sets the position of this axis in the plotting space + (in normalized coordinates). Only has an effect if + `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the range + of this axis changes together with the range of the + corresponding axis such that the scale of pixels per + unit is in a constant ratio. Both axes are still + zoomable, but when you zoom one, the other will zoom + the same amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce the + constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you + can only link axes of the same `type`. The linked axis + can have the opposite letter (to constrain the aspect + ratio) or the same letter (to match scales across + subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant and the + last constraint encountered will be ignored to avoid + possible inconsistent constraints via `scaleratio`. + scaleratio + If this axis is linked to another by `scaleanchor`, + this determines the pixel to unit scale ratio. For + example, if this value is 10, then every unit on this + axis spans 10 times the number of pixels as a unit on + the linked axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Determines whether or not spikes (aka droplines) are + drawn for this axis. Note: This only takes affect when + hovermode = closest + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned at the + *bottom* (*left*) or *top* (*right*) of the plotting + area. + spikecolor + Sets the spike color. If undefined, will use the series + color + spikedash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line If + *toaxis*, the line is drawn from the data point to the + axis the series is plotted on. If *across*, the line + is drawn across the entire plot area, and supercedes + *toaxis*. If *marker*, then a marker dot is drawn on + the axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the cursor + or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.yaxis.Tickformatstop instance + or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + YAxis + """ + super(YAxis, self).__init__('yaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.YAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.YAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout import (yaxis as v_yaxis) + + # Initialize validators + # --------------------- + self._validators['anchor'] = v_yaxis.AnchorValidator() + self._validators['automargin'] = v_yaxis.AutomarginValidator() + self._validators['autorange'] = v_yaxis.AutorangeValidator() + self._validators['calendar'] = v_yaxis.CalendarValidator() + self._validators['categoryarray'] = v_yaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_yaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_yaxis.CategoryorderValidator() + self._validators['color'] = v_yaxis.ColorValidator() + self._validators['constrain'] = v_yaxis.ConstrainValidator() + self._validators['constraintoward' + ] = v_yaxis.ConstraintowardValidator() + self._validators['domain'] = v_yaxis.DomainValidator() + self._validators['dtick'] = v_yaxis.DtickValidator() + self._validators['exponentformat'] = v_yaxis.ExponentformatValidator() + self._validators['fixedrange'] = v_yaxis.FixedrangeValidator() + self._validators['gridcolor'] = v_yaxis.GridcolorValidator() + self._validators['gridwidth'] = v_yaxis.GridwidthValidator() + self._validators['hoverformat'] = v_yaxis.HoverformatValidator() + self._validators['layer'] = v_yaxis.LayerValidator() + self._validators['linecolor'] = v_yaxis.LinecolorValidator() + self._validators['linewidth'] = v_yaxis.LinewidthValidator() + self._validators['mirror'] = v_yaxis.MirrorValidator() + self._validators['nticks'] = v_yaxis.NticksValidator() + self._validators['overlaying'] = v_yaxis.OverlayingValidator() + self._validators['position'] = v_yaxis.PositionValidator() + self._validators['range'] = v_yaxis.RangeValidator() + self._validators['rangemode'] = v_yaxis.RangemodeValidator() + self._validators['scaleanchor'] = v_yaxis.ScaleanchorValidator() + self._validators['scaleratio'] = v_yaxis.ScaleratioValidator() + self._validators['separatethousands' + ] = v_yaxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_yaxis.ShowexponentValidator() + self._validators['showgrid'] = v_yaxis.ShowgridValidator() + self._validators['showline'] = v_yaxis.ShowlineValidator() + self._validators['showspikes'] = v_yaxis.ShowspikesValidator() + self._validators['showticklabels'] = v_yaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_yaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_yaxis.ShowticksuffixValidator() + self._validators['side'] = v_yaxis.SideValidator() + self._validators['spikecolor'] = v_yaxis.SpikecolorValidator() + self._validators['spikedash'] = v_yaxis.SpikedashValidator() + self._validators['spikemode'] = v_yaxis.SpikemodeValidator() + self._validators['spikesnap'] = v_yaxis.SpikesnapValidator() + self._validators['spikethickness'] = v_yaxis.SpikethicknessValidator() + self._validators['tick0'] = v_yaxis.Tick0Validator() + self._validators['tickangle'] = v_yaxis.TickangleValidator() + self._validators['tickcolor'] = v_yaxis.TickcolorValidator() + self._validators['tickfont'] = v_yaxis.TickfontValidator() + self._validators['tickformat'] = v_yaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_yaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_yaxis.TicklenValidator() + self._validators['tickmode'] = v_yaxis.TickmodeValidator() + self._validators['tickprefix'] = v_yaxis.TickprefixValidator() + self._validators['ticks'] = v_yaxis.TicksValidator() + self._validators['ticksuffix'] = v_yaxis.TicksuffixValidator() + self._validators['ticktext'] = v_yaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_yaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_yaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_yaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_yaxis.TickwidthValidator() + self._validators['title'] = v_yaxis.TitleValidator() + self._validators['titlefont'] = v_yaxis.TitlefontValidator() + self._validators['type'] = v_yaxis.TypeValidator() + self._validators['visible'] = v_yaxis.VisibleValidator() + self._validators['zeroline'] = v_yaxis.ZerolineValidator() + self._validators['zerolinecolor'] = v_yaxis.ZerolinecolorValidator() + self._validators['zerolinewidth'] = v_yaxis.ZerolinewidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('anchor', None) + self.anchor = anchor if anchor is not None else v + v = arg.pop('automargin', None) + self.automargin = automargin if automargin is not None else v + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('constrain', None) + self.constrain = constrain if constrain is not None else v + v = arg.pop('constraintoward', None) + self.constraintoward = constraintoward if constraintoward is not None else v + v = arg.pop('domain', None) + self.domain = domain if domain is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('fixedrange', None) + self.fixedrange = fixedrange if fixedrange is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('mirror', None) + self.mirror = mirror if mirror is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('overlaying', None) + self.overlaying = overlaying if overlaying is not None else v + v = arg.pop('position', None) + self.position = position if position is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('scaleanchor', None) + self.scaleanchor = scaleanchor if scaleanchor is not None else v + v = arg.pop('scaleratio', None) + self.scaleratio = scaleratio if scaleratio is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showspikes', None) + self.showspikes = showspikes if showspikes is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('side', None) + self.side = side if side is not None else v + v = arg.pop('spikecolor', None) + self.spikecolor = spikecolor if spikecolor is not None else v + v = arg.pop('spikedash', None) + self.spikedash = spikedash if spikedash is not None else v + v = arg.pop('spikemode', None) + self.spikemode = spikemode if spikemode is not None else v + v = arg.pop('spikesnap', None) + self.spikesnap = spikesnap if spikesnap is not None else v + v = arg.pop('spikethickness', None) + self.spikethickness = spikethickness if spikethickness is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('zeroline', None) + self.zeroline = zeroline if zeroline is not None else v + v = arg.pop('zerolinecolor', None) + self.zerolinecolor = zerolinecolor if zerolinecolor is not None else v + v = arg.pop('zerolinewidth', None) + self.zerolinewidth = zerolinewidth if zerolinewidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/annotation/__init__.py b/plotly/graph_objs/layout/annotation/__init__.py new file mode 100644 index 0000000000..76631345ed --- /dev/null +++ b/plotly/graph_objs/layout/annotation/__init__.py @@ -0,0 +1,3 @@ +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.layout.annotation import hoverlabel +from ._font import Font diff --git a/plotly/graph_objs/layout/annotation/_font.py b/plotly/graph_objs/layout/annotation/_font.py new file mode 100644 index 0000000000..b9a23af53b --- /dev/null +++ b/plotly/graph_objs/layout/annotation/_font.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.annotation' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the annotation text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.annotation.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.annotation.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.annotation.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.annotation import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/annotation/_hoverlabel.py b/plotly/graph_objs/layout/annotation/_hoverlabel.py new file mode 100644 index 0000000000..177235ec8d --- /dev/null +++ b/plotly/graph_objs/layout/annotation/_hoverlabel.py @@ -0,0 +1,270 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Hoverlabel(BaseLayoutHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover label. By default uses + the annotation's `bgcolor` made opaque, or white if it was + transparent. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover label. By default uses + either dark grey or white, for maximum contrast with + `hoverlabel.bgcolor`. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the hover label text font. By default uses the global + hover font and size, with color from `hoverlabel.bordercolor`. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.annotation.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.annotation.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.annotation' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover label. By + default uses the annotation's `bgcolor` made opaque, or + white if it was transparent. + bordercolor + Sets the border color of the hover label. By default + uses either dark grey or white, for maximum contrast + with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses the + global hover font and size, with color from + `hoverlabel.bordercolor`. + """ + + def __init__( + self, arg=None, bgcolor=None, bordercolor=None, font=None, **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.annotation.Hoverlabel + bgcolor + Sets the background color of the hover label. By + default uses the annotation's `bgcolor` made opaque, or + white if it was transparent. + bordercolor + Sets the border color of the hover label. By default + uses either dark grey or white, for maximum contrast + with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses the + global hover font and size, with color from + `hoverlabel.bordercolor`. + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.annotation.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.layout.annotation.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.annotation import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/annotation/hoverlabel/__init__.py b/plotly/graph_objs/layout/annotation/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/layout/annotation/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/layout/annotation/hoverlabel/_font.py b/plotly/graph_objs/layout/annotation/hoverlabel/_font.py new file mode 100644 index 0000000000..e217937834 --- /dev/null +++ b/plotly/graph_objs/layout/annotation/hoverlabel/_font.py @@ -0,0 +1,221 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.annotation.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the hover label text font. By default uses the global + hover font and size, with color from `hoverlabel.bordercolor`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.annotation.hoverlabel.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.annotation.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.annotation.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.annotation.hoverlabel import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/__init__.py b/plotly/graph_objs/layout/geo/__init__.py new file mode 100644 index 0000000000..189826eba2 --- /dev/null +++ b/plotly/graph_objs/layout/geo/__init__.py @@ -0,0 +1,6 @@ +from ._projection import Projection +from plotly.graph_objs.layout.geo import projection +from ._lonaxis import Lonaxis +from ._lataxis import Lataxis +from ._domain import Domain +from ._center import Center diff --git a/plotly/graph_objs/layout/geo/_center.py b/plotly/graph_objs/layout/geo/_center.py new file mode 100644 index 0000000000..9ca950e011 --- /dev/null +++ b/plotly/graph_objs/layout/geo/_center.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Center(BaseLayoutHierarchyType): + + # lat + # --- + @property + def lat(self): + """ + Sets the latitude of the map's center. For all projection + types, the map's latitude center lies at the middle of the + latitude range by default. + + The 'lat' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lat'] + + @lat.setter + def lat(self, val): + self['lat'] = val + + # lon + # --- + @property + def lon(self): + """ + Sets the longitude of the map's center. By default, the map's + longitude center lies at the middle of the longitude range for + scoped projection and above `projection.rotation.lon` + otherwise. + + The 'lon' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lon'] + + @lon.setter + def lon(self, val): + self['lon'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + lat + Sets the latitude of the map's center. For all + projection types, the map's latitude center lies at the + middle of the latitude range by default. + lon + Sets the longitude of the map's center. By default, the + map's longitude center lies at the middle of the + longitude range for scoped projection and above + `projection.rotation.lon` otherwise. + """ + + def __init__(self, arg=None, lat=None, lon=None, **kwargs): + """ + Construct a new Center object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.geo.Center + lat + Sets the latitude of the map's center. For all + projection types, the map's latitude center lies at the + middle of the latitude range by default. + lon + Sets the longitude of the map's center. By default, the + map's longitude center lies at the middle of the + longitude range for scoped projection and above + `projection.rotation.lon` otherwise. + + Returns + ------- + Center + """ + super(Center, self).__init__('center') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.Center +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.Center""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo import (center as v_center) + + # Initialize validators + # --------------------- + self._validators['lat'] = v_center.LatValidator() + self._validators['lon'] = v_center.LonValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('lat', None) + self.lat = lat if lat is not None else v + v = arg.pop('lon', None) + self.lon = lon if lon is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/_domain.py b/plotly/graph_objs/layout/geo/_domain.py new file mode 100644 index 0000000000..4f47f31d6c --- /dev/null +++ b/plotly/graph_objs/layout/geo/_domain.py @@ -0,0 +1,232 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this geo subplot . Note that geo subplots are + constrained by domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y domain, but not + both. + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this geo subplot . Note that geo subplots are + constrained by domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y domain, but not + both. + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by domain. In + general, when `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both. + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by domain. In + general, when `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both. + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this geo subplot . Note that geo + subplots are constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit either + its x or y domain, but not both. + row + If there is a layout grid, use the domain for this row + in the grid for this geo subplot . Note that geo + subplots are constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit either + its x or y domain, but not both. + x + Sets the horizontal domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by + domain. In general, when `projection.scale` is set to + 1. a map will fit either its x or y domain, but not + both. + y + Sets the vertical domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by + domain. In general, when `projection.scale` is set to + 1. a map will fit either its x or y domain, but not + both. + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.geo.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this geo subplot . Note that geo + subplots are constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit either + its x or y domain, but not both. + row + If there is a layout grid, use the domain for this row + in the grid for this geo subplot . Note that geo + subplots are constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit either + its x or y domain, but not both. + x + Sets the horizontal domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by + domain. In general, when `projection.scale` is set to + 1. a map will fit either its x or y domain, but not + both. + y + Sets the vertical domain of this geo subplot (in plot + fraction). Note that geo subplots are constrained by + domain. In general, when `projection.scale` is set to + 1. a map will fit either its x or y domain, but not + both. + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/_lataxis.py b/plotly/graph_objs/layout/geo/_lataxis.py new file mode 100644 index 0000000000..61c2210466 --- /dev/null +++ b/plotly/graph_objs/layout/geo/_lataxis.py @@ -0,0 +1,283 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Lataxis(BaseLayoutHierarchyType): + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the graticule's longitude/latitude tick step. + + The 'dtick' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the graticule's stroke color. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the graticule's stroke width (in px). + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis (in degrees), sets the map's + clipped coordinates. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property is a number and may be specified as: + - An int or float + (1) The 'range[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Sets whether or not graticule are shown on the map. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the graticule's starting tick longitude/latitude. + + The 'tick0' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtick + Sets the graticule's longitude/latitude tick step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets the + map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the map. + tick0 + Sets the graticule's starting tick longitude/latitude. + """ + + def __init__( + self, + arg=None, + dtick=None, + gridcolor=None, + gridwidth=None, + range=None, + showgrid=None, + tick0=None, + **kwargs + ): + """ + Construct a new Lataxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.geo.Lataxis + dtick + Sets the graticule's longitude/latitude tick step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets the + map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the map. + tick0 + Sets the graticule's starting tick longitude/latitude. + + Returns + ------- + Lataxis + """ + super(Lataxis, self).__init__('lataxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.Lataxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.Lataxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo import (lataxis as v_lataxis) + + # Initialize validators + # --------------------- + self._validators['dtick'] = v_lataxis.DtickValidator() + self._validators['gridcolor'] = v_lataxis.GridcolorValidator() + self._validators['gridwidth'] = v_lataxis.GridwidthValidator() + self._validators['range'] = v_lataxis.RangeValidator() + self._validators['showgrid'] = v_lataxis.ShowgridValidator() + self._validators['tick0'] = v_lataxis.Tick0Validator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/_lonaxis.py b/plotly/graph_objs/layout/geo/_lonaxis.py new file mode 100644 index 0000000000..5bd570d187 --- /dev/null +++ b/plotly/graph_objs/layout/geo/_lonaxis.py @@ -0,0 +1,283 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Lonaxis(BaseLayoutHierarchyType): + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the graticule's longitude/latitude tick step. + + The 'dtick' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the graticule's stroke color. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the graticule's stroke width (in px). + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis (in degrees), sets the map's + clipped coordinates. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property is a number and may be specified as: + - An int or float + (1) The 'range[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Sets whether or not graticule are shown on the map. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the graticule's starting tick longitude/latitude. + + The 'tick0' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtick + Sets the graticule's longitude/latitude tick step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets the + map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the map. + tick0 + Sets the graticule's starting tick longitude/latitude. + """ + + def __init__( + self, + arg=None, + dtick=None, + gridcolor=None, + gridwidth=None, + range=None, + showgrid=None, + tick0=None, + **kwargs + ): + """ + Construct a new Lonaxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.geo.Lonaxis + dtick + Sets the graticule's longitude/latitude tick step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets the + map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the map. + tick0 + Sets the graticule's starting tick longitude/latitude. + + Returns + ------- + Lonaxis + """ + super(Lonaxis, self).__init__('lonaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.Lonaxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.Lonaxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo import (lonaxis as v_lonaxis) + + # Initialize validators + # --------------------- + self._validators['dtick'] = v_lonaxis.DtickValidator() + self._validators['gridcolor'] = v_lonaxis.GridcolorValidator() + self._validators['gridwidth'] = v_lonaxis.GridwidthValidator() + self._validators['range'] = v_lonaxis.RangeValidator() + self._validators['showgrid'] = v_lonaxis.ShowgridValidator() + self._validators['tick0'] = v_lonaxis.Tick0Validator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/_projection.py b/plotly/graph_objs/layout/geo/_projection.py new file mode 100644 index 0000000000..e59ed88436 --- /dev/null +++ b/plotly/graph_objs/layout/geo/_projection.py @@ -0,0 +1,216 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Projection(BaseLayoutHierarchyType): + + # parallels + # --------- + @property + def parallels(self): + """ + For conic projection types only. Sets the parallels (tangent, + secant) where the cone intersects the sphere. + + The 'parallels' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'parallels[0]' property is a number and may be specified as: + - An int or float + (1) The 'parallels[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['parallels'] + + @parallels.setter + def parallels(self, val): + self['parallels'] = val + + # rotation + # -------- + @property + def rotation(self): + """ + The 'rotation' property is an instance of Rotation + that may be specified as: + - An instance of plotly.graph_objs.layout.geo.projection.Rotation + - A dict of string/value properties that will be passed + to the Rotation constructor + + Supported dict properties: + + lat + Rotates the map along meridians (in degrees + North). + lon + Rotates the map along parallels (in degrees + East). Defaults to the center of the + `lonaxis.range` values. + roll + Roll the map (in degrees) For example, a roll + of *180* makes the map appear upside down. + + Returns + ------- + plotly.graph_objs.layout.geo.projection.Rotation + """ + return self['rotation'] + + @rotation.setter + def rotation(self, val): + self['rotation'] = val + + # scale + # ----- + @property + def scale(self): + """ + Zooms in or out on the map view. A scale of *1* corresponds to + the largest zoom level that fits the map's lon and lat ranges. + + The 'scale' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['scale'] + + @scale.setter + def scale(self, val): + self['scale'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the projection type. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['equirectangular', 'mercator', 'orthographic', 'natural + earth', 'kavrayskiy7', 'miller', 'robinson', 'eckert4', + 'azimuthal equal area', 'azimuthal equidistant', 'conic + equal area', 'conic conformal', 'conic equidistant', + 'gnomonic', 'stereographic', 'mollweide', 'hammer', + 'transverse mercator', 'albers usa', 'winkel tripel', + 'aitoff', 'sinusoidal'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + parallels + For conic projection types only. Sets the parallels + (tangent, secant) where the cone intersects the sphere. + rotation + plotly.graph_objs.layout.geo.projection.Rotation + instance or dict with compatible properties + scale + Zooms in or out on the map view. A scale of *1* + corresponds to the largest zoom level that fits the + map's lon and lat ranges. + type + Sets the projection type. + """ + + def __init__( + self, + arg=None, + parallels=None, + rotation=None, + scale=None, + type=None, + **kwargs + ): + """ + Construct a new Projection object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.geo.Projection + parallels + For conic projection types only. Sets the parallels + (tangent, secant) where the cone intersects the sphere. + rotation + plotly.graph_objs.layout.geo.projection.Rotation + instance or dict with compatible properties + scale + Zooms in or out on the map view. A scale of *1* + corresponds to the largest zoom level that fits the + map's lon and lat ranges. + type + Sets the projection type. + + Returns + ------- + Projection + """ + super(Projection, self).__init__('projection') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.Projection +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.Projection""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo import (projection as v_projection) + + # Initialize validators + # --------------------- + self._validators['parallels'] = v_projection.ParallelsValidator() + self._validators['rotation'] = v_projection.RotationValidator() + self._validators['scale'] = v_projection.ScaleValidator() + self._validators['type'] = v_projection.TypeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('parallels', None) + self.parallels = parallels if parallels is not None else v + v = arg.pop('rotation', None) + self.rotation = rotation if rotation is not None else v + v = arg.pop('scale', None) + self.scale = scale if scale is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/geo/projection/__init__.py b/plotly/graph_objs/layout/geo/projection/__init__.py new file mode 100644 index 0000000000..366702a7be --- /dev/null +++ b/plotly/graph_objs/layout/geo/projection/__init__.py @@ -0,0 +1 @@ +from ._rotation import Rotation diff --git a/plotly/graph_objs/layout/geo/projection/_rotation.py b/plotly/graph_objs/layout/geo/projection/_rotation.py new file mode 100644 index 0000000000..3c4d9e7274 --- /dev/null +++ b/plotly/graph_objs/layout/geo/projection/_rotation.py @@ -0,0 +1,154 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Rotation(BaseLayoutHierarchyType): + + # lat + # --- + @property + def lat(self): + """ + Rotates the map along meridians (in degrees North). + + The 'lat' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lat'] + + @lat.setter + def lat(self, val): + self['lat'] = val + + # lon + # --- + @property + def lon(self): + """ + Rotates the map along parallels (in degrees East). Defaults to + the center of the `lonaxis.range` values. + + The 'lon' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lon'] + + @lon.setter + def lon(self, val): + self['lon'] = val + + # roll + # ---- + @property + def roll(self): + """ + Roll the map (in degrees) For example, a roll of *180* makes + the map appear upside down. + + The 'roll' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['roll'] + + @roll.setter + def roll(self, val): + self['roll'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.geo.projection' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + lat + Rotates the map along meridians (in degrees North). + lon + Rotates the map along parallels (in degrees East). + Defaults to the center of the `lonaxis.range` values. + roll + Roll the map (in degrees) For example, a roll of *180* + makes the map appear upside down. + """ + + def __init__(self, arg=None, lat=None, lon=None, roll=None, **kwargs): + """ + Construct a new Rotation object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.geo.projection.Rotation + lat + Rotates the map along meridians (in degrees North). + lon + Rotates the map along parallels (in degrees East). + Defaults to the center of the `lonaxis.range` values. + roll + Roll the map (in degrees) For example, a roll of *180* + makes the map appear upside down. + + Returns + ------- + Rotation + """ + super(Rotation, self).__init__('rotation') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.geo.projection.Rotation +constructor must be a dict or +an instance of plotly.graph_objs.layout.geo.projection.Rotation""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.geo.projection import ( + rotation as v_rotation + ) + + # Initialize validators + # --------------------- + self._validators['lat'] = v_rotation.LatValidator() + self._validators['lon'] = v_rotation.LonValidator() + self._validators['roll'] = v_rotation.RollValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('lat', None) + self.lat = lat if lat is not None else v + v = arg.pop('lon', None) + self.lon = lon if lon is not None else v + v = arg.pop('roll', None) + self.roll = roll if roll is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/grid/__init__.py b/plotly/graph_objs/layout/grid/__init__.py new file mode 100644 index 0000000000..ee28990c0d --- /dev/null +++ b/plotly/graph_objs/layout/grid/__init__.py @@ -0,0 +1 @@ +from ._domain import Domain diff --git a/plotly/graph_objs/layout/grid/_domain.py b/plotly/graph_objs/layout/grid/_domain.py new file mode 100644 index 0000000000..e2c0b8a85d --- /dev/null +++ b/plotly/graph_objs/layout/grid/_domain.py @@ -0,0 +1,140 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this grid subplot (in plot + fraction). The first and last cells end exactly at the domain + edges, with no grout around the edges. + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this grid subplot (in plot + fraction). The first and last cells end exactly at the domain + edges, with no grout around the edges. + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.grid' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Sets the horizontal domain of this grid subplot (in + plot fraction). The first and last cells end exactly at + the domain edges, with no grout around the edges. + y + Sets the vertical domain of this grid subplot (in plot + fraction). The first and last cells end exactly at the + domain edges, with no grout around the edges. + """ + + def __init__(self, arg=None, x=None, y=None, **kwargs): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.grid.Domain + x + Sets the horizontal domain of this grid subplot (in + plot fraction). The first and last cells end exactly at + the domain edges, with no grout around the edges. + y + Sets the vertical domain of this grid subplot (in plot + fraction). The first and last cells end exactly at the + domain edges, with no grout around the edges. + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.grid.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.grid.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.grid import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/hoverlabel/__init__.py b/plotly/graph_objs/layout/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/layout/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/layout/hoverlabel/_font.py b/plotly/graph_objs/layout/hoverlabel/_font.py new file mode 100644 index 0000000000..7f81308815 --- /dev/null +++ b/plotly/graph_objs/layout/hoverlabel/_font.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the default hover label font used by all traces on the + graph. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.hoverlabel.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/legend/__init__.py b/plotly/graph_objs/layout/legend/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/layout/legend/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/layout/legend/_font.py b/plotly/graph_objs/layout/legend/_font.py new file mode 100644 index 0000000000..c54d6d1edd --- /dev/null +++ b/plotly/graph_objs/layout/legend/_font.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.legend' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the font used to text the legend items. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.legend.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.legend.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.legend.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.legend import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/__init__.py b/plotly/graph_objs/layout/mapbox/__init__.py new file mode 100644 index 0000000000..704e3c09d0 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/__init__.py @@ -0,0 +1,4 @@ +from ._layer import Layer +from plotly.graph_objs.layout.mapbox import layer +from ._domain import Domain +from ._center import Center diff --git a/plotly/graph_objs/layout/mapbox/_center.py b/plotly/graph_objs/layout/mapbox/_center.py new file mode 100644 index 0000000000..307ab40747 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/_center.py @@ -0,0 +1,122 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Center(BaseLayoutHierarchyType): + + # lat + # --- + @property + def lat(self): + """ + Sets the latitude of the center of the map (in degrees North). + + The 'lat' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lat'] + + @lat.setter + def lat(self, val): + self['lat'] = val + + # lon + # --- + @property + def lon(self): + """ + Sets the longitude of the center of the map (in degrees East). + + The 'lon' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['lon'] + + @lon.setter + def lon(self, val): + self['lon'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + lat + Sets the latitude of the center of the map (in degrees + North). + lon + Sets the longitude of the center of the map (in degrees + East). + """ + + def __init__(self, arg=None, lat=None, lon=None, **kwargs): + """ + Construct a new Center object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.mapbox.Center + lat + Sets the latitude of the center of the map (in degrees + North). + lon + Sets the longitude of the center of the map (in degrees + East). + + Returns + ------- + Center + """ + super(Center, self).__init__('center') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.Center +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.Center""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox import (center as v_center) + + # Initialize validators + # --------------------- + self._validators['lat'] = v_center.LatValidator() + self._validators['lon'] = v_center.LonValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('lat', None) + self.lat = lat if lat is not None else v + v = arg.pop('lon', None) + self.lon = lon if lon is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/_domain.py b/plotly/graph_objs/layout/mapbox/_domain.py new file mode 100644 index 0000000000..a6f154da79 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this mapbox subplot . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this mapbox subplot . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this mapbox subplot (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this mapbox subplot (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this mapbox subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this mapbox subplot . + x + Sets the horizontal domain of this mapbox subplot (in + plot fraction). + y + Sets the vertical domain of this mapbox subplot (in + plot fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.mapbox.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this mapbox subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this mapbox subplot . + x + Sets the horizontal domain of this mapbox subplot (in + plot fraction). + y + Sets the vertical domain of this mapbox subplot (in + plot fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/_layer.py b/plotly/graph_objs/layout/mapbox/_layer.py new file mode 100644 index 0000000000..d21daaa6c7 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/_layer.py @@ -0,0 +1,507 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Layer(BaseLayoutHierarchyType): + + # below + # ----- + @property + def below(self): + """ + Determines if the layer will be inserted before the layer with + the specified ID. If omitted or set to '', the layer will be + inserted above every existing layer. + + The 'below' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['below'] + + @below.setter + def below(self, val): + self['below'] = val + + # circle + # ------ + @property + def circle(self): + """ + The 'circle' property is an instance of Circle + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.layer.Circle + - A dict of string/value properties that will be passed + to the Circle constructor + + Supported dict properties: + + radius + Sets the circle radius. Has an effect only when + `type` is set to *circle*. + + Returns + ------- + plotly.graph_objs.layout.mapbox.layer.Circle + """ + return self['circle'] + + @circle.setter + def circle(self, val): + self['circle'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the primary layer color. If `type` is *circle*, color + corresponds to the circle color If `type` is *line*, color + corresponds to the line color If `type` is *fill*, color + corresponds to the fill color If `type` is *symbol*, color + corresponds to the icon color + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # fill + # ---- + @property + def fill(self): + """ + The 'fill' property is an instance of Fill + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.layer.Fill + - A dict of string/value properties that will be passed + to the Fill constructor + + Supported dict properties: + + outlinecolor + Sets the fill outline color. Has an effect only + when `type` is set to *fill*. + + Returns + ------- + plotly.graph_objs.layout.mapbox.layer.Fill + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.layer.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + width + Sets the line width. Has an effect only when + `type` is set to *line*. + + Returns + ------- + plotly.graph_objs.layout.mapbox.layer.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the layer. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # source + # ------ + @property + def source(self): + """ + Sets the source data for this layer. Source can be either a + URL, a geojson object (with `sourcetype` set to *geojson*) or + an array of tile URLS (with `sourcetype` set to *vector*). + + The 'source' property accepts values of any type + + Returns + ------- + Any + """ + return self['source'] + + @source.setter + def source(self, val): + self['source'] = val + + # sourcelayer + # ----------- + @property + def sourcelayer(self): + """ + Specifies the layer to use from a vector tile source. Required + for *vector* source type that supports multiple layers. + + The 'sourcelayer' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['sourcelayer'] + + @sourcelayer.setter + def sourcelayer(self, val): + self['sourcelayer'] = val + + # sourcetype + # ---------- + @property + def sourcetype(self): + """ + Sets the source type for this layer. Support for *raster*, + *image* and *video* source types is coming soon. + + The 'sourcetype' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['geojson', 'vector'] + + Returns + ------- + Any + """ + return self['sourcetype'] + + @sourcetype.setter + def sourcetype(self, val): + self['sourcetype'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + The 'symbol' property is an instance of Symbol + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.layer.Symbol + - A dict of string/value properties that will be passed + to the Symbol constructor + + Supported dict properties: + + icon + Sets the symbol icon image. Full list: + https://www.mapbox.com/maki-icons/ + iconsize + Sets the symbol icon size. Has an effect only + when `type` is set to *symbol*. + text + Sets the symbol text. + textfont + Sets the icon text font. Has an effect only + when `type` is set to *symbol*. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + + Returns + ------- + plotly.graph_objs.layout.mapbox.layer.Symbol + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the layer type. Support for *raster*, *background* types + is coming soon. Note that *line* and *fill* are not compatible + with Point GeoJSON geometries. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['circle', 'line', 'fill', 'symbol'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + below + Determines if the layer will be inserted before the + layer with the specified ID. If omitted or set to '', + the layer will be inserted above every existing layer. + circle + plotly.graph_objs.layout.mapbox.layer.Circle instance + or dict with compatible properties + color + Sets the primary layer color. If `type` is *circle*, + color corresponds to the circle color If `type` is + *line*, color corresponds to the line color If `type` + is *fill*, color corresponds to the fill color If + `type` is *symbol*, color corresponds to the icon color + fill + plotly.graph_objs.layout.mapbox.layer.Fill instance or + dict with compatible properties + line + plotly.graph_objs.layout.mapbox.layer.Line instance or + dict with compatible properties + opacity + Sets the opacity of the layer. + source + Sets the source data for this layer. Source can be + either a URL, a geojson object (with `sourcetype` set + to *geojson*) or an array of tile URLS (with + `sourcetype` set to *vector*). + sourcelayer + Specifies the layer to use from a vector tile source. + Required for *vector* source type that supports + multiple layers. + sourcetype + Sets the source type for this layer. Support for + *raster*, *image* and *video* source types is coming + soon. + symbol + plotly.graph_objs.layout.mapbox.layer.Symbol instance + or dict with compatible properties + type + Sets the layer type. Support for *raster*, *background* + types is coming soon. Note that *line* and *fill* are + not compatible with Point GeoJSON geometries. + """ + + def __init__( + self, + arg=None, + below=None, + circle=None, + color=None, + fill=None, + line=None, + opacity=None, + source=None, + sourcelayer=None, + sourcetype=None, + symbol=None, + type=None, + **kwargs + ): + """ + Construct a new Layer object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.mapbox.Layer + below + Determines if the layer will be inserted before the + layer with the specified ID. If omitted or set to '', + the layer will be inserted above every existing layer. + circle + plotly.graph_objs.layout.mapbox.layer.Circle instance + or dict with compatible properties + color + Sets the primary layer color. If `type` is *circle*, + color corresponds to the circle color If `type` is + *line*, color corresponds to the line color If `type` + is *fill*, color corresponds to the fill color If + `type` is *symbol*, color corresponds to the icon color + fill + plotly.graph_objs.layout.mapbox.layer.Fill instance or + dict with compatible properties + line + plotly.graph_objs.layout.mapbox.layer.Line instance or + dict with compatible properties + opacity + Sets the opacity of the layer. + source + Sets the source data for this layer. Source can be + either a URL, a geojson object (with `sourcetype` set + to *geojson*) or an array of tile URLS (with + `sourcetype` set to *vector*). + sourcelayer + Specifies the layer to use from a vector tile source. + Required for *vector* source type that supports + multiple layers. + sourcetype + Sets the source type for this layer. Support for + *raster*, *image* and *video* source types is coming + soon. + symbol + plotly.graph_objs.layout.mapbox.layer.Symbol instance + or dict with compatible properties + type + Sets the layer type. Support for *raster*, *background* + types is coming soon. Note that *line* and *fill* are + not compatible with Point GeoJSON geometries. + + Returns + ------- + Layer + """ + super(Layer, self).__init__('layers') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.Layer +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.Layer""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox import (layer as v_layer) + + # Initialize validators + # --------------------- + self._validators['below'] = v_layer.BelowValidator() + self._validators['circle'] = v_layer.CircleValidator() + self._validators['color'] = v_layer.ColorValidator() + self._validators['fill'] = v_layer.FillValidator() + self._validators['line'] = v_layer.LineValidator() + self._validators['opacity'] = v_layer.OpacityValidator() + self._validators['source'] = v_layer.SourceValidator() + self._validators['sourcelayer'] = v_layer.SourcelayerValidator() + self._validators['sourcetype'] = v_layer.SourcetypeValidator() + self._validators['symbol'] = v_layer.SymbolValidator() + self._validators['type'] = v_layer.TypeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('below', None) + self.below = below if below is not None else v + v = arg.pop('circle', None) + self.circle = circle if circle is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('source', None) + self.source = source if source is not None else v + v = arg.pop('sourcelayer', None) + self.sourcelayer = sourcelayer if sourcelayer is not None else v + v = arg.pop('sourcetype', None) + self.sourcetype = sourcetype if sourcetype is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/layer/__init__.py b/plotly/graph_objs/layout/mapbox/layer/__init__.py new file mode 100644 index 0000000000..872430a71b --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/__init__.py @@ -0,0 +1,5 @@ +from ._symbol import Symbol +from plotly.graph_objs.layout.mapbox.layer import symbol +from ._line import Line +from ._fill import Fill +from ._circle import Circle diff --git a/plotly/graph_objs/layout/mapbox/layer/_circle.py b/plotly/graph_objs/layout/mapbox/layer/_circle.py new file mode 100644 index 0000000000..697fa25532 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/_circle.py @@ -0,0 +1,95 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Circle(BaseLayoutHierarchyType): + + # radius + # ------ + @property + def radius(self): + """ + Sets the circle radius. Has an effect only when `type` is set + to *circle*. + + The 'radius' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['radius'] + + @radius.setter + def radius(self, val): + self['radius'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox.layer' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + radius + Sets the circle radius. Has an effect only when `type` + is set to *circle*. + """ + + def __init__(self, arg=None, radius=None, **kwargs): + """ + Construct a new Circle object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.mapbox.layer.Circle + radius + Sets the circle radius. Has an effect only when `type` + is set to *circle*. + + Returns + ------- + Circle + """ + super(Circle, self).__init__('circle') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.layer.Circle +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.layer.Circle""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox.layer import (circle as v_circle) + + # Initialize validators + # --------------------- + self._validators['radius'] = v_circle.RadiusValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('radius', None) + self.radius = radius if radius is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/layer/_fill.py b/plotly/graph_objs/layout/mapbox/layer/_fill.py new file mode 100644 index 0000000000..8608f1a884 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/_fill.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Fill(BaseLayoutHierarchyType): + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the fill outline color. Has an effect only when `type` is + set to *fill*. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox.layer' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + outlinecolor + Sets the fill outline color. Has an effect only when + `type` is set to *fill*. + """ + + def __init__(self, arg=None, outlinecolor=None, **kwargs): + """ + Construct a new Fill object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.mapbox.layer.Fill + outlinecolor + Sets the fill outline color. Has an effect only when + `type` is set to *fill*. + + Returns + ------- + Fill + """ + super(Fill, self).__init__('fill') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.layer.Fill +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.layer.Fill""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox.layer import (fill as v_fill) + + # Initialize validators + # --------------------- + self._validators['outlinecolor'] = v_fill.OutlinecolorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/layer/_line.py b/plotly/graph_objs/layout/mapbox/layer/_line.py new file mode 100644 index 0000000000..b02da4d88b --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/_line.py @@ -0,0 +1,95 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Line(BaseLayoutHierarchyType): + + # width + # ----- + @property + def width(self): + """ + Sets the line width. Has an effect only when `type` is set to + *line*. + + The 'width' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox.layer' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + width + Sets the line width. Has an effect only when `type` is + set to *line*. + """ + + def __init__(self, arg=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.mapbox.layer.Line + width + Sets the line width. Has an effect only when `type` is + set to *line*. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.layer.Line +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.layer.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox.layer import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/layer/_symbol.py b/plotly/graph_objs/layout/mapbox/layer/_symbol.py new file mode 100644 index 0000000000..e69b369ed0 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/_symbol.py @@ -0,0 +1,251 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Symbol(BaseLayoutHierarchyType): + + # icon + # ---- + @property + def icon(self): + """ + Sets the symbol icon image. Full list: + https://www.mapbox.com/maki-icons/ + + The 'icon' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['icon'] + + @icon.setter + def icon(self, val): + self['icon'] = val + + # iconsize + # -------- + @property + def iconsize(self): + """ + Sets the symbol icon size. Has an effect only when `type` is + set to *symbol*. + + The 'iconsize' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['iconsize'] + + @iconsize.setter + def iconsize(self, val): + self['iconsize'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the symbol text. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + Sets the icon text font. Has an effect only when `type` is set + to *symbol*. + + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.layout.mapbox.layer.symbol.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.mapbox.layer.symbol.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # textposition + # ------------ + @property + def textposition(self): + """ + Sets the positions of the `text` elements with respects to the + (x,y) coordinates. + + The 'textposition' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', 'bottom + center', 'bottom right'] + + Returns + ------- + Any + """ + return self['textposition'] + + @textposition.setter + def textposition(self, val): + self['textposition'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox.layer' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + icon + Sets the symbol icon image. Full list: + https://www.mapbox.com/maki-icons/ + iconsize + Sets the symbol icon size. Has an effect only when + `type` is set to *symbol*. + text + Sets the symbol text. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + """ + + def __init__( + self, + arg=None, + icon=None, + iconsize=None, + text=None, + textfont=None, + textposition=None, + **kwargs + ): + """ + Construct a new Symbol object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.mapbox.layer.Symbol + icon + Sets the symbol icon image. Full list: + https://www.mapbox.com/maki-icons/ + iconsize + Sets the symbol icon size. Has an effect only when + `type` is set to *symbol*. + text + Sets the symbol text. + textfont + Sets the icon text font. Has an effect only when `type` + is set to *symbol*. + textposition + Sets the positions of the `text` elements with respects + to the (x,y) coordinates. + + Returns + ------- + Symbol + """ + super(Symbol, self).__init__('symbol') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.layer.Symbol +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.layer.Symbol""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox.layer import (symbol as v_symbol) + + # Initialize validators + # --------------------- + self._validators['icon'] = v_symbol.IconValidator() + self._validators['iconsize'] = v_symbol.IconsizeValidator() + self._validators['text'] = v_symbol.TextValidator() + self._validators['textfont'] = v_symbol.TextfontValidator() + self._validators['textposition'] = v_symbol.TextpositionValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('icon', None) + self.icon = icon if icon is not None else v + v = arg.pop('iconsize', None) + self.iconsize = iconsize if iconsize is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + v = arg.pop('textposition', None) + self.textposition = textposition if textposition is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/mapbox/layer/symbol/__init__.py b/plotly/graph_objs/layout/mapbox/layer/symbol/__init__.py new file mode 100644 index 0000000000..67cdef05e2 --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/symbol/__init__.py @@ -0,0 +1 @@ +from ._textfont import Textfont diff --git a/plotly/graph_objs/layout/mapbox/layer/symbol/_textfont.py b/plotly/graph_objs/layout/mapbox/layer/symbol/_textfont.py new file mode 100644 index 0000000000..0e4735e43b --- /dev/null +++ b/plotly/graph_objs/layout/mapbox/layer/symbol/_textfont.py @@ -0,0 +1,221 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Textfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.mapbox.layer.symbol' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Textfont object + + Sets the icon text font. Has an effect only when `type` is set + to *symbol*. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.mapbox.layer.symbol.Textfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.mapbox.layer.symbol.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.mapbox.layer.symbol.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.mapbox.layer.symbol import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['size'] = v_textfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/__init__.py b/plotly/graph_objs/layout/polar/__init__.py new file mode 100644 index 0000000000..5687b0ceb7 --- /dev/null +++ b/plotly/graph_objs/layout/polar/__init__.py @@ -0,0 +1,5 @@ +from ._radialaxis import RadialAxis +from plotly.graph_objs.layout.polar import radialaxis +from ._domain import Domain +from ._angularaxis import AngularAxis +from plotly.graph_objs.layout.polar import angularaxis diff --git a/plotly/graph_objs/layout/polar/_angularaxis.py b/plotly/graph_objs/layout/polar/_angularaxis.py new file mode 100644 index 0000000000..3d69c663ea --- /dev/null +++ b/plotly/graph_objs/layout/polar/_angularaxis.py @@ -0,0 +1,1805 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class AngularAxis(BaseLayoutHierarchyType): + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # direction + # --------- + @property + def direction(self): + """ + Sets the direction corresponding to positive angles. + + The 'direction' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['counterclockwise', 'clockwise'] + + Returns + ------- + Any + """ + return self['direction'] + + @direction.setter + def direction(self, val): + self['direction'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # period + # ------ + @property + def period(self): + """ + Set the angular period. Has an effect only when + `angularaxis.type` is *category*. + + The 'period' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['period'] + + @period.setter + def period(self, val): + self['period'] = val + + # rotation + # -------- + @property + def rotation(self): + """ + Sets that start position (in degrees) of the angular axis By + default, polar subplots with `direction` set to + *counterclockwise* get a `rotation` of *0* which corresponds to + due East (like what mathematicians prefer). In turn, polar with + `direction` set to *clockwise* get a rotation of *90* which + corresponds to due North (like on a compass), + + The 'rotation' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['rotation'] + + @rotation.setter + def rotation(self, val): + self['rotation'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thetaunit + # --------- + @property + def thetaunit(self): + """ + Sets the format unit of the formatted *theta* values. Has an + effect only when `angularaxis.type` is *linear*. + + The 'thetaunit' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radians', 'degrees'] + + Returns + ------- + Any + """ + return self['thetaunit'] + + @thetaunit.setter + def thetaunit(self, val): + self['thetaunit'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.angularaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.polar.angularaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.polar.angularaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.polar.angularaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the angular axis type. If *linear*, set `thetaunit` to + determine the unit in which axis value are shown. If *category, + use `period` to set the number of integer coordinates around + polar axis. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + direction + Sets the direction corresponding to positive angles. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + period + Set the angular period. Has an effect only when + `angularaxis.type` is *category*. + rotation + Sets that start position (in degrees) of the angular + axis By default, polar subplots with `direction` set to + *counterclockwise* get a `rotation` of *0* which + corresponds to due East (like what mathematicians + prefer). In turn, polar with `direction` set to + *clockwise* get a rotation of *90* which corresponds to + due North (like on a compass), + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thetaunit + Sets the format unit of the formatted *theta* values. + Has an effect only when `angularaxis.type` is *linear*. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.angularaxis.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + type + Sets the angular axis type. If *linear*, set + `thetaunit` to determine the unit in which axis value + are shown. If *category, use `period` to set the number + of integer coordinates around polar axis. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + """ + + def __init__( + self, + arg=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + direction=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + nticks=None, + period=None, + rotation=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thetaunit=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + type=None, + visible=None, + **kwargs + ): + """ + Construct a new AngularAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.polar.AngularAxis + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + direction + Sets the direction corresponding to positive angles. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + period + Set the angular period. Has an effect only when + `angularaxis.type` is *category*. + rotation + Sets that start position (in degrees) of the angular + axis By default, polar subplots with `direction` set to + *counterclockwise* get a `rotation` of *0* which + corresponds to due East (like what mathematicians + prefer). In turn, polar with `direction` set to + *clockwise* get a rotation of *90* which corresponds to + due North (like on a compass), + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thetaunit + Sets the format unit of the formatted *theta* values. + Has an effect only when `angularaxis.type` is *linear*. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.angularaxis.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + type + Sets the angular axis type. If *linear*, set + `thetaunit` to determine the unit in which axis value + are shown. If *category, use `period` to set the number + of integer coordinates around polar axis. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + + Returns + ------- + AngularAxis + """ + super(AngularAxis, self).__init__('angularaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.AngularAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.AngularAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar import ( + angularaxis as v_angularaxis + ) + + # Initialize validators + # --------------------- + self._validators['categoryarray' + ] = v_angularaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_angularaxis.CategoryarraysrcValidator() + self._validators['categoryorder' + ] = v_angularaxis.CategoryorderValidator() + self._validators['color'] = v_angularaxis.ColorValidator() + self._validators['direction'] = v_angularaxis.DirectionValidator() + self._validators['dtick'] = v_angularaxis.DtickValidator() + self._validators['exponentformat' + ] = v_angularaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_angularaxis.GridcolorValidator() + self._validators['gridwidth'] = v_angularaxis.GridwidthValidator() + self._validators['hoverformat'] = v_angularaxis.HoverformatValidator() + self._validators['layer'] = v_angularaxis.LayerValidator() + self._validators['linecolor'] = v_angularaxis.LinecolorValidator() + self._validators['linewidth'] = v_angularaxis.LinewidthValidator() + self._validators['nticks'] = v_angularaxis.NticksValidator() + self._validators['period'] = v_angularaxis.PeriodValidator() + self._validators['rotation'] = v_angularaxis.RotationValidator() + self._validators['separatethousands' + ] = v_angularaxis.SeparatethousandsValidator() + self._validators['showexponent' + ] = v_angularaxis.ShowexponentValidator() + self._validators['showgrid'] = v_angularaxis.ShowgridValidator() + self._validators['showline'] = v_angularaxis.ShowlineValidator() + self._validators['showticklabels' + ] = v_angularaxis.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_angularaxis.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_angularaxis.ShowticksuffixValidator() + self._validators['thetaunit'] = v_angularaxis.ThetaunitValidator() + self._validators['tick0'] = v_angularaxis.Tick0Validator() + self._validators['tickangle'] = v_angularaxis.TickangleValidator() + self._validators['tickcolor'] = v_angularaxis.TickcolorValidator() + self._validators['tickfont'] = v_angularaxis.TickfontValidator() + self._validators['tickformat'] = v_angularaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_angularaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_angularaxis.TicklenValidator() + self._validators['tickmode'] = v_angularaxis.TickmodeValidator() + self._validators['tickprefix'] = v_angularaxis.TickprefixValidator() + self._validators['ticks'] = v_angularaxis.TicksValidator() + self._validators['ticksuffix'] = v_angularaxis.TicksuffixValidator() + self._validators['ticktext'] = v_angularaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_angularaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_angularaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_angularaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_angularaxis.TickwidthValidator() + self._validators['type'] = v_angularaxis.TypeValidator() + self._validators['visible'] = v_angularaxis.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('direction', None) + self.direction = direction if direction is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('period', None) + self.period = period if period is not None else v + v = arg.pop('rotation', None) + self.rotation = rotation if rotation is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thetaunit', None) + self.thetaunit = thetaunit if thetaunit is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/_domain.py b/plotly/graph_objs/layout/polar/_domain.py new file mode 100644 index 0000000000..bed81a2de1 --- /dev/null +++ b/plotly/graph_objs/layout/polar/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this polar subplot . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this polar subplot . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this polar subplot (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this polar subplot (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this polar subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this polar subplot . + x + Sets the horizontal domain of this polar subplot (in + plot fraction). + y + Sets the vertical domain of this polar subplot (in plot + fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.polar.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this polar subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this polar subplot . + x + Sets the horizontal domain of this polar subplot (in + plot fraction). + y + Sets the vertical domain of this polar subplot (in plot + fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/_radialaxis.py b/plotly/graph_objs/layout/polar/_radialaxis.py new file mode 100644 index 0000000000..df3153485e --- /dev/null +++ b/plotly/graph_objs/layout/polar/_radialaxis.py @@ -0,0 +1,1991 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class RadialAxis(BaseLayoutHierarchyType): + + # angle + # ----- + @property + def angle(self): + """ + Sets the angle (in degrees) from which the radial axis is + drawn. Note that by default, radial axis line on the theta=0 + line corresponds to a line pointing right (like what + mathematicians prefer). Defaults to the first `polar.sector` + angle. + + The 'angle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['angle'] + + @angle.setter + def angle(self, val): + self['angle'] = val + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *tozero*`, the range extends to 0, regardless of the input + data If *nonnegative*, the range is non-negative, regardless of + the input data. If *normal*, the range is computed in relation + to the extrema of the input data (same behavior as for + cartesian axes). + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['tozero', 'nonnegative', 'normal'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # side + # ---- + @property + def side(self): + """ + Determines on which side of radial axis line the tick and tick + labels appear. + + The 'side' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['clockwise', 'counterclockwise'] + + Returns + ------- + Any + """ + return self['side'] + + @side.setter + def side(self, val): + self['side'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.radialaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.polar.radialaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.polar.radialaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.polar.radialaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.polar.radialaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.polar.radialaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + angle + Sets the angle (in degrees) from which the radial axis + is drawn. Note that by default, radial axis line on the + theta=0 line corresponds to a line pointing right (like + what mathematicians prefer). Defaults to the first + `polar.sector` angle. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *tozero*`, the range extends to 0, regardless of the + input data If *nonnegative*, the range is non-negative, + regardless of the input data. If *normal*, the range is + computed in relation to the extrema of the input data + (same behavior as for cartesian axes). + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines on which side of radial axis line the tick + and tick labels appear. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.radialaxis.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + """ + + def __init__( + self, + arg=None, + angle=None, + autorange=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + side=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + **kwargs + ): + """ + Construct a new RadialAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.polar.RadialAxis + angle + Sets the angle (in degrees) from which the radial axis + is drawn. Note that by default, radial axis line on the + theta=0 line corresponds to a line pointing right (like + what mathematicians prefer). Defaults to the first + `polar.sector` angle. + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *tozero*`, the range extends to 0, regardless of the + input data If *nonnegative*, the range is non-negative, + regardless of the input data. If *normal*, the range is + computed in relation to the extrema of the input data + (same behavior as for cartesian axes). + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines on which side of radial axis line the tick + and tick labels appear. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.radialaxis.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + + Returns + ------- + RadialAxis + """ + super(RadialAxis, self).__init__('radialaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.RadialAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.RadialAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar import (radialaxis as v_radialaxis) + + # Initialize validators + # --------------------- + self._validators['angle'] = v_radialaxis.AngleValidator() + self._validators['autorange'] = v_radialaxis.AutorangeValidator() + self._validators['calendar'] = v_radialaxis.CalendarValidator() + self._validators['categoryarray' + ] = v_radialaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_radialaxis.CategoryarraysrcValidator() + self._validators['categoryorder' + ] = v_radialaxis.CategoryorderValidator() + self._validators['color'] = v_radialaxis.ColorValidator() + self._validators['dtick'] = v_radialaxis.DtickValidator() + self._validators['exponentformat' + ] = v_radialaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_radialaxis.GridcolorValidator() + self._validators['gridwidth'] = v_radialaxis.GridwidthValidator() + self._validators['hoverformat'] = v_radialaxis.HoverformatValidator() + self._validators['layer'] = v_radialaxis.LayerValidator() + self._validators['linecolor'] = v_radialaxis.LinecolorValidator() + self._validators['linewidth'] = v_radialaxis.LinewidthValidator() + self._validators['nticks'] = v_radialaxis.NticksValidator() + self._validators['range'] = v_radialaxis.RangeValidator() + self._validators['rangemode'] = v_radialaxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_radialaxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_radialaxis.ShowexponentValidator() + self._validators['showgrid'] = v_radialaxis.ShowgridValidator() + self._validators['showline'] = v_radialaxis.ShowlineValidator() + self._validators['showticklabels' + ] = v_radialaxis.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_radialaxis.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_radialaxis.ShowticksuffixValidator() + self._validators['side'] = v_radialaxis.SideValidator() + self._validators['tick0'] = v_radialaxis.Tick0Validator() + self._validators['tickangle'] = v_radialaxis.TickangleValidator() + self._validators['tickcolor'] = v_radialaxis.TickcolorValidator() + self._validators['tickfont'] = v_radialaxis.TickfontValidator() + self._validators['tickformat'] = v_radialaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_radialaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_radialaxis.TicklenValidator() + self._validators['tickmode'] = v_radialaxis.TickmodeValidator() + self._validators['tickprefix'] = v_radialaxis.TickprefixValidator() + self._validators['ticks'] = v_radialaxis.TicksValidator() + self._validators['ticksuffix'] = v_radialaxis.TicksuffixValidator() + self._validators['ticktext'] = v_radialaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_radialaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_radialaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_radialaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_radialaxis.TickwidthValidator() + self._validators['title'] = v_radialaxis.TitleValidator() + self._validators['titlefont'] = v_radialaxis.TitlefontValidator() + self._validators['type'] = v_radialaxis.TypeValidator() + self._validators['visible'] = v_radialaxis.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('angle', None) + self.angle = angle if angle is not None else v + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('side', None) + self.side = side if side is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/angularaxis/__init__.py b/plotly/graph_objs/layout/polar/angularaxis/__init__.py new file mode 100644 index 0000000000..774b737ce0 --- /dev/null +++ b/plotly/graph_objs/layout/polar/angularaxis/__init__.py @@ -0,0 +1,2 @@ +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/polar/angularaxis/_tickfont.py b/plotly/graph_objs/layout/polar/angularaxis/_tickfont.py new file mode 100644 index 0000000000..be3b03ff8f --- /dev/null +++ b/plotly/graph_objs/layout/polar/angularaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar.angularaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.polar.angularaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.angularaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.angularaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar.angularaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/angularaxis/_tickformatstop.py b/plotly/graph_objs/layout/polar/angularaxis/_tickformatstop.py new file mode 100644 index 0000000000..ea329e8cc8 --- /dev/null +++ b/plotly/graph_objs/layout/polar/angularaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar.angularaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.polar.angularax + is.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.angularaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.angularaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar.angularaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/radialaxis/__init__.py b/plotly/graph_objs/layout/polar/radialaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/polar/radialaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/polar/radialaxis/_tickfont.py b/plotly/graph_objs/layout/polar/radialaxis/_tickfont.py new file mode 100644 index 0000000000..e823e21938 --- /dev/null +++ b/plotly/graph_objs/layout/polar/radialaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar.radialaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.polar.radialaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.radialaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.radialaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar.radialaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/radialaxis/_tickformatstop.py b/plotly/graph_objs/layout/polar/radialaxis/_tickformatstop.py new file mode 100644 index 0000000000..aea49eeeb7 --- /dev/null +++ b/plotly/graph_objs/layout/polar/radialaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar.radialaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.polar.radialaxi + s.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.radialaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.radialaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar.radialaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/polar/radialaxis/_titlefont.py b/plotly/graph_objs/layout/polar/radialaxis/_titlefont.py new file mode 100644 index 0000000000..eeb8fd5eab --- /dev/null +++ b/plotly/graph_objs/layout/polar/radialaxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.polar.radialaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.polar.radialaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.polar.radialaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.polar.radialaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.polar.radialaxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/__init__.py b/plotly/graph_objs/layout/scene/__init__.py new file mode 100644 index 0000000000..8a315af1d5 --- /dev/null +++ b/plotly/graph_objs/layout/scene/__init__.py @@ -0,0 +1,12 @@ +from ._zaxis import ZAxis +from plotly.graph_objs.layout.scene import zaxis +from ._yaxis import YAxis +from plotly.graph_objs.layout.scene import yaxis +from ._xaxis import XAxis +from plotly.graph_objs.layout.scene import xaxis +from ._domain import Domain +from ._camera import Camera +from plotly.graph_objs.layout.scene import camera +from ._aspectratio import Aspectratio +from ._annotation import Annotation +from plotly.graph_objs.layout.scene import annotation diff --git a/plotly/graph_objs/layout/scene/_annotation.py b/plotly/graph_objs/layout/scene/_annotation.py new file mode 100644 index 0000000000..28095f4236 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_annotation.py @@ -0,0 +1,1409 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Annotation(BaseLayoutHierarchyType): + + # align + # ----- + @property + def align(self): + """ + Sets the horizontal alignment of the `text` within the box. Has + an effect only if `text` spans more two or more lines (i.e. + `text` contains one or more
HTML tags) or if an explicit + width is set to override the text width. + + The 'align' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['align'] + + @align.setter + def align(self, val): + self['align'] = val + + # arrowcolor + # ---------- + @property + def arrowcolor(self): + """ + Sets the color of the annotation arrow. + + The 'arrowcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['arrowcolor'] + + @arrowcolor.setter + def arrowcolor(self, val): + self['arrowcolor'] = val + + # arrowhead + # --------- + @property + def arrowhead(self): + """ + Sets the end annotation arrow head style. + + The 'arrowhead' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 8] + + Returns + ------- + int + """ + return self['arrowhead'] + + @arrowhead.setter + def arrowhead(self, val): + self['arrowhead'] = val + + # arrowside + # --------- + @property + def arrowside(self): + """ + Sets the annotation arrow head position. + + The 'arrowside' property is a flaglist and may be specified + as a string containing: + - Any combination of ['end', 'start'] joined with '+' characters + (e.g. 'end+start') + OR exactly one of ['none'] (e.g. 'none') + + Returns + ------- + Any + """ + return self['arrowside'] + + @arrowside.setter + def arrowside(self, val): + self['arrowside'] = val + + # arrowsize + # --------- + @property + def arrowsize(self): + """ + Sets the size of the end annotation arrow head, relative to + `arrowwidth`. A value of 1 (default) gives a head about 3x as + wide as the line. + + The 'arrowsize' property is a number and may be specified as: + - An int or float in the interval [0.3, inf] + + Returns + ------- + int|float + """ + return self['arrowsize'] + + @arrowsize.setter + def arrowsize(self, val): + self['arrowsize'] = val + + # arrowwidth + # ---------- + @property + def arrowwidth(self): + """ + Sets the width (in px) of annotation arrow line. + + The 'arrowwidth' property is a number and may be specified as: + - An int or float in the interval [0.1, inf] + + Returns + ------- + int|float + """ + return self['arrowwidth'] + + @arrowwidth.setter + def arrowwidth(self, val): + self['arrowwidth'] = val + + # ax + # -- + @property + def ax(self): + """ + Sets the x component of the arrow tail about the arrow head (in + pixels). + + The 'ax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['ax'] + + @ax.setter + def ax(self, val): + self['ax'] = val + + # ay + # -- + @property + def ay(self): + """ + Sets the y component of the arrow tail about the arrow head (in + pixels). + + The 'ay' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['ay'] + + @ay.setter + def ay(self, val): + self['ay'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the annotation. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the annotation `text`. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderpad + # --------- + @property + def borderpad(self): + """ + Sets the padding (in px) between the `text` and the enclosing + border. + + The 'borderpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderpad'] + + @borderpad.setter + def borderpad(self, val): + self['borderpad'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the annotation + `text`. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # captureevents + # ------------- + @property + def captureevents(self): + """ + Determines whether the annotation text box captures mouse move + and click events, or allows those events to pass through to + data points in the plot that may be behind the annotation. By + default `captureevents` is *false* unless `hovertext` is + provided. If you use the event `plotly_clickannotation` without + `hovertext` you must explicitly enable `captureevents`. + + The 'captureevents' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['captureevents'] + + @captureevents.setter + def captureevents(self, val): + self['captureevents'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the annotation text font. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.annotation.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.annotation.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # height + # ------ + @property + def height(self): + """ + Sets an explicit height for the text box. null (default) lets + the text set the box height. Taller text will be clipped. + + The 'height' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['height'] + + @height.setter + def height(self, val): + self['height'] = val + + # hoverlabel + # ---------- + @property + def hoverlabel(self): + """ + The 'hoverlabel' property is an instance of Hoverlabel + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.annotation.Hoverlabel + - A dict of string/value properties that will be passed + to the Hoverlabel constructor + + Supported dict properties: + + bgcolor + Sets the background color of the hover label. + By default uses the annotation's `bgcolor` made + opaque, or white if it was transparent. + bordercolor + Sets the border color of the hover label. By + default uses either dark grey or white, for + maximum contrast with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses + the global hover font and size, with color from + `hoverlabel.bordercolor`. + + Returns + ------- + plotly.graph_objs.layout.scene.annotation.Hoverlabel + """ + return self['hoverlabel'] + + @hoverlabel.setter + def hoverlabel(self, val): + self['hoverlabel'] = val + + # hovertext + # --------- + @property + def hovertext(self): + """ + Sets text to appear when hovering over this annotation. If + omitted or blank, no hover label will appear. + + The 'hovertext' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hovertext'] + + @hovertext.setter + def hovertext(self, val): + self['hovertext'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the opacity of the annotation (text + arrow). + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # showarrow + # --------- + @property + def showarrow(self): + """ + Determines whether or not the annotation is drawn with an + arrow. If *true*, `text` is placed near the arrow's tail. If + *false*, `text` lines up with the `x` and `y` provided. + + The 'showarrow' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showarrow'] + + @showarrow.setter + def showarrow(self, val): + self['showarrow'] = val + + # standoff + # -------- + @property + def standoff(self): + """ + Sets a distance, in pixels, to move the end arrowhead away from + the position it is pointing at, for example to point at the + edge of a marker independent of zoom. Note that this shortens + the arrow from the `ax` / `ay` vector, in contrast to `xshift` + / `yshift` which moves everything by this amount. + + The 'standoff' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['standoff'] + + @standoff.setter + def standoff(self, val): + self['standoff'] = val + + # startarrowhead + # -------------- + @property + def startarrowhead(self): + """ + Sets the start annotation arrow head style. + + The 'startarrowhead' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 8] + + Returns + ------- + int + """ + return self['startarrowhead'] + + @startarrowhead.setter + def startarrowhead(self, val): + self['startarrowhead'] = val + + # startarrowsize + # -------------- + @property + def startarrowsize(self): + """ + Sets the size of the start annotation arrow head, relative to + `arrowwidth`. A value of 1 (default) gives a head about 3x as + wide as the line. + + The 'startarrowsize' property is a number and may be specified as: + - An int or float in the interval [0.3, inf] + + Returns + ------- + int|float + """ + return self['startarrowsize'] + + @startarrowsize.setter + def startarrowsize(self, val): + self['startarrowsize'] = val + + # startstandoff + # ------------- + @property + def startstandoff(self): + """ + Sets a distance, in pixels, to move the start arrowhead away + from the position it is pointing at, for example to point at + the edge of a marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, in contrast to + `xshift` / `yshift` which moves everything by this amount. + + The 'startstandoff' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['startstandoff'] + + @startstandoff.setter + def startstandoff(self, val): + self['startstandoff'] = val + + # text + # ---- + @property + def text(self): + """ + Sets the text associated with this annotation. Plotly uses a + subset of HTML tags to do things like newline (
), bold + (), italics (), hyperlinks (). + Tags , , are also supported. + + The 'text' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['text'] + + @text.setter + def text(self, val): + self['text'] = val + + # textangle + # --------- + @property + def textangle(self): + """ + Sets the angle at which the `text` is drawn with respect to the + horizontal. + + The 'textangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['textangle'] + + @textangle.setter + def textangle(self, val): + self['textangle'] = val + + # valign + # ------ + @property + def valign(self): + """ + Sets the vertical alignment of the `text` within the box. Has + an effect only if an explicit height is set to override the + text height. + + The 'valign' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['valign'] + + @valign.setter + def valign(self, val): + self['valign'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this annotation is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets an explicit width for the text box. null (default) lets + the text set the box width. Wider text will be clipped. There + is no automatic wrapping; use
to start a new line. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # x + # - + @property + def x(self): + """ + Sets the annotation's x position. + + The 'x' property accepts values of any type + + Returns + ------- + Any + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the text box's horizontal position anchor This anchor + binds the `x` position to the *left*, *center* or *right* of + the annotation. For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the right-most portion of + the annotation lines up with the right-most edge of the + plotting area. If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is an arrow, + whereas for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xshift + # ------ + @property + def xshift(self): + """ + Shifts the position of the whole annotation and arrow to the + right (positive) or left (negative) by this many pixels. + + The 'xshift' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['xshift'] + + @xshift.setter + def xshift(self, val): + self['xshift'] = val + + # y + # - + @property + def y(self): + """ + Sets the annotation's y position. + + The 'y' property accepts values of any type + + Returns + ------- + Any + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the text box's vertical position anchor This anchor binds + the `y` position to the *top*, *middle* or *bottom* of the + annotation. For example, if `y` is set to 1, `yref` to *paper* + and `yanchor` to *top* then the top-most portion of the + annotation lines up with the top-most edge of the plotting + area. If *auto*, the anchor is equivalent to *middle* for data- + referenced annotations or if there is an arrow, whereas for + paper-referenced with no arrow, the anchor picked corresponds + to the closest side. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # yshift + # ------ + @property + def yshift(self): + """ + Shifts the position of the whole annotation and arrow up + (positive) or down (negative) by this many pixels. + + The 'yshift' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['yshift'] + + @yshift.setter + def yshift(self, val): + self['yshift'] = val + + # z + # - + @property + def z(self): + """ + Sets the annotation's z position. + + The 'z' property accepts values of any type + + Returns + ------- + Any + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + arrowwidth + Sets the width (in px) of annotation arrow line. + ax + Sets the x component of the arrow tail about the arrow + head (in pixels). + ay + Sets the y component of the arrow tail about the arrow + head (in pixels). + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the annotation + `text`. + borderpad + Sets the padding (in px) between the `text` and the + enclosing border. + borderwidth + Sets the width (in px) of the border enclosing the + annotation `text`. + captureevents + Determines whether the annotation text box captures + mouse move and click events, or allows those events to + pass through to data points in the plot that may be + behind the annotation. By default `captureevents` is + *false* unless `hovertext` is provided. If you use the + event `plotly_clickannotation` without `hovertext` you + must explicitly enable `captureevents`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. Taller text + will be clipped. + hoverlabel + plotly.graph_objs.layout.scene.annotation.Hoverlabel + instance or dict with compatible properties + hovertext + Sets text to appear when hovering over this annotation. + If omitted or blank, no hover label will appear. + opacity + Sets the opacity of the annotation (text + arrow). + showarrow + Determines whether or not the annotation is drawn with + an arrow. If *true*, `text` is placed near the arrow's + tail. If *false*, `text` lines up with the `x` and `y` + provided. + standoff + Sets a distance, in pixels, to move the end arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + startstandoff + Sets a distance, in pixels, to move the start arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. Plotly + uses a subset of HTML tags to do things like newline + (
), bold (), italics (), hyperlinks + (). Tags , , + are also supported. + textangle + Sets the angle at which the `text` is drawn with + respect to the horizontal. + valign + Sets the vertical alignment of the `text` within the + box. Has an effect only if an explicit height is set to + override the text height. + visible + Determines whether or not this annotation is visible. + width + Sets an explicit width for the text box. null (default) + lets the text set the box width. Wider text will be + clipped. There is no automatic wrapping; use
to + start a new line. + x + Sets the annotation's x position. + xanchor + Sets the text box's horizontal position anchor This + anchor binds the `x` position to the *left*, *center* + or *right* of the annotation. For example, if `x` is + set to 1, `xref` to *paper* and `xanchor` to *right* + then the right-most portion of the annotation lines up + with the right-most edge of the plotting area. If + *auto*, the anchor is equivalent to *center* for data- + referenced annotations or if there is an arrow, whereas + for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + xshift + Shifts the position of the whole annotation and arrow + to the right (positive) or left (negative) by this many + pixels. + y + Sets the annotation's y position. + yanchor + Sets the text box's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the annotation. For example, if `y` is set + to 1, `yref` to *paper* and `yanchor` to *top* then the + top-most portion of the annotation lines up with the + top-most edge of the plotting area. If *auto*, the + anchor is equivalent to *middle* for data-referenced + annotations or if there is an arrow, whereas for paper- + referenced with no arrow, the anchor picked corresponds + to the closest side. + yshift + Shifts the position of the whole annotation and arrow + up (positive) or down (negative) by this many pixels. + z + Sets the annotation's z position. + """ + + def __init__( + self, + arg=None, + align=None, + arrowcolor=None, + arrowhead=None, + arrowside=None, + arrowsize=None, + arrowwidth=None, + ax=None, + ay=None, + bgcolor=None, + bordercolor=None, + borderpad=None, + borderwidth=None, + captureevents=None, + font=None, + height=None, + hoverlabel=None, + hovertext=None, + opacity=None, + showarrow=None, + standoff=None, + startarrowhead=None, + startarrowsize=None, + startstandoff=None, + text=None, + textangle=None, + valign=None, + visible=None, + width=None, + x=None, + xanchor=None, + xshift=None, + y=None, + yanchor=None, + yshift=None, + z=None, + **kwargs + ): + """ + Construct a new Annotation object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.Annotation + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + arrowwidth + Sets the width (in px) of annotation arrow line. + ax + Sets the x component of the arrow tail about the arrow + head (in pixels). + ay + Sets the y component of the arrow tail about the arrow + head (in pixels). + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the annotation + `text`. + borderpad + Sets the padding (in px) between the `text` and the + enclosing border. + borderwidth + Sets the width (in px) of the border enclosing the + annotation `text`. + captureevents + Determines whether the annotation text box captures + mouse move and click events, or allows those events to + pass through to data points in the plot that may be + behind the annotation. By default `captureevents` is + *false* unless `hovertext` is provided. If you use the + event `plotly_clickannotation` without `hovertext` you + must explicitly enable `captureevents`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. Taller text + will be clipped. + hoverlabel + plotly.graph_objs.layout.scene.annotation.Hoverlabel + instance or dict with compatible properties + hovertext + Sets text to appear when hovering over this annotation. + If omitted or blank, no hover label will appear. + opacity + Sets the opacity of the annotation (text + arrow). + showarrow + Determines whether or not the annotation is drawn with + an arrow. If *true*, `text` is placed near the arrow's + tail. If *false*, `text` lines up with the `x` and `y` + provided. + standoff + Sets a distance, in pixels, to move the end arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow head, + relative to `arrowwidth`. A value of 1 (default) gives + a head about 3x as wide as the line. + startstandoff + Sets a distance, in pixels, to move the start arrowhead + away from the position it is pointing at, for example + to point at the edge of a marker independent of zoom. + Note that this shortens the arrow from the `ax` / `ay` + vector, in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. Plotly + uses a subset of HTML tags to do things like newline + (
), bold (), italics (), hyperlinks + (). Tags , , + are also supported. + textangle + Sets the angle at which the `text` is drawn with + respect to the horizontal. + valign + Sets the vertical alignment of the `text` within the + box. Has an effect only if an explicit height is set to + override the text height. + visible + Determines whether or not this annotation is visible. + width + Sets an explicit width for the text box. null (default) + lets the text set the box width. Wider text will be + clipped. There is no automatic wrapping; use
to + start a new line. + x + Sets the annotation's x position. + xanchor + Sets the text box's horizontal position anchor This + anchor binds the `x` position to the *left*, *center* + or *right* of the annotation. For example, if `x` is + set to 1, `xref` to *paper* and `xanchor` to *right* + then the right-most portion of the annotation lines up + with the right-most edge of the plotting area. If + *auto*, the anchor is equivalent to *center* for data- + referenced annotations or if there is an arrow, whereas + for paper-referenced with no arrow, the anchor picked + corresponds to the closest side. + xshift + Shifts the position of the whole annotation and arrow + to the right (positive) or left (negative) by this many + pixels. + y + Sets the annotation's y position. + yanchor + Sets the text box's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the annotation. For example, if `y` is set + to 1, `yref` to *paper* and `yanchor` to *top* then the + top-most portion of the annotation lines up with the + top-most edge of the plotting area. If *auto*, the + anchor is equivalent to *middle* for data-referenced + annotations or if there is an arrow, whereas for paper- + referenced with no arrow, the anchor picked corresponds + to the closest side. + yshift + Shifts the position of the whole annotation and arrow + up (positive) or down (negative) by this many pixels. + z + Sets the annotation's z position. + + Returns + ------- + Annotation + """ + super(Annotation, self).__init__('annotations') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.Annotation +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.Annotation""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (annotation as v_annotation) + + # Initialize validators + # --------------------- + self._validators['align'] = v_annotation.AlignValidator() + self._validators['arrowcolor'] = v_annotation.ArrowcolorValidator() + self._validators['arrowhead'] = v_annotation.ArrowheadValidator() + self._validators['arrowside'] = v_annotation.ArrowsideValidator() + self._validators['arrowsize'] = v_annotation.ArrowsizeValidator() + self._validators['arrowwidth'] = v_annotation.ArrowwidthValidator() + self._validators['ax'] = v_annotation.AxValidator() + self._validators['ay'] = v_annotation.AyValidator() + self._validators['bgcolor'] = v_annotation.BgcolorValidator() + self._validators['bordercolor'] = v_annotation.BordercolorValidator() + self._validators['borderpad'] = v_annotation.BorderpadValidator() + self._validators['borderwidth'] = v_annotation.BorderwidthValidator() + self._validators['captureevents' + ] = v_annotation.CaptureeventsValidator() + self._validators['font'] = v_annotation.FontValidator() + self._validators['height'] = v_annotation.HeightValidator() + self._validators['hoverlabel'] = v_annotation.HoverlabelValidator() + self._validators['hovertext'] = v_annotation.HovertextValidator() + self._validators['opacity'] = v_annotation.OpacityValidator() + self._validators['showarrow'] = v_annotation.ShowarrowValidator() + self._validators['standoff'] = v_annotation.StandoffValidator() + self._validators['startarrowhead' + ] = v_annotation.StartarrowheadValidator() + self._validators['startarrowsize' + ] = v_annotation.StartarrowsizeValidator() + self._validators['startstandoff' + ] = v_annotation.StartstandoffValidator() + self._validators['text'] = v_annotation.TextValidator() + self._validators['textangle'] = v_annotation.TextangleValidator() + self._validators['valign'] = v_annotation.ValignValidator() + self._validators['visible'] = v_annotation.VisibleValidator() + self._validators['width'] = v_annotation.WidthValidator() + self._validators['x'] = v_annotation.XValidator() + self._validators['xanchor'] = v_annotation.XanchorValidator() + self._validators['xshift'] = v_annotation.XshiftValidator() + self._validators['y'] = v_annotation.YValidator() + self._validators['yanchor'] = v_annotation.YanchorValidator() + self._validators['yshift'] = v_annotation.YshiftValidator() + self._validators['z'] = v_annotation.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('align', None) + self.align = align if align is not None else v + v = arg.pop('arrowcolor', None) + self.arrowcolor = arrowcolor if arrowcolor is not None else v + v = arg.pop('arrowhead', None) + self.arrowhead = arrowhead if arrowhead is not None else v + v = arg.pop('arrowside', None) + self.arrowside = arrowside if arrowside is not None else v + v = arg.pop('arrowsize', None) + self.arrowsize = arrowsize if arrowsize is not None else v + v = arg.pop('arrowwidth', None) + self.arrowwidth = arrowwidth if arrowwidth is not None else v + v = arg.pop('ax', None) + self.ax = ax if ax is not None else v + v = arg.pop('ay', None) + self.ay = ay if ay is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderpad', None) + self.borderpad = borderpad if borderpad is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('captureevents', None) + self.captureevents = captureevents if captureevents is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('height', None) + self.height = height if height is not None else v + v = arg.pop('hoverlabel', None) + self.hoverlabel = hoverlabel if hoverlabel is not None else v + v = arg.pop('hovertext', None) + self.hovertext = hovertext if hovertext is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('showarrow', None) + self.showarrow = showarrow if showarrow is not None else v + v = arg.pop('standoff', None) + self.standoff = standoff if standoff is not None else v + v = arg.pop('startarrowhead', None) + self.startarrowhead = startarrowhead if startarrowhead is not None else v + v = arg.pop('startarrowsize', None) + self.startarrowsize = startarrowsize if startarrowsize is not None else v + v = arg.pop('startstandoff', None) + self.startstandoff = startstandoff if startstandoff is not None else v + v = arg.pop('text', None) + self.text = text if text is not None else v + v = arg.pop('textangle', None) + self.textangle = textangle if textangle is not None else v + v = arg.pop('valign', None) + self.valign = valign if valign is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xshift', None) + self.xshift = xshift if xshift is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('yshift', None) + self.yshift = yshift if yshift is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_aspectratio.py b/plotly/graph_objs/layout/scene/_aspectratio.py new file mode 100644 index 0000000000..1c737cd9a0 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_aspectratio.py @@ -0,0 +1,144 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Aspectratio(BaseLayoutHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + + y + + z + + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Aspectratio object + + Sets this scene's axis aspectratio. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.Aspectratio + x + + y + + z + + + Returns + ------- + Aspectratio + """ + super(Aspectratio, self).__init__('aspectratio') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.Aspectratio +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.Aspectratio""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import ( + aspectratio as v_aspectratio + ) + + # Initialize validators + # --------------------- + self._validators['x'] = v_aspectratio.XValidator() + self._validators['y'] = v_aspectratio.YValidator() + self._validators['z'] = v_aspectratio.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_camera.py b/plotly/graph_objs/layout/scene/_camera.py new file mode 100644 index 0000000000..b3db7a2522 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_camera.py @@ -0,0 +1,201 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Camera(BaseLayoutHierarchyType): + + # center + # ------ + @property + def center(self): + """ + Sets the (x,y,z) components of the 'center' camera vector This + vector determines the translation (x,y,z) space about the + center of this scene. By default, there is no such translation. + + The 'center' property is an instance of Center + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.camera.Center + - A dict of string/value properties that will be passed + to the Center constructor + + Supported dict properties: + + x + + y + + z + + Returns + ------- + plotly.graph_objs.layout.scene.camera.Center + """ + return self['center'] + + @center.setter + def center(self, val): + self['center'] = val + + # eye + # --- + @property + def eye(self): + """ + Sets the (x,y,z) components of the 'eye' camera vector. This + vector determines the view point about the origin of this + scene. + + The 'eye' property is an instance of Eye + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.camera.Eye + - A dict of string/value properties that will be passed + to the Eye constructor + + Supported dict properties: + + x + + y + + z + + Returns + ------- + plotly.graph_objs.layout.scene.camera.Eye + """ + return self['eye'] + + @eye.setter + def eye(self, val): + self['eye'] = val + + # up + # -- + @property + def up(self): + """ + Sets the (x,y,z) components of the 'up' camera vector. This + vector determines the up direction of this scene with respect + to the page. The default is *{x: 0, y: 0, z: 1}* which means + that the z axis points up. + + The 'up' property is an instance of Up + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.camera.Up + - A dict of string/value properties that will be passed + to the Up constructor + + Supported dict properties: + + x + + y + + z + + Returns + ------- + plotly.graph_objs.layout.scene.camera.Up + """ + return self['up'] + + @up.setter + def up(self, val): + self['up'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + center + Sets the (x,y,z) components of the 'center' camera + vector This vector determines the translation (x,y,z) + space about the center of this scene. By default, there + is no such translation. + eye + Sets the (x,y,z) components of the 'eye' camera vector. + This vector determines the view point about the origin + of this scene. + up + Sets the (x,y,z) components of the 'up' camera vector. + This vector determines the up direction of this scene + with respect to the page. The default is *{x: 0, y: 0, + z: 1}* which means that the z axis points up. + """ + + def __init__(self, arg=None, center=None, eye=None, up=None, **kwargs): + """ + Construct a new Camera object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.Camera + center + Sets the (x,y,z) components of the 'center' camera + vector This vector determines the translation (x,y,z) + space about the center of this scene. By default, there + is no such translation. + eye + Sets the (x,y,z) components of the 'eye' camera vector. + This vector determines the view point about the origin + of this scene. + up + Sets the (x,y,z) components of the 'up' camera vector. + This vector determines the up direction of this scene + with respect to the page. The default is *{x: 0, y: 0, + z: 1}* which means that the z axis points up. + + Returns + ------- + Camera + """ + super(Camera, self).__init__('camera') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.Camera +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.Camera""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (camera as v_camera) + + # Initialize validators + # --------------------- + self._validators['center'] = v_camera.CenterValidator() + self._validators['eye'] = v_camera.EyeValidator() + self._validators['up'] = v_camera.UpValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('center', None) + self.center = center if center is not None else v + v = arg.pop('eye', None) + self.eye = eye if eye is not None else v + v = arg.pop('up', None) + self.up = up if up is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_domain.py b/plotly/graph_objs/layout/scene/_domain.py new file mode 100644 index 0000000000..80cc83b50c --- /dev/null +++ b/plotly/graph_objs/layout/scene/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this scene subplot . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this scene subplot . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this scene subplot (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this scene subplot (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this scene subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this scene subplot . + x + Sets the horizontal domain of this scene subplot (in + plot fraction). + y + Sets the vertical domain of this scene subplot (in plot + fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this scene subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this scene subplot . + x + Sets the horizontal domain of this scene subplot (in + plot fraction). + y + Sets the vertical domain of this scene subplot (in plot + fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_xaxis.py b/plotly/graph_objs/layout/scene/_xaxis.py new file mode 100644 index 0000000000..27df476837 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_xaxis.py @@ -0,0 +1,2323 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class XAxis(BaseLayoutHierarchyType): + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # backgroundcolor + # --------------- + @property + def backgroundcolor(self): + """ + Sets the background color of this axis' wall. + + The 'backgroundcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['backgroundcolor'] + + @backgroundcolor.setter + def backgroundcolor(self, val): + self['backgroundcolor'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # mirror + # ------ + @property + def mirror(self): + """ + Determines if the axis lines or/and ticks are mirrored to the + opposite side of the plotting area. If *true*, the axis lines + are mirrored. If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If *all*, axis + lines are mirrored on all shared-axes subplots. If *allticks*, + axis lines and ticks are mirrored on all shared-axes subplots. + + The 'mirror' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'ticks', False, 'all', 'allticks'] + + Returns + ------- + Any + """ + return self['mirror'] + + @mirror.setter + def mirror(self, val): + self['mirror'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showaxeslabels + # -------------- + @property + def showaxeslabels(self): + """ + Sets whether or not this axis is labeled + + The 'showaxeslabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showaxeslabels'] + + @showaxeslabels.setter + def showaxeslabels(self, val): + self['showaxeslabels'] = val + + # showbackground + # -------------- + @property + def showbackground(self): + """ + Sets whether or not this axis' wall has a background color. + + The 'showbackground' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showbackground'] + + @showbackground.setter + def showbackground(self, val): + self['showbackground'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showspikes + # ---------- + @property + def showspikes(self): + """ + Sets whether or not spikes starting from data points to this + axis' wall are shown on hover. + + The 'showspikes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showspikes'] + + @showspikes.setter + def showspikes(self, val): + self['showspikes'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # spikecolor + # ---------- + @property + def spikecolor(self): + """ + Sets the color of the spikes. + + The 'spikecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['spikecolor'] + + @spikecolor.setter + def spikecolor(self, val): + self['spikecolor'] = val + + # spikesides + # ---------- + @property + def spikesides(self): + """ + Sets whether or not spikes extending from the projection data + points to this axis' wall boundaries are shown on hover. + + The 'spikesides' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['spikesides'] + + @spikesides.setter + def spikesides(self, val): + self['spikesides'] = val + + # spikethickness + # -------------- + @property + def spikethickness(self): + """ + Sets the thickness (in px) of the spikes. + + The 'spikethickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['spikethickness'] + + @spikethickness.setter + def spikethickness(self, val): + self['spikethickness'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.xaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.xaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.scene.xaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.scene.xaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.xaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.xaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # zeroline + # -------- + @property + def zeroline(self): + """ + Determines whether or not a line is drawn at along the 0 value + of this axis. If *true*, the zero line is drawn on top of the + grid lines. + + The 'zeroline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zeroline'] + + @zeroline.setter + def zeroline(self, val): + self['zeroline'] = val + + # zerolinecolor + # ------------- + @property + def zerolinecolor(self): + """ + Sets the line color of the zero line. + + The 'zerolinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['zerolinecolor'] + + @zerolinecolor.setter + def zerolinecolor(self, val): + self['zerolinecolor'] = val + + # zerolinewidth + # ------------- + @property + def zerolinewidth(self): + """ + Sets the width (in px) of the zero line. + + The 'zerolinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zerolinewidth'] + + @zerolinewidth.setter + def zerolinewidth(self, val): + self['zerolinewidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.xaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + """ + + def __init__( + self, + arg=None, + autorange=None, + backgroundcolor=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + linecolor=None, + linewidth=None, + mirror=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showaxeslabels=None, + showbackground=None, + showexponent=None, + showgrid=None, + showline=None, + showspikes=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + spikecolor=None, + spikesides=None, + spikethickness=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + zeroline=None, + zerolinecolor=None, + zerolinewidth=None, + **kwargs + ): + """ + Construct a new XAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.XAxis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.xaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + XAxis + """ + super(XAxis, self).__init__('xaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.XAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.XAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (xaxis as v_xaxis) + + # Initialize validators + # --------------------- + self._validators['autorange'] = v_xaxis.AutorangeValidator() + self._validators['backgroundcolor' + ] = v_xaxis.BackgroundcolorValidator() + self._validators['calendar'] = v_xaxis.CalendarValidator() + self._validators['categoryarray'] = v_xaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_xaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_xaxis.CategoryorderValidator() + self._validators['color'] = v_xaxis.ColorValidator() + self._validators['dtick'] = v_xaxis.DtickValidator() + self._validators['exponentformat'] = v_xaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_xaxis.GridcolorValidator() + self._validators['gridwidth'] = v_xaxis.GridwidthValidator() + self._validators['hoverformat'] = v_xaxis.HoverformatValidator() + self._validators['linecolor'] = v_xaxis.LinecolorValidator() + self._validators['linewidth'] = v_xaxis.LinewidthValidator() + self._validators['mirror'] = v_xaxis.MirrorValidator() + self._validators['nticks'] = v_xaxis.NticksValidator() + self._validators['range'] = v_xaxis.RangeValidator() + self._validators['rangemode'] = v_xaxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_xaxis.SeparatethousandsValidator() + self._validators['showaxeslabels'] = v_xaxis.ShowaxeslabelsValidator() + self._validators['showbackground'] = v_xaxis.ShowbackgroundValidator() + self._validators['showexponent'] = v_xaxis.ShowexponentValidator() + self._validators['showgrid'] = v_xaxis.ShowgridValidator() + self._validators['showline'] = v_xaxis.ShowlineValidator() + self._validators['showspikes'] = v_xaxis.ShowspikesValidator() + self._validators['showticklabels'] = v_xaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_xaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_xaxis.ShowticksuffixValidator() + self._validators['spikecolor'] = v_xaxis.SpikecolorValidator() + self._validators['spikesides'] = v_xaxis.SpikesidesValidator() + self._validators['spikethickness'] = v_xaxis.SpikethicknessValidator() + self._validators['tick0'] = v_xaxis.Tick0Validator() + self._validators['tickangle'] = v_xaxis.TickangleValidator() + self._validators['tickcolor'] = v_xaxis.TickcolorValidator() + self._validators['tickfont'] = v_xaxis.TickfontValidator() + self._validators['tickformat'] = v_xaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_xaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_xaxis.TicklenValidator() + self._validators['tickmode'] = v_xaxis.TickmodeValidator() + self._validators['tickprefix'] = v_xaxis.TickprefixValidator() + self._validators['ticks'] = v_xaxis.TicksValidator() + self._validators['ticksuffix'] = v_xaxis.TicksuffixValidator() + self._validators['ticktext'] = v_xaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_xaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_xaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_xaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_xaxis.TickwidthValidator() + self._validators['title'] = v_xaxis.TitleValidator() + self._validators['titlefont'] = v_xaxis.TitlefontValidator() + self._validators['type'] = v_xaxis.TypeValidator() + self._validators['visible'] = v_xaxis.VisibleValidator() + self._validators['zeroline'] = v_xaxis.ZerolineValidator() + self._validators['zerolinecolor'] = v_xaxis.ZerolinecolorValidator() + self._validators['zerolinewidth'] = v_xaxis.ZerolinewidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('backgroundcolor', None) + self.backgroundcolor = backgroundcolor if backgroundcolor is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('mirror', None) + self.mirror = mirror if mirror is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showaxeslabels', None) + self.showaxeslabels = showaxeslabels if showaxeslabels is not None else v + v = arg.pop('showbackground', None) + self.showbackground = showbackground if showbackground is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showspikes', None) + self.showspikes = showspikes if showspikes is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('spikecolor', None) + self.spikecolor = spikecolor if spikecolor is not None else v + v = arg.pop('spikesides', None) + self.spikesides = spikesides if spikesides is not None else v + v = arg.pop('spikethickness', None) + self.spikethickness = spikethickness if spikethickness is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('zeroline', None) + self.zeroline = zeroline if zeroline is not None else v + v = arg.pop('zerolinecolor', None) + self.zerolinecolor = zerolinecolor if zerolinecolor is not None else v + v = arg.pop('zerolinewidth', None) + self.zerolinewidth = zerolinewidth if zerolinewidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_yaxis.py b/plotly/graph_objs/layout/scene/_yaxis.py new file mode 100644 index 0000000000..712f119399 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_yaxis.py @@ -0,0 +1,2323 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class YAxis(BaseLayoutHierarchyType): + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # backgroundcolor + # --------------- + @property + def backgroundcolor(self): + """ + Sets the background color of this axis' wall. + + The 'backgroundcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['backgroundcolor'] + + @backgroundcolor.setter + def backgroundcolor(self, val): + self['backgroundcolor'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # mirror + # ------ + @property + def mirror(self): + """ + Determines if the axis lines or/and ticks are mirrored to the + opposite side of the plotting area. If *true*, the axis lines + are mirrored. If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If *all*, axis + lines are mirrored on all shared-axes subplots. If *allticks*, + axis lines and ticks are mirrored on all shared-axes subplots. + + The 'mirror' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'ticks', False, 'all', 'allticks'] + + Returns + ------- + Any + """ + return self['mirror'] + + @mirror.setter + def mirror(self, val): + self['mirror'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showaxeslabels + # -------------- + @property + def showaxeslabels(self): + """ + Sets whether or not this axis is labeled + + The 'showaxeslabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showaxeslabels'] + + @showaxeslabels.setter + def showaxeslabels(self, val): + self['showaxeslabels'] = val + + # showbackground + # -------------- + @property + def showbackground(self): + """ + Sets whether or not this axis' wall has a background color. + + The 'showbackground' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showbackground'] + + @showbackground.setter + def showbackground(self, val): + self['showbackground'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showspikes + # ---------- + @property + def showspikes(self): + """ + Sets whether or not spikes starting from data points to this + axis' wall are shown on hover. + + The 'showspikes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showspikes'] + + @showspikes.setter + def showspikes(self, val): + self['showspikes'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # spikecolor + # ---------- + @property + def spikecolor(self): + """ + Sets the color of the spikes. + + The 'spikecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['spikecolor'] + + @spikecolor.setter + def spikecolor(self, val): + self['spikecolor'] = val + + # spikesides + # ---------- + @property + def spikesides(self): + """ + Sets whether or not spikes extending from the projection data + points to this axis' wall boundaries are shown on hover. + + The 'spikesides' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['spikesides'] + + @spikesides.setter + def spikesides(self, val): + self['spikesides'] = val + + # spikethickness + # -------------- + @property + def spikethickness(self): + """ + Sets the thickness (in px) of the spikes. + + The 'spikethickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['spikethickness'] + + @spikethickness.setter + def spikethickness(self, val): + self['spikethickness'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.yaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.yaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.scene.yaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.scene.yaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.yaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.yaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # zeroline + # -------- + @property + def zeroline(self): + """ + Determines whether or not a line is drawn at along the 0 value + of this axis. If *true*, the zero line is drawn on top of the + grid lines. + + The 'zeroline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zeroline'] + + @zeroline.setter + def zeroline(self, val): + self['zeroline'] = val + + # zerolinecolor + # ------------- + @property + def zerolinecolor(self): + """ + Sets the line color of the zero line. + + The 'zerolinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['zerolinecolor'] + + @zerolinecolor.setter + def zerolinecolor(self, val): + self['zerolinecolor'] = val + + # zerolinewidth + # ------------- + @property + def zerolinewidth(self): + """ + Sets the width (in px) of the zero line. + + The 'zerolinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zerolinewidth'] + + @zerolinewidth.setter + def zerolinewidth(self, val): + self['zerolinewidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.yaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + """ + + def __init__( + self, + arg=None, + autorange=None, + backgroundcolor=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + linecolor=None, + linewidth=None, + mirror=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showaxeslabels=None, + showbackground=None, + showexponent=None, + showgrid=None, + showline=None, + showspikes=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + spikecolor=None, + spikesides=None, + spikethickness=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + zeroline=None, + zerolinecolor=None, + zerolinewidth=None, + **kwargs + ): + """ + Construct a new YAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.YAxis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.yaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + YAxis + """ + super(YAxis, self).__init__('yaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.YAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.YAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (yaxis as v_yaxis) + + # Initialize validators + # --------------------- + self._validators['autorange'] = v_yaxis.AutorangeValidator() + self._validators['backgroundcolor' + ] = v_yaxis.BackgroundcolorValidator() + self._validators['calendar'] = v_yaxis.CalendarValidator() + self._validators['categoryarray'] = v_yaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_yaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_yaxis.CategoryorderValidator() + self._validators['color'] = v_yaxis.ColorValidator() + self._validators['dtick'] = v_yaxis.DtickValidator() + self._validators['exponentformat'] = v_yaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_yaxis.GridcolorValidator() + self._validators['gridwidth'] = v_yaxis.GridwidthValidator() + self._validators['hoverformat'] = v_yaxis.HoverformatValidator() + self._validators['linecolor'] = v_yaxis.LinecolorValidator() + self._validators['linewidth'] = v_yaxis.LinewidthValidator() + self._validators['mirror'] = v_yaxis.MirrorValidator() + self._validators['nticks'] = v_yaxis.NticksValidator() + self._validators['range'] = v_yaxis.RangeValidator() + self._validators['rangemode'] = v_yaxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_yaxis.SeparatethousandsValidator() + self._validators['showaxeslabels'] = v_yaxis.ShowaxeslabelsValidator() + self._validators['showbackground'] = v_yaxis.ShowbackgroundValidator() + self._validators['showexponent'] = v_yaxis.ShowexponentValidator() + self._validators['showgrid'] = v_yaxis.ShowgridValidator() + self._validators['showline'] = v_yaxis.ShowlineValidator() + self._validators['showspikes'] = v_yaxis.ShowspikesValidator() + self._validators['showticklabels'] = v_yaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_yaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_yaxis.ShowticksuffixValidator() + self._validators['spikecolor'] = v_yaxis.SpikecolorValidator() + self._validators['spikesides'] = v_yaxis.SpikesidesValidator() + self._validators['spikethickness'] = v_yaxis.SpikethicknessValidator() + self._validators['tick0'] = v_yaxis.Tick0Validator() + self._validators['tickangle'] = v_yaxis.TickangleValidator() + self._validators['tickcolor'] = v_yaxis.TickcolorValidator() + self._validators['tickfont'] = v_yaxis.TickfontValidator() + self._validators['tickformat'] = v_yaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_yaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_yaxis.TicklenValidator() + self._validators['tickmode'] = v_yaxis.TickmodeValidator() + self._validators['tickprefix'] = v_yaxis.TickprefixValidator() + self._validators['ticks'] = v_yaxis.TicksValidator() + self._validators['ticksuffix'] = v_yaxis.TicksuffixValidator() + self._validators['ticktext'] = v_yaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_yaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_yaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_yaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_yaxis.TickwidthValidator() + self._validators['title'] = v_yaxis.TitleValidator() + self._validators['titlefont'] = v_yaxis.TitlefontValidator() + self._validators['type'] = v_yaxis.TypeValidator() + self._validators['visible'] = v_yaxis.VisibleValidator() + self._validators['zeroline'] = v_yaxis.ZerolineValidator() + self._validators['zerolinecolor'] = v_yaxis.ZerolinecolorValidator() + self._validators['zerolinewidth'] = v_yaxis.ZerolinewidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('backgroundcolor', None) + self.backgroundcolor = backgroundcolor if backgroundcolor is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('mirror', None) + self.mirror = mirror if mirror is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showaxeslabels', None) + self.showaxeslabels = showaxeslabels if showaxeslabels is not None else v + v = arg.pop('showbackground', None) + self.showbackground = showbackground if showbackground is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showspikes', None) + self.showspikes = showspikes if showspikes is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('spikecolor', None) + self.spikecolor = spikecolor if spikecolor is not None else v + v = arg.pop('spikesides', None) + self.spikesides = spikesides if spikesides is not None else v + v = arg.pop('spikethickness', None) + self.spikethickness = spikethickness if spikethickness is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('zeroline', None) + self.zeroline = zeroline if zeroline is not None else v + v = arg.pop('zerolinecolor', None) + self.zerolinecolor = zerolinecolor if zerolinecolor is not None else v + v = arg.pop('zerolinewidth', None) + self.zerolinewidth = zerolinewidth if zerolinewidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/_zaxis.py b/plotly/graph_objs/layout/scene/_zaxis.py new file mode 100644 index 0000000000..0172c96129 --- /dev/null +++ b/plotly/graph_objs/layout/scene/_zaxis.py @@ -0,0 +1,2323 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class ZAxis(BaseLayoutHierarchyType): + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range of this axis is computed in + relation to the input data. See `rangemode` for more info. If + `range` is provided, then `autorange` is set to *false*. + + The 'autorange' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, False, 'reversed'] + + Returns + ------- + Any + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # backgroundcolor + # --------------- + @property + def backgroundcolor(self): + """ + Sets the background color of this axis' wall. + + The 'backgroundcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['backgroundcolor'] + + @backgroundcolor.setter + def backgroundcolor(self, val): + self['backgroundcolor'] = val + + # calendar + # -------- + @property + def calendar(self): + """ + Sets the calendar system to use for `range` and `tick0` if this + is a date axis. This does not set the calendar for interpreting + data on this axis, that's specified in the trace or via the + global `layout.calendar` + + The 'calendar' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['gregorian', 'chinese', 'coptic', 'discworld', + 'ethiopian', 'hebrew', 'islamic', 'julian', 'mayan', + 'nanakshahi', 'nepali', 'persian', 'jalali', 'taiwan', + 'thai', 'ummalqura'] + + Returns + ------- + Any + """ + return self['calendar'] + + @calendar.setter + def calendar(self, val): + self['calendar'] = val + + # categoryarray + # ------------- + @property + def categoryarray(self): + """ + Sets the order in which categories on this axis appear. Only + has an effect if `categoryorder` is set to *array*. Used with + `categoryorder`. + + The 'categoryarray' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['categoryarray'] + + @categoryarray.setter + def categoryarray(self, val): + self['categoryarray'] = val + + # categoryarraysrc + # ---------------- + @property + def categoryarraysrc(self): + """ + Sets the source reference on plot.ly for categoryarray . + + The 'categoryarraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['categoryarraysrc'] + + @categoryarraysrc.setter + def categoryarraysrc(self, val): + self['categoryarraysrc'] = val + + # categoryorder + # ------------- + @property + def categoryorder(self): + """ + Specifies the ordering logic for the case of categorical + variables. By default, plotly uses *trace*, which specifies the + order that is present in the data supplied. Set `categoryorder` + to *category ascending* or *category descending* if order + should be determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* to derive the + ordering from the attribute `categoryarray`. If a category is + not found in the `categoryarray` array, the sorting behavior + for that attribute will be identical to the *trace* mode. The + unspecified categories will follow the categories in + `categoryarray`. + + The 'categoryorder' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['trace', 'category ascending', 'category descending', + 'array'] + + Returns + ------- + Any + """ + return self['categoryorder'] + + @categoryorder.setter + def categoryorder(self, val): + self['categoryorder'] = val + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # mirror + # ------ + @property + def mirror(self): + """ + Determines if the axis lines or/and ticks are mirrored to the + opposite side of the plotting area. If *true*, the axis lines + are mirrored. If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If *all*, axis + lines are mirrored on all shared-axes subplots. If *allticks*, + axis lines and ticks are mirrored on all shared-axes subplots. + + The 'mirror' property is an enumeration that may be specified as: + - One of the following enumeration values: + [True, 'ticks', False, 'all', 'allticks'] + + Returns + ------- + Any + """ + return self['mirror'] + + @mirror.setter + def mirror(self, val): + self['mirror'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis. If the axis `type` is *log*, then + you must take the log of your desired range (e.g. to set the + range from 1 to 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, like date data, + though Date objects and unix milliseconds will be accepted and + converted to strings. If the axis `type` is *category*, it + should be numbers, using the scale where each category is + assigned a serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + If *normal*, the range is computed in relation to the extrema + of the input data. If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, the range is + non-negative, regardless of the input data. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['normal', 'tozero', 'nonnegative'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showaxeslabels + # -------------- + @property + def showaxeslabels(self): + """ + Sets whether or not this axis is labeled + + The 'showaxeslabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showaxeslabels'] + + @showaxeslabels.setter + def showaxeslabels(self, val): + self['showaxeslabels'] = val + + # showbackground + # -------------- + @property + def showbackground(self): + """ + Sets whether or not this axis' wall has a background color. + + The 'showbackground' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showbackground'] + + @showbackground.setter + def showbackground(self, val): + self['showbackground'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showspikes + # ---------- + @property + def showspikes(self): + """ + Sets whether or not spikes starting from data points to this + axis' wall are shown on hover. + + The 'showspikes' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showspikes'] + + @showspikes.setter + def showspikes(self, val): + self['showspikes'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # spikecolor + # ---------- + @property + def spikecolor(self): + """ + Sets the color of the spikes. + + The 'spikecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['spikecolor'] + + @spikecolor.setter + def spikecolor(self, val): + self['spikecolor'] = val + + # spikesides + # ---------- + @property + def spikesides(self): + """ + Sets whether or not spikes extending from the projection data + points to this axis' wall boundaries are shown on hover. + + The 'spikesides' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['spikesides'] + + @spikesides.setter + def spikesides(self, val): + self['spikesides'] = val + + # spikethickness + # -------------- + @property + def spikethickness(self): + """ + Sets the thickness (in px) of the spikes. + + The 'spikethickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['spikethickness'] + + @spikethickness.setter + def spikethickness(self, val): + self['spikethickness'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.zaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.zaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.scene.zaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.scene.zaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.zaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.zaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the axis type. By default, plotly attempts to determined + the axis type by looking into the data of the traces that + referenced the axis in question. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['-', 'linear', 'log', 'date', 'category'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # visible + # ------- + @property + def visible(self): + """ + A single toggle to hide the axis while preserving interaction + like dragging. Default is true when a cheater plot is present + on the axis, otherwise false + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # zeroline + # -------- + @property + def zeroline(self): + """ + Determines whether or not a line is drawn at along the 0 value + of this axis. If *true*, the zero line is drawn on top of the + grid lines. + + The 'zeroline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['zeroline'] + + @zeroline.setter + def zeroline(self, val): + self['zeroline'] = val + + # zerolinecolor + # ------------- + @property + def zerolinecolor(self): + """ + Sets the line color of the zero line. + + The 'zerolinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['zerolinecolor'] + + @zerolinecolor.setter + def zerolinecolor(self, val): + self['zerolinecolor'] = val + + # zerolinewidth + # ------------- + @property + def zerolinewidth(self): + """ + Sets the width (in px) of the zero line. + + The 'zerolinewidth' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['zerolinewidth'] + + @zerolinewidth.setter + def zerolinewidth(self, val): + self['zerolinewidth'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.zaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + """ + + def __init__( + self, + arg=None, + autorange=None, + backgroundcolor=None, + calendar=None, + categoryarray=None, + categoryarraysrc=None, + categoryorder=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + linecolor=None, + linewidth=None, + mirror=None, + nticks=None, + range=None, + rangemode=None, + separatethousands=None, + showaxeslabels=None, + showbackground=None, + showexponent=None, + showgrid=None, + showline=None, + showspikes=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + spikecolor=None, + spikesides=None, + spikethickness=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + type=None, + visible=None, + zeroline=None, + zerolinecolor=None, + zerolinewidth=None, + **kwargs + ): + """ + Construct a new ZAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.ZAxis + autorange + Determines whether or not the range of this axis is + computed in relation to the input data. See `rangemode` + for more info. If `range` is provided, then `autorange` + is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and `tick0` + if this is a date axis. This does not set the calendar + for interpreting data on this axis, that's specified in + the trace or via the global `layout.calendar` + categoryarray + Sets the order in which categories on this axis appear. + Only has an effect if `categoryorder` is set to + *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for categoryarray + . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses *trace*, + which specifies the order that is present in the data + supplied. Set `categoryorder` to *category ascending* + or *category descending* if order should be determined + by the alphanumerical order of the category names. Set + `categoryorder` to *array* to derive the ordering from + the attribute `categoryarray`. If a category is not + found in the `categoryarray` array, the sorting + behavior for that attribute will be identical to the + *trace* mode. The unspecified categories will follow + the categories in `categoryarray`. + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are mirrored + to the opposite side of the plotting area. If *true*, + the axis lines are mirrored. If *ticks*, the axis lines + and ticks are mirrored. If *false*, mirroring is + disable. If *all*, axis lines are mirrored on all + shared-axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + range + Sets the range of this axis. If the axis `type` is + *log*, then you must take the log of your desired range + (e.g. to set the range from 1 to 100, set the range + from 0 to 2). If the axis `type` is *date*, it should + be date strings, like date data, though Date objects + and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order it + appears. + rangemode + If *normal*, the range is computed in relation to the + extrema of the input data. If *tozero*`, the range + extends to 0, regardless of the input data If + *nonnegative*, the range is non-negative, regardless of + the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a background + color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showspikes + Sets whether or not spikes starting from data points to + this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall boundaries + are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.zaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts to + determined the axis type by looking into the data of + the traces that referenced the axis in question. + visible + A single toggle to hide the axis while preserving + interaction like dragging. Default is true when a + cheater plot is present on the axis, otherwise false + zeroline + Determines whether or not a line is drawn at along the + 0 value of this axis. If *true*, the zero line is drawn + on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line. + + Returns + ------- + ZAxis + """ + super(ZAxis, self).__init__('zaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.ZAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.ZAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene import (zaxis as v_zaxis) + + # Initialize validators + # --------------------- + self._validators['autorange'] = v_zaxis.AutorangeValidator() + self._validators['backgroundcolor' + ] = v_zaxis.BackgroundcolorValidator() + self._validators['calendar'] = v_zaxis.CalendarValidator() + self._validators['categoryarray'] = v_zaxis.CategoryarrayValidator() + self._validators['categoryarraysrc' + ] = v_zaxis.CategoryarraysrcValidator() + self._validators['categoryorder'] = v_zaxis.CategoryorderValidator() + self._validators['color'] = v_zaxis.ColorValidator() + self._validators['dtick'] = v_zaxis.DtickValidator() + self._validators['exponentformat'] = v_zaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_zaxis.GridcolorValidator() + self._validators['gridwidth'] = v_zaxis.GridwidthValidator() + self._validators['hoverformat'] = v_zaxis.HoverformatValidator() + self._validators['linecolor'] = v_zaxis.LinecolorValidator() + self._validators['linewidth'] = v_zaxis.LinewidthValidator() + self._validators['mirror'] = v_zaxis.MirrorValidator() + self._validators['nticks'] = v_zaxis.NticksValidator() + self._validators['range'] = v_zaxis.RangeValidator() + self._validators['rangemode'] = v_zaxis.RangemodeValidator() + self._validators['separatethousands' + ] = v_zaxis.SeparatethousandsValidator() + self._validators['showaxeslabels'] = v_zaxis.ShowaxeslabelsValidator() + self._validators['showbackground'] = v_zaxis.ShowbackgroundValidator() + self._validators['showexponent'] = v_zaxis.ShowexponentValidator() + self._validators['showgrid'] = v_zaxis.ShowgridValidator() + self._validators['showline'] = v_zaxis.ShowlineValidator() + self._validators['showspikes'] = v_zaxis.ShowspikesValidator() + self._validators['showticklabels'] = v_zaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_zaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_zaxis.ShowticksuffixValidator() + self._validators['spikecolor'] = v_zaxis.SpikecolorValidator() + self._validators['spikesides'] = v_zaxis.SpikesidesValidator() + self._validators['spikethickness'] = v_zaxis.SpikethicknessValidator() + self._validators['tick0'] = v_zaxis.Tick0Validator() + self._validators['tickangle'] = v_zaxis.TickangleValidator() + self._validators['tickcolor'] = v_zaxis.TickcolorValidator() + self._validators['tickfont'] = v_zaxis.TickfontValidator() + self._validators['tickformat'] = v_zaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_zaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_zaxis.TicklenValidator() + self._validators['tickmode'] = v_zaxis.TickmodeValidator() + self._validators['tickprefix'] = v_zaxis.TickprefixValidator() + self._validators['ticks'] = v_zaxis.TicksValidator() + self._validators['ticksuffix'] = v_zaxis.TicksuffixValidator() + self._validators['ticktext'] = v_zaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_zaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_zaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_zaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_zaxis.TickwidthValidator() + self._validators['title'] = v_zaxis.TitleValidator() + self._validators['titlefont'] = v_zaxis.TitlefontValidator() + self._validators['type'] = v_zaxis.TypeValidator() + self._validators['visible'] = v_zaxis.VisibleValidator() + self._validators['zeroline'] = v_zaxis.ZerolineValidator() + self._validators['zerolinecolor'] = v_zaxis.ZerolinecolorValidator() + self._validators['zerolinewidth'] = v_zaxis.ZerolinewidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('backgroundcolor', None) + self.backgroundcolor = backgroundcolor if backgroundcolor is not None else v + v = arg.pop('calendar', None) + self.calendar = calendar if calendar is not None else v + v = arg.pop('categoryarray', None) + self.categoryarray = categoryarray if categoryarray is not None else v + v = arg.pop('categoryarraysrc', None) + self.categoryarraysrc = categoryarraysrc if categoryarraysrc is not None else v + v = arg.pop('categoryorder', None) + self.categoryorder = categoryorder if categoryorder is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('mirror', None) + self.mirror = mirror if mirror is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showaxeslabels', None) + self.showaxeslabels = showaxeslabels if showaxeslabels is not None else v + v = arg.pop('showbackground', None) + self.showbackground = showbackground if showbackground is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showspikes', None) + self.showspikes = showspikes if showspikes is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('spikecolor', None) + self.spikecolor = spikecolor if spikecolor is not None else v + v = arg.pop('spikesides', None) + self.spikesides = spikesides if spikesides is not None else v + v = arg.pop('spikethickness', None) + self.spikethickness = spikethickness if spikethickness is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('zeroline', None) + self.zeroline = zeroline if zeroline is not None else v + v = arg.pop('zerolinecolor', None) + self.zerolinecolor = zerolinecolor if zerolinecolor is not None else v + v = arg.pop('zerolinewidth', None) + self.zerolinewidth = zerolinewidth if zerolinewidth is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/annotation/__init__.py b/plotly/graph_objs/layout/scene/annotation/__init__.py new file mode 100644 index 0000000000..54fab678b0 --- /dev/null +++ b/plotly/graph_objs/layout/scene/annotation/__init__.py @@ -0,0 +1,3 @@ +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.layout.scene.annotation import hoverlabel +from ._font import Font diff --git a/plotly/graph_objs/layout/scene/annotation/_font.py b/plotly/graph_objs/layout/scene/annotation/_font.py new file mode 100644 index 0000000000..fd8e3a52f2 --- /dev/null +++ b/plotly/graph_objs/layout/scene/annotation/_font.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.annotation' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the annotation text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.annotation.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.annotation.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.annotation.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.annotation import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/annotation/_hoverlabel.py b/plotly/graph_objs/layout/scene/annotation/_hoverlabel.py new file mode 100644 index 0000000000..0069aa2b20 --- /dev/null +++ b/plotly/graph_objs/layout/scene/annotation/_hoverlabel.py @@ -0,0 +1,270 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Hoverlabel(BaseLayoutHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover label. By default uses + the annotation's `bgcolor` made opaque, or white if it was + transparent. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover label. By default uses + either dark grey or white, for maximum contrast with + `hoverlabel.bgcolor`. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the hover label text font. By default uses the global + hover font and size, with color from `hoverlabel.bordercolor`. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.scene.annotation.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.scene.annotation.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.annotation' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover label. By + default uses the annotation's `bgcolor` made opaque, or + white if it was transparent. + bordercolor + Sets the border color of the hover label. By default + uses either dark grey or white, for maximum contrast + with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses the + global hover font and size, with color from + `hoverlabel.bordercolor`. + """ + + def __init__( + self, arg=None, bgcolor=None, bordercolor=None, font=None, **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.annotation.Hoverlabel + bgcolor + Sets the background color of the hover label. By + default uses the annotation's `bgcolor` made opaque, or + white if it was transparent. + bordercolor + Sets the border color of the hover label. By default + uses either dark grey or white, for maximum contrast + with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses the + global hover font and size, with color from + `hoverlabel.bordercolor`. + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.annotation.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.annotation.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.annotation import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/annotation/hoverlabel/__init__.py b/plotly/graph_objs/layout/scene/annotation/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/layout/scene/annotation/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/layout/scene/annotation/hoverlabel/_font.py b/plotly/graph_objs/layout/scene/annotation/hoverlabel/_font.py new file mode 100644 index 0000000000..990d750161 --- /dev/null +++ b/plotly/graph_objs/layout/scene/annotation/hoverlabel/_font.py @@ -0,0 +1,221 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.annotation.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the hover label text font. By default uses the global + hover font and size, with color from `hoverlabel.bordercolor`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.annotatio + n.hoverlabel.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.annotation.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.annotation.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.annotation.hoverlabel import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/camera/__init__.py b/plotly/graph_objs/layout/scene/camera/__init__.py new file mode 100644 index 0000000000..544ca035c0 --- /dev/null +++ b/plotly/graph_objs/layout/scene/camera/__init__.py @@ -0,0 +1,3 @@ +from ._up import Up +from ._eye import Eye +from ._center import Center diff --git a/plotly/graph_objs/layout/scene/camera/_center.py b/plotly/graph_objs/layout/scene/camera/_center.py new file mode 100644 index 0000000000..e155b59e38 --- /dev/null +++ b/plotly/graph_objs/layout/scene/camera/_center.py @@ -0,0 +1,144 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Center(BaseLayoutHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.camera' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + + y + + z + + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Center object + + Sets the (x,y,z) components of the 'center' camera vector This + vector determines the translation (x,y,z) space about the + center of this scene. By default, there is no such translation. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.camera.Center + x + + y + + z + + + Returns + ------- + Center + """ + super(Center, self).__init__('center') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.camera.Center +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.camera.Center""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.camera import (center as v_center) + + # Initialize validators + # --------------------- + self._validators['x'] = v_center.XValidator() + self._validators['y'] = v_center.YValidator() + self._validators['z'] = v_center.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/camera/_eye.py b/plotly/graph_objs/layout/scene/camera/_eye.py new file mode 100644 index 0000000000..d5b119e004 --- /dev/null +++ b/plotly/graph_objs/layout/scene/camera/_eye.py @@ -0,0 +1,144 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Eye(BaseLayoutHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.camera' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + + y + + z + + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Eye object + + Sets the (x,y,z) components of the 'eye' camera vector. This + vector determines the view point about the origin of this + scene. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.camera.Eye + x + + y + + z + + + Returns + ------- + Eye + """ + super(Eye, self).__init__('eye') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.camera.Eye +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.camera.Eye""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.camera import (eye as v_eye) + + # Initialize validators + # --------------------- + self._validators['x'] = v_eye.XValidator() + self._validators['y'] = v_eye.YValidator() + self._validators['z'] = v_eye.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/camera/_up.py b/plotly/graph_objs/layout/scene/camera/_up.py new file mode 100644 index 0000000000..7be83331d5 --- /dev/null +++ b/plotly/graph_objs/layout/scene/camera/_up.py @@ -0,0 +1,144 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Up(BaseLayoutHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.camera' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + + y + + z + + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Up object + + Sets the (x,y,z) components of the 'up' camera vector. This + vector determines the up direction of this scene with respect + to the page. The default is *{x: 0, y: 0, z: 1}* which means + that the z axis points up. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.scene.camera.Up + x + + y + + z + + + Returns + ------- + Up + """ + super(Up, self).__init__('up') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.camera.Up +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.camera.Up""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.camera import (up as v_up) + + # Initialize validators + # --------------------- + self._validators['x'] = v_up.XValidator() + self._validators['y'] = v_up.YValidator() + self._validators['z'] = v_up.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/xaxis/__init__.py b/plotly/graph_objs/layout/scene/xaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/scene/xaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/scene/xaxis/_tickfont.py b/plotly/graph_objs/layout/scene/xaxis/_tickfont.py new file mode 100644 index 0000000000..6b93d51983 --- /dev/null +++ b/plotly/graph_objs/layout/scene/xaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.xaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.xaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.xaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.xaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/xaxis/_tickformatstop.py b/plotly/graph_objs/layout/scene/xaxis/_tickformatstop.py new file mode 100644 index 0000000000..207df65912 --- /dev/null +++ b/plotly/graph_objs/layout/scene/xaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.xaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.xaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.xaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.xaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/xaxis/_titlefont.py b/plotly/graph_objs/layout/scene/xaxis/_titlefont.py new file mode 100644 index 0000000000..2693cb505b --- /dev/null +++ b/plotly/graph_objs/layout/scene/xaxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.xaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.xaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.xaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.xaxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/yaxis/__init__.py b/plotly/graph_objs/layout/scene/yaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/scene/yaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/scene/yaxis/_tickfont.py b/plotly/graph_objs/layout/scene/yaxis/_tickfont.py new file mode 100644 index 0000000000..2738df812f --- /dev/null +++ b/plotly/graph_objs/layout/scene/yaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.yaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.yaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.yaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.yaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/yaxis/_tickformatstop.py b/plotly/graph_objs/layout/scene/yaxis/_tickformatstop.py new file mode 100644 index 0000000000..2b45324a33 --- /dev/null +++ b/plotly/graph_objs/layout/scene/yaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.yaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.yaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.yaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.yaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/yaxis/_titlefont.py b/plotly/graph_objs/layout/scene/yaxis/_titlefont.py new file mode 100644 index 0000000000..bbab19f927 --- /dev/null +++ b/plotly/graph_objs/layout/scene/yaxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.yaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.yaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.yaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.yaxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/zaxis/__init__.py b/plotly/graph_objs/layout/scene/zaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/scene/zaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/scene/zaxis/_tickfont.py b/plotly/graph_objs/layout/scene/zaxis/_tickfont.py new file mode 100644 index 0000000000..20943ef126 --- /dev/null +++ b/plotly/graph_objs/layout/scene/zaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.zaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.zaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.zaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.zaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.zaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/zaxis/_tickformatstop.py b/plotly/graph_objs/layout/scene/zaxis/_tickformatstop.py new file mode 100644 index 0000000000..423af1fe60 --- /dev/null +++ b/plotly/graph_objs/layout/scene/zaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.zaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.zaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.zaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.zaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.zaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/scene/zaxis/_titlefont.py b/plotly/graph_objs/layout/scene/zaxis/_titlefont.py new file mode 100644 index 0000000000..1f79fb3b31 --- /dev/null +++ b/plotly/graph_objs/layout/scene/zaxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.scene.zaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.scene.zaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.scene.zaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.scene.zaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.scene.zaxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/shape/__init__.py b/plotly/graph_objs/layout/shape/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/layout/shape/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/layout/shape/_line.py b/plotly/graph_objs/layout/shape/_line.py new file mode 100644 index 0000000000..6ac757dd8e --- /dev/null +++ b/plotly/graph_objs/layout/shape/_line.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Line(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.shape' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.shape.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.shape.Line +constructor must be a dict or +an instance of plotly.graph_objs.layout.shape.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.shape import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/__init__.py b/plotly/graph_objs/layout/slider/__init__.py new file mode 100644 index 0000000000..b951d547d5 --- /dev/null +++ b/plotly/graph_objs/layout/slider/__init__.py @@ -0,0 +1,6 @@ +from ._transition import Transition +from ._step import Step +from ._pad import Pad +from ._font import Font +from ._currentvalue import Currentvalue +from plotly.graph_objs.layout.slider import currentvalue diff --git a/plotly/graph_objs/layout/slider/_currentvalue.py b/plotly/graph_objs/layout/slider/_currentvalue.py new file mode 100644 index 0000000000..ba6d226a51 --- /dev/null +++ b/plotly/graph_objs/layout/slider/_currentvalue.py @@ -0,0 +1,279 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Currentvalue(BaseLayoutHierarchyType): + + # font + # ---- + @property + def font(self): + """ + Sets the font of the current value label text. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.slider.currentvalue.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.slider.currentvalue.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # offset + # ------ + @property + def offset(self): + """ + The amount of space, in pixels, between the current value label + and the slider. + + The 'offset' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['offset'] + + @offset.setter + def offset(self, val): + self['offset'] = val + + # prefix + # ------ + @property + def prefix(self): + """ + When currentvalue.visible is true, this sets the prefix of the + label. + + The 'prefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['prefix'] + + @prefix.setter + def prefix(self, val): + self['prefix'] = val + + # suffix + # ------ + @property + def suffix(self): + """ + When currentvalue.visible is true, this sets the suffix of the + label. + + The 'suffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['suffix'] + + @suffix.setter + def suffix(self, val): + self['suffix'] = val + + # visible + # ------- + @property + def visible(self): + """ + Shows the currently-selected value above the slider. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + The alignment of the value readout relative to the length of + the slider. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + font + Sets the font of the current value label text. + offset + The amount of space, in pixels, between the current + value label and the slider. + prefix + When currentvalue.visible is true, this sets the prefix + of the label. + suffix + When currentvalue.visible is true, this sets the suffix + of the label. + visible + Shows the currently-selected value above the slider. + xanchor + The alignment of the value readout relative to the + length of the slider. + """ + + def __init__( + self, + arg=None, + font=None, + offset=None, + prefix=None, + suffix=None, + visible=None, + xanchor=None, + **kwargs + ): + """ + Construct a new Currentvalue object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.slider.Currentvalue + font + Sets the font of the current value label text. + offset + The amount of space, in pixels, between the current + value label and the slider. + prefix + When currentvalue.visible is true, this sets the prefix + of the label. + suffix + When currentvalue.visible is true, this sets the suffix + of the label. + visible + Shows the currently-selected value above the slider. + xanchor + The alignment of the value readout relative to the + length of the slider. + + Returns + ------- + Currentvalue + """ + super(Currentvalue, self).__init__('currentvalue') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.Currentvalue +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.Currentvalue""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider import ( + currentvalue as v_currentvalue + ) + + # Initialize validators + # --------------------- + self._validators['font'] = v_currentvalue.FontValidator() + self._validators['offset'] = v_currentvalue.OffsetValidator() + self._validators['prefix'] = v_currentvalue.PrefixValidator() + self._validators['suffix'] = v_currentvalue.SuffixValidator() + self._validators['visible'] = v_currentvalue.VisibleValidator() + self._validators['xanchor'] = v_currentvalue.XanchorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('offset', None) + self.offset = offset if offset is not None else v + v = arg.pop('prefix', None) + self.prefix = prefix if prefix is not None else v + v = arg.pop('suffix', None) + self.suffix = suffix if suffix is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/_font.py b/plotly/graph_objs/layout/slider/_font.py new file mode 100644 index 0000000000..80b544dff3 --- /dev/null +++ b/plotly/graph_objs/layout/slider/_font.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the font of the slider step labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.slider.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/_pad.py b/plotly/graph_objs/layout/slider/_pad.py new file mode 100644 index 0000000000..126f6b5604 --- /dev/null +++ b/plotly/graph_objs/layout/slider/_pad.py @@ -0,0 +1,185 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Pad(BaseLayoutHierarchyType): + + # b + # - + @property + def b(self): + """ + The amount of padding (in px) along the bottom of the + component. + + The 'b' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # l + # - + @property + def l(self): + """ + The amount of padding (in px) on the left side of the + component. + + The 'l' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['l'] + + @l.setter + def l(self, val): + self['l'] = val + + # r + # - + @property + def r(self): + """ + The amount of padding (in px) on the right side of the + component. + + The 'r' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # t + # - + @property + def t(self): + """ + The amount of padding (in px) along the top of the component. + + The 't' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + b + The amount of padding (in px) along the bottom of the + component. + l + The amount of padding (in px) on the left side of the + component. + r + The amount of padding (in px) on the right side of the + component. + t + The amount of padding (in px) along the top of the + component. + """ + + def __init__(self, arg=None, b=None, l=None, r=None, t=None, **kwargs): + """ + Construct a new Pad object + + Set the padding of the slider component along each side. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.slider.Pad + b + The amount of padding (in px) along the bottom of the + component. + l + The amount of padding (in px) on the left side of the + component. + r + The amount of padding (in px) on the right side of the + component. + t + The amount of padding (in px) along the top of the + component. + + Returns + ------- + Pad + """ + super(Pad, self).__init__('pad') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.Pad +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.Pad""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider import (pad as v_pad) + + # Initialize validators + # --------------------- + self._validators['b'] = v_pad.BValidator() + self._validators['l'] = v_pad.LValidator() + self._validators['r'] = v_pad.RValidator() + self._validators['t'] = v_pad.TValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('l', None) + self.l = l if l is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/_step.py b/plotly/graph_objs/layout/slider/_step.py new file mode 100644 index 0000000000..42c9494aa6 --- /dev/null +++ b/plotly/graph_objs/layout/slider/_step.py @@ -0,0 +1,256 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Step(BaseLayoutHierarchyType): + + # args + # ---- + @property + def args(self): + """ + Sets the arguments values to be passed to the Plotly method set + in `method` on slide. + + The 'args' property is an info array that may be specified as a + list or tuple of up to 3 elements where: + + (0) The 'args[0]' property accepts values of any type + (1) The 'args[1]' property accepts values of any type + (2) The 'args[2]' property accepts values of any type + + Returns + ------- + list + """ + return self['args'] + + @args.setter + def args(self, val): + self['args'] = val + + # execute + # ------- + @property + def execute(self): + """ + When true, the API method is executed. When false, all other + behaviors are the same and command execution is skipped. This + may be useful when hooking into, for example, the + `plotly_sliderchange` method and executing the API command + manually without losing the benefit of the slider automatically + binding to the state of the plot through the specification of + `method` and `args`. + + The 'execute' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['execute'] + + @execute.setter + def execute(self, val): + self['execute'] = val + + # label + # ----- + @property + def label(self): + """ + Sets the text label to appear on the slider + + The 'label' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # method + # ------ + @property + def method(self): + """ + Sets the Plotly method to be called when the slider value is + changed. If the `skip` method is used, the API slider will + function as normal but will perform no API calls and will not + bind automatically to state updates. This may be used to create + a component interface and attach to slider events manually via + JavaScript. + + The 'method' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['restyle', 'relayout', 'animate', 'update', 'skip'] + + Returns + ------- + Any + """ + return self['method'] + + @method.setter + def method(self, val): + self['method'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of the slider step, used to refer to the step + programatically. Defaults to the slider label if not provided. + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + args + Sets the arguments values to be passed to the Plotly + method set in `method` on slide. + execute + When true, the API method is executed. When false, all + other behaviors are the same and command execution is + skipped. This may be useful when hooking into, for + example, the `plotly_sliderchange` method and executing + the API command manually without losing the benefit of + the slider automatically binding to the state of the + plot through the specification of `method` and `args`. + label + Sets the text label to appear on the slider + method + Sets the Plotly method to be called when the slider + value is changed. If the `skip` method is used, the API + slider will function as normal but will perform no API + calls and will not bind automatically to state updates. + This may be used to create a component interface and + attach to slider events manually via JavaScript. + value + Sets the value of the slider step, used to refer to the + step programatically. Defaults to the slider label if + not provided. + """ + + def __init__( + self, + arg=None, + args=None, + execute=None, + label=None, + method=None, + value=None, + **kwargs + ): + """ + Construct a new Step object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.slider.Step + args + Sets the arguments values to be passed to the Plotly + method set in `method` on slide. + execute + When true, the API method is executed. When false, all + other behaviors are the same and command execution is + skipped. This may be useful when hooking into, for + example, the `plotly_sliderchange` method and executing + the API command manually without losing the benefit of + the slider automatically binding to the state of the + plot through the specification of `method` and `args`. + label + Sets the text label to appear on the slider + method + Sets the Plotly method to be called when the slider + value is changed. If the `skip` method is used, the API + slider will function as normal but will perform no API + calls and will not bind automatically to state updates. + This may be used to create a component interface and + attach to slider events manually via JavaScript. + value + Sets the value of the slider step, used to refer to the + step programatically. Defaults to the slider label if + not provided. + + Returns + ------- + Step + """ + super(Step, self).__init__('steps') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.Step +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.Step""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider import (step as v_step) + + # Initialize validators + # --------------------- + self._validators['args'] = v_step.ArgsValidator() + self._validators['execute'] = v_step.ExecuteValidator() + self._validators['label'] = v_step.LabelValidator() + self._validators['method'] = v_step.MethodValidator() + self._validators['value'] = v_step.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('args', None) + self.args = args if args is not None else v + v = arg.pop('execute', None) + self.execute = execute if execute is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('method', None) + self.method = method if method is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/_transition.py b/plotly/graph_objs/layout/slider/_transition.py new file mode 100644 index 0000000000..37790bd91a --- /dev/null +++ b/plotly/graph_objs/layout/slider/_transition.py @@ -0,0 +1,130 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Transition(BaseLayoutHierarchyType): + + # duration + # -------- + @property + def duration(self): + """ + Sets the duration of the slider transition + + The 'duration' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['duration'] + + @duration.setter + def duration(self, val): + self['duration'] = val + + # easing + # ------ + @property + def easing(self): + """ + Sets the easing function of the slider transition + + The 'easing' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'quad', 'cubic', 'sin', 'exp', 'circle', + 'elastic', 'back', 'bounce', 'linear-in', 'quad-in', + 'cubic-in', 'sin-in', 'exp-in', 'circle-in', 'elastic-in', + 'back-in', 'bounce-in', 'linear-out', 'quad-out', + 'cubic-out', 'sin-out', 'exp-out', 'circle-out', + 'elastic-out', 'back-out', 'bounce-out', 'linear-in-out', + 'quad-in-out', 'cubic-in-out', 'sin-in-out', 'exp-in-out', + 'circle-in-out', 'elastic-in-out', 'back-in-out', + 'bounce-in-out'] + + Returns + ------- + Any + """ + return self['easing'] + + @easing.setter + def easing(self, val): + self['easing'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + duration + Sets the duration of the slider transition + easing + Sets the easing function of the slider transition + """ + + def __init__(self, arg=None, duration=None, easing=None, **kwargs): + """ + Construct a new Transition object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.slider.Transition + duration + Sets the duration of the slider transition + easing + Sets the easing function of the slider transition + + Returns + ------- + Transition + """ + super(Transition, self).__init__('transition') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.Transition +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.Transition""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider import ( + transition as v_transition + ) + + # Initialize validators + # --------------------- + self._validators['duration'] = v_transition.DurationValidator() + self._validators['easing'] = v_transition.EasingValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('duration', None) + self.duration = duration if duration is not None else v + v = arg.pop('easing', None) + self.easing = easing if easing is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/slider/currentvalue/__init__.py b/plotly/graph_objs/layout/slider/currentvalue/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/layout/slider/currentvalue/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/layout/slider/currentvalue/_font.py b/plotly/graph_objs/layout/slider/currentvalue/_font.py new file mode 100644 index 0000000000..8139ad96b1 --- /dev/null +++ b/plotly/graph_objs/layout/slider/currentvalue/_font.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.slider.currentvalue' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the font of the current value label text. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.slider.currentvalue.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.slider.currentvalue.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.slider.currentvalue.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.slider.currentvalue import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/__init__.py b/plotly/graph_objs/layout/ternary/__init__.py new file mode 100644 index 0000000000..02c5549ed6 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/__init__.py @@ -0,0 +1,7 @@ +from ._domain import Domain +from ._caxis import Caxis +from plotly.graph_objs.layout.ternary import caxis +from ._baxis import Baxis +from plotly.graph_objs.layout.ternary import baxis +from ._aaxis import Aaxis +from plotly.graph_objs.layout.ternary import aaxis diff --git a/plotly/graph_objs/layout/ternary/_aaxis.py b/plotly/graph_objs/layout/ternary/_aaxis.py new file mode 100644 index 0000000000..62d19e7f29 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/_aaxis.py @@ -0,0 +1,1575 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Aaxis(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # min + # --- + @property + def min(self): + """ + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the other two + axes. The full view corresponds to all the minima set to zero. + + The 'min' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['min'] + + @min.setter + def min(self, val): + self['min'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.aaxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.aaxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.ternary.aaxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.ternary.aaxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.aaxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.aaxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.aaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + """ + + def __init__( + self, + arg=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + min=None, + nticks=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + **kwargs + ): + """ + Construct a new Aaxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.ternary.Aaxis + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.aaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + Aaxis + """ + super(Aaxis, self).__init__('aaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.Aaxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.Aaxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary import (aaxis as v_aaxis) + + # Initialize validators + # --------------------- + self._validators['color'] = v_aaxis.ColorValidator() + self._validators['dtick'] = v_aaxis.DtickValidator() + self._validators['exponentformat'] = v_aaxis.ExponentformatValidator() + self._validators['gridcolor'] = v_aaxis.GridcolorValidator() + self._validators['gridwidth'] = v_aaxis.GridwidthValidator() + self._validators['hoverformat'] = v_aaxis.HoverformatValidator() + self._validators['layer'] = v_aaxis.LayerValidator() + self._validators['linecolor'] = v_aaxis.LinecolorValidator() + self._validators['linewidth'] = v_aaxis.LinewidthValidator() + self._validators['min'] = v_aaxis.MinValidator() + self._validators['nticks'] = v_aaxis.NticksValidator() + self._validators['separatethousands' + ] = v_aaxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_aaxis.ShowexponentValidator() + self._validators['showgrid'] = v_aaxis.ShowgridValidator() + self._validators['showline'] = v_aaxis.ShowlineValidator() + self._validators['showticklabels'] = v_aaxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_aaxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_aaxis.ShowticksuffixValidator() + self._validators['tick0'] = v_aaxis.Tick0Validator() + self._validators['tickangle'] = v_aaxis.TickangleValidator() + self._validators['tickcolor'] = v_aaxis.TickcolorValidator() + self._validators['tickfont'] = v_aaxis.TickfontValidator() + self._validators['tickformat'] = v_aaxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_aaxis.TickformatstopsValidator() + self._validators['ticklen'] = v_aaxis.TicklenValidator() + self._validators['tickmode'] = v_aaxis.TickmodeValidator() + self._validators['tickprefix'] = v_aaxis.TickprefixValidator() + self._validators['ticks'] = v_aaxis.TicksValidator() + self._validators['ticksuffix'] = v_aaxis.TicksuffixValidator() + self._validators['ticktext'] = v_aaxis.TicktextValidator() + self._validators['ticktextsrc'] = v_aaxis.TicktextsrcValidator() + self._validators['tickvals'] = v_aaxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_aaxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_aaxis.TickwidthValidator() + self._validators['title'] = v_aaxis.TitleValidator() + self._validators['titlefont'] = v_aaxis.TitlefontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('min', None) + self.min = min if min is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/_baxis.py b/plotly/graph_objs/layout/ternary/_baxis.py new file mode 100644 index 0000000000..2dabcce932 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/_baxis.py @@ -0,0 +1,1575 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Baxis(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # min + # --- + @property + def min(self): + """ + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the other two + axes. The full view corresponds to all the minima set to zero. + + The 'min' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['min'] + + @min.setter + def min(self, val): + self['min'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.baxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.baxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.ternary.baxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.ternary.baxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.baxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.baxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.baxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + """ + + def __init__( + self, + arg=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + min=None, + nticks=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + **kwargs + ): + """ + Construct a new Baxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.ternary.Baxis + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.baxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + Baxis + """ + super(Baxis, self).__init__('baxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.Baxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.Baxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary import (baxis as v_baxis) + + # Initialize validators + # --------------------- + self._validators['color'] = v_baxis.ColorValidator() + self._validators['dtick'] = v_baxis.DtickValidator() + self._validators['exponentformat'] = v_baxis.ExponentformatValidator() + self._validators['gridcolor'] = v_baxis.GridcolorValidator() + self._validators['gridwidth'] = v_baxis.GridwidthValidator() + self._validators['hoverformat'] = v_baxis.HoverformatValidator() + self._validators['layer'] = v_baxis.LayerValidator() + self._validators['linecolor'] = v_baxis.LinecolorValidator() + self._validators['linewidth'] = v_baxis.LinewidthValidator() + self._validators['min'] = v_baxis.MinValidator() + self._validators['nticks'] = v_baxis.NticksValidator() + self._validators['separatethousands' + ] = v_baxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_baxis.ShowexponentValidator() + self._validators['showgrid'] = v_baxis.ShowgridValidator() + self._validators['showline'] = v_baxis.ShowlineValidator() + self._validators['showticklabels'] = v_baxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_baxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_baxis.ShowticksuffixValidator() + self._validators['tick0'] = v_baxis.Tick0Validator() + self._validators['tickangle'] = v_baxis.TickangleValidator() + self._validators['tickcolor'] = v_baxis.TickcolorValidator() + self._validators['tickfont'] = v_baxis.TickfontValidator() + self._validators['tickformat'] = v_baxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_baxis.TickformatstopsValidator() + self._validators['ticklen'] = v_baxis.TicklenValidator() + self._validators['tickmode'] = v_baxis.TickmodeValidator() + self._validators['tickprefix'] = v_baxis.TickprefixValidator() + self._validators['ticks'] = v_baxis.TicksValidator() + self._validators['ticksuffix'] = v_baxis.TicksuffixValidator() + self._validators['ticktext'] = v_baxis.TicktextValidator() + self._validators['ticktextsrc'] = v_baxis.TicktextsrcValidator() + self._validators['tickvals'] = v_baxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_baxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_baxis.TickwidthValidator() + self._validators['title'] = v_baxis.TitleValidator() + self._validators['titlefont'] = v_baxis.TitlefontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('min', None) + self.min = min if min is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/_caxis.py b/plotly/graph_objs/layout/ternary/_caxis.py new file mode 100644 index 0000000000..58cd65500b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/_caxis.py @@ -0,0 +1,1575 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Caxis(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets default for all colors associated with this axis all at + once: line, font, tick, and grid colors. Grid color is + lightened by blending this with the plot background Individual + pieces can override this. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # gridcolor + # --------- + @property + def gridcolor(self): + """ + Sets the color of the grid lines. + + The 'gridcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['gridcolor'] + + @gridcolor.setter + def gridcolor(self, val): + self['gridcolor'] = val + + # gridwidth + # --------- + @property + def gridwidth(self): + """ + Sets the width (in px) of the grid lines. + + The 'gridwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['gridwidth'] + + @gridwidth.setter + def gridwidth(self, val): + self['gridwidth'] = val + + # hoverformat + # ----------- + @property + def hoverformat(self): + """ + Sets the hover text formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'hoverformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['hoverformat'] + + @hoverformat.setter + def hoverformat(self, val): + self['hoverformat'] = val + + # layer + # ----- + @property + def layer(self): + """ + Sets the layer on which this axis is displayed. If *above + traces*, this axis is displayed above all the subplot's traces + If *below traces*, this axis is displayed below all the + subplot's traces, but above the grid lines. Useful when used + together with scatter-like traces with `cliponaxis` set to + *false* to show markers and/or text nodes above this axis. + + The 'layer' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['above traces', 'below traces'] + + Returns + ------- + Any + """ + return self['layer'] + + @layer.setter + def layer(self, val): + self['layer'] = val + + # linecolor + # --------- + @property + def linecolor(self): + """ + Sets the axis line color. + + The 'linecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['linecolor'] + + @linecolor.setter + def linecolor(self, val): + self['linecolor'] = val + + # linewidth + # --------- + @property + def linewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'linewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['linewidth'] + + @linewidth.setter + def linewidth(self, val): + self['linewidth'] = val + + # min + # --- + @property + def min(self): + """ + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the other two + axes. The full view corresponds to all the minima set to zero. + + The 'min' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['min'] + + @min.setter + def min(self, val): + self['min'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [1, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showgrid + # -------- + @property + def showgrid(self): + """ + Determines whether or not grid lines are drawn. If *true*, the + grid lines are drawn at every tick mark. + + The 'showgrid' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showgrid'] + + @showgrid.setter + def showgrid(self, val): + self['showgrid'] = val + + # showline + # -------- + @property + def showline(self): + """ + Determines whether or not a line bounding this axis is drawn. + + The 'showline' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showline'] + + @showline.setter + def showline(self, val): + self['showline'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the tick font. + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.caxis.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.caxis.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.ternary.caxis.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.layout.ternary.caxis.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of this axis. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this axis' title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.layout.ternary.caxis.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.ternary.caxis.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.caxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + """ + + def __init__( + self, + arg=None, + color=None, + dtick=None, + exponentformat=None, + gridcolor=None, + gridwidth=None, + hoverformat=None, + layer=None, + linecolor=None, + linewidth=None, + min=None, + nticks=None, + separatethousands=None, + showexponent=None, + showgrid=None, + showline=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + **kwargs + ): + """ + Construct a new Caxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.ternary.Caxis + color + Sets default for all colors associated with this axis + all at once: line, font, tick, and grid colors. Grid + color is lightened by blending this with the plot + background Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + layer + Sets the layer on which this axis is displayed. If + *above traces*, this axis is displayed above all the + subplot's traces If *below traces*, this axis is + displayed below all the subplot's traces, but above the + grid lines. Useful when used together with scatter-like + traces with `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The maximum is + determined by the sum minus the minimum values of the + other two axes. The full view corresponds to all the + minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showgrid + Determines whether or not grid lines are drawn. If + *true*, the grid lines are drawn at every tick mark. + showline + Determines whether or not a line bounding this axis is + drawn. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.caxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + + Returns + ------- + Caxis + """ + super(Caxis, self).__init__('caxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.Caxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.Caxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary import (caxis as v_caxis) + + # Initialize validators + # --------------------- + self._validators['color'] = v_caxis.ColorValidator() + self._validators['dtick'] = v_caxis.DtickValidator() + self._validators['exponentformat'] = v_caxis.ExponentformatValidator() + self._validators['gridcolor'] = v_caxis.GridcolorValidator() + self._validators['gridwidth'] = v_caxis.GridwidthValidator() + self._validators['hoverformat'] = v_caxis.HoverformatValidator() + self._validators['layer'] = v_caxis.LayerValidator() + self._validators['linecolor'] = v_caxis.LinecolorValidator() + self._validators['linewidth'] = v_caxis.LinewidthValidator() + self._validators['min'] = v_caxis.MinValidator() + self._validators['nticks'] = v_caxis.NticksValidator() + self._validators['separatethousands' + ] = v_caxis.SeparatethousandsValidator() + self._validators['showexponent'] = v_caxis.ShowexponentValidator() + self._validators['showgrid'] = v_caxis.ShowgridValidator() + self._validators['showline'] = v_caxis.ShowlineValidator() + self._validators['showticklabels'] = v_caxis.ShowticklabelsValidator() + self._validators['showtickprefix'] = v_caxis.ShowtickprefixValidator() + self._validators['showticksuffix'] = v_caxis.ShowticksuffixValidator() + self._validators['tick0'] = v_caxis.Tick0Validator() + self._validators['tickangle'] = v_caxis.TickangleValidator() + self._validators['tickcolor'] = v_caxis.TickcolorValidator() + self._validators['tickfont'] = v_caxis.TickfontValidator() + self._validators['tickformat'] = v_caxis.TickformatValidator() + self._validators['tickformatstops' + ] = v_caxis.TickformatstopsValidator() + self._validators['ticklen'] = v_caxis.TicklenValidator() + self._validators['tickmode'] = v_caxis.TickmodeValidator() + self._validators['tickprefix'] = v_caxis.TickprefixValidator() + self._validators['ticks'] = v_caxis.TicksValidator() + self._validators['ticksuffix'] = v_caxis.TicksuffixValidator() + self._validators['ticktext'] = v_caxis.TicktextValidator() + self._validators['ticktextsrc'] = v_caxis.TicktextsrcValidator() + self._validators['tickvals'] = v_caxis.TickvalsValidator() + self._validators['tickvalssrc'] = v_caxis.TickvalssrcValidator() + self._validators['tickwidth'] = v_caxis.TickwidthValidator() + self._validators['title'] = v_caxis.TitleValidator() + self._validators['titlefont'] = v_caxis.TitlefontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('gridcolor', None) + self.gridcolor = gridcolor if gridcolor is not None else v + v = arg.pop('gridwidth', None) + self.gridwidth = gridwidth if gridwidth is not None else v + v = arg.pop('hoverformat', None) + self.hoverformat = hoverformat if hoverformat is not None else v + v = arg.pop('layer', None) + self.layer = layer if layer is not None else v + v = arg.pop('linecolor', None) + self.linecolor = linecolor if linecolor is not None else v + v = arg.pop('linewidth', None) + self.linewidth = linewidth if linewidth is not None else v + v = arg.pop('min', None) + self.min = min if min is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showgrid', None) + self.showgrid = showgrid if showgrid is not None else v + v = arg.pop('showline', None) + self.showline = showline if showline is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/_domain.py b/plotly/graph_objs/layout/ternary/_domain.py new file mode 100644 index 0000000000..dba4523078 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Domain(BaseLayoutHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this ternary subplot . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this ternary subplot . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this ternary subplot (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this ternary subplot (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this ternary subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this ternary subplot . + x + Sets the horizontal domain of this ternary subplot (in + plot fraction). + y + Sets the vertical domain of this ternary subplot (in + plot fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.ternary.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this ternary subplot . + row + If there is a layout grid, use the domain for this row + in the grid for this ternary subplot . + x + Sets the horizontal domain of this ternary subplot (in + plot fraction). + y + Sets the vertical domain of this ternary subplot (in + plot fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.Domain +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/aaxis/__init__.py b/plotly/graph_objs/layout/ternary/aaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/aaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/ternary/aaxis/_tickfont.py b/plotly/graph_objs/layout/ternary/aaxis/_tickfont.py new file mode 100644 index 0000000000..8b62b9271f --- /dev/null +++ b/plotly/graph_objs/layout/ternary/aaxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.aaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.aaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.aaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.aaxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/aaxis/_tickformatstop.py b/plotly/graph_objs/layout/ternary/aaxis/_tickformatstop.py new file mode 100644 index 0000000000..9930958de2 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/aaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.aaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.aaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.aaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.aaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/aaxis/_titlefont.py b/plotly/graph_objs/layout/ternary/aaxis/_titlefont.py new file mode 100644 index 0000000000..db1d34fb8b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/aaxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.aaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.aaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.aaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.aaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.aaxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/baxis/__init__.py b/plotly/graph_objs/layout/ternary/baxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/baxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/ternary/baxis/_tickfont.py b/plotly/graph_objs/layout/ternary/baxis/_tickfont.py new file mode 100644 index 0000000000..8996a6aaec --- /dev/null +++ b/plotly/graph_objs/layout/ternary/baxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.baxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.baxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.baxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.baxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/baxis/_tickformatstop.py b/plotly/graph_objs/layout/ternary/baxis/_tickformatstop.py new file mode 100644 index 0000000000..f0dcc4fa2d --- /dev/null +++ b/plotly/graph_objs/layout/ternary/baxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.baxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.baxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.baxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.baxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/baxis/_titlefont.py b/plotly/graph_objs/layout/ternary/baxis/_titlefont.py new file mode 100644 index 0000000000..ab65440660 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/baxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.baxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.baxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.baxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.baxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.baxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/caxis/__init__.py b/plotly/graph_objs/layout/ternary/caxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/caxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/ternary/caxis/_tickfont.py b/plotly/graph_objs/layout/ternary/caxis/_tickfont.py new file mode 100644 index 0000000000..5a0116b89b --- /dev/null +++ b/plotly/graph_objs/layout/ternary/caxis/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.caxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.caxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.caxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.caxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.caxis import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/caxis/_tickformatstop.py b/plotly/graph_objs/layout/ternary/caxis/_tickformatstop.py new file mode 100644 index 0000000000..1870380554 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/caxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.caxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.caxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.caxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.caxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.caxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/ternary/caxis/_titlefont.py b/plotly/graph_objs/layout/ternary/caxis/_titlefont.py new file mode 100644 index 0000000000..e64a74ffb7 --- /dev/null +++ b/plotly/graph_objs/layout/ternary/caxis/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.ternary.caxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.ternary.caxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.ternary.caxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.ternary.caxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.ternary.caxis import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/updatemenu/__init__.py b/plotly/graph_objs/layout/updatemenu/__init__.py new file mode 100644 index 0000000000..61834a378e --- /dev/null +++ b/plotly/graph_objs/layout/updatemenu/__init__.py @@ -0,0 +1,3 @@ +from ._pad import Pad +from ._font import Font +from ._button import Button diff --git a/plotly/graph_objs/layout/updatemenu/_button.py b/plotly/graph_objs/layout/updatemenu/_button.py new file mode 100644 index 0000000000..48852ae788 --- /dev/null +++ b/plotly/graph_objs/layout/updatemenu/_button.py @@ -0,0 +1,224 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Button(BaseLayoutHierarchyType): + + # args + # ---- + @property + def args(self): + """ + Sets the arguments values to be passed to the Plotly method set + in `method` on click. + + The 'args' property is an info array that may be specified as a + list or tuple of up to 3 elements where: + + (0) The 'args[0]' property accepts values of any type + (1) The 'args[1]' property accepts values of any type + (2) The 'args[2]' property accepts values of any type + + Returns + ------- + list + """ + return self['args'] + + @args.setter + def args(self, val): + self['args'] = val + + # execute + # ------- + @property + def execute(self): + """ + When true, the API method is executed. When false, all other + behaviors are the same and command execution is skipped. This + may be useful when hooking into, for example, the + `plotly_buttonclicked` method and executing the API command + manually without losing the benefit of the updatemenu + automatically binding to the state of the plot through the + specification of `method` and `args`. + + The 'execute' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['execute'] + + @execute.setter + def execute(self, val): + self['execute'] = val + + # label + # ----- + @property + def label(self): + """ + Sets the text label to appear on the button. + + The 'label' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # method + # ------ + @property + def method(self): + """ + Sets the Plotly method to be called on click. If the `skip` + method is used, the API updatemenu will function as normal but + will perform no API calls and will not bind automatically to + state updates. This may be used to create a component interface + and attach to updatemenu events manually via JavaScript. + + The 'method' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['restyle', 'relayout', 'animate', 'update', 'skip'] + + Returns + ------- + Any + """ + return self['method'] + + @method.setter + def method(self, val): + self['method'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.updatemenu' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + args + Sets the arguments values to be passed to the Plotly + method set in `method` on click. + execute + When true, the API method is executed. When false, all + other behaviors are the same and command execution is + skipped. This may be useful when hooking into, for + example, the `plotly_buttonclicked` method and + executing the API command manually without losing the + benefit of the updatemenu automatically binding to the + state of the plot through the specification of `method` + and `args`. + label + Sets the text label to appear on the button. + method + Sets the Plotly method to be called on click. If the + `skip` method is used, the API updatemenu will function + as normal but will perform no API calls and will not + bind automatically to state updates. This may be used + to create a component interface and attach to + updatemenu events manually via JavaScript. + """ + + def __init__( + self, + arg=None, + args=None, + execute=None, + label=None, + method=None, + **kwargs + ): + """ + Construct a new Button object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.updatemenu.Button + args + Sets the arguments values to be passed to the Plotly + method set in `method` on click. + execute + When true, the API method is executed. When false, all + other behaviors are the same and command execution is + skipped. This may be useful when hooking into, for + example, the `plotly_buttonclicked` method and + executing the API command manually without losing the + benefit of the updatemenu automatically binding to the + state of the plot through the specification of `method` + and `args`. + label + Sets the text label to appear on the button. + method + Sets the Plotly method to be called on click. If the + `skip` method is used, the API updatemenu will function + as normal but will perform no API calls and will not + bind automatically to state updates. This may be used + to create a component interface and attach to + updatemenu events manually via JavaScript. + + Returns + ------- + Button + """ + super(Button, self).__init__('buttons') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.updatemenu.Button +constructor must be a dict or +an instance of plotly.graph_objs.layout.updatemenu.Button""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.updatemenu import (button as v_button) + + # Initialize validators + # --------------------- + self._validators['args'] = v_button.ArgsValidator() + self._validators['execute'] = v_button.ExecuteValidator() + self._validators['label'] = v_button.LabelValidator() + self._validators['method'] = v_button.MethodValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('args', None) + self.args = args if args is not None else v + v = arg.pop('execute', None) + self.execute = execute if execute is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('method', None) + self.method = method if method is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/updatemenu/_font.py b/plotly/graph_objs/layout/updatemenu/_font.py new file mode 100644 index 0000000000..df30a50f7e --- /dev/null +++ b/plotly/graph_objs/layout/updatemenu/_font.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.updatemenu' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the font of the update menu button text. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.updatemenu.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.updatemenu.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.updatemenu.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.updatemenu import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/updatemenu/_pad.py b/plotly/graph_objs/layout/updatemenu/_pad.py new file mode 100644 index 0000000000..2150e9fb2d --- /dev/null +++ b/plotly/graph_objs/layout/updatemenu/_pad.py @@ -0,0 +1,185 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Pad(BaseLayoutHierarchyType): + + # b + # - + @property + def b(self): + """ + The amount of padding (in px) along the bottom of the + component. + + The 'b' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['b'] + + @b.setter + def b(self, val): + self['b'] = val + + # l + # - + @property + def l(self): + """ + The amount of padding (in px) on the left side of the + component. + + The 'l' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['l'] + + @l.setter + def l(self, val): + self['l'] = val + + # r + # - + @property + def r(self): + """ + The amount of padding (in px) on the right side of the + component. + + The 'r' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['r'] + + @r.setter + def r(self, val): + self['r'] = val + + # t + # - + @property + def t(self): + """ + The amount of padding (in px) along the top of the component. + + The 't' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['t'] + + @t.setter + def t(self, val): + self['t'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.updatemenu' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + b + The amount of padding (in px) along the bottom of the + component. + l + The amount of padding (in px) on the left side of the + component. + r + The amount of padding (in px) on the right side of the + component. + t + The amount of padding (in px) along the top of the + component. + """ + + def __init__(self, arg=None, b=None, l=None, r=None, t=None, **kwargs): + """ + Construct a new Pad object + + Sets the padding around the buttons or dropdown menu. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.updatemenu.Pad + b + The amount of padding (in px) along the bottom of the + component. + l + The amount of padding (in px) on the left side of the + component. + r + The amount of padding (in px) on the right side of the + component. + t + The amount of padding (in px) along the top of the + component. + + Returns + ------- + Pad + """ + super(Pad, self).__init__('pad') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.updatemenu.Pad +constructor must be a dict or +an instance of plotly.graph_objs.layout.updatemenu.Pad""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.updatemenu import (pad as v_pad) + + # Initialize validators + # --------------------- + self._validators['b'] = v_pad.BValidator() + self._validators['l'] = v_pad.LValidator() + self._validators['r'] = v_pad.RValidator() + self._validators['t'] = v_pad.TValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('b', None) + self.b = b if b is not None else v + v = arg.pop('l', None) + self.l = l if l is not None else v + v = arg.pop('r', None) + self.r = r if r is not None else v + v = arg.pop('t', None) + self.t = t if t is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/__init__.py b/plotly/graph_objs/layout/xaxis/__init__.py new file mode 100644 index 0000000000..e113871b91 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/__init__.py @@ -0,0 +1,7 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont +from ._rangeslider import Rangeslider +from plotly.graph_objs.layout.xaxis import rangeslider +from ._rangeselector import Rangeselector +from plotly.graph_objs.layout.xaxis import rangeselector diff --git a/plotly/graph_objs/layout/xaxis/_rangeselector.py b/plotly/graph_objs/layout/xaxis/_rangeselector.py new file mode 100644 index 0000000000..72dd0995d7 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/_rangeselector.py @@ -0,0 +1,589 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Rangeselector(BaseLayoutHierarchyType): + + # activecolor + # ----------- + @property + def activecolor(self): + """ + Sets the background color of the active range selector button. + + The 'activecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['activecolor'] + + @activecolor.setter + def activecolor(self, val): + self['activecolor'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the range selector buttons. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the color of the border enclosing the range selector. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) of the border enclosing the range + selector. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # buttons + # ------- + @property + def buttons(self): + """ + Sets the specifications for each buttons. By default, a range + selector comes with no buttons. + + The 'buttons' property is a tuple of instances of + Button that may be specified as: + - A list or tuple of instances of plotly.graph_objs.layout.xaxis.rangeselector.Button + - A list or tuple of dicts of string/value properties that + will be passed to the Button constructor + + Supported dict properties: + + count + Sets the number of steps to take to update the + range. Use with `step` to specify the update + interval. + label + Sets the text label to appear on the button. + step + The unit of measurement that the `count` value + will set the range by. + stepmode + Sets the range update mode. If *backward*, the + range update shifts the start of range back + *count* times *step* milliseconds. If *todate*, + the range update shifts the start of range back + to the first timestamp from *count* times + *step* milliseconds back. For example, with + `step` set to *year* and `count` set to *1* the + range update shifts the start of the range back + to January 01 of the current year. Month and + year *todate* are currently available only for + the built-in (Gregorian) calendar. + + Returns + ------- + tuple[plotly.graph_objs.layout.xaxis.rangeselector.Button] + """ + return self['buttons'] + + @buttons.setter + def buttons(self, val): + self['buttons'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font of the range selector button text. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.rangeselector.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.layout.xaxis.rangeselector.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this range selector is visible. Note + that range selectors are only available for x axes of `type` + set to or auto-typed to *date*. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position (in normalized coordinates) of the range + selector. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets the range selector's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* or + *right* of the range selector. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position (in normalized coordinates) of the range + selector. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets the range selector's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the range selector. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + activecolor + Sets the background color of the active range selector + button. + bgcolor + Sets the background color of the range selector + buttons. + bordercolor + Sets the color of the border enclosing the range + selector. + borderwidth + Sets the width (in px) of the border enclosing the + range selector. + buttons + Sets the specifications for each buttons. By default, a + range selector comes with no buttons. + font + Sets the font of the range selector button text. + visible + Determines whether or not this range selector is + visible. Note that range selectors are only available + for x axes of `type` set to or auto-typed to *date*. + x + Sets the x position (in normalized coordinates) of the + range selector. + xanchor + Sets the range selector's horizontal position anchor. + This anchor binds the `x` position to the *left*, + *center* or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + range selector. + yanchor + Sets the range selector's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + """ + + def __init__( + self, + arg=None, + activecolor=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + buttons=None, + font=None, + visible=None, + x=None, + xanchor=None, + y=None, + yanchor=None, + **kwargs + ): + """ + Construct a new Rangeselector object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.Rangeselector + activecolor + Sets the background color of the active range selector + button. + bgcolor + Sets the background color of the range selector + buttons. + bordercolor + Sets the color of the border enclosing the range + selector. + borderwidth + Sets the width (in px) of the border enclosing the + range selector. + buttons + Sets the specifications for each buttons. By default, a + range selector comes with no buttons. + font + Sets the font of the range selector button text. + visible + Determines whether or not this range selector is + visible. Note that range selectors are only available + for x axes of `type` set to or auto-typed to *date*. + x + Sets the x position (in normalized coordinates) of the + range selector. + xanchor + Sets the range selector's horizontal position anchor. + This anchor binds the `x` position to the *left*, + *center* or *right* of the range selector. + y + Sets the y position (in normalized coordinates) of the + range selector. + yanchor + Sets the range selector's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the range selector. + + Returns + ------- + Rangeselector + """ + super(Rangeselector, self).__init__('rangeselector') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.Rangeselector +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.Rangeselector""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis import ( + rangeselector as v_rangeselector + ) + + # Initialize validators + # --------------------- + self._validators['activecolor' + ] = v_rangeselector.ActivecolorValidator() + self._validators['bgcolor'] = v_rangeselector.BgcolorValidator() + self._validators['bordercolor' + ] = v_rangeselector.BordercolorValidator() + self._validators['borderwidth' + ] = v_rangeselector.BorderwidthValidator() + self._validators['buttons'] = v_rangeselector.ButtonsValidator() + self._validators['font'] = v_rangeselector.FontValidator() + self._validators['visible'] = v_rangeselector.VisibleValidator() + self._validators['x'] = v_rangeselector.XValidator() + self._validators['xanchor'] = v_rangeselector.XanchorValidator() + self._validators['y'] = v_rangeselector.YValidator() + self._validators['yanchor'] = v_rangeselector.YanchorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('activecolor', None) + self.activecolor = activecolor if activecolor is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('buttons', None) + self.buttons = buttons if buttons is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/_rangeslider.py b/plotly/graph_objs/layout/xaxis/_rangeslider.py new file mode 100644 index 0000000000..0f53e04c7b --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/_rangeslider.py @@ -0,0 +1,431 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Rangeslider(BaseLayoutHierarchyType): + + # autorange + # --------- + @property + def autorange(self): + """ + Determines whether or not the range slider range is computed in + relation to the input data. If `range` is provided, then + `autorange` is set to *false*. + + The 'autorange' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autorange'] + + @autorange.setter + def autorange(self, val): + self['autorange'] = val + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the range slider. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the range slider. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the border color of the range slider. + + The 'borderwidth' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # range + # ----- + @property + def range(self): + """ + Sets the range of the range slider. If not set, defaults to the + full xaxis range. If the axis `type` is *log*, then you must + take the log of your desired range. If the axis `type` is + *date*, it should be date strings, like date data, though Date + objects and unix milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it should be + numbers, using the scale where each category is assigned a + serial number from zero in the order it appears. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + The height of the range slider as a fraction of the total plot + area height. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not the range slider will be visible. If + visible, perpendicular axes will be set to `fixedrange` + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # yaxis + # ----- + @property + def yaxis(self): + """ + The 'yaxis' property is an instance of YAxis + that may be specified as: + - An instance of plotly.graph_objs.layout.xaxis.rangeslider.YAxis + - A dict of string/value properties that will be passed + to the YAxis constructor + + Supported dict properties: + + range + Sets the range of this axis for the + rangeslider. + rangemode + Determines whether or not the range of this + axis in the rangeslider use the same value than + in the main plot when zooming in/out. If + *auto*, the autorange will be used. If *fixed*, + the `range` is used. If *match*, the current + range of the corresponding y-axis on the main + subplot is used. + + Returns + ------- + plotly.graph_objs.layout.xaxis.rangeslider.YAxis + """ + return self['yaxis'] + + @yaxis.setter + def yaxis(self, val): + self['yaxis'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autorange + Determines whether or not the range slider range is + computed in relation to the input data. If `range` is + provided, then `autorange` is set to *false*. + bgcolor + Sets the background color of the range slider. + bordercolor + Sets the border color of the range slider. + borderwidth + Sets the border color of the range slider. + range + Sets the range of the range slider. If not set, + defaults to the full xaxis range. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + thickness + The height of the range slider as a fraction of the + total plot area height. + visible + Determines whether or not the range slider will be + visible. If visible, perpendicular axes will be set to + `fixedrange` + yaxis + plotly.graph_objs.layout.xaxis.rangeslider.YAxis + instance or dict with compatible properties + """ + + def __init__( + self, + arg=None, + autorange=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + range=None, + thickness=None, + visible=None, + yaxis=None, + **kwargs + ): + """ + Construct a new Rangeslider object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.Rangeslider + autorange + Determines whether or not the range slider range is + computed in relation to the input data. If `range` is + provided, then `autorange` is set to *false*. + bgcolor + Sets the background color of the range slider. + bordercolor + Sets the border color of the range slider. + borderwidth + Sets the border color of the range slider. + range + Sets the range of the range slider. If not set, + defaults to the full xaxis range. If the axis `type` is + *log*, then you must take the log of your desired + range. If the axis `type` is *date*, it should be date + strings, like date data, though Date objects and unix + milliseconds will be accepted and converted to strings. + If the axis `type` is *category*, it should be numbers, + using the scale where each category is assigned a + serial number from zero in the order it appears. + thickness + The height of the range slider as a fraction of the + total plot area height. + visible + Determines whether or not the range slider will be + visible. If visible, perpendicular axes will be set to + `fixedrange` + yaxis + plotly.graph_objs.layout.xaxis.rangeslider.YAxis + instance or dict with compatible properties + + Returns + ------- + Rangeslider + """ + super(Rangeslider, self).__init__('rangeslider') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.Rangeslider +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.Rangeslider""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis import ( + rangeslider as v_rangeslider + ) + + # Initialize validators + # --------------------- + self._validators['autorange'] = v_rangeslider.AutorangeValidator() + self._validators['bgcolor'] = v_rangeslider.BgcolorValidator() + self._validators['bordercolor'] = v_rangeslider.BordercolorValidator() + self._validators['borderwidth'] = v_rangeslider.BorderwidthValidator() + self._validators['range'] = v_rangeslider.RangeValidator() + self._validators['thickness'] = v_rangeslider.ThicknessValidator() + self._validators['visible'] = v_rangeslider.VisibleValidator() + self._validators['yaxis'] = v_rangeslider.YAxisValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autorange', None) + self.autorange = autorange if autorange is not None else v + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('yaxis', None) + self.yaxis = yaxis if yaxis is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/_tickfont.py b/plotly/graph_objs/layout/xaxis/_tickfont.py new file mode 100644 index 0000000000..75e37a309a --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.xaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/_tickformatstop.py b/plotly/graph_objs/layout/xaxis/_tickformatstop.py new file mode 100644 index 0000000000..3a3f1c2850 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/_titlefont.py b/plotly/graph_objs/layout/xaxis/_titlefont.py new file mode 100644 index 0000000000..728f606eb8 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/_titlefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.xaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/rangeselector/__init__.py b/plotly/graph_objs/layout/xaxis/rangeselector/__init__.py new file mode 100644 index 0000000000..1cf74165a9 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/rangeselector/__init__.py @@ -0,0 +1,2 @@ +from ._font import Font +from ._button import Button diff --git a/plotly/graph_objs/layout/xaxis/rangeselector/_button.py b/plotly/graph_objs/layout/xaxis/rangeselector/_button.py new file mode 100644 index 0000000000..9346746581 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/rangeselector/_button.py @@ -0,0 +1,222 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Button(BaseLayoutHierarchyType): + + # count + # ----- + @property + def count(self): + """ + Sets the number of steps to take to update the range. Use with + `step` to specify the update interval. + + The 'count' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['count'] + + @count.setter + def count(self, val): + self['count'] = val + + # label + # ----- + @property + def label(self): + """ + Sets the text label to appear on the button. + + The 'label' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # step + # ---- + @property + def step(self): + """ + The unit of measurement that the `count` value will set the + range by. + + The 'step' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['month', 'year', 'day', 'hour', 'minute', 'second', + 'all'] + + Returns + ------- + Any + """ + return self['step'] + + @step.setter + def step(self, val): + self['step'] = val + + # stepmode + # -------- + @property + def stepmode(self): + """ + Sets the range update mode. If *backward*, the range update + shifts the start of range back *count* times *step* + milliseconds. If *todate*, the range update shifts the start of + range back to the first timestamp from *count* times *step* + milliseconds back. For example, with `step` set to *year* and + `count` set to *1* the range update shifts the start of the + range back to January 01 of the current year. Month and year + *todate* are currently available only for the built-in + (Gregorian) calendar. + + The 'stepmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['backward', 'todate'] + + Returns + ------- + Any + """ + return self['stepmode'] + + @stepmode.setter + def stepmode(self, val): + self['stepmode'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis.rangeselector' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + count + Sets the number of steps to take to update the range. + Use with `step` to specify the update interval. + label + Sets the text label to appear on the button. + step + The unit of measurement that the `count` value will set + the range by. + stepmode + Sets the range update mode. If *backward*, the range + update shifts the start of range back *count* times + *step* milliseconds. If *todate*, the range update + shifts the start of range back to the first timestamp + from *count* times *step* milliseconds back. For + example, with `step` set to *year* and `count` set to + *1* the range update shifts the start of the range back + to January 01 of the current year. Month and year + *todate* are currently available only for the built-in + (Gregorian) calendar. + """ + + def __init__( + self, + arg=None, + count=None, + label=None, + step=None, + stepmode=None, + **kwargs + ): + """ + Construct a new Button object + + Sets the specifications for each buttons. By default, a range + selector comes with no buttons. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.rangeselector.Button + count + Sets the number of steps to take to update the range. + Use with `step` to specify the update interval. + label + Sets the text label to appear on the button. + step + The unit of measurement that the `count` value will set + the range by. + stepmode + Sets the range update mode. If *backward*, the range + update shifts the start of range back *count* times + *step* milliseconds. If *todate*, the range update + shifts the start of range back to the first timestamp + from *count* times *step* milliseconds back. For + example, with `step` set to *year* and `count` set to + *1* the range update shifts the start of the range back + to January 01 of the current year. Month and year + *todate* are currently available only for the built-in + (Gregorian) calendar. + + Returns + ------- + Button + """ + super(Button, self).__init__('buttons') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.rangeselector.Button +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.rangeselector.Button""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis.rangeselector import ( + button as v_button + ) + + # Initialize validators + # --------------------- + self._validators['count'] = v_button.CountValidator() + self._validators['label'] = v_button.LabelValidator() + self._validators['step'] = v_button.StepValidator() + self._validators['stepmode'] = v_button.StepmodeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('count', None) + self.count = count if count is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('step', None) + self.step = step if step is not None else v + v = arg.pop('stepmode', None) + self.stepmode = stepmode if stepmode is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/rangeselector/_font.py b/plotly/graph_objs/layout/xaxis/rangeselector/_font.py new file mode 100644 index 0000000000..daf75122b9 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/rangeselector/_font.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Font(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis.rangeselector' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Font object + + Sets the font of the range selector button text. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.rangeselector.Font + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.rangeselector.Font +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.rangeselector.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis.rangeselector import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['size'] = v_font.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/xaxis/rangeslider/__init__.py b/plotly/graph_objs/layout/xaxis/rangeslider/__init__.py new file mode 100644 index 0000000000..6e17affa81 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/rangeslider/__init__.py @@ -0,0 +1 @@ +from ._yaxis import YAxis diff --git a/plotly/graph_objs/layout/xaxis/rangeslider/_yaxis.py b/plotly/graph_objs/layout/xaxis/rangeslider/_yaxis.py new file mode 100644 index 0000000000..ce342fa689 --- /dev/null +++ b/plotly/graph_objs/layout/xaxis/rangeslider/_yaxis.py @@ -0,0 +1,139 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class YAxis(BaseLayoutHierarchyType): + + # range + # ----- + @property + def range(self): + """ + Sets the range of this axis for the rangeslider. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property accepts values of any type + (1) The 'range[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # rangemode + # --------- + @property + def rangemode(self): + """ + Determines whether or not the range of this axis in the + rangeslider use the same value than in the main plot when + zooming in/out. If *auto*, the autorange will be used. If + *fixed*, the `range` is used. If *match*, the current range of + the corresponding y-axis on the main subplot is used. + + The 'rangemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'fixed', 'match'] + + Returns + ------- + Any + """ + return self['rangemode'] + + @rangemode.setter + def rangemode(self, val): + self['rangemode'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.xaxis.rangeslider' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + range + Sets the range of this axis for the rangeslider. + rangemode + Determines whether or not the range of this axis in the + rangeslider use the same value than in the main plot + when zooming in/out. If *auto*, the autorange will be + used. If *fixed*, the `range` is used. If *match*, the + current range of the corresponding y-axis on the main + subplot is used. + """ + + def __init__(self, arg=None, range=None, rangemode=None, **kwargs): + """ + Construct a new YAxis object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.xaxis.rangeslider.YAxis + range + Sets the range of this axis for the rangeslider. + rangemode + Determines whether or not the range of this axis in the + rangeslider use the same value than in the main plot + when zooming in/out. If *auto*, the autorange will be + used. If *fixed*, the `range` is used. If *match*, the + current range of the corresponding y-axis on the main + subplot is used. + + Returns + ------- + YAxis + """ + super(YAxis, self).__init__('yaxis') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.xaxis.rangeslider.YAxis +constructor must be a dict or +an instance of plotly.graph_objs.layout.xaxis.rangeslider.YAxis""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.xaxis.rangeslider import ( + yaxis as v_yaxis + ) + + # Initialize validators + # --------------------- + self._validators['range'] = v_yaxis.RangeValidator() + self._validators['rangemode'] = v_yaxis.RangemodeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('rangemode', None) + self.rangemode = rangemode if rangemode is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/yaxis/__init__.py b/plotly/graph_objs/layout/yaxis/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/layout/yaxis/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/layout/yaxis/_tickfont.py b/plotly/graph_objs/layout/yaxis/_tickfont.py new file mode 100644 index 0000000000..51c5facd84 --- /dev/null +++ b/plotly/graph_objs/layout/yaxis/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickfont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the tick font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.yaxis.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.yaxis.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.layout.yaxis.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.yaxis import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/yaxis/_tickformatstop.py b/plotly/graph_objs/layout/yaxis/_tickformatstop.py new file mode 100644 index 0000000000..fd55e0e01f --- /dev/null +++ b/plotly/graph_objs/layout/yaxis/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Tickformatstop(BaseLayoutHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.layout.yaxis.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.yaxis.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.layout.yaxis.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.yaxis import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/layout/yaxis/_titlefont.py b/plotly/graph_objs/layout/yaxis/_titlefont.py new file mode 100644 index 0000000000..05460b3cc3 --- /dev/null +++ b/plotly/graph_objs/layout/yaxis/_titlefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseLayoutHierarchyType +import copy + + +class Titlefont(BaseLayoutHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'layout.yaxis' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this axis' title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.layout.yaxis.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.layout.yaxis.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.layout.yaxis.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.layout.yaxis import (titlefont as v_titlefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/__init__.py b/plotly/graph_objs/mesh3d/__init__.py new file mode 100644 index 0000000000..d9d1852c54 --- /dev/null +++ b/plotly/graph_objs/mesh3d/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._lightposition import Lightposition +from ._lighting import Lighting +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.mesh3d import hoverlabel +from ._contour import Contour +from ._colorbar import ColorBar +from plotly.graph_objs.mesh3d import colorbar diff --git a/plotly/graph_objs/mesh3d/_colorbar.py b/plotly/graph_objs/mesh3d/_colorbar.py new file mode 100644 index 0000000000..3e306d9b1b --- /dev/null +++ b/plotly/graph_objs/mesh3d/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.mesh3d.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.mesh3d.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.mesh3d.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.mesh3d.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.mesh3d.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.mesh3d.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/_contour.py b/plotly/graph_objs/mesh3d/_contour.py new file mode 100644 index 0000000000..035263d307 --- /dev/null +++ b/plotly/graph_objs/mesh3d/_contour.py @@ -0,0 +1,184 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Contour(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour lines. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # show + # ---- + @property + def show(self): + """ + Sets whether or not dynamic contours are shown on hover + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width of the contour lines. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour lines. + show + Sets whether or not dynamic contours are shown on hover + width + Sets the width of the contour lines. + """ + + def __init__(self, arg=None, color=None, show=None, width=None, **kwargs): + """ + Construct a new Contour object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.Contour + color + Sets the color of the contour lines. + show + Sets whether or not dynamic contours are shown on hover + width + Sets the width of the contour lines. + + Returns + ------- + Contour + """ + super(Contour, self).__init__('contour') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.Contour +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.Contour""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (contour as v_contour) + + # Initialize validators + # --------------------- + self._validators['color'] = v_contour.ColorValidator() + self._validators['show'] = v_contour.ShowValidator() + self._validators['width'] = v_contour.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/_hoverlabel.py b/plotly/graph_objs/mesh3d/_hoverlabel.py new file mode 100644 index 0000000000..78a2a1ecdf --- /dev/null +++ b/plotly/graph_objs/mesh3d/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.mesh3d.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.mesh3d.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/_lighting.py b/plotly/graph_objs/mesh3d/_lighting.py new file mode 100644 index 0000000000..9b44033d67 --- /dev/null +++ b/plotly/graph_objs/mesh3d/_lighting.py @@ -0,0 +1,292 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lighting(BaseTraceHierarchyType): + + # ambient + # ------- + @property + def ambient(self): + """ + Ambient light increases overall color visibility but can wash + out the image. + + The 'ambient' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['ambient'] + + @ambient.setter + def ambient(self, val): + self['ambient'] = val + + # diffuse + # ------- + @property + def diffuse(self): + """ + Represents the extent that incident rays are reflected in a + range of angles. + + The 'diffuse' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['diffuse'] + + @diffuse.setter + def diffuse(self, val): + self['diffuse'] = val + + # facenormalsepsilon + # ------------------ + @property + def facenormalsepsilon(self): + """ + Epsilon for face normals calculation avoids math issues arising + from degenerate geometry. + + The 'facenormalsepsilon' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['facenormalsepsilon'] + + @facenormalsepsilon.setter + def facenormalsepsilon(self, val): + self['facenormalsepsilon'] = val + + # fresnel + # ------- + @property + def fresnel(self): + """ + Represents the reflectance as a dependency of the viewing + angle; e.g. paper is reflective when viewing it from the edge + of the paper (almost 90 degrees), causing shine. + + The 'fresnel' property is a number and may be specified as: + - An int or float in the interval [0, 5] + + Returns + ------- + int|float + """ + return self['fresnel'] + + @fresnel.setter + def fresnel(self, val): + self['fresnel'] = val + + # roughness + # --------- + @property + def roughness(self): + """ + Alters specular reflection; the rougher the surface, the wider + and less contrasty the shine. + + The 'roughness' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['roughness'] + + @roughness.setter + def roughness(self, val): + self['roughness'] = val + + # specular + # -------- + @property + def specular(self): + """ + Represents the level that incident rays are reflected in a + single direction, causing shine. + + The 'specular' property is a number and may be specified as: + - An int or float in the interval [0, 2] + + Returns + ------- + int|float + """ + return self['specular'] + + @specular.setter + def specular(self, val): + self['specular'] = val + + # vertexnormalsepsilon + # -------------------- + @property + def vertexnormalsepsilon(self): + """ + Epsilon for vertex normals calculation avoids math issues + arising from degenerate geometry. + + The 'vertexnormalsepsilon' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['vertexnormalsepsilon'] + + @vertexnormalsepsilon.setter + def vertexnormalsepsilon(self, val): + self['vertexnormalsepsilon'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids math issues + arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids math + issues arising from degenerate geometry. + """ + + def __init__( + self, + arg=None, + ambient=None, + diffuse=None, + facenormalsepsilon=None, + fresnel=None, + roughness=None, + specular=None, + vertexnormalsepsilon=None, + **kwargs + ): + """ + Construct a new Lighting object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.Lighting + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids math issues + arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids math + issues arising from degenerate geometry. + + Returns + ------- + Lighting + """ + super(Lighting, self).__init__('lighting') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.Lighting +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.Lighting""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (lighting as v_lighting) + + # Initialize validators + # --------------------- + self._validators['ambient'] = v_lighting.AmbientValidator() + self._validators['diffuse'] = v_lighting.DiffuseValidator() + self._validators['facenormalsepsilon' + ] = v_lighting.FacenormalsepsilonValidator() + self._validators['fresnel'] = v_lighting.FresnelValidator() + self._validators['roughness'] = v_lighting.RoughnessValidator() + self._validators['specular'] = v_lighting.SpecularValidator() + self._validators['vertexnormalsepsilon' + ] = v_lighting.VertexnormalsepsilonValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('ambient', None) + self.ambient = ambient if ambient is not None else v + v = arg.pop('diffuse', None) + self.diffuse = diffuse if diffuse is not None else v + v = arg.pop('facenormalsepsilon', None) + self.facenormalsepsilon = facenormalsepsilon if facenormalsepsilon is not None else v + v = arg.pop('fresnel', None) + self.fresnel = fresnel if fresnel is not None else v + v = arg.pop('roughness', None) + self.roughness = roughness if roughness is not None else v + v = arg.pop('specular', None) + self.specular = specular if specular is not None else v + v = arg.pop('vertexnormalsepsilon', None) + self.vertexnormalsepsilon = vertexnormalsepsilon if vertexnormalsepsilon is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/_lightposition.py b/plotly/graph_objs/mesh3d/_lightposition.py new file mode 100644 index 0000000000..eb66e3ab45 --- /dev/null +++ b/plotly/graph_objs/mesh3d/_lightposition.py @@ -0,0 +1,151 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lightposition(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Numeric vector, representing the X coordinate for each vertex. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Numeric vector, representing the Y coordinate for each vertex. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Numeric vector, representing the Z coordinate for each vertex. + + The 'z' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Lightposition object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.Lightposition + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + + Returns + ------- + Lightposition + """ + super(Lightposition, self).__init__('lightposition') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.Lightposition +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.Lightposition""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (lightposition as v_lightposition) + + # Initialize validators + # --------------------- + self._validators['x'] = v_lightposition.XValidator() + self._validators['y'] = v_lightposition.YValidator() + self._validators['z'] = v_lightposition.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/_stream.py b/plotly/graph_objs/mesh3d/_stream.py new file mode 100644 index 0000000000..0997208a3c --- /dev/null +++ b/plotly/graph_objs/mesh3d/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.Stream +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/colorbar/__init__.py b/plotly/graph_objs/mesh3d/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/mesh3d/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/mesh3d/colorbar/_tickfont.py b/plotly/graph_objs/mesh3d/colorbar/_tickfont.py new file mode 100644 index 0000000000..6ff8a45bba --- /dev/null +++ b/plotly/graph_objs/mesh3d/colorbar/_tickfont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.mesh3d.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d.colorbar import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/colorbar/_tickformatstop.py b/plotly/graph_objs/mesh3d/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..bc4b486a4d --- /dev/null +++ b/plotly/graph_objs/mesh3d/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.mesh3d.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/colorbar/_titlefont.py b/plotly/graph_objs/mesh3d/colorbar/_titlefont.py new file mode 100644 index 0000000000..ae674bd5bf --- /dev/null +++ b/plotly/graph_objs/mesh3d/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.mesh3d.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/mesh3d/hoverlabel/__init__.py b/plotly/graph_objs/mesh3d/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/mesh3d/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/mesh3d/hoverlabel/_font.py b/plotly/graph_objs/mesh3d/hoverlabel/_font.py new file mode 100644 index 0000000000..026380109b --- /dev/null +++ b/plotly/graph_objs/mesh3d/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'mesh3d.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.mesh3d.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.mesh3d.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.mesh3d.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.mesh3d.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/__init__.py b/plotly/graph_objs/ohlc/__init__.py new file mode 100644 index 0000000000..54774dbc51 --- /dev/null +++ b/plotly/graph_objs/ohlc/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._line import Line +from ._increasing import Increasing +from plotly.graph_objs.ohlc import increasing +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.ohlc import hoverlabel +from ._decreasing import Decreasing +from plotly.graph_objs.ohlc import decreasing diff --git a/plotly/graph_objs/ohlc/_decreasing.py b/plotly/graph_objs/ohlc/_decreasing.py new file mode 100644 index 0000000000..d96acabc4d --- /dev/null +++ b/plotly/graph_objs/ohlc/_decreasing.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Decreasing(BaseTraceHierarchyType): + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.ohlc.decreasing.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.ohlc.decreasing.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + line + plotly.graph_objs.ohlc.decreasing.Line instance or dict + with compatible properties + """ + + def __init__(self, arg=None, line=None, **kwargs): + """ + Construct a new Decreasing object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.Decreasing + line + plotly.graph_objs.ohlc.decreasing.Line instance or dict + with compatible properties + + Returns + ------- + Decreasing + """ + super(Decreasing, self).__init__('decreasing') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.Decreasing +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.Decreasing""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc import (decreasing as v_decreasing) + + # Initialize validators + # --------------------- + self._validators['line'] = v_decreasing.LineValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('line', None) + self.line = line if line is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/_hoverlabel.py b/plotly/graph_objs/ohlc/_hoverlabel.py new file mode 100644 index 0000000000..edae802ffe --- /dev/null +++ b/plotly/graph_objs/ohlc/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.ohlc.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.ohlc.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/_increasing.py b/plotly/graph_objs/ohlc/_increasing.py new file mode 100644 index 0000000000..2ff83c99ca --- /dev/null +++ b/plotly/graph_objs/ohlc/_increasing.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Increasing(BaseTraceHierarchyType): + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.ohlc.increasing.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + plotly.graph_objs.ohlc.increasing.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + line + plotly.graph_objs.ohlc.increasing.Line instance or dict + with compatible properties + """ + + def __init__(self, arg=None, line=None, **kwargs): + """ + Construct a new Increasing object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.Increasing + line + plotly.graph_objs.ohlc.increasing.Line instance or dict + with compatible properties + + Returns + ------- + Increasing + """ + super(Increasing, self).__init__('increasing') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.Increasing +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.Increasing""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc import (increasing as v_increasing) + + # Initialize validators + # --------------------- + self._validators['line'] = v_increasing.LineValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('line', None) + self.line = line if line is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/_line.py b/plotly/graph_objs/ohlc/_line.py new file mode 100644 index 0000000000..3fc4d94738 --- /dev/null +++ b/plotly/graph_objs/ohlc/_line.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). Note that this style setting can also be + set per direction via `increasing.line.dash` and + `decreasing.line.dash`. + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + [object Object] Note that this style setting can also be set + per direction via `increasing.line.width` and + `decreasing.line.width`. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). Note that this style setting can + also be set per direction via `increasing.line.dash` + and `decreasing.line.dash`. + width + [object Object] Note that this style setting can also + be set per direction via `increasing.line.width` and + `decreasing.line.width`. + """ + + def __init__(self, arg=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.Line + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). Note that this style setting can + also be set per direction via `increasing.line.dash` + and `decreasing.line.dash`. + width + [object Object] Note that this style setting can also + be set per direction via `increasing.line.width` and + `decreasing.line.width`. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.Line +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/_stream.py b/plotly/graph_objs/ohlc/_stream.py new file mode 100644 index 0000000000..09b79c1e13 --- /dev/null +++ b/plotly/graph_objs/ohlc/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.Stream +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/decreasing/__init__.py b/plotly/graph_objs/ohlc/decreasing/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/ohlc/decreasing/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/ohlc/decreasing/_line.py b/plotly/graph_objs/ohlc/decreasing/_line.py new file mode 100644 index 0000000000..69df74ed8e --- /dev/null +++ b/plotly/graph_objs/ohlc/decreasing/_line.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc.decreasing' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.decreasing.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.decreasing.Line +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.decreasing.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc.decreasing import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/hoverlabel/__init__.py b/plotly/graph_objs/ohlc/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/ohlc/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/ohlc/hoverlabel/_font.py b/plotly/graph_objs/ohlc/hoverlabel/_font.py new file mode 100644 index 0000000000..b197b9e24e --- /dev/null +++ b/plotly/graph_objs/ohlc/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/ohlc/increasing/__init__.py b/plotly/graph_objs/ohlc/increasing/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/ohlc/increasing/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/ohlc/increasing/_line.py b/plotly/graph_objs/ohlc/increasing/_line.py new file mode 100644 index 0000000000..b89a929812 --- /dev/null +++ b/plotly/graph_objs/ohlc/increasing/_line.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'ohlc.increasing' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.ohlc.increasing.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.ohlc.increasing.Line +constructor must be a dict or +an instance of plotly.graph_objs.ohlc.increasing.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.ohlc.increasing import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/__init__.py b/plotly/graph_objs/parcoords/__init__.py new file mode 100644 index 0000000000..0bcfec144a --- /dev/null +++ b/plotly/graph_objs/parcoords/__init__.py @@ -0,0 +1,10 @@ +from ._tickfont import Tickfont +from ._stream import Stream +from ._rangefont import Rangefont +from ._line import Line +from plotly.graph_objs.parcoords import line +from ._labelfont import Labelfont +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.parcoords import hoverlabel +from ._domain import Domain +from ._dimension import Dimension diff --git a/plotly/graph_objs/parcoords/_dimension.py b/plotly/graph_objs/parcoords/_dimension.py new file mode 100644 index 0000000000..bd8874c9a1 --- /dev/null +++ b/plotly/graph_objs/parcoords/_dimension.py @@ -0,0 +1,477 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Dimension(BaseTraceHierarchyType): + + # constraintrange + # --------------- + @property + def constraintrange(self): + """ + The domain range to which the filter on the dimension is + constrained. Must be an array of `[fromValue, toValue]` with + `fromValue <= toValue`, or if `multiselect` is not disabled, + you may give an array of arrays, where each inner array is + `[fromValue, toValue]`. + + The 'constraintrange' property is an info array that may be specified as a + list or tuple of up to 2 elements where: + + (0) The 'constraintrange[0]' property is a number and may be specified as: + - An int or float + (1) The 'constraintrange[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['constraintrange'] + + @constraintrange.setter + def constraintrange(self, val): + self['constraintrange'] = val + + # label + # ----- + @property + def label(self): + """ + The shown name of the dimension. + + The 'label' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # multiselect + # ----------- + @property + def multiselect(self): + """ + Do we allow multiple selection ranges or just a single range? + + The 'multiselect' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['multiselect'] + + @multiselect.setter + def multiselect(self, val): + self['multiselect'] = val + + # range + # ----- + @property + def range(self): + """ + The domain range that represents the full, shown axis extent. + Defaults to the `values` extent. Must be an array of + `[fromValue, toValue]` with finite numbers as elements. + + The 'range' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'range[0]' property is a number and may be specified as: + - An int or float + (1) The 'range[1]' property is a number and may be specified as: + - An int or float + + Returns + ------- + list + """ + return self['range'] + + @range.setter + def range(self, val): + self['range'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + language which is similar to those of Python. See https://githu + b.com/d3/d3-format/blob/master/README.md#locale_format + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # values + # ------ + @property + def values(self): + """ + Dimension values. `values[n]` represents the value of the `n`th + point in the dataset, therefore the `values` vector for all + dimensions must be the same (longer vectors will be truncated). + Each value must be a finite number. + + The 'values' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['values'] + + @values.setter + def values(self, val): + self['values'] = val + + # valuessrc + # --------- + @property + def valuessrc(self): + """ + Sets the source reference on plot.ly for values . + + The 'valuessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuessrc'] + + @valuessrc.setter + def valuessrc(self, val): + self['valuessrc'] = val + + # visible + # ------- + @property + def visible(self): + """ + Shows the dimension when set to `true` (the default). Hides the + dimension for `false`. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + constraintrange + The domain range to which the filter on the dimension + is constrained. Must be an array of `[fromValue, + toValue]` with `fromValue <= toValue`, or if + `multiselect` is not disabled, you may give an array of + arrays, where each inner array is `[fromValue, + toValue]`. + label + The shown name of the dimension. + multiselect + Do we allow multiple selection ranges or just a single + range? + range + The domain range that represents the full, shown axis + extent. Defaults to the `values` extent. Must be an + array of `[fromValue, toValue]` with finite numbers as + elements. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + values + Dimension values. `values[n]` represents the value of + the `n`th point in the dataset, therefore the `values` + vector for all dimensions must be the same (longer + vectors will be truncated). Each value must be a finite + number. + valuessrc + Sets the source reference on plot.ly for values . + visible + Shows the dimension when set to `true` (the default). + Hides the dimension for `false`. + """ + + def __init__( + self, + arg=None, + constraintrange=None, + label=None, + multiselect=None, + range=None, + tickformat=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + values=None, + valuessrc=None, + visible=None, + **kwargs + ): + """ + Construct a new Dimension object + + The dimensions (variables) of the parallel coordinates chart. + 2..60 dimensions are supported. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Dimension + constraintrange + The domain range to which the filter on the dimension + is constrained. Must be an array of `[fromValue, + toValue]` with `fromValue <= toValue`, or if + `multiselect` is not disabled, you may give an array of + arrays, where each inner array is `[fromValue, + toValue]`. + label + The shown name of the dimension. + multiselect + Do we allow multiple selection ranges or just a single + range? + range + The domain range that represents the full, shown axis + extent. Defaults to the `values` extent. Must be an + array of `[fromValue, toValue]` with finite numbers as + elements. + tickformat + Sets the tick label formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + values + Dimension values. `values[n]` represents the value of + the `n`th point in the dataset, therefore the `values` + vector for all dimensions must be the same (longer + vectors will be truncated). Each value must be a finite + number. + valuessrc + Sets the source reference on plot.ly for values . + visible + Shows the dimension when set to `true` (the default). + Hides the dimension for `false`. + + Returns + ------- + Dimension + """ + super(Dimension, self).__init__('dimensions') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Dimension +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Dimension""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (dimension as v_dimension) + + # Initialize validators + # --------------------- + self._validators['constraintrange' + ] = v_dimension.ConstraintrangeValidator() + self._validators['label'] = v_dimension.LabelValidator() + self._validators['multiselect'] = v_dimension.MultiselectValidator() + self._validators['range'] = v_dimension.RangeValidator() + self._validators['tickformat'] = v_dimension.TickformatValidator() + self._validators['ticktext'] = v_dimension.TicktextValidator() + self._validators['ticktextsrc'] = v_dimension.TicktextsrcValidator() + self._validators['tickvals'] = v_dimension.TickvalsValidator() + self._validators['tickvalssrc'] = v_dimension.TickvalssrcValidator() + self._validators['values'] = v_dimension.ValuesValidator() + self._validators['valuessrc'] = v_dimension.ValuessrcValidator() + self._validators['visible'] = v_dimension.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('constraintrange', None) + self.constraintrange = constraintrange if constraintrange is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('multiselect', None) + self.multiselect = multiselect if multiselect is not None else v + v = arg.pop('range', None) + self.range = range if range is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('values', None) + self.values = values if values is not None else v + v = arg.pop('valuessrc', None) + self.valuessrc = valuessrc if valuessrc is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_domain.py b/plotly/graph_objs/parcoords/_domain.py new file mode 100644 index 0000000000..b2a1f904d0 --- /dev/null +++ b/plotly/graph_objs/parcoords/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Domain(BaseTraceHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this parcoords trace . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this parcoords trace . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this parcoords trace (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this parcoords trace (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this parcoords trace . + row + If there is a layout grid, use the domain for this row + in the grid for this parcoords trace . + x + Sets the horizontal domain of this parcoords trace (in + plot fraction). + y + Sets the vertical domain of this parcoords trace (in + plot fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this parcoords trace . + row + If there is a layout grid, use the domain for this row + in the grid for this parcoords trace . + x + Sets the horizontal domain of this parcoords trace (in + plot fraction). + y + Sets the vertical domain of this parcoords trace (in + plot fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Domain +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_hoverlabel.py b/plotly/graph_objs/parcoords/_hoverlabel.py new file mode 100644 index 0000000000..4f2f38ef8a --- /dev/null +++ b/plotly/graph_objs/parcoords/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.parcoords.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.parcoords.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_labelfont.py b/plotly/graph_objs/parcoords/_labelfont.py new file mode 100644 index 0000000000..36542ecaba --- /dev/null +++ b/plotly/graph_objs/parcoords/_labelfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Labelfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Labelfont object + + Sets the font for the `dimension` labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Labelfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Labelfont + """ + super(Labelfont, self).__init__('labelfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Labelfont +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Labelfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (labelfont as v_labelfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_labelfont.ColorValidator() + self._validators['family'] = v_labelfont.FamilyValidator() + self._validators['size'] = v_labelfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_line.py b/plotly/graph_objs/parcoords/_line.py new file mode 100644 index 0000000000..958164be07 --- /dev/null +++ b/plotly/graph_objs/parcoords/_line.py @@ -0,0 +1,719 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if line.color` is set to a numerical array. + Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `line.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. The default value is false, so + that `parcoords` colorscale can default to `Viridis`. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `line.color` is set to a numerical array + and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Sets the upper bound of the color domain. Value should be + associated to the `line.color` array index, and if set, + `line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Sets the lower bound of the color domain. Value should be + associated to the `line.color` array index, and if set, + `line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the line color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to parcoords.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.parcoords.line.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.parcoords.line.colorbar.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.parcoords.line.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `line.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be + a palette name string of the following list: Greys, YlGnBu, + Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, + Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Reverses the color mapping if true (`cmin` will correspond to + the last color in the array and `cmax` will correspond to the + first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if line.color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. The default value is false, so that `parcoords` + colorscale can default to `Viridis`. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmin` must be set as + well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmax` must be set as + well. + color + Sets the line color. It accepts either a specific color + or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.parcoords.line.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `line.cmin` and `line.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + reversescale=None, + showscale=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Line + autocolorscale + Has an effect only if line.color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. The default value is false, so that `parcoords` + colorscale can default to `Viridis`. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmin` must be set as + well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmax` must be set as + well. + color + Sets the line color. It accepts either a specific color + or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.parcoords.line.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `line.cmin` and `line.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Line +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorbar'] = v_line.ColorBarValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['showscale'] = v_line.ShowscaleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_rangefont.py b/plotly/graph_objs/parcoords/_rangefont.py new file mode 100644 index 0000000000..7f69687f28 --- /dev/null +++ b/plotly/graph_objs/parcoords/_rangefont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Rangefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Rangefont object + + Sets the font for the `dimension` range values. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Rangefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Rangefont + """ + super(Rangefont, self).__init__('rangefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Rangefont +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Rangefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (rangefont as v_rangefont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_rangefont.ColorValidator() + self._validators['family'] = v_rangefont.FamilyValidator() + self._validators['size'] = v_rangefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_stream.py b/plotly/graph_objs/parcoords/_stream.py new file mode 100644 index 0000000000..6d357f3b29 --- /dev/null +++ b/plotly/graph_objs/parcoords/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Stream +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/_tickfont.py b/plotly/graph_objs/parcoords/_tickfont.py new file mode 100644 index 0000000000..b213dba5ef --- /dev/null +++ b/plotly/graph_objs/parcoords/_tickfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the font for the `dimension` tick values. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/hoverlabel/__init__.py b/plotly/graph_objs/parcoords/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/parcoords/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/parcoords/hoverlabel/_font.py b/plotly/graph_objs/parcoords/hoverlabel/_font.py new file mode 100644 index 0000000000..cd00e140ce --- /dev/null +++ b/plotly/graph_objs/parcoords/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.parcoords.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/line/__init__.py b/plotly/graph_objs/parcoords/line/__init__.py new file mode 100644 index 0000000000..3f3e799a40 --- /dev/null +++ b/plotly/graph_objs/parcoords/line/__init__.py @@ -0,0 +1,2 @@ +from ._colorbar import ColorBar +from plotly.graph_objs.parcoords.line import colorbar diff --git a/plotly/graph_objs/parcoords/line/_colorbar.py b/plotly/graph_objs/parcoords/line/_colorbar.py new file mode 100644 index 0000000000..9de09a52f6 --- /dev/null +++ b/plotly/graph_objs/parcoords/line/_colorbar.py @@ -0,0 +1,1736 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.parcoords.line.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.parcoords.line.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.parcoords.line.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.parcoords.line.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.parcoords.line.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.parcoords.line.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords.line' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.parcoords.line.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.parcoords.line.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.parcoords.line.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.line.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.line.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords.line import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/line/colorbar/__init__.py b/plotly/graph_objs/parcoords/line/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/parcoords/line/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/parcoords/line/colorbar/_tickfont.py b/plotly/graph_objs/parcoords/line/colorbar/_tickfont.py new file mode 100644 index 0000000000..7d3d09a9e9 --- /dev/null +++ b/plotly/graph_objs/parcoords/line/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords.line.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.parcoords.line.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.line.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.line.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords.line.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/line/colorbar/_tickformatstop.py b/plotly/graph_objs/parcoords/line/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..59327dfe09 --- /dev/null +++ b/plotly/graph_objs/parcoords/line/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords.line.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.parcoords.line.colorba + r.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.line.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.line.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords.line.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/parcoords/line/colorbar/_titlefont.py b/plotly/graph_objs/parcoords/line/colorbar/_titlefont.py new file mode 100644 index 0000000000..f5ebe844ad --- /dev/null +++ b/plotly/graph_objs/parcoords/line/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'parcoords.line.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.parcoords.line.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.parcoords.line.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.parcoords.line.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.parcoords.line.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/__init__.py b/plotly/graph_objs/pie/__init__.py new file mode 100644 index 0000000000..72369aa3c4 --- /dev/null +++ b/plotly/graph_objs/pie/__init__.py @@ -0,0 +1,9 @@ +from ._textfont import Textfont +from ._stream import Stream +from ._outsidetextfont import Outsidetextfont +from ._marker import Marker +from plotly.graph_objs.pie import marker +from ._insidetextfont import Insidetextfont +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.pie import hoverlabel +from ._domain import Domain diff --git a/plotly/graph_objs/pie/_domain.py b/plotly/graph_objs/pie/_domain.py new file mode 100644 index 0000000000..d2d5e42d00 --- /dev/null +++ b/plotly/graph_objs/pie/_domain.py @@ -0,0 +1,197 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Domain(BaseTraceHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this pie trace . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this pie trace . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this pie trace (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this pie trace (in plot fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this pie trace . + row + If there is a layout grid, use the domain for this row + in the grid for this pie trace . + x + Sets the horizontal domain of this pie trace (in plot + fraction). + y + Sets the vertical domain of this pie trace (in plot + fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this pie trace . + row + If there is a layout grid, use the domain for this row + in the grid for this pie trace . + x + Sets the horizontal domain of this pie trace (in plot + fraction). + y + Sets the vertical domain of this pie trace (in plot + fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Domain +constructor must be a dict or +an instance of plotly.graph_objs.pie.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_hoverlabel.py b/plotly/graph_objs/pie/_hoverlabel.py new file mode 100644 index 0000000000..422f259020 --- /dev/null +++ b/plotly/graph_objs/pie/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.pie.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.pie.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.pie.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_insidetextfont.py b/plotly/graph_objs/pie/_insidetextfont.py new file mode 100644 index 0000000000..ec4ac23745 --- /dev/null +++ b/plotly/graph_objs/pie/_insidetextfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Insidetextfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Insidetextfont object + + Sets the font used for `textinfo` lying inside the pie. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Insidetextfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Insidetextfont + """ + super(Insidetextfont, self).__init__('insidetextfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Insidetextfont +constructor must be a dict or +an instance of plotly.graph_objs.pie.Insidetextfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (insidetextfont as v_insidetextfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_insidetextfont.ColorValidator() + self._validators['family'] = v_insidetextfont.FamilyValidator() + self._validators['size'] = v_insidetextfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_marker.py b/plotly/graph_objs/pie/_marker.py new file mode 100644 index 0000000000..36c665260e --- /dev/null +++ b/plotly/graph_objs/pie/_marker.py @@ -0,0 +1,171 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # colors + # ------ + @property + def colors(self): + """ + Sets the color of each sector of this pie chart. If not + specified, the default trace color set is used to pick the + sector colors. + + The 'colors' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['colors'] + + @colors.setter + def colors(self, val): + self['colors'] = val + + # colorssrc + # --------- + @property + def colorssrc(self): + """ + Sets the source reference on plot.ly for colors . + + The 'colorssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorssrc'] + + @colorssrc.setter + def colorssrc(self, val): + self['colorssrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.pie.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the line enclosing each + sector. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the line enclosing + each sector. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.pie.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + colors + Sets the color of each sector of this pie chart. If not + specified, the default trace color set is used to pick + the sector colors. + colorssrc + Sets the source reference on plot.ly for colors . + line + plotly.graph_objs.pie.marker.Line instance or dict with + compatible properties + """ + + def __init__( + self, arg=None, colors=None, colorssrc=None, line=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Marker + colors + Sets the color of each sector of this pie chart. If not + specified, the default trace color set is used to pick + the sector colors. + colorssrc + Sets the source reference on plot.ly for colors . + line + plotly.graph_objs.pie.marker.Line instance or dict with + compatible properties + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Marker +constructor must be a dict or +an instance of plotly.graph_objs.pie.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['colors'] = v_marker.ColorsValidator() + self._validators['colorssrc'] = v_marker.ColorssrcValidator() + self._validators['line'] = v_marker.LineValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('colors', None) + self.colors = colors if colors is not None else v + v = arg.pop('colorssrc', None) + self.colorssrc = colorssrc if colorssrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_outsidetextfont.py b/plotly/graph_objs/pie/_outsidetextfont.py new file mode 100644 index 0000000000..11fa096c28 --- /dev/null +++ b/plotly/graph_objs/pie/_outsidetextfont.py @@ -0,0 +1,219 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Outsidetextfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Outsidetextfont object + + Sets the font used for `textinfo` lying outside the pie. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Outsidetextfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Outsidetextfont + """ + super(Outsidetextfont, self).__init__('outsidetextfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Outsidetextfont +constructor must be a dict or +an instance of plotly.graph_objs.pie.Outsidetextfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import ( + outsidetextfont as v_outsidetextfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_outsidetextfont.ColorValidator() + self._validators['family'] = v_outsidetextfont.FamilyValidator() + self._validators['size'] = v_outsidetextfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_stream.py b/plotly/graph_objs/pie/_stream.py new file mode 100644 index 0000000000..22b025d365 --- /dev/null +++ b/plotly/graph_objs/pie/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Stream +constructor must be a dict or +an instance of plotly.graph_objs.pie.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/_textfont.py b/plotly/graph_objs/pie/_textfont.py new file mode 100644 index 0000000000..f817775159 --- /dev/null +++ b/plotly/graph_objs/pie/_textfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Textfont object + + Sets the font used for `textinfo`. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.Textfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.pie.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['size'] = v_textfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/hoverlabel/__init__.py b/plotly/graph_objs/pie/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/pie/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/pie/hoverlabel/_font.py b/plotly/graph_objs/pie/hoverlabel/_font.py new file mode 100644 index 0000000000..0f7671d1be --- /dev/null +++ b/plotly/graph_objs/pie/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.pie.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pie/marker/__init__.py b/plotly/graph_objs/pie/marker/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/pie/marker/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/pie/marker/_line.py b/plotly/graph_objs/pie/marker/_line.py new file mode 100644 index 0000000000..f08fca406a --- /dev/null +++ b/plotly/graph_objs/pie/marker/_line.py @@ -0,0 +1,223 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the line enclosing each sector. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the line enclosing each sector. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pie.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the line enclosing each sector. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the line enclosing each + sector. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pie.marker.Line + color + Sets the color of the line enclosing each sector. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the line enclosing each + sector. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pie.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.pie.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.pie.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pointcloud/__init__.py b/plotly/graph_objs/pointcloud/__init__.py new file mode 100644 index 0000000000..2c793275e8 --- /dev/null +++ b/plotly/graph_objs/pointcloud/__init__.py @@ -0,0 +1,5 @@ +from ._stream import Stream +from ._marker import Marker +from plotly.graph_objs.pointcloud import marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.pointcloud import hoverlabel diff --git a/plotly/graph_objs/pointcloud/_hoverlabel.py b/plotly/graph_objs/pointcloud/_hoverlabel.py new file mode 100644 index 0000000000..0c5597f722 --- /dev/null +++ b/plotly/graph_objs/pointcloud/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.pointcloud.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.pointcloud.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pointcloud' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pointcloud.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pointcloud.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.pointcloud.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.pointcloud import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pointcloud/_marker.py b/plotly/graph_objs/pointcloud/_marker.py new file mode 100644 index 0000000000..bec3be4cb9 --- /dev/null +++ b/plotly/graph_objs/pointcloud/_marker.py @@ -0,0 +1,330 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # blend + # ----- + @property + def blend(self): + """ + Determines if colors are blended together for a translucency + effect in case `opacity` is specified as a value less then `1`. + Setting `blend` to `true` reduces zoom/pan speed if used with + large numbers of points. + + The 'blend' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['blend'] + + @blend.setter + def blend(self, val): + self['blend'] = val + + # border + # ------ + @property + def border(self): + """ + The 'border' property is an instance of Border + that may be specified as: + - An instance of plotly.graph_objs.pointcloud.marker.Border + - A dict of string/value properties that will be passed + to the Border constructor + + Supported dict properties: + + arearatio + Specifies what fraction of the marker area is + covered with the border. + color + Sets the stroke color. It accepts a specific + color. If the color is not fully opaque and + there are hundreds of thousands of points, it + may cause slower zooming and panning. + + Returns + ------- + plotly.graph_objs.pointcloud.marker.Border + """ + return self['border'] + + @border.setter + def border(self, val): + self['border'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker fill color. It accepts a specific color.If the + color is not fully opaque and there are hundreds of thousandsof + points, it may cause slower zooming and panning. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. The default value is `1` (fully + opaque). If the markers are not fully opaque and there are + hundreds of thousands of points, it may cause slower zooming + and panning. Opacity fades the color even if `blend` is left on + `false` even if there is no translucency effect in that case. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # sizemax + # ------- + @property + def sizemax(self): + """ + Sets the maximum size (in px) of the rendered marker points. + Effective when the `pointcloud` shows only few points. + + The 'sizemax' property is a number and may be specified as: + - An int or float in the interval [0.1, inf] + + Returns + ------- + int|float + """ + return self['sizemax'] + + @sizemax.setter + def sizemax(self, val): + self['sizemax'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Sets the minimum size (in px) of the rendered marker points, + effective when the `pointcloud` shows a million or more points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0.1, 2] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pointcloud' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + blend + Determines if colors are blended together for a + translucency effect in case `opacity` is specified as a + value less then `1`. Setting `blend` to `true` reduces + zoom/pan speed if used with large numbers of points. + border + plotly.graph_objs.pointcloud.marker.Border instance or + dict with compatible properties + color + Sets the marker fill color. It accepts a specific + color.If the color is not fully opaque and there are + hundreds of thousandsof points, it may cause slower + zooming and panning. + opacity + Sets the marker opacity. The default value is `1` + (fully opaque). If the markers are not fully opaque and + there are hundreds of thousands of points, it may cause + slower zooming and panning. Opacity fades the color + even if `blend` is left on `false` even if there is no + translucency effect in that case. + sizemax + Sets the maximum size (in px) of the rendered marker + points. Effective when the `pointcloud` shows only few + points. + sizemin + Sets the minimum size (in px) of the rendered marker + points, effective when the `pointcloud` shows a million + or more points. + """ + + def __init__( + self, + arg=None, + blend=None, + border=None, + color=None, + opacity=None, + sizemax=None, + sizemin=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pointcloud.Marker + blend + Determines if colors are blended together for a + translucency effect in case `opacity` is specified as a + value less then `1`. Setting `blend` to `true` reduces + zoom/pan speed if used with large numbers of points. + border + plotly.graph_objs.pointcloud.marker.Border instance or + dict with compatible properties + color + Sets the marker fill color. It accepts a specific + color.If the color is not fully opaque and there are + hundreds of thousandsof points, it may cause slower + zooming and panning. + opacity + Sets the marker opacity. The default value is `1` + (fully opaque). If the markers are not fully opaque and + there are hundreds of thousands of points, it may cause + slower zooming and panning. Opacity fades the color + even if `blend` is left on `false` even if there is no + translucency effect in that case. + sizemax + Sets the maximum size (in px) of the rendered marker + points. Effective when the `pointcloud` shows only few + points. + sizemin + Sets the minimum size (in px) of the rendered marker + points, effective when the `pointcloud` shows a million + or more points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pointcloud.Marker +constructor must be a dict or +an instance of plotly.graph_objs.pointcloud.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.pointcloud import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['blend'] = v_marker.BlendValidator() + self._validators['border'] = v_marker.BorderValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['sizemax'] = v_marker.SizemaxValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('blend', None) + self.blend = blend if blend is not None else v + v = arg.pop('border', None) + self.border = border if border is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('sizemax', None) + self.sizemax = sizemax if sizemax is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pointcloud/_stream.py b/plotly/graph_objs/pointcloud/_stream.py new file mode 100644 index 0000000000..c1152e229c --- /dev/null +++ b/plotly/graph_objs/pointcloud/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pointcloud' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.pointcloud.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pointcloud.Stream +constructor must be a dict or +an instance of plotly.graph_objs.pointcloud.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.pointcloud import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pointcloud/hoverlabel/__init__.py b/plotly/graph_objs/pointcloud/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/pointcloud/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/pointcloud/hoverlabel/_font.py b/plotly/graph_objs/pointcloud/hoverlabel/_font.py new file mode 100644 index 0000000000..0c6dfff8a8 --- /dev/null +++ b/plotly/graph_objs/pointcloud/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pointcloud.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.pointcloud.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pointcloud.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.pointcloud.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.pointcloud.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/pointcloud/marker/__init__.py b/plotly/graph_objs/pointcloud/marker/__init__.py new file mode 100644 index 0000000000..be1ce10864 --- /dev/null +++ b/plotly/graph_objs/pointcloud/marker/__init__.py @@ -0,0 +1 @@ +from ._border import Border diff --git a/plotly/graph_objs/pointcloud/marker/_border.py b/plotly/graph_objs/pointcloud/marker/_border.py new file mode 100644 index 0000000000..60ad4e01ca --- /dev/null +++ b/plotly/graph_objs/pointcloud/marker/_border.py @@ -0,0 +1,169 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Border(BaseTraceHierarchyType): + + # arearatio + # --------- + @property + def arearatio(self): + """ + Specifies what fraction of the marker area is covered with the + border. + + The 'arearatio' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['arearatio'] + + @arearatio.setter + def arearatio(self, val): + self['arearatio'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stroke color. It accepts a specific color. If the + color is not fully opaque and there are hundreds of thousands + of points, it may cause slower zooming and panning. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'pointcloud.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + arearatio + Specifies what fraction of the marker area is covered + with the border. + color + Sets the stroke color. It accepts a specific color. If + the color is not fully opaque and there are hundreds of + thousands of points, it may cause slower zooming and + panning. + """ + + def __init__(self, arg=None, arearatio=None, color=None, **kwargs): + """ + Construct a new Border object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.pointcloud.marker.Border + arearatio + Specifies what fraction of the marker area is covered + with the border. + color + Sets the stroke color. It accepts a specific color. If + the color is not fully opaque and there are hundreds of + thousands of points, it may cause slower zooming and + panning. + + Returns + ------- + Border + """ + super(Border, self).__init__('border') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.pointcloud.marker.Border +constructor must be a dict or +an instance of plotly.graph_objs.pointcloud.marker.Border""" + ) + + # Import validators + # ----------------- + from plotly.validators.pointcloud.marker import (border as v_border) + + # Initialize validators + # --------------------- + self._validators['arearatio'] = v_border.ArearatioValidator() + self._validators['color'] = v_border.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('arearatio', None) + self.arearatio = arearatio if arearatio is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/__init__.py b/plotly/graph_objs/sankey/__init__.py new file mode 100644 index 0000000000..4e567948c4 --- /dev/null +++ b/plotly/graph_objs/sankey/__init__.py @@ -0,0 +1,9 @@ +from ._textfont import Textfont +from ._stream import Stream +from ._node import Node +from plotly.graph_objs.sankey import node +from ._link import Link +from plotly.graph_objs.sankey import link +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.sankey import hoverlabel +from ._domain import Domain diff --git a/plotly/graph_objs/sankey/_domain.py b/plotly/graph_objs/sankey/_domain.py new file mode 100644 index 0000000000..ffe0712394 --- /dev/null +++ b/plotly/graph_objs/sankey/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Domain(BaseTraceHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this sankey trace . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this sankey trace . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this sankey trace (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this sankey trace (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this sankey trace . + row + If there is a layout grid, use the domain for this row + in the grid for this sankey trace . + x + Sets the horizontal domain of this sankey trace (in + plot fraction). + y + Sets the vertical domain of this sankey trace (in plot + fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this sankey trace . + row + If there is a layout grid, use the domain for this row + in the grid for this sankey trace . + x + Sets the horizontal domain of this sankey trace (in + plot fraction). + y + Sets the vertical domain of this sankey trace (in plot + fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Domain +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/_hoverlabel.py b/plotly/graph_objs/sankey/_hoverlabel.py new file mode 100644 index 0000000000..4cef751b78 --- /dev/null +++ b/plotly/graph_objs/sankey/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.sankey.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.sankey.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/_link.py b/plotly/graph_objs/sankey/_link.py new file mode 100644 index 0000000000..3c64543a2b --- /dev/null +++ b/plotly/graph_objs/sankey/_link.py @@ -0,0 +1,450 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Link(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the `link` color. It can be a single value, or an array + for specifying color for each `link`. If `link.color` is + omitted, then by default, a translucent grey link will be used. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # label + # ----- + @property + def label(self): + """ + The shown name of the link. + + The 'label' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # labelsrc + # -------- + @property + def labelsrc(self): + """ + Sets the source reference on plot.ly for label . + + The 'labelsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['labelsrc'] + + @labelsrc.setter + def labelsrc(self, val): + self['labelsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.sankey.link.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the `line` around each + `link`. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the `line` around + each `link`. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.sankey.link.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # source + # ------ + @property + def source(self): + """ + An integer number `[0..nodes.length - 1]` that represents the + source node. + + The 'source' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['source'] + + @source.setter + def source(self, val): + self['source'] = val + + # sourcesrc + # --------- + @property + def sourcesrc(self): + """ + Sets the source reference on plot.ly for source . + + The 'sourcesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sourcesrc'] + + @sourcesrc.setter + def sourcesrc(self, val): + self['sourcesrc'] = val + + # target + # ------ + @property + def target(self): + """ + An integer number `[0..nodes.length - 1]` that represents the + target node. + + The 'target' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['target'] + + @target.setter + def target(self, val): + self['target'] = val + + # targetsrc + # --------- + @property + def targetsrc(self): + """ + Sets the source reference on plot.ly for target . + + The 'targetsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['targetsrc'] + + @targetsrc.setter + def targetsrc(self, val): + self['targetsrc'] = val + + # value + # ----- + @property + def value(self): + """ + A numeric value representing the flow volume value. + + The 'value' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valuesrc + # -------- + @property + def valuesrc(self): + """ + Sets the source reference on plot.ly for value . + + The 'valuesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuesrc'] + + @valuesrc.setter + def valuesrc(self, val): + self['valuesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the `link` color. It can be a single value, or an + array for specifying color for each `link`. If + `link.color` is omitted, then by default, a translucent + grey link will be used. + colorsrc + Sets the source reference on plot.ly for color . + label + The shown name of the link. + labelsrc + Sets the source reference on plot.ly for label . + line + plotly.graph_objs.sankey.link.Line instance or dict + with compatible properties + source + An integer number `[0..nodes.length - 1]` that + represents the source node. + sourcesrc + Sets the source reference on plot.ly for source . + target + An integer number `[0..nodes.length - 1]` that + represents the target node. + targetsrc + Sets the source reference on plot.ly for target . + value + A numeric value representing the flow volume value. + valuesrc + Sets the source reference on plot.ly for value . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + label=None, + labelsrc=None, + line=None, + source=None, + sourcesrc=None, + target=None, + targetsrc=None, + value=None, + valuesrc=None, + **kwargs + ): + """ + Construct a new Link object + + The links of the Sankey plot. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Link + color + Sets the `link` color. It can be a single value, or an + array for specifying color for each `link`. If + `link.color` is omitted, then by default, a translucent + grey link will be used. + colorsrc + Sets the source reference on plot.ly for color . + label + The shown name of the link. + labelsrc + Sets the source reference on plot.ly for label . + line + plotly.graph_objs.sankey.link.Line instance or dict + with compatible properties + source + An integer number `[0..nodes.length - 1]` that + represents the source node. + sourcesrc + Sets the source reference on plot.ly for source . + target + An integer number `[0..nodes.length - 1]` that + represents the target node. + targetsrc + Sets the source reference on plot.ly for target . + value + A numeric value representing the flow volume value. + valuesrc + Sets the source reference on plot.ly for value . + + Returns + ------- + Link + """ + super(Link, self).__init__('link') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Link +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Link""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (link as v_link) + + # Initialize validators + # --------------------- + self._validators['color'] = v_link.ColorValidator() + self._validators['colorsrc'] = v_link.ColorsrcValidator() + self._validators['label'] = v_link.LabelValidator() + self._validators['labelsrc'] = v_link.LabelsrcValidator() + self._validators['line'] = v_link.LineValidator() + self._validators['source'] = v_link.SourceValidator() + self._validators['sourcesrc'] = v_link.SourcesrcValidator() + self._validators['target'] = v_link.TargetValidator() + self._validators['targetsrc'] = v_link.TargetsrcValidator() + self._validators['value'] = v_link.ValueValidator() + self._validators['valuesrc'] = v_link.ValuesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('labelsrc', None) + self.labelsrc = labelsrc if labelsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('source', None) + self.source = source if source is not None else v + v = arg.pop('sourcesrc', None) + self.sourcesrc = sourcesrc if sourcesrc is not None else v + v = arg.pop('target', None) + self.target = target if target is not None else v + v = arg.pop('targetsrc', None) + self.targetsrc = targetsrc if targetsrc is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valuesrc', None) + self.valuesrc = valuesrc if valuesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/_node.py b/plotly/graph_objs/sankey/_node.py new file mode 100644 index 0000000000..84f6d9c70e --- /dev/null +++ b/plotly/graph_objs/sankey/_node.py @@ -0,0 +1,339 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Node(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the `node` color. It can be a single value, or an array + for specifying color for each `node`. If `node.color` is + omitted, then the default `Plotly` color palette will be cycled + through to have a variety of colors. These defaults are not + fully opaque, to allow some visibility of what is beneath the + node. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # label + # ----- + @property + def label(self): + """ + The shown name of the node. + + The 'label' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # labelsrc + # -------- + @property + def labelsrc(self): + """ + Sets the source reference on plot.ly for label . + + The 'labelsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['labelsrc'] + + @labelsrc.setter + def labelsrc(self, val): + self['labelsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.sankey.node.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the color of the `line` around each + `node`. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the `line` around + each `node`. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.sankey.node.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # pad + # --- + @property + def pad(self): + """ + Sets the padding (in px) between the `nodes`. + + The 'pad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['pad'] + + @pad.setter + def pad(self, val): + self['pad'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the `nodes`. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the `node` color. It can be a single value, or an + array for specifying color for each `node`. If + `node.color` is omitted, then the default `Plotly` + color palette will be cycled through to have a variety + of colors. These defaults are not fully opaque, to + allow some visibility of what is beneath the node. + colorsrc + Sets the source reference on plot.ly for color . + label + The shown name of the node. + labelsrc + Sets the source reference on plot.ly for label . + line + plotly.graph_objs.sankey.node.Line instance or dict + with compatible properties + pad + Sets the padding (in px) between the `nodes`. + thickness + Sets the thickness (in px) of the `nodes`. + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + label=None, + labelsrc=None, + line=None, + pad=None, + thickness=None, + **kwargs + ): + """ + Construct a new Node object + + The nodes of the Sankey plot. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Node + color + Sets the `node` color. It can be a single value, or an + array for specifying color for each `node`. If + `node.color` is omitted, then the default `Plotly` + color palette will be cycled through to have a variety + of colors. These defaults are not fully opaque, to + allow some visibility of what is beneath the node. + colorsrc + Sets the source reference on plot.ly for color . + label + The shown name of the node. + labelsrc + Sets the source reference on plot.ly for label . + line + plotly.graph_objs.sankey.node.Line instance or dict + with compatible properties + pad + Sets the padding (in px) between the `nodes`. + thickness + Sets the thickness (in px) of the `nodes`. + + Returns + ------- + Node + """ + super(Node, self).__init__('node') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Node +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Node""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (node as v_node) + + # Initialize validators + # --------------------- + self._validators['color'] = v_node.ColorValidator() + self._validators['colorsrc'] = v_node.ColorsrcValidator() + self._validators['label'] = v_node.LabelValidator() + self._validators['labelsrc'] = v_node.LabelsrcValidator() + self._validators['line'] = v_node.LineValidator() + self._validators['pad'] = v_node.PadValidator() + self._validators['thickness'] = v_node.ThicknessValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('labelsrc', None) + self.labelsrc = labelsrc if labelsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('pad', None) + self.pad = pad if pad is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/_stream.py b/plotly/graph_objs/sankey/_stream.py new file mode 100644 index 0000000000..067f239ad6 --- /dev/null +++ b/plotly/graph_objs/sankey/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Stream +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/_textfont.py b/plotly/graph_objs/sankey/_textfont.py new file mode 100644 index 0000000000..2af1aec334 --- /dev/null +++ b/plotly/graph_objs/sankey/_textfont.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Textfont object + + Sets the font for node labels + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.Textfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.sankey.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['size'] = v_textfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/hoverlabel/__init__.py b/plotly/graph_objs/sankey/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/sankey/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/sankey/hoverlabel/_font.py b/plotly/graph_objs/sankey/hoverlabel/_font.py new file mode 100644 index 0000000000..8346992c78 --- /dev/null +++ b/plotly/graph_objs/sankey/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.sankey.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/link/__init__.py b/plotly/graph_objs/sankey/link/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/sankey/link/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/sankey/link/_line.py b/plotly/graph_objs/sankey/link/_line.py new file mode 100644 index 0000000000..2907cfe61d --- /dev/null +++ b/plotly/graph_objs/sankey/link/_line.py @@ -0,0 +1,223 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the `line` around each `link`. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the `line` around each `link`. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey.link' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the `line` around each `link`. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the `line` around each + `link`. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.link.Line + color + Sets the color of the `line` around each `link`. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the `line` around each + `link`. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.link.Line +constructor must be a dict or +an instance of plotly.graph_objs.sankey.link.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey.link import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/sankey/node/__init__.py b/plotly/graph_objs/sankey/node/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/sankey/node/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/sankey/node/_line.py b/plotly/graph_objs/sankey/node/_line.py new file mode 100644 index 0000000000..d2c5714882 --- /dev/null +++ b/plotly/graph_objs/sankey/node/_line.py @@ -0,0 +1,223 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the `line` around each `node`. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the `line` around each `node`. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'sankey.node' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the `line` around each `node`. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the `line` around each + `node`. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.sankey.node.Line + color + Sets the color of the `line` around each `node`. + colorsrc + Sets the source reference on plot.ly for color . + width + Sets the width (in px) of the `line` around each + `node`. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.sankey.node.Line +constructor must be a dict or +an instance of plotly.graph_objs.sankey.node.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.sankey.node import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/__init__.py b/plotly/graph_objs/scatter/__init__.py new file mode 100644 index 0000000000..8e2223f8c2 --- /dev/null +++ b/plotly/graph_objs/scatter/__init__.py @@ -0,0 +1,13 @@ +from ._unselected import Unselected +from plotly.graph_objs.scatter import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scatter import selected +from ._marker import Marker +from plotly.graph_objs.scatter import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scatter import hoverlabel +from ._error_y import ErrorY +from ._error_x import ErrorX diff --git a/plotly/graph_objs/scatter/_error_x.py b/plotly/graph_objs/scatter/_error_x.py new file mode 100644 index 0000000000..7f59663184 --- /dev/null +++ b/plotly/graph_objs/scatter/_error_x.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorX(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_ystyle + # ----------- + @property + def copy_ystyle(self): + """ + The 'copy_ystyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_ystyle'] + + @copy_ystyle.setter + def copy_ystyle(self, val): + self['copy_ystyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_ystyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorX object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.ErrorX + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorX + """ + super(ErrorX, self).__init__('error_x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.ErrorX +constructor must be a dict or +an instance of plotly.graph_objs.scatter.ErrorX""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (error_x as v_error_x) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_x.ArrayValidator() + self._validators['arrayminus'] = v_error_x.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_x.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_x.ArraysrcValidator() + self._validators['color'] = v_error_x.ColorValidator() + self._validators['copy_ystyle'] = v_error_x.CopyYstyleValidator() + self._validators['symmetric'] = v_error_x.SymmetricValidator() + self._validators['thickness'] = v_error_x.ThicknessValidator() + self._validators['traceref'] = v_error_x.TracerefValidator() + self._validators['tracerefminus'] = v_error_x.TracerefminusValidator() + self._validators['type'] = v_error_x.TypeValidator() + self._validators['value'] = v_error_x.ValueValidator() + self._validators['valueminus'] = v_error_x.ValueminusValidator() + self._validators['visible'] = v_error_x.VisibleValidator() + self._validators['width'] = v_error_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_ystyle', None) + self.copy_ystyle = copy_ystyle if copy_ystyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_error_y.py b/plotly/graph_objs/scatter/_error_y.py new file mode 100644 index 0000000000..9840012a61 --- /dev/null +++ b/plotly/graph_objs/scatter/_error_y.py @@ -0,0 +1,561 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorY(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorY object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.ErrorY + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorY + """ + super(ErrorY, self).__init__('error_y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.ErrorY +constructor must be a dict or +an instance of plotly.graph_objs.scatter.ErrorY""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (error_y as v_error_y) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_y.ArrayValidator() + self._validators['arrayminus'] = v_error_y.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_y.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_y.ArraysrcValidator() + self._validators['color'] = v_error_y.ColorValidator() + self._validators['symmetric'] = v_error_y.SymmetricValidator() + self._validators['thickness'] = v_error_y.ThicknessValidator() + self._validators['traceref'] = v_error_y.TracerefValidator() + self._validators['tracerefminus'] = v_error_y.TracerefminusValidator() + self._validators['type'] = v_error_y.TypeValidator() + self._validators['value'] = v_error_y.ValueValidator() + self._validators['valueminus'] = v_error_y.ValueminusValidator() + self._validators['visible'] = v_error_y.VisibleValidator() + self._validators['width'] = v_error_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_hoverlabel.py b/plotly/graph_objs/scatter/_hoverlabel.py new file mode 100644 index 0000000000..a8f58955ba --- /dev/null +++ b/plotly/graph_objs/scatter/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scatter.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatter.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_line.py b/plotly/graph_objs/scatter/_line.py new file mode 100644 index 0000000000..d6671b27c7 --- /dev/null +++ b/plotly/graph_objs/scatter/_line.py @@ -0,0 +1,309 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # shape + # ----- + @property + def shape(self): + """ + Determines the line shape. With *spline* the lines are drawn + using spline interpolation. The other available values + correspond to step-wise line shapes. + + The 'shape' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'spline', 'hv', 'vh', 'hvh', 'vhv'] + + Returns + ------- + Any + """ + return self['shape'] + + @shape.setter + def shape(self, val): + self['shape'] = val + + # simplify + # -------- + @property + def simplify(self): + """ + Simplifies lines by removing nearly-collinear points. When + transitioning lines, it may be desirable to disable this so + that the number of points along the resulting SVG path is + unaffected. + + The 'simplify' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['simplify'] + + @simplify.setter + def simplify(self, val): + self['simplify'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Has an effect only if `shape` is set to *spline* Sets the + amount of smoothing. *0* corresponds to no smoothing + (equivalent to a *linear* shape). + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + simplify + Simplifies lines by removing nearly-collinear points. + When transitioning lines, it may be desirable to + disable this so that the number of points along the + resulting SVG path is unaffected. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + shape=None, + simplify=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + simplify + Simplifies lines by removing nearly-collinear points. + When transitioning lines, it may be desirable to + disable this so that the number of points along the + resulting SVG path is unaffected. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['shape'] = v_line.ShapeValidator() + self._validators['simplify'] = v_line.SimplifyValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('shape', None) + self.shape = shape if shape is not None else v + v = arg.pop('simplify', None) + self.simplify = simplify if simplify is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_marker.py b/plotly/graph_objs/scatter/_marker.py new file mode 100644 index 0000000000..8498efe367 --- /dev/null +++ b/plotly/graph_objs/scatter/_marker.py @@ -0,0 +1,1245 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatter.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scatter.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter.marker.colorbar.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scatter.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # gradient + # -------- + @property + def gradient(self): + """ + The 'gradient' property is an instance of Gradient + that may be specified as: + - An instance of plotly.graph_objs.scatter.marker.Gradient + - A dict of string/value properties that will be passed + to the Gradient constructor + + Supported dict properties: + + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + . + + Returns + ------- + plotly.graph_objs.scatter.marker.Gradient + """ + return self['gradient'] + + @gradient.setter + def gradient(self, val): + self['gradient'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatter.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scatter.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # maxdisplayed + # ------------ + @property + def maxdisplayed(self): + """ + Sets a maximum number of points to be drawn on the graph. *0* + corresponds to no limit. + + The 'maxdisplayed' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['maxdisplayed'] + + @maxdisplayed.setter + def maxdisplayed(self, val): + self['maxdisplayed'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatter.marker.Gradient instance or + dict with compatible properties + line + plotly.graph_objs.scatter.marker.Line instance or dict + with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + gradient=None, + line=None, + maxdisplayed=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatter.marker.Gradient instance or + dict with compatible properties + line + plotly.graph_objs.scatter.marker.Line instance or dict + with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['gradient'] = v_marker.GradientValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['maxdisplayed'] = v_marker.MaxdisplayedValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('gradient', None) + self.gradient = gradient if gradient is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('maxdisplayed', None) + self.maxdisplayed = maxdisplayed if maxdisplayed is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_selected.py b/plotly/graph_objs/scatter/_selected.py new file mode 100644 index 0000000000..fffc5bd54c --- /dev/null +++ b/plotly/graph_objs/scatter/_selected.py @@ -0,0 +1,138 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatter.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scatter.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatter.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scatter.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatter.selected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.scatter.selected.Textfont instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Selected + marker + plotly.graph_objs.scatter.selected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.scatter.selected.Textfont instance or + dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_stream.py b/plotly/graph_objs/scatter/_stream.py new file mode 100644 index 0000000000..b93e817c58 --- /dev/null +++ b/plotly/graph_objs/scatter/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_textfont.py b/plotly/graph_objs/scatter/_textfont.py new file mode 100644 index 0000000000..0c9301a524 --- /dev/null +++ b/plotly/graph_objs/scatter/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/_unselected.py b/plotly/graph_objs/scatter/_unselected.py new file mode 100644 index 0000000000..e7db30628d --- /dev/null +++ b/plotly/graph_objs/scatter/_unselected.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatter.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatter.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatter.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatter.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatter.unselected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.scatter.unselected.Textfont instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.Unselected + marker + plotly.graph_objs.scatter.unselected.Marker instance or + dict with compatible properties + textfont + plotly.graph_objs.scatter.unselected.Textfont instance + or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scatter.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/hoverlabel/__init__.py b/plotly/graph_objs/scatter/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scatter/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scatter/hoverlabel/_font.py b/plotly/graph_objs/scatter/hoverlabel/_font.py new file mode 100644 index 0000000000..d2c2857789 --- /dev/null +++ b/plotly/graph_objs/scatter/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scatter.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/__init__.py b/plotly/graph_objs/scatter/marker/__init__.py new file mode 100644 index 0000000000..0e59207081 --- /dev/null +++ b/plotly/graph_objs/scatter/marker/__init__.py @@ -0,0 +1,4 @@ +from ._line import Line +from ._gradient import Gradient +from ._colorbar import ColorBar +from plotly.graph_objs.scatter.marker import colorbar diff --git a/plotly/graph_objs/scatter/marker/_colorbar.py b/plotly/graph_objs/scatter/marker/_colorbar.py new file mode 100644 index 0000000000..e0a3407205 --- /dev/null +++ b/plotly/graph_objs/scatter/marker/_colorbar.py @@ -0,0 +1,1736 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scatter.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatter.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scatter.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scatter.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scatter.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatter.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter.marker.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter.marker.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/_gradient.py b/plotly/graph_objs/scatter/marker/_gradient.py new file mode 100644 index 0000000000..2dfd7b600a --- /dev/null +++ b/plotly/graph_objs/scatter/marker/_gradient.py @@ -0,0 +1,228 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Gradient(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the final color of the gradient fill: the center color for + radial, the right for horizontal, or the bottom for vertical. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the type of gradient used to fill the markers + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radial', 'horizontal', 'vertical', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # typesrc + # ------- + @property + def typesrc(self): + """ + Sets the source reference on plot.ly for type . + + The 'typesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['typesrc'] + + @typesrc.setter + def typesrc(self, val): + self['typesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + type=None, + typesrc=None, + **kwargs + ): + """ + Construct a new Gradient object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.marker.Gradient + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + + Returns + ------- + Gradient + """ + super(Gradient, self).__init__('gradient') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.Gradient +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.Gradient""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker import (gradient as v_gradient) + + # Initialize validators + # --------------------- + self._validators['color'] = v_gradient.ColorValidator() + self._validators['colorsrc'] = v_gradient.ColorsrcValidator() + self._validators['type'] = v_gradient.TypeValidator() + self._validators['typesrc'] = v_gradient.TypesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('typesrc', None) + self.typesrc = typesrc if typesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/_line.py b/plotly/graph_objs/scatter/marker/_line.py new file mode 100644 index 0000000000..a4ea83c3d0 --- /dev/null +++ b/plotly/graph_objs/scatter/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatter.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/colorbar/__init__.py b/plotly/graph_objs/scatter/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scatter/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scatter/marker/colorbar/_tickfont.py b/plotly/graph_objs/scatter/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..d4e9172d1c --- /dev/null +++ b/plotly/graph_objs/scatter/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scatter/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..6b7282b26f --- /dev/null +++ b/plotly/graph_objs/scatter/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter.marker.colorba + r.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/marker/colorbar/_titlefont.py b/plotly/graph_objs/scatter/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..d61181b111 --- /dev/null +++ b/plotly/graph_objs/scatter/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scatter.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/selected/__init__.py b/plotly/graph_objs/scatter/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatter/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatter/selected/_marker.py b/plotly/graph_objs/scatter/selected/_marker.py new file mode 100644 index 0000000000..95b3f3c1d5 --- /dev/null +++ b/plotly/graph_objs/scatter/selected/_marker.py @@ -0,0 +1,187 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatter.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/selected/_textfont.py b/plotly/graph_objs/scatter/selected/_textfont.py new file mode 100644 index 0000000000..d028e152f9 --- /dev/null +++ b/plotly/graph_objs/scatter/selected/_textfont.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.selected import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/unselected/__init__.py b/plotly/graph_objs/scatter/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatter/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatter/unselected/_marker.py b/plotly/graph_objs/scatter/unselected/_marker.py new file mode 100644 index 0000000000..4ef41c8541 --- /dev/null +++ b/plotly/graph_objs/scatter/unselected/_marker.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatter.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter/unselected/_textfont.py b/plotly/graph_objs/scatter/unselected/_textfont.py new file mode 100644 index 0000000000..64e137e701 --- /dev/null +++ b/plotly/graph_objs/scatter/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/__init__.py b/plotly/graph_objs/scatter3d/__init__.py new file mode 100644 index 0000000000..d4e7a5481c --- /dev/null +++ b/plotly/graph_objs/scatter3d/__init__.py @@ -0,0 +1,12 @@ +from ._textfont import Textfont +from ._stream import Stream +from ._projection import Projection +from plotly.graph_objs.scatter3d import projection +from ._marker import Marker +from plotly.graph_objs.scatter3d import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scatter3d import hoverlabel +from ._error_z import ErrorZ +from ._error_y import ErrorY +from ._error_x import ErrorX diff --git a/plotly/graph_objs/scatter3d/_error_x.py b/plotly/graph_objs/scatter3d/_error_x.py new file mode 100644 index 0000000000..f95916e146 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_error_x.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorX(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_zstyle + # ----------- + @property + def copy_zstyle(self): + """ + The 'copy_zstyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_zstyle'] + + @copy_zstyle.setter + def copy_zstyle(self, val): + self['copy_zstyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_zstyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorX object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.ErrorX + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorX + """ + super(ErrorX, self).__init__('error_x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.ErrorX +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.ErrorX""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (error_x as v_error_x) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_x.ArrayValidator() + self._validators['arrayminus'] = v_error_x.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_x.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_x.ArraysrcValidator() + self._validators['color'] = v_error_x.ColorValidator() + self._validators['copy_zstyle'] = v_error_x.CopyZstyleValidator() + self._validators['symmetric'] = v_error_x.SymmetricValidator() + self._validators['thickness'] = v_error_x.ThicknessValidator() + self._validators['traceref'] = v_error_x.TracerefValidator() + self._validators['tracerefminus'] = v_error_x.TracerefminusValidator() + self._validators['type'] = v_error_x.TypeValidator() + self._validators['value'] = v_error_x.ValueValidator() + self._validators['valueminus'] = v_error_x.ValueminusValidator() + self._validators['visible'] = v_error_x.VisibleValidator() + self._validators['width'] = v_error_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_zstyle', None) + self.copy_zstyle = copy_zstyle if copy_zstyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_error_y.py b/plotly/graph_objs/scatter3d/_error_y.py new file mode 100644 index 0000000000..052ed98d6b --- /dev/null +++ b/plotly/graph_objs/scatter3d/_error_y.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorY(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_zstyle + # ----------- + @property + def copy_zstyle(self): + """ + The 'copy_zstyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_zstyle'] + + @copy_zstyle.setter + def copy_zstyle(self, val): + self['copy_zstyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_zstyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorY object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.ErrorY + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorY + """ + super(ErrorY, self).__init__('error_y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.ErrorY +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.ErrorY""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (error_y as v_error_y) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_y.ArrayValidator() + self._validators['arrayminus'] = v_error_y.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_y.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_y.ArraysrcValidator() + self._validators['color'] = v_error_y.ColorValidator() + self._validators['copy_zstyle'] = v_error_y.CopyZstyleValidator() + self._validators['symmetric'] = v_error_y.SymmetricValidator() + self._validators['thickness'] = v_error_y.ThicknessValidator() + self._validators['traceref'] = v_error_y.TracerefValidator() + self._validators['tracerefminus'] = v_error_y.TracerefminusValidator() + self._validators['type'] = v_error_y.TypeValidator() + self._validators['value'] = v_error_y.ValueValidator() + self._validators['valueminus'] = v_error_y.ValueminusValidator() + self._validators['visible'] = v_error_y.VisibleValidator() + self._validators['width'] = v_error_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_zstyle', None) + self.copy_zstyle = copy_zstyle if copy_zstyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_error_z.py b/plotly/graph_objs/scatter3d/_error_z.py new file mode 100644 index 0000000000..f134fcc8e8 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_error_z.py @@ -0,0 +1,561 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorZ(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorZ object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.ErrorZ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorZ + """ + super(ErrorZ, self).__init__('error_z') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.ErrorZ +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.ErrorZ""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (error_z as v_error_z) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_z.ArrayValidator() + self._validators['arrayminus'] = v_error_z.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_z.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_z.ArraysrcValidator() + self._validators['color'] = v_error_z.ColorValidator() + self._validators['symmetric'] = v_error_z.SymmetricValidator() + self._validators['thickness'] = v_error_z.ThicknessValidator() + self._validators['traceref'] = v_error_z.TracerefValidator() + self._validators['tracerefminus'] = v_error_z.TracerefminusValidator() + self._validators['type'] = v_error_z.TypeValidator() + self._validators['value'] = v_error_z.ValueValidator() + self._validators['valueminus'] = v_error_z.ValueminusValidator() + self._validators['visible'] = v_error_z.VisibleValidator() + self._validators['width'] = v_error_z.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_hoverlabel.py b/plotly/graph_objs/scatter3d/_hoverlabel.py new file mode 100644 index 0000000000..f862185d19 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatter3d.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_line.py b/plotly/graph_objs/scatter3d/_line.py new file mode 100644 index 0000000000..03ac910276 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_line.py @@ -0,0 +1,545 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `line.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `line.color` is set to a numerical array + and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Sets the upper bound of the color domain. Value should be + associated to the `line.color` array index, and if set, + `line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Sets the lower bound of the color domain. Value should be + associated to the `line.color` array index, and if set, + `line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the line color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatter3d.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `line.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be + a palette name string of the following list: Greys, YlGnBu, + Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, + Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of the lines. + + The 'dash' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + + Returns + ------- + Any + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Reverses the color mapping if true (`cmin` will correspond to + the last color in the array and `cmax` will correspond to the + first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `line.color` is set to a numerical array. + Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmin` must be set as + well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmax` must be set as + well. + color + Sets the line color. It accepts either a specific color + or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `line.cmin` and `line.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + dash + Sets the dash style of the lines. + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + dash=None, + reversescale=None, + showscale=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Line + autocolorscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmin` must be set as + well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the `line.color` + array index, and if set, `line.cmax` must be set as + well. + color + Sets the line color. It accepts either a specific color + or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `line.cmin` and `line.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + dash + Sets the dash style of the lines. + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['showscale'] = v_line.ShowscaleValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_marker.py b/plotly/graph_objs/scatter3d/_marker.py new file mode 100644 index 0000000000..d3adcf1337 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_marker.py @@ -0,0 +1,1077 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatter3d.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter3d.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scatter3d.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + + Returns + ------- + plotly.graph_objs.scatter3d.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. Note that the marker opacity for + scatter3d traces must be a scalar value for performance + reasons. To set a blending opacity value (i.e. which is not + transparent), set *marker.color* to an rgba color and use its + alpha channel. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['circle', 'circle-open', 'square', 'square-open', + 'diamond', 'diamond-open', 'cross', 'x'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter3d.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scatter3d.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. Note that the marker opacity + for scatter3d traces must be a scalar value for + performance reasons. To set a blending opacity value + (i.e. which is not transparent), set *marker.color* to + an rgba color and use its alpha channel. + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter3d.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scatter3d.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. Note that the marker opacity + for scatter3d traces must be a scalar value for + performance reasons. To set a blending opacity value + (i.e. which is not transparent), set *marker.color* to + an rgba color and use its alpha channel. + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_projection.py b/plotly/graph_objs/scatter3d/_projection.py new file mode 100644 index 0000000000..713e9ab936 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_projection.py @@ -0,0 +1,187 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Projection(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is an instance of X + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.projection.X + - A dict of string/value properties that will be passed + to the X constructor + + Supported dict properties: + + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the x axis. + + Returns + ------- + plotly.graph_objs.scatter3d.projection.X + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is an instance of Y + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.projection.Y + - A dict of string/value properties that will be passed + to the Y constructor + + Supported dict properties: + + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the y axis. + + Returns + ------- + plotly.graph_objs.scatter3d.projection.Y + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is an instance of Z + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.projection.Z + - A dict of string/value properties that will be passed + to the Z constructor + + Supported dict properties: + + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the z axis. + + Returns + ------- + plotly.graph_objs.scatter3d.projection.Z + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + plotly.graph_objs.scatter3d.projection.X instance or + dict with compatible properties + y + plotly.graph_objs.scatter3d.projection.Y instance or + dict with compatible properties + z + plotly.graph_objs.scatter3d.projection.Z instance or + dict with compatible properties + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Projection object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Projection + x + plotly.graph_objs.scatter3d.projection.X instance or + dict with compatible properties + y + plotly.graph_objs.scatter3d.projection.Y instance or + dict with compatible properties + z + plotly.graph_objs.scatter3d.projection.Z instance or + dict with compatible properties + + Returns + ------- + Projection + """ + super(Projection, self).__init__('projection') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Projection +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Projection""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (projection as v_projection) + + # Initialize validators + # --------------------- + self._validators['x'] = v_projection.XValidator() + self._validators['y'] = v_projection.YValidator() + self._validators['z'] = v_projection.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_stream.py b/plotly/graph_objs/scatter3d/_stream.py new file mode 100644 index 0000000000..b25604fab0 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/_textfont.py b/plotly/graph_objs/scatter3d/_textfont.py new file mode 100644 index 0000000000..abbf264e48 --- /dev/null +++ b/plotly/graph_objs/scatter3d/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/hoverlabel/__init__.py b/plotly/graph_objs/scatter3d/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scatter3d/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scatter3d/hoverlabel/_font.py b/plotly/graph_objs/scatter3d/hoverlabel/_font.py new file mode 100644 index 0000000000..9a2f23b009 --- /dev/null +++ b/plotly/graph_objs/scatter3d/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter3d.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/marker/__init__.py b/plotly/graph_objs/scatter3d/marker/__init__.py new file mode 100644 index 0000000000..b7529bfadd --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.scatter3d.marker import colorbar diff --git a/plotly/graph_objs/scatter3d/marker/_colorbar.py b/plotly/graph_objs/scatter3d/marker/_colorbar.py new file mode 100644 index 0000000000..f406d736d8 --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/_colorbar.py @@ -0,0 +1,1736 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatter3d.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scatter3d.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scatter3d.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scatter3d.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatter3d.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter3d.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter3d.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter3d.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/marker/_line.py b/plotly/graph_objs/scatter3d/marker/_line.py new file mode 100644 index 0000000000..e392607184 --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/_line.py @@ -0,0 +1,486 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatter3d.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/marker/colorbar/__init__.py b/plotly/graph_objs/scatter3d/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scatter3d/marker/colorbar/_tickfont.py b/plotly/graph_objs/scatter3d/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..faefecf3ed --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter3d.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scatter3d/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..7524d51abe --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.marker.color + bar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/marker/colorbar/_titlefont.py b/plotly/graph_objs/scatter3d/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..c19f9312ed --- /dev/null +++ b/plotly/graph_objs/scatter3d/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatter3d.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/projection/__init__.py b/plotly/graph_objs/scatter3d/projection/__init__.py new file mode 100644 index 0000000000..a9611dfd9f --- /dev/null +++ b/plotly/graph_objs/scatter3d/projection/__init__.py @@ -0,0 +1,3 @@ +from ._z import Z +from ._y import Y +from ._x import X diff --git a/plotly/graph_objs/scatter3d/projection/_x.py b/plotly/graph_objs/scatter3d/projection/_x.py new file mode 100644 index 0000000000..6f4191ba4c --- /dev/null +++ b/plotly/graph_objs/scatter3d/projection/_x.py @@ -0,0 +1,152 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class X(BaseTraceHierarchyType): + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the projection color. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # scale + # ----- + @property + def scale(self): + """ + Sets the scale factor determining the size of the projection + marker points. + + The 'scale' property is a number and may be specified as: + - An int or float in the interval [0, 10] + + Returns + ------- + int|float + """ + return self['scale'] + + @scale.setter + def scale(self, val): + self['scale'] = val + + # show + # ---- + @property + def show(self): + """ + Sets whether or not projections are shown along the x axis. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.projection' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the x + axis. + """ + + def __init__( + self, arg=None, opacity=None, scale=None, show=None, **kwargs + ): + """ + Construct a new X object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.projection.X + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the x + axis. + + Returns + ------- + X + """ + super(X, self).__init__('x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.projection.X +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.projection.X""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.projection import (x as v_x) + + # Initialize validators + # --------------------- + self._validators['opacity'] = v_x.OpacityValidator() + self._validators['scale'] = v_x.ScaleValidator() + self._validators['show'] = v_x.ShowValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('scale', None) + self.scale = scale if scale is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/projection/_y.py b/plotly/graph_objs/scatter3d/projection/_y.py new file mode 100644 index 0000000000..f9765df9e9 --- /dev/null +++ b/plotly/graph_objs/scatter3d/projection/_y.py @@ -0,0 +1,152 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Y(BaseTraceHierarchyType): + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the projection color. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # scale + # ----- + @property + def scale(self): + """ + Sets the scale factor determining the size of the projection + marker points. + + The 'scale' property is a number and may be specified as: + - An int or float in the interval [0, 10] + + Returns + ------- + int|float + """ + return self['scale'] + + @scale.setter + def scale(self, val): + self['scale'] = val + + # show + # ---- + @property + def show(self): + """ + Sets whether or not projections are shown along the y axis. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.projection' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the y + axis. + """ + + def __init__( + self, arg=None, opacity=None, scale=None, show=None, **kwargs + ): + """ + Construct a new Y object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.projection.Y + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the y + axis. + + Returns + ------- + Y + """ + super(Y, self).__init__('y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.projection.Y +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.projection.Y""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.projection import (y as v_y) + + # Initialize validators + # --------------------- + self._validators['opacity'] = v_y.OpacityValidator() + self._validators['scale'] = v_y.ScaleValidator() + self._validators['show'] = v_y.ShowValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('scale', None) + self.scale = scale if scale is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatter3d/projection/_z.py b/plotly/graph_objs/scatter3d/projection/_z.py new file mode 100644 index 0000000000..54d38cdf33 --- /dev/null +++ b/plotly/graph_objs/scatter3d/projection/_z.py @@ -0,0 +1,152 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Z(BaseTraceHierarchyType): + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the projection color. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # scale + # ----- + @property + def scale(self): + """ + Sets the scale factor determining the size of the projection + marker points. + + The 'scale' property is a number and may be specified as: + - An int or float in the interval [0, 10] + + Returns + ------- + int|float + """ + return self['scale'] + + @scale.setter + def scale(self, val): + self['scale'] = val + + # show + # ---- + @property + def show(self): + """ + Sets whether or not projections are shown along the z axis. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatter3d.projection' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the z + axis. + """ + + def __init__( + self, arg=None, opacity=None, scale=None, show=None, **kwargs + ): + """ + Construct a new Z object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatter3d.projection.Z + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of the + projection marker points. + show + Sets whether or not projections are shown along the z + axis. + + Returns + ------- + Z + """ + super(Z, self).__init__('z') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatter3d.projection.Z +constructor must be a dict or +an instance of plotly.graph_objs.scatter3d.projection.Z""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatter3d.projection import (z as v_z) + + # Initialize validators + # --------------------- + self._validators['opacity'] = v_z.OpacityValidator() + self._validators['scale'] = v_z.ScaleValidator() + self._validators['show'] = v_z.ShowValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('scale', None) + self.scale = scale if scale is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/__init__.py b/plotly/graph_objs/scattercarpet/__init__.py new file mode 100644 index 0000000000..a0bfe9a608 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.scattercarpet import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scattercarpet import selected +from ._marker import Marker +from plotly.graph_objs.scattercarpet import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scattercarpet import hoverlabel diff --git a/plotly/graph_objs/scattercarpet/_hoverlabel.py b/plotly/graph_objs/scattercarpet/_hoverlabel.py new file mode 100644 index 0000000000..24a718bcbb --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattercarpet.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_line.py b/plotly/graph_objs/scattercarpet/_line.py new file mode 100644 index 0000000000..934d6c5e5a --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_line.py @@ -0,0 +1,272 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # shape + # ----- + @property + def shape(self): + """ + Determines the line shape. With *spline* the lines are drawn + using spline interpolation. The other available values + correspond to step-wise line shapes. + + The 'shape' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'spline'] + + Returns + ------- + Any + """ + return self['shape'] + + @shape.setter + def shape(self, val): + self['shape'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Has an effect only if `shape` is set to *spline* Sets the + amount of smoothing. *0* corresponds to no smoothing + (equivalent to a *linear* shape). + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + shape=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['shape'] = v_line.ShapeValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('shape', None) + self.shape = shape if shape is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_marker.py b/plotly/graph_objs/scattercarpet/_marker.py new file mode 100644 index 0000000000..73c5bb44b8 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_marker.py @@ -0,0 +1,1244 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattercarpet.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattercarpet.marker.colorbar + .Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scattercarpet.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # gradient + # -------- + @property + def gradient(self): + """ + The 'gradient' property is an instance of Gradient + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.marker.Gradient + - A dict of string/value properties that will be passed + to the Gradient constructor + + Supported dict properties: + + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + . + + Returns + ------- + plotly.graph_objs.scattercarpet.marker.Gradient + """ + return self['gradient'] + + @gradient.setter + def gradient(self, val): + self['gradient'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmin` must be + set as well. + cmin + Has an effect only if `color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmax` must be + set as well. + color + Sets the color. It accepts either a specific + color or an array of numbers that are mapped to + the colorscale relative to the max and min + values of the array or relative to `cmin` and + `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `cmin` and `cmax`. Alternatively, + `colorscale` may be a palette name string of + the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, + Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scattercarpet.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # maxdisplayed + # ------------ + @property + def maxdisplayed(self): + """ + Sets a maximum number of points to be drawn on the graph. *0* + corresponds to no limit. + + The 'maxdisplayed' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['maxdisplayed'] + + @maxdisplayed.setter + def maxdisplayed(self, val): + self['maxdisplayed'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattercarpet.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scattercarpet.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattercarpet.marker.Line instance or + dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + gradient=None, + line=None, + maxdisplayed=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattercarpet.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scattercarpet.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattercarpet.marker.Line instance or + dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['gradient'] = v_marker.GradientValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['maxdisplayed'] = v_marker.MaxdisplayedValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('gradient', None) + self.gradient = gradient if gradient is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('maxdisplayed', None) + self.maxdisplayed = maxdisplayed if maxdisplayed is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_selected.py b/plotly/graph_objs/scattercarpet/_selected.py new file mode 100644 index 0000000000..370783350f --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_selected.py @@ -0,0 +1,138 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scattercarpet.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scattercarpet.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattercarpet.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.selected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.Selected + marker + plotly.graph_objs.scattercarpet.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_stream.py b/plotly/graph_objs/scattercarpet/_stream.py new file mode 100644 index 0000000000..ec5b1f18fb --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_textfont.py b/plotly/graph_objs/scattercarpet/_textfont.py new file mode 100644 index 0000000000..976f324989 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/_unselected.py b/plotly/graph_objs/scattercarpet/_unselected.py new file mode 100644 index 0000000000..edc49b0ef7 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/_unselected.py @@ -0,0 +1,145 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattercarpet.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattercarpet.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattercarpet.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.Unselected + marker + plotly.graph_objs.scattercarpet.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet import ( + unselected as v_unselected + ) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/hoverlabel/__init__.py b/plotly/graph_objs/scattercarpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scattercarpet/hoverlabel/_font.py b/plotly/graph_objs/scattercarpet/hoverlabel/_font.py new file mode 100644 index 0000000000..254141cf29 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/__init__.py b/plotly/graph_objs/scattercarpet/marker/__init__.py new file mode 100644 index 0000000000..5d2ebb72ce --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/__init__.py @@ -0,0 +1,4 @@ +from ._line import Line +from ._gradient import Gradient +from ._colorbar import ColorBar +from plotly.graph_objs.scattercarpet.marker import colorbar diff --git a/plotly/graph_objs/scattercarpet/marker/_colorbar.py b/plotly/graph_objs/scattercarpet/marker/_colorbar.py new file mode 100644 index 0000000000..037264b5fb --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattercarpet.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scattercarpet.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scattercarpet.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scattercarpet.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattercarpet.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattercarpet.marker.colorbar.Tickfor + matstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattercarpet.marker.colorbar.Tickfor + matstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/_gradient.py b/plotly/graph_objs/scattercarpet/marker/_gradient.py new file mode 100644 index 0000000000..09af68a044 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/_gradient.py @@ -0,0 +1,230 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Gradient(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the final color of the gradient fill: the center color for + radial, the right for horizontal, or the bottom for vertical. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the type of gradient used to fill the markers + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radial', 'horizontal', 'vertical', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # typesrc + # ------- + @property + def typesrc(self): + """ + Sets the source reference on plot.ly for type . + + The 'typesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['typesrc'] + + @typesrc.setter + def typesrc(self, val): + self['typesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + type=None, + typesrc=None, + **kwargs + ): + """ + Construct a new Gradient object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.marker.Gradient + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + + Returns + ------- + Gradient + """ + super(Gradient, self).__init__('gradient') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.Gradient +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.Gradient""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker import ( + gradient as v_gradient + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_gradient.ColorValidator() + self._validators['colorsrc'] = v_gradient.ColorsrcValidator() + self._validators['type'] = v_gradient.TypeValidator() + self._validators['typesrc'] = v_gradient.TypesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('typesrc', None) + self.typesrc = typesrc if typesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/_line.py b/plotly/graph_objs/scattercarpet/marker/_line.py new file mode 100644 index 0000000000..cc29dc600b --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/_line.py @@ -0,0 +1,509 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `color` is set to a numerical array. + Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `color` is set to a numerical array and + `cmin`, `cmax` are set by the user. In this case, it controls + whether the range of colors in `colorscale` is mapped to the + range of values in the `color` array (`cauto: true`), or the + `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the upper bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmin` must be set as + well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `color` is set to a numerical array. Sets + the lower bound of the color domain. Value should be associated + to the `color` array index, and if set, `cmax` must be set as + well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the color. It accepts either a specific color or an array + of numbers that are mapped to the colorscale relative to the + max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattercarpet.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `color` is set to + a numerical array. The colorscale must be an array containing + arrays mapping a normalized value to an rgb, rgba, hex, hsl, + hsv, or named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the + bounds of the colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `color` is set to a numerical array. + Reverses the color mapping if true (`cmin` will correspond to + the last color in the array and `cmax` will correspond to the + first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color. It accepts either a specific color or + an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or + relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.marker.Line + autocolorscale + Has an effect only if `color` is set to a numerical + array. Determines whether the colorscale is a default + palette (`autocolorscale: true`) or the palette + determined by `colorscale`. In case `colorscale` is + unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this + case, it controls whether the range of colors in + `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a numerical + array. Sets the upper bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmin` must be set as well. + cmin + Has an effect only if `color` is set to a numerical + array. Sets the lower bound of the color domain. Value + should be associated to the `color` array index, and if + set, `cmax` must be set as well. + color + Sets the color. It accepts either a specific color or + an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or + relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if `color` + is set to a numerical array. The colorscale must be an + array containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) + values are required. For example, `[[0, 'rgb(0,0,255)', + [1, 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use `cmin` and `cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` + will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/colorbar/__init__.py b/plotly/graph_objs/scattercarpet/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scattercarpet/marker/colorbar/_tickfont.py b/plotly/graph_objs/scattercarpet/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..54b5416d9a --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.marker.c + olorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scattercarpet/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..36be86eafb --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.marker.c + olorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/marker/colorbar/_titlefont.py b/plotly/graph_objs/scattercarpet/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..8710a2eab8 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattercarpet.marker.c + olorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/selected/__init__.py b/plotly/graph_objs/scattercarpet/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scattercarpet/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scattercarpet/selected/_marker.py b/plotly/graph_objs/scattercarpet/selected/_marker.py new file mode 100644 index 0000000000..f3363472a0 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/selected/_marker.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.selected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/selected/_textfont.py b/plotly/graph_objs/scattercarpet/selected/_textfont.py new file mode 100644 index 0000000000..0b2b996667 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/unselected/__init__.py b/plotly/graph_objs/scattercarpet/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scattercarpet/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scattercarpet/unselected/_marker.py b/plotly/graph_objs/scattercarpet/unselected/_marker.py new file mode 100644 index 0000000000..5eb89f8ab3 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattercarpet/unselected/_textfont.py b/plotly/graph_objs/scattercarpet/unselected/_textfont.py new file mode 100644 index 0000000000..04abdb1db7 --- /dev/null +++ b/plotly/graph_objs/scattercarpet/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattercarpet.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattercarpet.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattercarpet.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattercarpet.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattercarpet.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/__init__.py b/plotly/graph_objs/scattergeo/__init__.py new file mode 100644 index 0000000000..a8d91a3750 --- /dev/null +++ b/plotly/graph_objs/scattergeo/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.scattergeo import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scattergeo import selected +from ._marker import Marker +from plotly.graph_objs.scattergeo import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scattergeo import hoverlabel diff --git a/plotly/graph_objs/scattergeo/_hoverlabel.py b/plotly/graph_objs/scattergeo/_hoverlabel.py new file mode 100644 index 0000000000..63524a5190 --- /dev/null +++ b/plotly/graph_objs/scattergeo/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattergeo.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_line.py b/plotly/graph_objs/scattergeo/_line.py new file mode 100644 index 0000000000..51f0a8a97f --- /dev/null +++ b/plotly/graph_objs/scattergeo/_line.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_marker.py b/plotly/graph_objs/scattergeo/_marker.py new file mode 100644 index 0000000000..275265bff1 --- /dev/null +++ b/plotly/graph_objs/scattergeo/_marker.py @@ -0,0 +1,1214 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattergeo.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergeo.marker.colorbar.Ti + ckformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scattergeo.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # gradient + # -------- + @property + def gradient(self): + """ + The 'gradient' property is an instance of Gradient + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.marker.Gradient + - A dict of string/value properties that will be passed + to the Gradient constructor + + Supported dict properties: + + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + . + + Returns + ------- + plotly.graph_objs.scattergeo.marker.Gradient + """ + return self['gradient'] + + @gradient.setter + def gradient(self, val): + self['gradient'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scattergeo.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergeo.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scattergeo.marker.Gradient instance + or dict with compatible properties + line + plotly.graph_objs.scattergeo.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + gradient=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergeo.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scattergeo.marker.Gradient instance + or dict with compatible properties + line + plotly.graph_objs.scattergeo.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['gradient'] = v_marker.GradientValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('gradient', None) + self.gradient = gradient if gradient is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_selected.py b/plotly/graph_objs/scattergeo/_selected.py new file mode 100644 index 0000000000..55d344fd48 --- /dev/null +++ b/plotly/graph_objs/scattergeo/_selected.py @@ -0,0 +1,138 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scattergeo.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scattergeo.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattergeo.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.selected.Textfont instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Selected + marker + plotly.graph_objs.scattergeo.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.selected.Textfont instance + or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_stream.py b/plotly/graph_objs/scattergeo/_stream.py new file mode 100644 index 0000000000..19ccdeb9bb --- /dev/null +++ b/plotly/graph_objs/scattergeo/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_textfont.py b/plotly/graph_objs/scattergeo/_textfont.py new file mode 100644 index 0000000000..a117c1e762 --- /dev/null +++ b/plotly/graph_objs/scattergeo/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/_unselected.py b/plotly/graph_objs/scattergeo/_unselected.py new file mode 100644 index 0000000000..0d79059a08 --- /dev/null +++ b/plotly/graph_objs/scattergeo/_unselected.py @@ -0,0 +1,142 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattergeo.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattergeo.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattergeo.unselected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.Unselected + marker + plotly.graph_objs.scattergeo.unselected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/hoverlabel/__init__.py b/plotly/graph_objs/scattergeo/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scattergeo/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scattergeo/hoverlabel/_font.py b/plotly/graph_objs/scattergeo/hoverlabel/_font.py new file mode 100644 index 0000000000..312ecb39c1 --- /dev/null +++ b/plotly/graph_objs/scattergeo/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/__init__.py b/plotly/graph_objs/scattergeo/marker/__init__.py new file mode 100644 index 0000000000..6359f441e5 --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/__init__.py @@ -0,0 +1,4 @@ +from ._line import Line +from ._gradient import Gradient +from ._colorbar import ColorBar +from plotly.graph_objs.scattergeo.marker import colorbar diff --git a/plotly/graph_objs/scattergeo/marker/_colorbar.py b/plotly/graph_objs/scattergeo/marker/_colorbar.py new file mode 100644 index 0000000000..66104ad8e8 --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattergeo.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scattergeo.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scattergeo.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scattergeo.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattergeo.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergeo.marker.colorbar.Tickformat + stop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergeo.marker.colorbar.Tickformat + stop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/_gradient.py b/plotly/graph_objs/scattergeo/marker/_gradient.py new file mode 100644 index 0000000000..b52d83880b --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/_gradient.py @@ -0,0 +1,230 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Gradient(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the final color of the gradient fill: the center color for + radial, the right for horizontal, or the bottom for vertical. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the type of gradient used to fill the markers + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radial', 'horizontal', 'vertical', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # typesrc + # ------- + @property + def typesrc(self): + """ + Sets the source reference on plot.ly for type . + + The 'typesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['typesrc'] + + @typesrc.setter + def typesrc(self, val): + self['typesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + type=None, + typesrc=None, + **kwargs + ): + """ + Construct a new Gradient object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.marker.Gradient + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + + Returns + ------- + Gradient + """ + super(Gradient, self).__init__('gradient') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.Gradient +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.Gradient""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker import ( + gradient as v_gradient + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_gradient.ColorValidator() + self._validators['colorsrc'] = v_gradient.ColorsrcValidator() + self._validators['type'] = v_gradient.TypeValidator() + self._validators['typesrc'] = v_gradient.TypesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('typesrc', None) + self.typesrc = typesrc if typesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/_line.py b/plotly/graph_objs/scattergeo/marker/_line.py new file mode 100644 index 0000000000..7f7065f9a4 --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattergeo.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/colorbar/__init__.py b/plotly/graph_objs/scattergeo/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scattergeo/marker/colorbar/_tickfont.py b/plotly/graph_objs/scattergeo/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..b4a0cd6431 --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scattergeo/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..c1a21424fd --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergeo.marker.colo + rbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/marker/colorbar/_titlefont.py b/plotly/graph_objs/scattergeo/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..53a09e2def --- /dev/null +++ b/plotly/graph_objs/scattergeo/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/selected/__init__.py b/plotly/graph_objs/scattergeo/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scattergeo/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scattergeo/selected/_marker.py b/plotly/graph_objs/scattergeo/selected/_marker.py new file mode 100644 index 0000000000..80a0d8cc9a --- /dev/null +++ b/plotly/graph_objs/scattergeo/selected/_marker.py @@ -0,0 +1,187 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/selected/_textfont.py b/plotly/graph_objs/scattergeo/selected/_textfont.py new file mode 100644 index 0000000000..29814a9260 --- /dev/null +++ b/plotly/graph_objs/scattergeo/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/unselected/__init__.py b/plotly/graph_objs/scattergeo/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scattergeo/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scattergeo/unselected/_marker.py b/plotly/graph_objs/scattergeo/unselected/_marker.py new file mode 100644 index 0000000000..b7743f93aa --- /dev/null +++ b/plotly/graph_objs/scattergeo/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergeo/unselected/_textfont.py b/plotly/graph_objs/scattergeo/unselected/_textfont.py new file mode 100644 index 0000000000..8d18391138 --- /dev/null +++ b/plotly/graph_objs/scattergeo/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergeo.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergeo.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergeo.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattergeo.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergeo.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/__init__.py b/plotly/graph_objs/scattergl/__init__.py new file mode 100644 index 0000000000..2cf5899d5b --- /dev/null +++ b/plotly/graph_objs/scattergl/__init__.py @@ -0,0 +1,12 @@ +from ._unselected import Unselected +from plotly.graph_objs.scattergl import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scattergl import selected +from ._marker import Marker +from plotly.graph_objs.scattergl import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scattergl import hoverlabel +from ._error_y import ErrorY +from ._error_x import ErrorX diff --git a/plotly/graph_objs/scattergl/_error_x.py b/plotly/graph_objs/scattergl/_error_x.py new file mode 100644 index 0000000000..4c71049d43 --- /dev/null +++ b/plotly/graph_objs/scattergl/_error_x.py @@ -0,0 +1,587 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorX(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # copy_ystyle + # ----------- + @property + def copy_ystyle(self): + """ + The 'copy_ystyle' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['copy_ystyle'] + + @copy_ystyle.setter + def copy_ystyle(self, val): + self['copy_ystyle'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + copy_ystyle=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorX object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.ErrorX + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorX + """ + super(ErrorX, self).__init__('error_x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.ErrorX +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.ErrorX""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (error_x as v_error_x) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_x.ArrayValidator() + self._validators['arrayminus'] = v_error_x.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_x.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_x.ArraysrcValidator() + self._validators['color'] = v_error_x.ColorValidator() + self._validators['copy_ystyle'] = v_error_x.CopyYstyleValidator() + self._validators['symmetric'] = v_error_x.SymmetricValidator() + self._validators['thickness'] = v_error_x.ThicknessValidator() + self._validators['traceref'] = v_error_x.TracerefValidator() + self._validators['tracerefminus'] = v_error_x.TracerefminusValidator() + self._validators['type'] = v_error_x.TypeValidator() + self._validators['value'] = v_error_x.ValueValidator() + self._validators['valueminus'] = v_error_x.ValueminusValidator() + self._validators['visible'] = v_error_x.VisibleValidator() + self._validators['width'] = v_error_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('copy_ystyle', None) + self.copy_ystyle = copy_ystyle if copy_ystyle is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_error_y.py b/plotly/graph_objs/scattergl/_error_y.py new file mode 100644 index 0000000000..2a78a5be7c --- /dev/null +++ b/plotly/graph_objs/scattergl/_error_y.py @@ -0,0 +1,561 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ErrorY(BaseTraceHierarchyType): + + # array + # ----- + @property + def array(self): + """ + Sets the data corresponding the length of each error bar. + Values are plotted relative to the underlying data. + + The 'array' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['array'] + + @array.setter + def array(self, val): + self['array'] = val + + # arrayminus + # ---------- + @property + def arrayminus(self): + """ + Sets the data corresponding the length of each error bar in the + bottom (left) direction for vertical (horizontal) bars Values + are plotted relative to the underlying data. + + The 'arrayminus' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['arrayminus'] + + @arrayminus.setter + def arrayminus(self, val): + self['arrayminus'] = val + + # arrayminussrc + # ------------- + @property + def arrayminussrc(self): + """ + Sets the source reference on plot.ly for arrayminus . + + The 'arrayminussrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arrayminussrc'] + + @arrayminussrc.setter + def arrayminussrc(self, val): + self['arrayminussrc'] = val + + # arraysrc + # -------- + @property + def arraysrc(self): + """ + Sets the source reference on plot.ly for array . + + The 'arraysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['arraysrc'] + + @arraysrc.setter + def arraysrc(self, val): + self['arraysrc'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the stoke color of the error bars. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # symmetric + # --------- + @property + def symmetric(self): + """ + Determines whether or not the error bars have the same length + in both direction (top/bottom for vertical bars, left/right for + horizontal bars. + + The 'symmetric' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['symmetric'] + + @symmetric.setter + def symmetric(self, val): + self['symmetric'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness (in px) of the error bars. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # traceref + # -------- + @property + def traceref(self): + """ + The 'traceref' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['traceref'] + + @traceref.setter + def traceref(self, val): + self['traceref'] = val + + # tracerefminus + # ------------- + @property + def tracerefminus(self): + """ + The 'tracerefminus' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['tracerefminus'] + + @tracerefminus.setter + def tracerefminus(self, val): + self['tracerefminus'] = val + + # type + # ---- + @property + def type(self): + """ + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. Set this + constant in `value`. If *percent*, the bar lengths correspond + to a percentage of underlying data. Set this percentage in + `value`. If *sqrt*, the bar lengths correspond to the sqaure of + the underlying data. If *array*, the bar lengths are set with + data set `array`. + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['percent', 'constant', 'sqrt', 'data'] + + Returns + ------- + Any + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # value + # ----- + @property + def value(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars. + + The 'value' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # valueminus + # ---------- + @property + def valueminus(self): + """ + Sets the value of either the percentage (if `type` is set to + *percent*) or the constant (if `type` is set to *constant*) + corresponding to the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + + The 'valueminus' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['valueminus'] + + @valueminus.setter + def valueminus(self, val): + self['valueminus'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this set of error bars is visible. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the cross-bar at both ends of the + error bars. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + """ + + def __init__( + self, + arg=None, + array=None, + arrayminus=None, + arrayminussrc=None, + arraysrc=None, + color=None, + symmetric=None, + thickness=None, + traceref=None, + tracerefminus=None, + type=None, + value=None, + valueminus=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new ErrorY object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.ErrorY + array + Sets the data corresponding the length of each error + bar. Values are plotted relative to the underlying + data. + arrayminus + Sets the data corresponding the length of each error + bar in the bottom (left) direction for vertical + (horizontal) bars Values are plotted relative to the + underlying data. + arrayminussrc + Sets the source reference on plot.ly for arrayminus . + arraysrc + Sets the source reference on plot.ly for array . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have the same + length in both direction (top/bottom for vertical bars, + left/right for horizontal bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error bars. If + *constant`, the bar lengths are of a constant value. + Set this constant in `value`. If *percent*, the bar + lengths correspond to a percentage of underlying data. + Set this percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the underlying + data. If *array*, the bar lengths are set with data set + `array`. + value + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars. + valueminus + Sets the value of either the percentage (if `type` is + set to *percent*) or the constant (if `type` is set to + *constant*) corresponding to the lengths of the error + bars in the bottom (left) direction for vertical + (horizontal) bars + visible + Determines whether or not this set of error bars is + visible. + width + Sets the width (in px) of the cross-bar at both ends of + the error bars. + + Returns + ------- + ErrorY + """ + super(ErrorY, self).__init__('error_y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.ErrorY +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.ErrorY""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (error_y as v_error_y) + + # Initialize validators + # --------------------- + self._validators['array'] = v_error_y.ArrayValidator() + self._validators['arrayminus'] = v_error_y.ArrayminusValidator() + self._validators['arrayminussrc'] = v_error_y.ArrayminussrcValidator() + self._validators['arraysrc'] = v_error_y.ArraysrcValidator() + self._validators['color'] = v_error_y.ColorValidator() + self._validators['symmetric'] = v_error_y.SymmetricValidator() + self._validators['thickness'] = v_error_y.ThicknessValidator() + self._validators['traceref'] = v_error_y.TracerefValidator() + self._validators['tracerefminus'] = v_error_y.TracerefminusValidator() + self._validators['type'] = v_error_y.TypeValidator() + self._validators['value'] = v_error_y.ValueValidator() + self._validators['valueminus'] = v_error_y.ValueminusValidator() + self._validators['visible'] = v_error_y.VisibleValidator() + self._validators['width'] = v_error_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('array', None) + self.array = array if array is not None else v + v = arg.pop('arrayminus', None) + self.arrayminus = arrayminus if arrayminus is not None else v + v = arg.pop('arrayminussrc', None) + self.arrayminussrc = arrayminussrc if arrayminussrc is not None else v + v = arg.pop('arraysrc', None) + self.arraysrc = arraysrc if arraysrc is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('symmetric', None) + self.symmetric = symmetric if symmetric is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('traceref', None) + self.traceref = traceref if traceref is not None else v + v = arg.pop('tracerefminus', None) + self.tracerefminus = tracerefminus if tracerefminus is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + v = arg.pop('valueminus', None) + self.valueminus = valueminus if valueminus is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_hoverlabel.py b/plotly/graph_objs/scattergl/_hoverlabel.py new file mode 100644 index 0000000000..0541eb84d3 --- /dev/null +++ b/plotly/graph_objs/scattergl/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scattergl.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattergl.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_line.py b/plotly/graph_objs/scattergl/_line.py new file mode 100644 index 0000000000..b1d81fec16 --- /dev/null +++ b/plotly/graph_objs/scattergl/_line.py @@ -0,0 +1,186 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the style of the lines. + + The 'dash' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + + Returns + ------- + Any + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Line + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_marker.py b/plotly/graph_objs/scattergl/_marker.py new file mode 100644 index 0000000000..ad0ab61b1a --- /dev/null +++ b/plotly/graph_objs/scattergl/_marker.py @@ -0,0 +1,1167 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattergl.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scattergl.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergl.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scattergl.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scattergl.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scattergl.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergl.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scattergl.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergl.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scattergl.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_selected.py b/plotly/graph_objs/scattergl/_selected.py new file mode 100644 index 0000000000..cb16f9c696 --- /dev/null +++ b/plotly/graph_objs/scattergl/_selected.py @@ -0,0 +1,103 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergl.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scattergl.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattergl.selected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Selected + marker + plotly.graph_objs.scattergl.selected.Marker instance or + dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_stream.py b/plotly/graph_objs/scattergl/_stream.py new file mode 100644 index 0000000000..923018f272 --- /dev/null +++ b/plotly/graph_objs/scattergl/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/_unselected.py b/plotly/graph_objs/scattergl/_unselected.py new file mode 100644 index 0000000000..6be4536c8f --- /dev/null +++ b/plotly/graph_objs/scattergl/_unselected.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattergl.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattergl.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattergl.unselected.Marker instance + or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.Unselected + marker + plotly.graph_objs.scattergl.unselected.Marker instance + or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/hoverlabel/__init__.py b/plotly/graph_objs/scattergl/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scattergl/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scattergl/hoverlabel/_font.py b/plotly/graph_objs/scattergl/hoverlabel/_font.py new file mode 100644 index 0000000000..f21f312708 --- /dev/null +++ b/plotly/graph_objs/scattergl/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/marker/__init__.py b/plotly/graph_objs/scattergl/marker/__init__.py new file mode 100644 index 0000000000..977c8947b3 --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.scattergl.marker import colorbar diff --git a/plotly/graph_objs/scattergl/marker/_colorbar.py b/plotly/graph_objs/scattergl/marker/_colorbar.py new file mode 100644 index 0000000000..6e6dad6d95 --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/_colorbar.py @@ -0,0 +1,1736 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scattergl.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattergl.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scattergl.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scattergl.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scattergl.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattergl.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergl.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergl.marker.colorbar.Tickformats + top instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/marker/_line.py b/plotly/graph_objs/scattergl/marker/_line.py new file mode 100644 index 0000000000..b74ce0d804 --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattergl.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/marker/colorbar/__init__.py b/plotly/graph_objs/scattergl/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scattergl/marker/colorbar/_tickfont.py b/plotly/graph_objs/scattergl/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..7d07c7ca9b --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scattergl/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..b80f5db706 --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattergl.marker.color + bar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/marker/colorbar/_titlefont.py b/plotly/graph_objs/scattergl/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..ffe2306403 --- /dev/null +++ b/plotly/graph_objs/scattergl/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/selected/__init__.py b/plotly/graph_objs/scattergl/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/scattergl/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/scattergl/selected/_marker.py b/plotly/graph_objs/scattergl/selected/_marker.py new file mode 100644 index 0000000000..67cdfa8a38 --- /dev/null +++ b/plotly/graph_objs/scattergl/selected/_marker.py @@ -0,0 +1,187 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattergl/unselected/__init__.py b/plotly/graph_objs/scattergl/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/scattergl/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/scattergl/unselected/_marker.py b/plotly/graph_objs/scattergl/unselected/_marker.py new file mode 100644 index 0000000000..e8437d8142 --- /dev/null +++ b/plotly/graph_objs/scattergl/unselected/_marker.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattergl.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattergl.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattergl.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattergl.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattergl.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/__init__.py b/plotly/graph_objs/scattermapbox/__init__.py new file mode 100644 index 0000000000..61c48854a1 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.scattermapbox import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scattermapbox import selected +from ._marker import Marker +from plotly.graph_objs.scattermapbox import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scattermapbox import hoverlabel diff --git a/plotly/graph_objs/scattermapbox/_hoverlabel.py b/plotly/graph_objs/scattermapbox/_hoverlabel.py new file mode 100644 index 0000000000..99b23d69b6 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scattermapbox.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_line.py b/plotly/graph_objs/scattermapbox/_line.py new file mode 100644 index 0000000000..8c279adb12 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_line.py @@ -0,0 +1,157 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.Line + color + Sets the line color. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Line +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_marker.py b/plotly/graph_objs/scattermapbox/_marker.py new file mode 100644 index 0000000000..ad68c8af94 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_marker.py @@ -0,0 +1,1001 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scattermapbox.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattermapbox.marker.colorbar + .Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scattermapbox.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol. Full list: https://www.mapbox.com/maki- + icons/ Note that the array `marker.color` and `marker.size` are + only available for *circle* symbols. + + The 'symbol' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattermapbox.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol. Full list: + https://www.mapbox.com/maki-icons/ Note that the array + `marker.color` and `marker.size` are only available for + *circle* symbols. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattermapbox.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol. Full list: + https://www.mapbox.com/maki-icons/ Note that the array + `marker.color` and `marker.size` are only available for + *circle* symbols. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_selected.py b/plotly/graph_objs/scattermapbox/_selected.py new file mode 100644 index 0000000000..c3b63d82be --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_selected.py @@ -0,0 +1,103 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scattermapbox.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattermapbox.selected.Marker + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.Selected + marker + plotly.graph_objs.scattermapbox.selected.Marker + instance or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_stream.py b/plotly/graph_objs/scattermapbox/_stream.py new file mode 100644 index 0000000000..30d1f206f9 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_textfont.py b/plotly/graph_objs/scattermapbox/_textfont.py new file mode 100644 index 0000000000..a0ea92466b --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_textfont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Textfont object + + Sets the icon text font. Has an effect only when `type` is set + to *symbol*. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.Textfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['size'] = v_textfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/_unselected.py b/plotly/graph_objs/scattermapbox/_unselected.py new file mode 100644 index 0000000000..8b8266ad47 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/_unselected.py @@ -0,0 +1,109 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scattermapbox.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scattermapbox.unselected.Marker + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.Unselected + marker + plotly.graph_objs.scattermapbox.unselected.Marker + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox import ( + unselected as v_unselected + ) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/hoverlabel/__init__.py b/plotly/graph_objs/scattermapbox/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scattermapbox/hoverlabel/_font.py b/plotly/graph_objs/scattermapbox/hoverlabel/_font.py new file mode 100644 index 0000000000..542d32dc56 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/marker/__init__.py b/plotly/graph_objs/scattermapbox/marker/__init__.py new file mode 100644 index 0000000000..cb92c8b0bb --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/__init__.py @@ -0,0 +1,2 @@ +from ._colorbar import ColorBar +from plotly.graph_objs.scattermapbox.marker import colorbar diff --git a/plotly/graph_objs/scattermapbox/marker/_colorbar.py b/plotly/graph_objs/scattermapbox/marker/_colorbar.py new file mode 100644 index 0000000000..fadc9d0ea8 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattermapbox.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scattermapbox.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scattermapbox.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scattermapbox.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scattermapbox.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattermapbox.marker.colorbar.Tickfor + matstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scattermapbox.marker.colorbar.Tickfor + matstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/marker/colorbar/__init__.py b/plotly/graph_objs/scattermapbox/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scattermapbox/marker/colorbar/_tickfont.py b/plotly/graph_objs/scattermapbox/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..b69242c62c --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.marker.c + olorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scattermapbox/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..77460cca88 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.marker.c + olorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/marker/colorbar/_titlefont.py b/plotly/graph_objs/scattermapbox/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..22d8b60fff --- /dev/null +++ b/plotly/graph_objs/scattermapbox/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scattermapbox.marker.c + olorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/selected/__init__.py b/plotly/graph_objs/scattermapbox/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/scattermapbox/selected/_marker.py b/plotly/graph_objs/scattermapbox/selected/_marker.py new file mode 100644 index 0000000000..490987f429 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/selected/_marker.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.selected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scattermapbox/unselected/__init__.py b/plotly/graph_objs/scattermapbox/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/scattermapbox/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/scattermapbox/unselected/_marker.py b/plotly/graph_objs/scattermapbox/unselected/_marker.py new file mode 100644 index 0000000000..cc0513a72f --- /dev/null +++ b/plotly/graph_objs/scattermapbox/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scattermapbox.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scattermapbox.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scattermapbox.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scattermapbox.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scattermapbox.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/__init__.py b/plotly/graph_objs/scatterpolar/__init__.py new file mode 100644 index 0000000000..0ee49c4eb3 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.scatterpolar import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scatterpolar import selected +from ._marker import Marker +from plotly.graph_objs.scatterpolar import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scatterpolar import hoverlabel diff --git a/plotly/graph_objs/scatterpolar/_hoverlabel.py b/plotly/graph_objs/scatterpolar/_hoverlabel.py new file mode 100644 index 0000000000..8ffb93364b --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_hoverlabel.py @@ -0,0 +1,405 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatterpolar.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_line.py b/plotly/graph_objs/scatterpolar/_line.py new file mode 100644 index 0000000000..24524e72a7 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_line.py @@ -0,0 +1,272 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # shape + # ----- + @property + def shape(self): + """ + Determines the line shape. With *spline* the lines are drawn + using spline interpolation. The other available values + correspond to step-wise line shapes. + + The 'shape' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'spline'] + + Returns + ------- + Any + """ + return self['shape'] + + @shape.setter + def shape(self, val): + self['shape'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Has an effect only if `shape` is set to *spline* Sets the + amount of smoothing. *0* corresponds to no smoothing + (equivalent to a *linear* shape). + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + shape=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['shape'] = v_line.ShapeValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('shape', None) + self.shape = shape if shape is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_marker.py b/plotly/graph_objs/scatterpolar/_marker.py new file mode 100644 index 0000000000..e4ae0e903c --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_marker.py @@ -0,0 +1,1245 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterpolar.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolar.marker.colorbar. + Tickformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scatterpolar.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # gradient + # -------- + @property + def gradient(self): + """ + The 'gradient' property is an instance of Gradient + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.marker.Gradient + - A dict of string/value properties that will be passed + to the Gradient constructor + + Supported dict properties: + + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + . + + Returns + ------- + plotly.graph_objs.scatterpolar.marker.Gradient + """ + return self['gradient'] + + @gradient.setter + def gradient(self, val): + self['gradient'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scatterpolar.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # maxdisplayed + # ------------ + @property + def maxdisplayed(self): + """ + Sets a maximum number of points to be drawn on the graph. *0* + corresponds to no limit. + + The 'maxdisplayed' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['maxdisplayed'] + + @maxdisplayed.setter + def maxdisplayed(self, val): + self['maxdisplayed'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolar.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatterpolar.marker.Gradient instance + or dict with compatible properties + line + plotly.graph_objs.scatterpolar.marker.Line instance or + dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + gradient=None, + line=None, + maxdisplayed=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolar.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatterpolar.marker.Gradient instance + or dict with compatible properties + line + plotly.graph_objs.scatterpolar.marker.Line instance or + dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['gradient'] = v_marker.GradientValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['maxdisplayed'] = v_marker.MaxdisplayedValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('gradient', None) + self.gradient = gradient if gradient is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('maxdisplayed', None) + self.maxdisplayed = maxdisplayed if maxdisplayed is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_selected.py b/plotly/graph_objs/scatterpolar/_selected.py new file mode 100644 index 0000000000..d3214a71af --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_selected.py @@ -0,0 +1,138 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scatterpolar.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scatterpolar.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterpolar.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.selected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.Selected + marker + plotly.graph_objs.scatterpolar.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_stream.py b/plotly/graph_objs/scatterpolar/_stream.py new file mode 100644 index 0000000000..d74b21c792 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_textfont.py b/plotly/graph_objs/scatterpolar/_textfont.py new file mode 100644 index 0000000000..09aa08f9da --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_textfont.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/_unselected.py b/plotly/graph_objs/scatterpolar/_unselected.py new file mode 100644 index 0000000000..ca62697145 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/_unselected.py @@ -0,0 +1,143 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterpolar.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterpolar.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterpolar.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.Unselected + marker + plotly.graph_objs.scatterpolar.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/hoverlabel/__init__.py b/plotly/graph_objs/scatterpolar/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scatterpolar/hoverlabel/_font.py b/plotly/graph_objs/scatterpolar/hoverlabel/_font.py new file mode 100644 index 0000000000..8df5ffe31d --- /dev/null +++ b/plotly/graph_objs/scatterpolar/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/__init__.py b/plotly/graph_objs/scatterpolar/marker/__init__.py new file mode 100644 index 0000000000..b6b87dc145 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/__init__.py @@ -0,0 +1,4 @@ +from ._line import Line +from ._gradient import Gradient +from ._colorbar import ColorBar +from plotly.graph_objs.scatterpolar.marker import colorbar diff --git a/plotly/graph_objs/scatterpolar/marker/_colorbar.py b/plotly/graph_objs/scatterpolar/marker/_colorbar.py new file mode 100644 index 0000000000..7855f49331 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterpolar.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scatterpolar.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scatterpolar.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolar.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterpolar.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolar.marker.colorbar.Tickform + atstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolar.marker.colorbar.Tickform + atstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/_gradient.py b/plotly/graph_objs/scatterpolar/marker/_gradient.py new file mode 100644 index 0000000000..d94efb02a7 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/_gradient.py @@ -0,0 +1,230 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Gradient(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the final color of the gradient fill: the center color for + radial, the right for horizontal, or the bottom for vertical. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the type of gradient used to fill the markers + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radial', 'horizontal', 'vertical', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # typesrc + # ------- + @property + def typesrc(self): + """ + Sets the source reference on plot.ly for type . + + The 'typesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['typesrc'] + + @typesrc.setter + def typesrc(self, val): + self['typesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + type=None, + typesrc=None, + **kwargs + ): + """ + Construct a new Gradient object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.marker.Gradient + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + + Returns + ------- + Gradient + """ + super(Gradient, self).__init__('gradient') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.Gradient +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.Gradient""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker import ( + gradient as v_gradient + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_gradient.ColorValidator() + self._validators['colorsrc'] = v_gradient.ColorsrcValidator() + self._validators['type'] = v_gradient.TypeValidator() + self._validators['typesrc'] = v_gradient.TypesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('typesrc', None) + self.typesrc = typesrc if typesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/_line.py b/plotly/graph_objs/scatterpolar/marker/_line.py new file mode 100644 index 0000000000..4c6aaafd6f --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/_line.py @@ -0,0 +1,516 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterpolar.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/colorbar/__init__.py b/plotly/graph_objs/scatterpolar/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scatterpolar/marker/colorbar/_tickfont.py b/plotly/graph_objs/scatterpolar/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..fab2a2f888 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scatterpolar/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..df730ecf90 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.marker.co + lorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/marker/colorbar/_titlefont.py b/plotly/graph_objs/scatterpolar/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..fa4725e3b1 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolar.marker.co + lorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/selected/__init__.py b/plotly/graph_objs/scatterpolar/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterpolar/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterpolar/selected/_marker.py b/plotly/graph_objs/scatterpolar/selected/_marker.py new file mode 100644 index 0000000000..56c6933bac --- /dev/null +++ b/plotly/graph_objs/scatterpolar/selected/_marker.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.selected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/selected/_textfont.py b/plotly/graph_objs/scatterpolar/selected/_textfont.py new file mode 100644 index 0000000000..d104c93108 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/unselected/__init__.py b/plotly/graph_objs/scatterpolar/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterpolar/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterpolar/unselected/_marker.py b/plotly/graph_objs/scatterpolar/unselected/_marker.py new file mode 100644 index 0000000000..0166389765 --- /dev/null +++ b/plotly/graph_objs/scatterpolar/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolar/unselected/_textfont.py b/plotly/graph_objs/scatterpolar/unselected/_textfont.py new file mode 100644 index 0000000000..3f907f2c5c --- /dev/null +++ b/plotly/graph_objs/scatterpolar/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolar.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolar.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolar.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolar.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolar.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/__init__.py b/plotly/graph_objs/scatterpolargl/__init__.py new file mode 100644 index 0000000000..1e538db474 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/__init__.py @@ -0,0 +1,10 @@ +from ._unselected import Unselected +from plotly.graph_objs.scatterpolargl import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scatterpolargl import selected +from ._marker import Marker +from plotly.graph_objs.scatterpolargl import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scatterpolargl import hoverlabel diff --git a/plotly/graph_objs/scatterpolargl/_hoverlabel.py b/plotly/graph_objs/scatterpolargl/_hoverlabel.py new file mode 100644 index 0000000000..9cc495681e --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatterpolargl.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/_line.py b/plotly/graph_objs/scatterpolargl/_line.py new file mode 100644 index 0000000000..6df33114f8 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_line.py @@ -0,0 +1,186 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the style of the lines. + + The 'dash' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + + Returns + ------- + Any + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + """ + + def __init__(self, arg=None, color=None, dash=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.Line + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/_marker.py b/plotly/graph_objs/scatterpolargl/_marker.py new file mode 100644 index 0000000000..149154e263 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_marker.py @@ -0,0 +1,1167 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterpolargl.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolargl.marker.colorba + r.Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scatterpolargl.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scatterpolargl.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolargl.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scatterpolargl.marker.Line instance + or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolargl.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.scatterpolargl.marker.Line instance + or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/_selected.py b/plotly/graph_objs/scatterpolargl/_selected.py new file mode 100644 index 0000000000..d8da644aa8 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_selected.py @@ -0,0 +1,139 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scatterpolargl.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scatterpolargl.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterpolargl.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.selected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.Selected + marker + plotly.graph_objs.scatterpolargl.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/_stream.py b/plotly/graph_objs/scatterpolargl/_stream.py new file mode 100644 index 0000000000..d136d99292 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/_unselected.py b/plotly/graph_objs/scatterpolargl/_unselected.py new file mode 100644 index 0000000000..2f9854898b --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/_unselected.py @@ -0,0 +1,145 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterpolargl.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterpolargl.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterpolargl.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.Unselected + marker + plotly.graph_objs.scatterpolargl.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl import ( + unselected as v_unselected + ) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/hoverlabel/__init__.py b/plotly/graph_objs/scatterpolargl/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scatterpolargl/hoverlabel/_font.py b/plotly/graph_objs/scatterpolargl/hoverlabel/_font.py new file mode 100644 index 0000000000..6e2f4deafd --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/hoverlabel/_font.py @@ -0,0 +1,314 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.hoverlabel import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/marker/__init__.py b/plotly/graph_objs/scatterpolargl/marker/__init__.py new file mode 100644 index 0000000000..073df902bd --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.scatterpolargl.marker import colorbar diff --git a/plotly/graph_objs/scatterpolargl/marker/_colorbar.py b/plotly/graph_objs/scatterpolargl/marker/_colorbar.py new file mode 100644 index 0000000000..e896c70f80 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scatterpolargl.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scatterpolargl.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scatterpolargl.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterpolargl.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfo + rmatstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfo + rmatstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/marker/_line.py b/plotly/graph_objs/scatterpolargl/marker/_line.py new file mode 100644 index 0000000000..bbb4f16ffe --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/_line.py @@ -0,0 +1,516 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterpolargl.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/marker/colorbar/__init__.py b/plotly/graph_objs/scatterpolargl/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickfont.py b/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..0aac5353e6 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.marker. + colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..6d9405b7c3 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.marker. + colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/marker/colorbar/_titlefont.py b/plotly/graph_objs/scatterpolargl/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..5d3d3cf88a --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterpolargl.marker. + colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/selected/__init__.py b/plotly/graph_objs/scatterpolargl/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterpolargl/selected/_marker.py b/plotly/graph_objs/scatterpolargl/selected/_marker.py new file mode 100644 index 0000000000..f2ee941920 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/selected/_marker.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.selected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/selected/_textfont.py b/plotly/graph_objs/scatterpolargl/selected/_textfont.py new file mode 100644 index 0000000000..1eee948fb0 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/unselected/__init__.py b/plotly/graph_objs/scatterpolargl/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterpolargl/unselected/_marker.py b/plotly/graph_objs/scatterpolargl/unselected/_marker.py new file mode 100644 index 0000000000..58e2577229 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterpolargl/unselected/_textfont.py b/plotly/graph_objs/scatterpolargl/unselected/_textfont.py new file mode 100644 index 0000000000..a332d499a1 --- /dev/null +++ b/plotly/graph_objs/scatterpolargl/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterpolargl.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterpolargl.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterpolargl.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterpolargl.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterpolargl.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/__init__.py b/plotly/graph_objs/scatterternary/__init__.py new file mode 100644 index 0000000000..661912d2d4 --- /dev/null +++ b/plotly/graph_objs/scatterternary/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.scatterternary import unselected +from ._textfont import Textfont +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.scatterternary import selected +from ._marker import Marker +from plotly.graph_objs.scatterternary import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.scatterternary import hoverlabel diff --git a/plotly/graph_objs/scatterternary/_hoverlabel.py b/plotly/graph_objs/scatterternary/_hoverlabel.py new file mode 100644 index 0000000000..6b4dba4190 --- /dev/null +++ b/plotly/graph_objs/scatterternary/_hoverlabel.py @@ -0,0 +1,407 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.scatterternary.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import ( + hoverlabel as v_hoverlabel + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_line.py b/plotly/graph_objs/scatterternary/_line.py new file mode 100644 index 0000000000..50e6bba7a1 --- /dev/null +++ b/plotly/graph_objs/scatterternary/_line.py @@ -0,0 +1,272 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # dash + # ---- + @property + def dash(self): + """ + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + + The 'dash' property is a string and must be specified as: + - One of the following strings: + ['solid', 'dot', 'dash', 'longdash', 'dashdot', + 'longdashdot'] + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['dash'] + + @dash.setter + def dash(self, val): + self['dash'] = val + + # shape + # ----- + @property + def shape(self): + """ + Determines the line shape. With *spline* the lines are drawn + using spline interpolation. The other available values + correspond to step-wise line shapes. + + The 'shape' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['linear', 'spline'] + + Returns + ------- + Any + """ + return self['shape'] + + @shape.setter + def shape(self, val): + self['shape'] = val + + # smoothing + # --------- + @property + def smoothing(self): + """ + Has an effect only if `shape` is set to *spline* Sets the + amount of smoothing. *0* corresponds to no smoothing + (equivalent to a *linear* shape). + + The 'smoothing' property is a number and may be specified as: + - An int or float in the interval [0, 1.3] + + Returns + ------- + int|float + """ + return self['smoothing'] + + @smoothing.setter + def smoothing(self, val): + self['smoothing'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the line width (in px). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + """ + + def __init__( + self, + arg=None, + color=None, + dash=None, + shape=None, + smoothing=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.Line + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash type string + (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or + *longdashdot*) or a dash length list in px (eg + *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the lines are + drawn using spline interpolation. The other available + values correspond to step-wise line shapes. + smoothing + Has an effect only if `shape` is set to *spline* Sets + the amount of smoothing. *0* corresponds to no + smoothing (equivalent to a *linear* shape). + width + Sets the line width (in px). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['dash'] = v_line.DashValidator() + self._validators['shape'] = v_line.ShapeValidator() + self._validators['smoothing'] = v_line.SmoothingValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('dash', None) + self.dash = dash if dash is not None else v + v = arg.pop('shape', None) + self.shape = shape if shape is not None else v + v = arg.pop('smoothing', None) + self.smoothing = smoothing if smoothing is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_marker.py b/plotly/graph_objs/scatterternary/_marker.py new file mode 100644 index 0000000000..3be6374e7b --- /dev/null +++ b/plotly/graph_objs/scatterternary/_marker.py @@ -0,0 +1,1245 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterternary.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterternary.marker.colorba + r.Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.scatterternary.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # gradient + # -------- + @property + def gradient(self): + """ + The 'gradient' property is an instance of Gradient + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.marker.Gradient + - A dict of string/value properties that will be passed + to the Gradient constructor + + Supported dict properties: + + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + . + + Returns + ------- + plotly.graph_objs.scatterternary.marker.Gradient + """ + return self['gradient'] + + @gradient.setter + def gradient(self, val): + self['gradient'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.scatterternary.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # maxdisplayed + # ------------ + @property + def maxdisplayed(self): + """ + Sets a maximum number of points to be drawn on the graph. *0* + corresponds to no limit. + + The 'maxdisplayed' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['maxdisplayed'] + + @maxdisplayed.setter + def maxdisplayed(self, val): + self['maxdisplayed'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterternary.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatterternary.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatterternary.marker.Line instance + or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + gradient=None, + line=None, + maxdisplayed=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterternary.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + gradient + plotly.graph_objs.scatterternary.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatterternary.marker.Line instance + or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on the + graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['gradient'] = v_marker.GradientValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['maxdisplayed'] = v_marker.MaxdisplayedValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('gradient', None) + self.gradient = gradient if gradient is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('maxdisplayed', None) + self.maxdisplayed = maxdisplayed if maxdisplayed is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_selected.py b/plotly/graph_objs/scatterternary/_selected.py new file mode 100644 index 0000000000..b0bda69041 --- /dev/null +++ b/plotly/graph_objs/scatterternary/_selected.py @@ -0,0 +1,139 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.scatterternary.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.selected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of selected points. + + Returns + ------- + plotly.graph_objs.scatterternary.selected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterternary.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.selected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.Selected + marker + plotly.graph_objs.scatterternary.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.selected.Textfont + instance or dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Selected +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + self._validators['textfont'] = v_selected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_stream.py b/plotly/graph_objs/scatterternary/_stream.py new file mode 100644 index 0000000000..170bc9ef71 --- /dev/null +++ b/plotly/graph_objs/scatterternary/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Stream +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_textfont.py b/plotly/graph_objs/scatterternary/_textfont.py new file mode 100644 index 0000000000..aa8435853c --- /dev/null +++ b/plotly/graph_objs/scatterternary/_textfont.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Textfont object + + Sets the text font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.Textfont + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import (textfont as v_textfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + self._validators['colorsrc'] = v_textfont.ColorsrcValidator() + self._validators['family'] = v_textfont.FamilyValidator() + self._validators['familysrc'] = v_textfont.FamilysrcValidator() + self._validators['size'] = v_textfont.SizeValidator() + self._validators['sizesrc'] = v_textfont.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/_unselected.py b/plotly/graph_objs/scatterternary/_unselected.py new file mode 100644 index 0000000000..324312a4e6 --- /dev/null +++ b/plotly/graph_objs/scatterternary/_unselected.py @@ -0,0 +1,145 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterternary.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # textfont + # -------- + @property + def textfont(self): + """ + The 'textfont' property is an instance of Textfont + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.unselected.Textfont + - A dict of string/value properties that will be passed + to the Textfont constructor + + Supported dict properties: + + color + Sets the text font color of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.scatterternary.unselected.Textfont + """ + return self['textfont'] + + @textfont.setter + def textfont(self, val): + self['textfont'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.scatterternary.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.unselected.Textfont + instance or dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, textfont=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.Unselected + marker + plotly.graph_objs.scatterternary.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.unselected.Textfont + instance or dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary import ( + unselected as v_unselected + ) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + self._validators['textfont'] = v_unselected.TextfontValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + v = arg.pop('textfont', None) + self.textfont = textfont if textfont is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/hoverlabel/__init__.py b/plotly/graph_objs/scatterternary/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/scatterternary/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/scatterternary/hoverlabel/_font.py b/plotly/graph_objs/scatterternary/hoverlabel/_font.py new file mode 100644 index 0000000000..ba8de92401 --- /dev/null +++ b/plotly/graph_objs/scatterternary/hoverlabel/_font.py @@ -0,0 +1,314 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.hoverlabel import ( + font as v_font + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/__init__.py b/plotly/graph_objs/scatterternary/marker/__init__.py new file mode 100644 index 0000000000..c66a50cf28 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/__init__.py @@ -0,0 +1,4 @@ +from ._line import Line +from ._gradient import Gradient +from ._colorbar import ColorBar +from plotly.graph_objs.scatterternary.marker import colorbar diff --git a/plotly/graph_objs/scatterternary/marker/_colorbar.py b/plotly/graph_objs/scatterternary/marker/_colorbar.py new file mode 100644 index 0000000000..0adbd9c345 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/_colorbar.py @@ -0,0 +1,1738 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterternary.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.scatterternary.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.scatterternary.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.scatterternary.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.scatterternary.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterternary.marker.colorbar.Tickfo + rmatstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterternary.marker.colorbar.Tickfo + rmatstop instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker import ( + colorbar as v_colorbar + ) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/_gradient.py b/plotly/graph_objs/scatterternary/marker/_gradient.py new file mode 100644 index 0000000000..322c9af458 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/_gradient.py @@ -0,0 +1,230 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Gradient(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the final color of the gradient fill: the center color for + radial, the right for horizontal, or the bottom for vertical. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # type + # ---- + @property + def type(self): + """ + Sets the type of gradient used to fill the markers + + The 'type' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['radial', 'horizontal', 'vertical', 'none'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['type'] + + @type.setter + def type(self, val): + self['type'] = val + + # typesrc + # ------- + @property + def typesrc(self): + """ + Sets the source reference on plot.ly for type . + + The 'typesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['typesrc'] + + @typesrc.setter + def typesrc(self, val): + self['typesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + type=None, + typesrc=None, + **kwargs + ): + """ + Construct a new Gradient object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.marker.Gradient + color + Sets the final color of the gradient fill: the center + color for radial, the right for horizontal, or the + bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color . + type + Sets the type of gradient used to fill the markers + typesrc + Sets the source reference on plot.ly for type . + + Returns + ------- + Gradient + """ + super(Gradient, self).__init__('gradient') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.Gradient +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.Gradient""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker import ( + gradient as v_gradient + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_gradient.ColorValidator() + self._validators['colorsrc'] = v_gradient.ColorsrcValidator() + self._validators['type'] = v_gradient.TypeValidator() + self._validators['typesrc'] = v_gradient.TypesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('type', None) + self.type = type if type is not None else v + v = arg.pop('typesrc', None) + self.typesrc = typesrc if typesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/_line.py b/plotly/graph_objs/scatterternary/marker/_line.py new file mode 100644 index 0000000000..20108fc630 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/_line.py @@ -0,0 +1,516 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to scatterternary.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/colorbar/__init__.py b/plotly/graph_objs/scatterternary/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/scatterternary/marker/colorbar/_tickfont.py b/plotly/graph_objs/scatterternary/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..021ab25549 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.marker. + colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/scatterternary/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..dfce0ebf03 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.marker. + colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/marker/colorbar/_titlefont.py b/plotly/graph_objs/scatterternary/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..697cc20251 --- /dev/null +++ b/plotly/graph_objs/scatterternary/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.scatterternary.marker. + colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/selected/__init__.py b/plotly/graph_objs/scatterternary/selected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterternary/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterternary/selected/_marker.py b/plotly/graph_objs/scatterternary/selected/_marker.py new file mode 100644 index 0000000000..d88a004a2f --- /dev/null +++ b/plotly/graph_objs/scatterternary/selected/_marker.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.selected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/selected/_textfont.py b/plotly/graph_objs/scatterternary/selected/_textfont.py new file mode 100644 index 0000000000..7851878fb2 --- /dev/null +++ b/plotly/graph_objs/scatterternary/selected/_textfont.py @@ -0,0 +1,133 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of selected points. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.selected.Textfont + color + Sets the text font color of selected points. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.selected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.selected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.selected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/unselected/__init__.py b/plotly/graph_objs/scatterternary/unselected/__init__.py new file mode 100644 index 0000000000..adba53218c --- /dev/null +++ b/plotly/graph_objs/scatterternary/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import Textfont +from ._marker import Marker diff --git a/plotly/graph_objs/scatterternary/unselected/_marker.py b/plotly/graph_objs/scatterternary/unselected/_marker.py new file mode 100644 index 0000000000..1d399fb91e --- /dev/null +++ b/plotly/graph_objs/scatterternary/unselected/_marker.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.unselected import ( + marker as v_marker + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/scatterternary/unselected/_textfont.py b/plotly/graph_objs/scatterternary/unselected/_textfont.py new file mode 100644 index 0000000000..f199e48ae4 --- /dev/null +++ b/plotly/graph_objs/scatterternary/unselected/_textfont.py @@ -0,0 +1,136 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Textfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the text font color of unselected points, applied only + when a selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'scatterternary.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the text font color of unselected points, applied + only when a selection exists. + """ + + def __init__(self, arg=None, color=None, **kwargs): + """ + Construct a new Textfont object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.scatterternary.unselected.Textfont + color + Sets the text font color of unselected points, applied + only when a selection exists. + + Returns + ------- + Textfont + """ + super(Textfont, self).__init__('textfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.scatterternary.unselected.Textfont +constructor must be a dict or +an instance of plotly.graph_objs.scatterternary.unselected.Textfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.scatterternary.unselected import ( + textfont as v_textfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_textfont.ColorValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/__init__.py b/plotly/graph_objs/splom/__init__.py new file mode 100644 index 0000000000..800a35d517 --- /dev/null +++ b/plotly/graph_objs/splom/__init__.py @@ -0,0 +1,11 @@ +from ._unselected import Unselected +from plotly.graph_objs.splom import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.splom import selected +from ._marker import Marker +from plotly.graph_objs.splom import marker +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.splom import hoverlabel +from ._dimension import Dimension +from ._diagonal import Diagonal diff --git a/plotly/graph_objs/splom/_diagonal.py b/plotly/graph_objs/splom/_diagonal.py new file mode 100644 index 0000000000..84325311e3 --- /dev/null +++ b/plotly/graph_objs/splom/_diagonal.py @@ -0,0 +1,94 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Diagonal(BaseTraceHierarchyType): + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not subplots on the diagonal are + displayed. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + visible + Determines whether or not subplots on the diagonal are + displayed. + """ + + def __init__(self, arg=None, visible=None, **kwargs): + """ + Construct a new Diagonal object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Diagonal + visible + Determines whether or not subplots on the diagonal are + displayed. + + Returns + ------- + Diagonal + """ + super(Diagonal, self).__init__('diagonal') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Diagonal +constructor must be a dict or +an instance of plotly.graph_objs.splom.Diagonal""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (diagonal as v_diagonal) + + # Initialize validators + # --------------------- + self._validators['visible'] = v_diagonal.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_dimension.py b/plotly/graph_objs/splom/_dimension.py new file mode 100644 index 0000000000..7774b4af09 --- /dev/null +++ b/plotly/graph_objs/splom/_dimension.py @@ -0,0 +1,189 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Dimension(BaseTraceHierarchyType): + + # label + # ----- + @property + def label(self): + """ + Sets the label corresponding to this splom dimension. + + The 'label' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['label'] + + @label.setter + def label(self, val): + self['label'] = val + + # values + # ------ + @property + def values(self): + """ + Sets the dimension values to be plotted. + + The 'values' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['values'] + + @values.setter + def values(self, val): + self['values'] = val + + # valuessrc + # --------- + @property + def valuessrc(self): + """ + Sets the source reference on plot.ly for values . + + The 'valuessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuessrc'] + + @valuessrc.setter + def valuessrc(self, val): + self['valuessrc'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines whether or not this dimension is shown on the graph. + Note that even visible false dimension contribute to the + default grid generate by this splom trace. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + label + Sets the label corresponding to this splom dimension. + values + Sets the dimension values to be plotted. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this dimension is shown on + the graph. Note that even visible false dimension + contribute to the default grid generate by this splom + trace. + """ + + def __init__( + self, + arg=None, + label=None, + values=None, + valuessrc=None, + visible=None, + **kwargs + ): + """ + Construct a new Dimension object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Dimension + label + Sets the label corresponding to this splom dimension. + values + Sets the dimension values to be plotted. + valuessrc + Sets the source reference on plot.ly for values . + visible + Determines whether or not this dimension is shown on + the graph. Note that even visible false dimension + contribute to the default grid generate by this splom + trace. + + Returns + ------- + Dimension + """ + super(Dimension, self).__init__('dimensions') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Dimension +constructor must be a dict or +an instance of plotly.graph_objs.splom.Dimension""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (dimension as v_dimension) + + # Initialize validators + # --------------------- + self._validators['label'] = v_dimension.LabelValidator() + self._validators['values'] = v_dimension.ValuesValidator() + self._validators['valuessrc'] = v_dimension.ValuessrcValidator() + self._validators['visible'] = v_dimension.VisibleValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('label', None) + self.label = label if label is not None else v + v = arg.pop('values', None) + self.values = values if values is not None else v + v = arg.pop('valuessrc', None) + self.valuessrc = valuessrc if valuessrc is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_hoverlabel.py b/plotly/graph_objs/splom/_hoverlabel.py new file mode 100644 index 0000000000..ac8cd2e981 --- /dev/null +++ b/plotly/graph_objs/splom/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.splom.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.splom.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.splom.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_marker.py b/plotly/graph_objs/splom/_marker.py new file mode 100644 index 0000000000..6764e5f785 --- /dev/null +++ b/plotly/graph_objs/splom/_marker.py @@ -0,0 +1,1167 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.colorscale`. In case `colorscale` is unspecified or + `autocolorscale` is true, the default palette will be chosen + according to whether numbers in the `color` array are all + positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.color` array index, and if set, + `marker.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to splom.marker.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorbar + # -------- + @property + def colorbar(self): + """ + The 'colorbar' property is an instance of ColorBar + that may be specified as: + - An instance of plotly.graph_objs.splom.marker.ColorBar + - A dict of string/value properties that will be passed + to the ColorBar constructor + + Supported dict properties: + + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.splom.marker.colorbar.Tickfor + matstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + plotly.graph_objs.splom.marker.ColorBar + """ + return self['colorbar'] + + @colorbar.setter + def colorbar(self, val): + self['colorbar'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if `marker.color` is + set to a numerical array. The colorscale must be an array + containing arrays mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At minimum, a mapping for + the lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color space, use + `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` + may be a palette name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.splom.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.splom.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # opacitysrc + # ---------- + @property + def opacitysrc(self): + """ + Sets the source reference on plot.ly for opacity . + + The 'opacitysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['opacitysrc'] + + @opacitysrc.setter + def opacitysrc(self, val): + self['opacitysrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # showscale + # --------- + @property + def showscale(self): + """ + Has an effect only if `marker.color` is set to a numerical + array. Determines whether or not a colorbar is displayed. + + The 'showscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showscale'] + + @showscale.setter + def showscale(self, val): + self['showscale'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizemin + # ------- + @property + def sizemin(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the minimum size (in px) of the rendered marker + points. + + The 'sizemin' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['sizemin'] + + @sizemin.setter + def sizemin(self, val): + self['sizemin'] = val + + # sizemode + # -------- + @property + def sizemode(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the rule for which the data in `size` is converted + to pixels. + + The 'sizemode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['diameter', 'area'] + + Returns + ------- + Any + """ + return self['sizemode'] + + @sizemode.setter + def sizemode(self, val): + self['sizemode'] = val + + # sizeref + # ------- + @property + def sizeref(self): + """ + Has an effect only if `marker.size` is set to a numerical + array. Sets the scale factor used to determine the rendered + size of marker points. Use with `sizemin` and `sizemode`. + + The 'sizeref' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['sizeref'] + + @sizeref.setter + def sizeref(self, val): + self['sizeref'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # symbolsrc + # --------- + @property + def symbolsrc(self): + """ + Sets the source reference on plot.ly for symbol . + + The 'symbolsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['symbolsrc'] + + @symbolsrc.setter + def symbolsrc(self, val): + self['symbolsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.splom.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.splom.marker.Line instance or dict + with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorbar=None, + colorscale=None, + colorsrc=None, + line=None, + opacity=None, + opacitysrc=None, + reversescale=None, + showscale=None, + size=None, + sizemin=None, + sizemode=None, + sizeref=None, + sizesrc=None, + symbol=None, + symbolsrc=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Marker + autocolorscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case `colorscale` + is unspecified or `autocolorscale` is true, the default + palette will be chosen according to whether numbers in + the `color` array are all positive, all negative or + mixed. + cauto + Has an effect only if `marker.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmin` + must be set as well. + cmin + Has an effect only if `marker.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.color` array index, and if set, `marker.cmax` + must be set as well. + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.splom.marker.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.cmin` and `marker.cmax`. Alternatively, + `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, + RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + line + plotly.graph_objs.splom.marker.Line instance or dict + with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for opacity . + reversescale + Has an effect only if `marker.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + showscale + Has an effect only if `marker.color` is set to a + numerical array. Determines whether or not a colorbar + is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) of the + rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the data in + `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. Use with + `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size . + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for symbol . + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Marker +constructor must be a dict or +an instance of plotly.graph_objs.splom.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_marker.AutocolorscaleValidator() + self._validators['cauto'] = v_marker.CautoValidator() + self._validators['cmax'] = v_marker.CmaxValidator() + self._validators['cmin'] = v_marker.CminValidator() + self._validators['color'] = v_marker.ColorValidator() + self._validators['colorbar'] = v_marker.ColorBarValidator() + self._validators['colorscale'] = v_marker.ColorscaleValidator() + self._validators['colorsrc'] = v_marker.ColorsrcValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['opacitysrc'] = v_marker.OpacitysrcValidator() + self._validators['reversescale'] = v_marker.ReversescaleValidator() + self._validators['showscale'] = v_marker.ShowscaleValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['sizemin'] = v_marker.SizeminValidator() + self._validators['sizemode'] = v_marker.SizemodeValidator() + self._validators['sizeref'] = v_marker.SizerefValidator() + self._validators['sizesrc'] = v_marker.SizesrcValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + self._validators['symbolsrc'] = v_marker.SymbolsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorbar', None) + self.colorbar = colorbar if colorbar is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('opacitysrc', None) + self.opacitysrc = opacitysrc if opacitysrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('showscale', None) + self.showscale = showscale if showscale is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizemin', None) + self.sizemin = sizemin if sizemin is not None else v + v = arg.pop('sizemode', None) + self.sizemode = sizemode if sizemode is not None else v + v = arg.pop('sizeref', None) + self.sizeref = sizeref if sizeref is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + v = arg.pop('symbolsrc', None) + self.symbolsrc = symbolsrc if symbolsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_selected.py b/plotly/graph_objs/splom/_selected.py new file mode 100644 index 0000000000..b052d99472 --- /dev/null +++ b/plotly/graph_objs/splom/_selected.py @@ -0,0 +1,103 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.splom.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.splom.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.splom.selected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Selected + marker + plotly.graph_objs.splom.selected.Marker instance or + dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Selected +constructor must be a dict or +an instance of plotly.graph_objs.splom.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_stream.py b/plotly/graph_objs/splom/_stream.py new file mode 100644 index 0000000000..ea8366f829 --- /dev/null +++ b/plotly/graph_objs/splom/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Stream +constructor must be a dict or +an instance of plotly.graph_objs.splom.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/_unselected.py b/plotly/graph_objs/splom/_unselected.py new file mode 100644 index 0000000000..c9dd126cf6 --- /dev/null +++ b/plotly/graph_objs/splom/_unselected.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.splom.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.splom.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.splom.unselected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.Unselected + marker + plotly.graph_objs.splom.unselected.Marker instance or + dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.splom.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/hoverlabel/__init__.py b/plotly/graph_objs/splom/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/splom/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/splom/hoverlabel/_font.py b/plotly/graph_objs/splom/hoverlabel/_font.py new file mode 100644 index 0000000000..f1feda4919 --- /dev/null +++ b/plotly/graph_objs/splom/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.splom.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/marker/__init__.py b/plotly/graph_objs/splom/marker/__init__.py new file mode 100644 index 0000000000..d2d000bfde --- /dev/null +++ b/plotly/graph_objs/splom/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._colorbar import ColorBar +from plotly.graph_objs.splom.marker import colorbar diff --git a/plotly/graph_objs/splom/marker/_colorbar.py b/plotly/graph_objs/splom/marker/_colorbar.py new file mode 100644 index 0000000000..5fb711b162 --- /dev/null +++ b/plotly/graph_objs/splom/marker/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.splom.marker.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.splom.marker.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.splom.marker.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.splom.marker.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.splom.marker.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.splom.marker.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.splom.marker.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.marker.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.splom.marker.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.marker.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.splom.marker.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.marker import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/marker/_line.py b/plotly/graph_objs/splom/marker/_line.py new file mode 100644 index 0000000000..b12ee857af --- /dev/null +++ b/plotly/graph_objs/splom/marker/_line.py @@ -0,0 +1,515 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # autocolorscale + # -------------- + @property + def autocolorscale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Determines whether the colorscale is a default palette + (`autocolorscale: true`) or the palette determined by + `marker.line.colorscale`. In case `colorscale` is unspecified + or `autocolorscale` is true, the default palette will be + chosen according to whether numbers in the `color` array are + all positive, all negative or mixed. + + The 'autocolorscale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['autocolorscale'] + + @autocolorscale.setter + def autocolorscale(self, val): + self['autocolorscale'] = val + + # cauto + # ----- + @property + def cauto(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array and `cmin`, `cmax` are set by the user. In this case, it + controls whether the range of colors in `colorscale` is mapped + to the range of values in the `color` array (`cauto: true`), or + the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + + The 'cauto' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['cauto'] + + @cauto.setter + def cauto(self, val): + self['cauto'] = val + + # cmax + # ---- + @property + def cmax(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the upper bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + + The 'cmax' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmax'] + + @cmax.setter + def cmax(self, val): + self['cmax'] = val + + # cmin + # ---- + @property + def cmin(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Sets the lower bound of the color domain. Value should + be associated to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + + The 'cmin' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['cmin'] + + @cmin.setter + def cmin(self, val): + self['cmin'] = val + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A number that will be interpreted as a color + according to splom.marker.line.colorscale + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorscale + # ---------- + @property + def colorscale(self): + """ + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The colorscale + must be an array containing arrays mapping a normalized value + to an rgb, rgba, hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and highest (1) values + are required. For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the colorscale in + color space, use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name string of the + following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, + Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, + Earth, Electric, Viridis, Cividis + + The 'colorscale' property is a colorscale and may be + specified as: + - A list of 2-element lists where the first element is the + normalized color level value (starting at 0 and ending at 1), + and the second item is a valid color string. + (e.g. [[0, 'green'], [0.5, 'red'], [1.0, 'rgb(0, 0, 255)']]) + - One of the following named colorscales: + ['Greys', 'YlGnBu', 'Greens', 'YlOrRd', 'Bluered', 'RdBu', + 'Reds', 'Blues', 'Picnic', 'Rainbow', 'Portland', 'Jet', + 'Hot', 'Blackbody', 'Earth', 'Electric', 'Viridis'] + + Returns + ------- + str + """ + return self['colorscale'] + + @colorscale.setter + def colorscale(self, val): + self['colorscale'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # reversescale + # ------------ + @property + def reversescale(self): + """ + Has an effect only if `marker.line.color` is set to a numerical + array. Reverses the color mapping if true (`cmin` will + correspond to the last color in the array and `cmax` will + correspond to the first color). + + The 'reversescale' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['reversescale'] + + @reversescale.setter + def reversescale(self, val): + self['reversescale'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + autocolorscale=None, + cauto=None, + cmax=None, + cmin=None, + color=None, + colorscale=None, + colorsrc=None, + reversescale=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.marker.Line + autocolorscale + Has an effect only if `marker.line.color` is set to a + numerical array. Determines whether the colorscale is a + default palette (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` is + true, the default palette will be chosen according to + whether numbers in the `color` array are all positive, + all negative or mixed. + cauto + Has an effect only if `marker.line.color` is set to a + numerical array and `cmin`, `cmax` are set by the user. + In this case, it controls whether the range of colors + in `colorscale` is mapped to the range of values in the + `color` array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the upper bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is set to a + numerical array. Sets the lower bound of the color + domain. Value should be associated to the + `marker.line.color` array index, and if set, + `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical array. The + colorscale must be an array containing arrays mapping a + normalized value to an rgb, rgba, hex, hsl, hsv, or + named color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. + To control the bounds of the colorscale in color space, + use `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette name + string of the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, + Portland, Jet, Hot, Blackbody, Earth, Electric, + Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color . + reversescale + Has an effect only if `marker.line.color` is set to a + numerical array. Reverses the color mapping if true + (`cmin` will correspond to the last color in the array + and `cmax` will correspond to the first color). + width + Sets the width (in px) of the lines bounding the marker + points. + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.splom.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['autocolorscale'] = v_line.AutocolorscaleValidator() + self._validators['cauto'] = v_line.CautoValidator() + self._validators['cmax'] = v_line.CmaxValidator() + self._validators['cmin'] = v_line.CminValidator() + self._validators['color'] = v_line.ColorValidator() + self._validators['colorscale'] = v_line.ColorscaleValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['reversescale'] = v_line.ReversescaleValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('autocolorscale', None) + self.autocolorscale = autocolorscale if autocolorscale is not None else v + v = arg.pop('cauto', None) + self.cauto = cauto if cauto is not None else v + v = arg.pop('cmax', None) + self.cmax = cmax if cmax is not None else v + v = arg.pop('cmin', None) + self.cmin = cmin if cmin is not None else v + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorscale', None) + self.colorscale = colorscale if colorscale is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('reversescale', None) + self.reversescale = reversescale if reversescale is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/marker/colorbar/__init__.py b/plotly/graph_objs/splom/marker/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/splom/marker/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/splom/marker/colorbar/_tickfont.py b/plotly/graph_objs/splom/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..f4ecf3501f --- /dev/null +++ b/plotly/graph_objs/splom/marker/colorbar/_tickfont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.splom.marker.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.marker.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.splom.marker.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.marker.colorbar import ( + tickfont as v_tickfont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/marker/colorbar/_tickformatstop.py b/plotly/graph_objs/splom/marker/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..0b515e20c4 --- /dev/null +++ b/plotly/graph_objs/splom/marker/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.splom.marker.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.marker.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.splom.marker.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.marker.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/marker/colorbar/_titlefont.py b/plotly/graph_objs/splom/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..1a56d23b6f --- /dev/null +++ b/plotly/graph_objs/splom/marker/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.marker.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.splom.marker.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.marker.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.splom.marker.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.marker.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/selected/__init__.py b/plotly/graph_objs/splom/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/splom/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/splom/selected/_marker.py b/plotly/graph_objs/splom/selected/_marker.py new file mode 100644 index 0000000000..85cce23c18 --- /dev/null +++ b/plotly/graph_objs/splom/selected/_marker.py @@ -0,0 +1,186 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.splom.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.splom.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/splom/unselected/__init__.py b/plotly/graph_objs/splom/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/splom/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/splom/unselected/_marker.py b/plotly/graph_objs/splom/unselected/_marker.py new file mode 100644 index 0000000000..b1ead05160 --- /dev/null +++ b/plotly/graph_objs/splom/unselected/_marker.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'splom.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.splom.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.splom.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.splom.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.splom.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/__init__.py b/plotly/graph_objs/surface/__init__.py new file mode 100644 index 0000000000..55b53efac9 --- /dev/null +++ b/plotly/graph_objs/surface/__init__.py @@ -0,0 +1,9 @@ +from ._stream import Stream +from ._lightposition import Lightposition +from ._lighting import Lighting +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.surface import hoverlabel +from ._contours import Contours +from plotly.graph_objs.surface import contours +from ._colorbar import ColorBar +from plotly.graph_objs.surface import colorbar diff --git a/plotly/graph_objs/surface/_colorbar.py b/plotly/graph_objs/surface/_colorbar.py new file mode 100644 index 0000000000..38e129538b --- /dev/null +++ b/plotly/graph_objs/surface/_colorbar.py @@ -0,0 +1,1735 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class ColorBar(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the color of padded area. + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the axis line color. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # borderwidth + # ----------- + @property + def borderwidth(self): + """ + Sets the width (in px) or the border enclosing this color bar. + + The 'borderwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['borderwidth'] + + @borderwidth.setter + def borderwidth(self, val): + self['borderwidth'] = val + + # dtick + # ----- + @property + def dtick(self): + """ + Sets the step in-between ticks on this axis. Use with `tick0`. + Must be a positive number, or special strings available to + *log* and *date* axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick number. For + example, to set a tick mark at 1, 10, 100, 1000, ... set dtick + to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. + To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special values; + *L*, where `f` is a positive number, gives ticks linearly + spaced in value (but not position). For example `tick0` = 0.1, + `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To + show powers of 10 plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and + *D2*. If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval between + ticks to one day, set `dtick` to 86400000.0. *date* also has + special values *M* gives ticks spaced by a number of months. + `n` must be a positive integer. To set ticks on the 15th of + every third month, set `tick0` to *2000-01-15* and `dtick` to + *M3*. To set ticks every 4 years, set `dtick` to *M48* + + The 'dtick' property accepts values of any type + + Returns + ------- + Any + """ + return self['dtick'] + + @dtick.setter + def dtick(self, val): + self['dtick'] = val + + # exponentformat + # -------------- + @property + def exponentformat(self): + """ + Determines a formatting rule for the tick exponents. For + example, consider the number 1,000,000,000. If *none*, it + appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If + *B*, 1B. + + The 'exponentformat' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['none', 'e', 'E', 'power', 'SI', 'B'] + + Returns + ------- + Any + """ + return self['exponentformat'] + + @exponentformat.setter + def exponentformat(self, val): + self['exponentformat'] = val + + # len + # --- + @property + def len(self): + """ + Sets the length of the color bar This measure excludes the + padding of both ends. That is, the color bar length is this + length minus the padding on both ends. + + The 'len' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['len'] + + @len.setter + def len(self, val): + self['len'] = val + + # lenmode + # ------- + @property + def lenmode(self): + """ + Determines whether this color bar's length (i.e. the measure in + the color variation direction) is set in units of plot + *fraction* or in *pixels. Use `len` to set the value. + + The 'lenmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['lenmode'] + + @lenmode.setter + def lenmode(self, val): + self['lenmode'] = val + + # nticks + # ------ + @property + def nticks(self): + """ + Specifies the maximum number of ticks for the particular axis. + The actual number of ticks will be chosen automatically to be + less than or equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + + The 'nticks' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['nticks'] + + @nticks.setter + def nticks(self, val): + self['nticks'] = val + + # outlinecolor + # ------------ + @property + def outlinecolor(self): + """ + Sets the axis line color. + + The 'outlinecolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outlinecolor'] + + @outlinecolor.setter + def outlinecolor(self, val): + self['outlinecolor'] = val + + # outlinewidth + # ------------ + @property + def outlinewidth(self): + """ + Sets the width (in px) of the axis line. + + The 'outlinewidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlinewidth'] + + @outlinewidth.setter + def outlinewidth(self, val): + self['outlinewidth'] = val + + # separatethousands + # ----------------- + @property + def separatethousands(self): + """ + If "true", even 4-digit integers are separated + + The 'separatethousands' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['separatethousands'] + + @separatethousands.setter + def separatethousands(self, val): + self['separatethousands'] = val + + # showexponent + # ------------ + @property + def showexponent(self): + """ + If *all*, all exponents are shown besides their significands. + If *first*, only the exponent of the first tick is shown. If + *last*, only the exponent of the last tick is shown. If *none*, + no exponents appear. + + The 'showexponent' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showexponent'] + + @showexponent.setter + def showexponent(self, val): + self['showexponent'] = val + + # showticklabels + # -------------- + @property + def showticklabels(self): + """ + Determines whether or not the tick labels are drawn. + + The 'showticklabels' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['showticklabels'] + + @showticklabels.setter + def showticklabels(self, val): + self['showticklabels'] = val + + # showtickprefix + # -------------- + @property + def showtickprefix(self): + """ + If *all*, all tick labels are displayed with a prefix. If + *first*, only the first tick is displayed with a prefix. If + *last*, only the last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + + The 'showtickprefix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showtickprefix'] + + @showtickprefix.setter + def showtickprefix(self, val): + self['showtickprefix'] = val + + # showticksuffix + # -------------- + @property + def showticksuffix(self): + """ + Same as `showtickprefix` but for tick suffixes. + + The 'showticksuffix' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['all', 'first', 'last', 'none'] + + Returns + ------- + Any + """ + return self['showticksuffix'] + + @showticksuffix.setter + def showticksuffix(self, val): + self['showticksuffix'] = val + + # thickness + # --------- + @property + def thickness(self): + """ + Sets the thickness of the color bar This measure excludes the + size of the padding, ticks and labels. + + The 'thickness' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['thickness'] + + @thickness.setter + def thickness(self, val): + self['thickness'] = val + + # thicknessmode + # ------------- + @property + def thicknessmode(self): + """ + Determines whether this color bar's thickness (i.e. the measure + in the constant color direction) is set in units of plot + *fraction* or in *pixels*. Use `thickness` to set the value. + + The 'thicknessmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['fraction', 'pixels'] + + Returns + ------- + Any + """ + return self['thicknessmode'] + + @thicknessmode.setter + def thicknessmode(self, val): + self['thicknessmode'] = val + + # tick0 + # ----- + @property + def tick0(self): + """ + Sets the placement of the first tick on this axis. Use with + `dtick`. If the axis `type` is *log*, then you must take the + log of your starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when `dtick`=*L* (see + `dtick` for more info). If the axis `type` is *date*, it should + be a date string, like date data. If the axis `type` is + *category*, it should be a number, using the scale where each + category is assigned a serial number from zero in the order it + appears. + + The 'tick0' property accepts values of any type + + Returns + ------- + Any + """ + return self['tick0'] + + @tick0.setter + def tick0(self, val): + self['tick0'] = val + + # tickangle + # --------- + @property + def tickangle(self): + """ + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the tick + labels vertically. + + The 'tickangle' property is a angle (in degrees) that may be + specified as a number between -180 and 180. Numeric values outside this + range are converted to the equivalent value + (e.g. 270 is converted to -90). + + Returns + ------- + int|float + """ + return self['tickangle'] + + @tickangle.setter + def tickangle(self, val): + self['tickangle'] = val + + # tickcolor + # --------- + @property + def tickcolor(self): + """ + Sets the tick color. + + The 'tickcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['tickcolor'] + + @tickcolor.setter + def tickcolor(self, val): + self['tickcolor'] = val + + # tickfont + # -------- + @property + def tickfont(self): + """ + Sets the color bar's tick label font + + The 'tickfont' property is an instance of Tickfont + that may be specified as: + - An instance of plotly.graph_objs.surface.colorbar.Tickfont + - A dict of string/value properties that will be passed + to the Tickfont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.surface.colorbar.Tickfont + """ + return self['tickfont'] + + @tickfont.setter + def tickfont(self, val): + self['tickfont'] = val + + # tickformat + # ---------- + @property + def tickformat(self): + """ + Sets the tick label formatting rule using d3 formatting mini- + languages which are very similar to those in Python. For + numbers, see: https://github.com/d3/d3-format/blob/master/READM + E.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one item to + d3's date formatter: *%{n}f* for fractional seconds with n + digits. For example, *2016-10-13 09:15:23.456* with tickformat + *%H~%M~%S.%2f* would display *09~15~23.46* + + The 'tickformat' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickformat'] + + @tickformat.setter + def tickformat(self, val): + self['tickformat'] = val + + # tickformatstops + # --------------- + @property + def tickformatstops(self): + """ + The 'tickformatstops' property is a tuple of instances of + Tickformatstop that may be specified as: + - A list or tuple of instances of plotly.graph_objs.surface.colorbar.Tickformatstop + - A list or tuple of dicts of string/value properties that + will be passed to the Tickformatstop constructor + + Supported dict properties: + + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat* + + Returns + ------- + tuple[plotly.graph_objs.surface.colorbar.Tickformatstop] + """ + return self['tickformatstops'] + + @tickformatstops.setter + def tickformatstops(self, val): + self['tickformatstops'] = val + + # ticklen + # ------- + @property + def ticklen(self): + """ + Sets the tick length (in px). + + The 'ticklen' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ticklen'] + + @ticklen.setter + def ticklen(self, val): + self['ticklen'] = val + + # tickmode + # -------- + @property + def tickmode(self): + """ + Sets the tick mode for this axis. If *auto*, the number of + ticks is set via `nticks`. If *linear*, the placement of the + ticks is determined by a starting position `tick0` and a tick + step `dtick` (*linear* is the default value if `tick0` and + `dtick` are provided). If *array*, the placement of the ticks + is set via `tickvals` and the tick text is `ticktext`. (*array* + is the default value if `tickvals` is provided). + + The 'tickmode' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['auto', 'linear', 'array'] + + Returns + ------- + Any + """ + return self['tickmode'] + + @tickmode.setter + def tickmode(self, val): + self['tickmode'] = val + + # tickprefix + # ---------- + @property + def tickprefix(self): + """ + Sets a tick label prefix. + + The 'tickprefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['tickprefix'] + + @tickprefix.setter + def tickprefix(self, val): + self['tickprefix'] = val + + # ticks + # ----- + @property + def ticks(self): + """ + Determines whether ticks are drawn or not. If **, this axis' + ticks are not drawn. If *outside* (*inside*), this axis' are + drawn outside (inside) the axis lines. + + The 'ticks' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['outside', 'inside', ''] + + Returns + ------- + Any + """ + return self['ticks'] + + @ticks.setter + def ticks(self, val): + self['ticks'] = val + + # ticksuffix + # ---------- + @property + def ticksuffix(self): + """ + Sets a tick label suffix. + + The 'ticksuffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['ticksuffix'] + + @ticksuffix.setter + def ticksuffix(self, val): + self['ticksuffix'] = val + + # ticktext + # -------- + @property + def ticktext(self): + """ + Sets the text displayed at the ticks position via `tickvals`. + Only has an effect if `tickmode` is set to *array*. Used with + `tickvals`. + + The 'ticktext' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['ticktext'] + + @ticktext.setter + def ticktext(self, val): + self['ticktext'] = val + + # ticktextsrc + # ----------- + @property + def ticktextsrc(self): + """ + Sets the source reference on plot.ly for ticktext . + + The 'ticktextsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['ticktextsrc'] + + @ticktextsrc.setter + def ticktextsrc(self, val): + self['ticktextsrc'] = val + + # tickvals + # -------- + @property + def tickvals(self): + """ + Sets the values at which ticks on this axis appear. Only has an + effect if `tickmode` is set to *array*. Used with `ticktext`. + + The 'tickvals' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['tickvals'] + + @tickvals.setter + def tickvals(self, val): + self['tickvals'] = val + + # tickvalssrc + # ----------- + @property + def tickvalssrc(self): + """ + Sets the source reference on plot.ly for tickvals . + + The 'tickvalssrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['tickvalssrc'] + + @tickvalssrc.setter + def tickvalssrc(self, val): + self['tickvalssrc'] = val + + # tickwidth + # --------- + @property + def tickwidth(self): + """ + Sets the tick width (in px). + + The 'tickwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['tickwidth'] + + @tickwidth.setter + def tickwidth(self, val): + self['tickwidth'] = val + + # title + # ----- + @property + def title(self): + """ + Sets the title of the color bar. + + The 'title' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['title'] + + @title.setter + def title(self, val): + self['title'] = val + + # titlefont + # --------- + @property + def titlefont(self): + """ + Sets this color bar's title font. + + The 'titlefont' property is an instance of Titlefont + that may be specified as: + - An instance of plotly.graph_objs.surface.colorbar.Titlefont + - A dict of string/value properties that will be passed + to the Titlefont constructor + + Supported dict properties: + + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + Returns + ------- + plotly.graph_objs.surface.colorbar.Titlefont + """ + return self['titlefont'] + + @titlefont.setter + def titlefont(self, val): + self['titlefont'] = val + + # titleside + # --------- + @property + def titleside(self): + """ + Determines the location of the colorbar title with respect to + the color bar. + + The 'titleside' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['right', 'top', 'bottom'] + + Returns + ------- + Any + """ + return self['titleside'] + + @titleside.setter + def titleside(self, val): + self['titleside'] = val + + # x + # - + @property + def x(self): + """ + Sets the x position of the color bar (in plot fraction). + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # xanchor + # ------- + @property + def xanchor(self): + """ + Sets this color bar's horizontal position anchor. This anchor + binds the `x` position to the *left*, *center* or *right* of + the color bar. + + The 'xanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + + Returns + ------- + Any + """ + return self['xanchor'] + + @xanchor.setter + def xanchor(self, val): + self['xanchor'] = val + + # xpad + # ---- + @property + def xpad(self): + """ + Sets the amount of padding (in px) along the x direction. + + The 'xpad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['xpad'] + + @xpad.setter + def xpad(self, val): + self['xpad'] = val + + # y + # - + @property + def y(self): + """ + Sets the y position of the color bar (in plot fraction). + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-2, 3] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # yanchor + # ------- + @property + def yanchor(self): + """ + Sets this color bar's vertical position anchor This anchor + binds the `y` position to the *top*, *middle* or *bottom* of + the color bar. + + The 'yanchor' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['top', 'middle', 'bottom'] + + Returns + ------- + Any + """ + return self['yanchor'] + + @yanchor.setter + def yanchor(self, val): + self['yanchor'] = val + + # ypad + # ---- + @property + def ypad(self): + """ + Sets the amount of padding (in px) along the y direction. + + The 'ypad' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['ypad'] + + @ypad.setter + def ypad(self, val): + self['ypad'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.surface.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bordercolor=None, + borderwidth=None, + dtick=None, + exponentformat=None, + len=None, + lenmode=None, + nticks=None, + outlinecolor=None, + outlinewidth=None, + separatethousands=None, + showexponent=None, + showticklabels=None, + showtickprefix=None, + showticksuffix=None, + thickness=None, + thicknessmode=None, + tick0=None, + tickangle=None, + tickcolor=None, + tickfont=None, + tickformat=None, + tickformatstops=None, + ticklen=None, + tickmode=None, + tickprefix=None, + ticks=None, + ticksuffix=None, + ticktext=None, + ticktextsrc=None, + tickvals=None, + tickvalssrc=None, + tickwidth=None, + title=None, + titlefont=None, + titleside=None, + x=None, + xanchor=None, + xpad=None, + y=None, + yanchor=None, + ypad=None, + **kwargs + ): + """ + Construct a new ColorBar object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.ColorBar + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing this + color bar. + dtick + Sets the step in-between ticks on this axis. Use with + `tick0`. Must be a positive number, or special strings + available to *log* and *date* axes. If the axis `type` + is *log*, then ticks are set every 10^(n*dtick) where n + is the tick number. For example, to set a tick mark at + 1, 10, 100, 1000, ... set dtick to 1. To set tick marks + at 1, 100, 10000, ... set dtick to 2. To set tick marks + at 1, 5, 25, 125, 625, 3125, ... set dtick to + log_10(5), or 0.69897000433. *log* has several special + values; *L*, where `f` is a positive number, gives + ticks linearly spaced in value (but not position). For + example `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus + small digits between, use *D1* (all digits) or *D2* + (only 2 and 5). `tick0` is ignored for *D1* and *D2*. + If the axis `type` is *date*, then you must convert the + time to milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to 86400000.0. + *date* also has special values *M* gives ticks + spaced by a number of months. `n` must be a positive + integer. To set ticks on the 15th of every third month, + set `tick0` to *2000-01-15* and `dtick` to *M3*. To set + ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick exponents. + For example, consider the number 1,000,000,000. If + *none*, it appears as 1,000,000,000. If *e*, 1e+9. If + *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super + script). If *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure excludes + the padding of both ends. That is, the color bar length + is this length minus the padding on both ends. + lenmode + Determines whether this color bar's length (i.e. the + measure in the color variation direction) is set in + units of plot *fraction* or in *pixels. Use `len` to + set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks will be + chosen automatically to be less than or equal to + `nticks`. Has an effect only if `tickmode` is set to + *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of the + first tick is shown. If *last*, only the exponent of + the last tick is shown. If *none*, no exponents appear. + showticklabels + Determines whether or not the tick labels are drawn. + showtickprefix + If *all*, all tick labels are displayed with a prefix. + If *first*, only the first tick is displayed with a + prefix. If *last*, only the last tick is displayed with + a suffix. If *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This measure + excludes the size of the padding, ticks and labels. + thicknessmode + Determines whether this color bar's thickness (i.e. the + measure in the constant color direction) is set in + units of plot *fraction* or in *pixels*. Use + `thickness` to set the value. + tick0 + Sets the placement of the first tick on this axis. Use + with `dtick`. If the axis `type` is *log*, then you + must take the log of your starting tick (e.g. to set + the starting tick to 100, set the `tick0` to 2) except + when `dtick`=*L* (see `dtick` for more info). If the + axis `type` is *date*, it should be a date string, like + date data. If the axis `type` is *category*, it should + be a number, using the scale where each category is + assigned a serial number from zero in the order it + appears. + tickangle + Sets the angle of the tick labels with respect to the + horizontal. For example, a `tickangle` of -90 draws the + tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 formatting + mini-languages which are very similar to those in + Python. For numbers, see: https://github.com/d3/d3-form + at/blob/master/README.md#locale_format And for dates + see: https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We add one + item to d3's date formatter: *%{n}f* for fractional + seconds with n digits. For example, *2016-10-13 + 09:15:23.456* with tickformat *%H~%M~%S.%2f* would + display *09~15~23.46* + tickformatstops + plotly.graph_objs.surface.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, the number + of ticks is set via `nticks`. If *linear*, the + placement of the ticks is determined by a starting + position `tick0` and a tick step `dtick` (*linear* is + the default value if `tick0` and `dtick` are provided). + If *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. (*array* is + the default value if `tickvals` is provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If **, this + axis' ticks are not drawn. If *outside* (*inside*), + this axis' are drawn outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position via + `tickvals`. Only has an effect if `tickmode` is set to + *array*. Used with `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for ticktext . + tickvals + Sets the values at which ticks on this axis appear. + Only has an effect if `tickmode` is set to *array*. + Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title with + respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position anchor. This + anchor binds the `x` position to the *left*, *center* + or *right* of the color bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor This + anchor binds the `y` position to the *top*, *middle* or + *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction. + + Returns + ------- + ColorBar + """ + super(ColorBar, self).__init__('colorbar') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.ColorBar +constructor must be a dict or +an instance of plotly.graph_objs.surface.ColorBar""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import (colorbar as v_colorbar) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_colorbar.BgcolorValidator() + self._validators['bordercolor'] = v_colorbar.BordercolorValidator() + self._validators['borderwidth'] = v_colorbar.BorderwidthValidator() + self._validators['dtick'] = v_colorbar.DtickValidator() + self._validators['exponentformat' + ] = v_colorbar.ExponentformatValidator() + self._validators['len'] = v_colorbar.LenValidator() + self._validators['lenmode'] = v_colorbar.LenmodeValidator() + self._validators['nticks'] = v_colorbar.NticksValidator() + self._validators['outlinecolor'] = v_colorbar.OutlinecolorValidator() + self._validators['outlinewidth'] = v_colorbar.OutlinewidthValidator() + self._validators['separatethousands' + ] = v_colorbar.SeparatethousandsValidator() + self._validators['showexponent'] = v_colorbar.ShowexponentValidator() + self._validators['showticklabels' + ] = v_colorbar.ShowticklabelsValidator() + self._validators['showtickprefix' + ] = v_colorbar.ShowtickprefixValidator() + self._validators['showticksuffix' + ] = v_colorbar.ShowticksuffixValidator() + self._validators['thickness'] = v_colorbar.ThicknessValidator() + self._validators['thicknessmode'] = v_colorbar.ThicknessmodeValidator() + self._validators['tick0'] = v_colorbar.Tick0Validator() + self._validators['tickangle'] = v_colorbar.TickangleValidator() + self._validators['tickcolor'] = v_colorbar.TickcolorValidator() + self._validators['tickfont'] = v_colorbar.TickfontValidator() + self._validators['tickformat'] = v_colorbar.TickformatValidator() + self._validators['tickformatstops' + ] = v_colorbar.TickformatstopsValidator() + self._validators['ticklen'] = v_colorbar.TicklenValidator() + self._validators['tickmode'] = v_colorbar.TickmodeValidator() + self._validators['tickprefix'] = v_colorbar.TickprefixValidator() + self._validators['ticks'] = v_colorbar.TicksValidator() + self._validators['ticksuffix'] = v_colorbar.TicksuffixValidator() + self._validators['ticktext'] = v_colorbar.TicktextValidator() + self._validators['ticktextsrc'] = v_colorbar.TicktextsrcValidator() + self._validators['tickvals'] = v_colorbar.TickvalsValidator() + self._validators['tickvalssrc'] = v_colorbar.TickvalssrcValidator() + self._validators['tickwidth'] = v_colorbar.TickwidthValidator() + self._validators['title'] = v_colorbar.TitleValidator() + self._validators['titlefont'] = v_colorbar.TitlefontValidator() + self._validators['titleside'] = v_colorbar.TitlesideValidator() + self._validators['x'] = v_colorbar.XValidator() + self._validators['xanchor'] = v_colorbar.XanchorValidator() + self._validators['xpad'] = v_colorbar.XpadValidator() + self._validators['y'] = v_colorbar.YValidator() + self._validators['yanchor'] = v_colorbar.YanchorValidator() + self._validators['ypad'] = v_colorbar.YpadValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('borderwidth', None) + self.borderwidth = borderwidth if borderwidth is not None else v + v = arg.pop('dtick', None) + self.dtick = dtick if dtick is not None else v + v = arg.pop('exponentformat', None) + self.exponentformat = exponentformat if exponentformat is not None else v + v = arg.pop('len', None) + self.len = len if len is not None else v + v = arg.pop('lenmode', None) + self.lenmode = lenmode if lenmode is not None else v + v = arg.pop('nticks', None) + self.nticks = nticks if nticks is not None else v + v = arg.pop('outlinecolor', None) + self.outlinecolor = outlinecolor if outlinecolor is not None else v + v = arg.pop('outlinewidth', None) + self.outlinewidth = outlinewidth if outlinewidth is not None else v + v = arg.pop('separatethousands', None) + self.separatethousands = separatethousands if separatethousands is not None else v + v = arg.pop('showexponent', None) + self.showexponent = showexponent if showexponent is not None else v + v = arg.pop('showticklabels', None) + self.showticklabels = showticklabels if showticklabels is not None else v + v = arg.pop('showtickprefix', None) + self.showtickprefix = showtickprefix if showtickprefix is not None else v + v = arg.pop('showticksuffix', None) + self.showticksuffix = showticksuffix if showticksuffix is not None else v + v = arg.pop('thickness', None) + self.thickness = thickness if thickness is not None else v + v = arg.pop('thicknessmode', None) + self.thicknessmode = thicknessmode if thicknessmode is not None else v + v = arg.pop('tick0', None) + self.tick0 = tick0 if tick0 is not None else v + v = arg.pop('tickangle', None) + self.tickangle = tickangle if tickangle is not None else v + v = arg.pop('tickcolor', None) + self.tickcolor = tickcolor if tickcolor is not None else v + v = arg.pop('tickfont', None) + self.tickfont = tickfont if tickfont is not None else v + v = arg.pop('tickformat', None) + self.tickformat = tickformat if tickformat is not None else v + v = arg.pop('tickformatstops', None) + self.tickformatstops = tickformatstops if tickformatstops is not None else v + v = arg.pop('ticklen', None) + self.ticklen = ticklen if ticklen is not None else v + v = arg.pop('tickmode', None) + self.tickmode = tickmode if tickmode is not None else v + v = arg.pop('tickprefix', None) + self.tickprefix = tickprefix if tickprefix is not None else v + v = arg.pop('ticks', None) + self.ticks = ticks if ticks is not None else v + v = arg.pop('ticksuffix', None) + self.ticksuffix = ticksuffix if ticksuffix is not None else v + v = arg.pop('ticktext', None) + self.ticktext = ticktext if ticktext is not None else v + v = arg.pop('ticktextsrc', None) + self.ticktextsrc = ticktextsrc if ticktextsrc is not None else v + v = arg.pop('tickvals', None) + self.tickvals = tickvals if tickvals is not None else v + v = arg.pop('tickvalssrc', None) + self.tickvalssrc = tickvalssrc if tickvalssrc is not None else v + v = arg.pop('tickwidth', None) + self.tickwidth = tickwidth if tickwidth is not None else v + v = arg.pop('title', None) + self.title = title if title is not None else v + v = arg.pop('titlefont', None) + self.titlefont = titlefont if titlefont is not None else v + v = arg.pop('titleside', None) + self.titleside = titleside if titleside is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('xanchor', None) + self.xanchor = xanchor if xanchor is not None else v + v = arg.pop('xpad', None) + self.xpad = xpad if xpad is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('yanchor', None) + self.yanchor = yanchor if yanchor is not None else v + v = arg.pop('ypad', None) + self.ypad = ypad if ypad is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/_contours.py b/plotly/graph_objs/surface/_contours.py new file mode 100644 index 0000000000..0903139e66 --- /dev/null +++ b/plotly/graph_objs/surface/_contours.py @@ -0,0 +1,232 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Contours(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + The 'x' property is an instance of X + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.X + - A dict of string/value properties that will be passed + to the X constructor + + Supported dict properties: + + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the x dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.x.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the x dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + plotly.graph_objs.surface.contours.X + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + The 'y' property is an instance of Y + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.Y + - A dict of string/value properties that will be passed + to the Y constructor + + Supported dict properties: + + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the y dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.y.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the y dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + plotly.graph_objs.surface.contours.Y + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + The 'z' property is an instance of Z + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.Z + - A dict of string/value properties that will be passed + to the Z constructor + + Supported dict properties: + + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the z dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.z.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the z dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + plotly.graph_objs.surface.contours.Z + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + plotly.graph_objs.surface.contours.X instance or dict + with compatible properties + y + plotly.graph_objs.surface.contours.Y instance or dict + with compatible properties + z + plotly.graph_objs.surface.contours.Z instance or dict + with compatible properties + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Contours object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.Contours + x + plotly.graph_objs.surface.contours.X instance or dict + with compatible properties + y + plotly.graph_objs.surface.contours.Y instance or dict + with compatible properties + z + plotly.graph_objs.surface.contours.Z instance or dict + with compatible properties + + Returns + ------- + Contours + """ + super(Contours, self).__init__('contours') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.Contours +constructor must be a dict or +an instance of plotly.graph_objs.surface.Contours""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import (contours as v_contours) + + # Initialize validators + # --------------------- + self._validators['x'] = v_contours.XValidator() + self._validators['y'] = v_contours.YValidator() + self._validators['z'] = v_contours.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/_hoverlabel.py b/plotly/graph_objs/surface/_hoverlabel.py new file mode 100644 index 0000000000..311e8ca368 --- /dev/null +++ b/plotly/graph_objs/surface/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.surface.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.surface.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.surface.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/_lighting.py b/plotly/graph_objs/surface/_lighting.py new file mode 100644 index 0000000000..f4f27a771c --- /dev/null +++ b/plotly/graph_objs/surface/_lighting.py @@ -0,0 +1,228 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lighting(BaseTraceHierarchyType): + + # ambient + # ------- + @property + def ambient(self): + """ + Ambient light increases overall color visibility but can wash + out the image. + + The 'ambient' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['ambient'] + + @ambient.setter + def ambient(self, val): + self['ambient'] = val + + # diffuse + # ------- + @property + def diffuse(self): + """ + Represents the extent that incident rays are reflected in a + range of angles. + + The 'diffuse' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['diffuse'] + + @diffuse.setter + def diffuse(self, val): + self['diffuse'] = val + + # fresnel + # ------- + @property + def fresnel(self): + """ + Represents the reflectance as a dependency of the viewing + angle; e.g. paper is reflective when viewing it from the edge + of the paper (almost 90 degrees), causing shine. + + The 'fresnel' property is a number and may be specified as: + - An int or float in the interval [0, 5] + + Returns + ------- + int|float + """ + return self['fresnel'] + + @fresnel.setter + def fresnel(self, val): + self['fresnel'] = val + + # roughness + # --------- + @property + def roughness(self): + """ + Alters specular reflection; the rougher the surface, the wider + and less contrasty the shine. + + The 'roughness' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['roughness'] + + @roughness.setter + def roughness(self, val): + self['roughness'] = val + + # specular + # -------- + @property + def specular(self): + """ + Represents the level that incident rays are reflected in a + single direction, causing shine. + + The 'specular' property is a number and may be specified as: + - An int or float in the interval [0, 2] + + Returns + ------- + int|float + """ + return self['specular'] + + @specular.setter + def specular(self, val): + self['specular'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + """ + + def __init__( + self, + arg=None, + ambient=None, + diffuse=None, + fresnel=None, + roughness=None, + specular=None, + **kwargs + ): + """ + Construct a new Lighting object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.Lighting + ambient + Ambient light increases overall color visibility but + can wash out the image. + diffuse + Represents the extent that incident rays are reflected + in a range of angles. + fresnel + Represents the reflectance as a dependency of the + viewing angle; e.g. paper is reflective when viewing it + from the edge of the paper (almost 90 degrees), causing + shine. + roughness + Alters specular reflection; the rougher the surface, + the wider and less contrasty the shine. + specular + Represents the level that incident rays are reflected + in a single direction, causing shine. + + Returns + ------- + Lighting + """ + super(Lighting, self).__init__('lighting') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.Lighting +constructor must be a dict or +an instance of plotly.graph_objs.surface.Lighting""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import (lighting as v_lighting) + + # Initialize validators + # --------------------- + self._validators['ambient'] = v_lighting.AmbientValidator() + self._validators['diffuse'] = v_lighting.DiffuseValidator() + self._validators['fresnel'] = v_lighting.FresnelValidator() + self._validators['roughness'] = v_lighting.RoughnessValidator() + self._validators['specular'] = v_lighting.SpecularValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('ambient', None) + self.ambient = ambient if ambient is not None else v + v = arg.pop('diffuse', None) + self.diffuse = diffuse if diffuse is not None else v + v = arg.pop('fresnel', None) + self.fresnel = fresnel if fresnel is not None else v + v = arg.pop('roughness', None) + self.roughness = roughness if roughness is not None else v + v = arg.pop('specular', None) + self.specular = specular if specular is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/_lightposition.py b/plotly/graph_objs/surface/_lightposition.py new file mode 100644 index 0000000000..6c9d225b7e --- /dev/null +++ b/plotly/graph_objs/surface/_lightposition.py @@ -0,0 +1,153 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Lightposition(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Numeric vector, representing the X coordinate for each vertex. + + The 'x' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Numeric vector, representing the Y coordinate for each vertex. + + The 'y' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Numeric vector, representing the Z coordinate for each vertex. + + The 'z' property is a number and may be specified as: + - An int or float in the interval [-100000, 100000] + + Returns + ------- + int|float + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Lightposition object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.Lightposition + x + Numeric vector, representing the X coordinate for each + vertex. + y + Numeric vector, representing the Y coordinate for each + vertex. + z + Numeric vector, representing the Z coordinate for each + vertex. + + Returns + ------- + Lightposition + """ + super(Lightposition, self).__init__('lightposition') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.Lightposition +constructor must be a dict or +an instance of plotly.graph_objs.surface.Lightposition""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import ( + lightposition as v_lightposition + ) + + # Initialize validators + # --------------------- + self._validators['x'] = v_lightposition.XValidator() + self._validators['y'] = v_lightposition.YValidator() + self._validators['z'] = v_lightposition.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/_stream.py b/plotly/graph_objs/surface/_stream.py new file mode 100644 index 0000000000..b06b4c9cd4 --- /dev/null +++ b/plotly/graph_objs/surface/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.Stream +constructor must be a dict or +an instance of plotly.graph_objs.surface.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/colorbar/__init__.py b/plotly/graph_objs/surface/colorbar/__init__.py new file mode 100644 index 0000000000..fc5f545e7b --- /dev/null +++ b/plotly/graph_objs/surface/colorbar/__init__.py @@ -0,0 +1,3 @@ +from ._titlefont import Titlefont +from ._tickformatstop import Tickformatstop +from ._tickfont import Tickfont diff --git a/plotly/graph_objs/surface/colorbar/_tickfont.py b/plotly/graph_objs/surface/colorbar/_tickfont.py new file mode 100644 index 0000000000..28f5510f76 --- /dev/null +++ b/plotly/graph_objs/surface/colorbar/_tickfont.py @@ -0,0 +1,218 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickfont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Tickfont object + + Sets the color bar's tick label font + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.colorbar.Tickfont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Tickfont + """ + super(Tickfont, self).__init__('tickfont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.colorbar.Tickfont +constructor must be a dict or +an instance of plotly.graph_objs.surface.colorbar.Tickfont""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.colorbar import (tickfont as v_tickfont) + + # Initialize validators + # --------------------- + self._validators['color'] = v_tickfont.ColorValidator() + self._validators['family'] = v_tickfont.FamilyValidator() + self._validators['size'] = v_tickfont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/colorbar/_tickformatstop.py b/plotly/graph_objs/surface/colorbar/_tickformatstop.py new file mode 100644 index 0000000000..045e2887f3 --- /dev/null +++ b/plotly/graph_objs/surface/colorbar/_tickformatstop.py @@ -0,0 +1,134 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Tickformatstop(BaseTraceHierarchyType): + + # dtickrange + # ---------- + @property + def dtickrange(self): + """ + range [*min*, *max*], where *min*, *max* - dtick values which + describe some zoom level, it is possible to omit *min* or *max* + value by passing *null* + + The 'dtickrange' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'dtickrange[0]' property accepts values of any type + (1) The 'dtickrange[1]' property accepts values of any type + + Returns + ------- + list + """ + return self['dtickrange'] + + @dtickrange.setter + def dtickrange(self, val): + self['dtickrange'] = val + + # value + # ----- + @property + def value(self): + """ + string - dtickformat for described zoom level, the same as + *tickformat* + + The 'value' property is a string and must be specified as: + - A string + - A number that will be converted to a string + + Returns + ------- + str + """ + return self['value'] + + @value.setter + def value(self, val): + self['value'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + """ + + def __init__(self, arg=None, dtickrange=None, value=None, **kwargs): + """ + Construct a new Tickformatstop object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.colorbar.Tickformatstop + dtickrange + range [*min*, *max*], where *min*, *max* - dtick values + which describe some zoom level, it is possible to omit + *min* or *max* value by passing *null* + value + string - dtickformat for described zoom level, the same + as *tickformat* + + Returns + ------- + Tickformatstop + """ + super(Tickformatstop, self).__init__('tickformatstops') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.colorbar.Tickformatstop +constructor must be a dict or +an instance of plotly.graph_objs.surface.colorbar.Tickformatstop""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.colorbar import ( + tickformatstop as v_tickformatstop + ) + + # Initialize validators + # --------------------- + self._validators['dtickrange'] = v_tickformatstop.DtickrangeValidator() + self._validators['value'] = v_tickformatstop.ValueValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('dtickrange', None) + self.dtickrange = dtickrange if dtickrange is not None else v + v = arg.pop('value', None) + self.value = value if value is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/colorbar/_titlefont.py b/plotly/graph_objs/surface/colorbar/_titlefont.py new file mode 100644 index 0000000000..6aa62dfcfd --- /dev/null +++ b/plotly/graph_objs/surface/colorbar/_titlefont.py @@ -0,0 +1,220 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Titlefont(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.colorbar' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + """ + + def __init__(self, arg=None, color=None, family=None, size=None, **kwargs): + """ + Construct a new Titlefont object + + Sets this color bar's title font. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.colorbar.Titlefont + color + + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size + + + Returns + ------- + Titlefont + """ + super(Titlefont, self).__init__('titlefont') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.colorbar.Titlefont +constructor must be a dict or +an instance of plotly.graph_objs.surface.colorbar.Titlefont""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.colorbar import ( + titlefont as v_titlefont + ) + + # Initialize validators + # --------------------- + self._validators['color'] = v_titlefont.ColorValidator() + self._validators['family'] = v_titlefont.FamilyValidator() + self._validators['size'] = v_titlefont.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/__init__.py b/plotly/graph_objs/surface/contours/__init__.py new file mode 100644 index 0000000000..a39c97f2a4 --- /dev/null +++ b/plotly/graph_objs/surface/contours/__init__.py @@ -0,0 +1,6 @@ +from ._z import Z +from plotly.graph_objs.surface.contours import z +from ._y import Y +from plotly.graph_objs.surface.contours import y +from ._x import X +from plotly.graph_objs.surface.contours import x diff --git a/plotly/graph_objs/surface/contours/_x.py b/plotly/graph_objs/surface/contours/_x.py new file mode 100644 index 0000000000..61fd6edf69 --- /dev/null +++ b/plotly/graph_objs/surface/contours/_x.py @@ -0,0 +1,406 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class X(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour lines. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # highlight + # --------- + @property + def highlight(self): + """ + Determines whether or not contour lines about the x dimension + are highlighted on hover. + + The 'highlight' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['highlight'] + + @highlight.setter + def highlight(self, val): + self['highlight'] = val + + # highlightcolor + # -------------- + @property + def highlightcolor(self): + """ + Sets the color of the highlighted contour lines. + + The 'highlightcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['highlightcolor'] + + @highlightcolor.setter + def highlightcolor(self, val): + self['highlightcolor'] = val + + # highlightwidth + # -------------- + @property + def highlightwidth(self): + """ + Sets the width of the highlighted contour lines. + + The 'highlightwidth' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['highlightwidth'] + + @highlightwidth.setter + def highlightwidth(self, val): + self['highlightwidth'] = val + + # project + # ------- + @property + def project(self): + """ + The 'project' property is an instance of Project + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.x.Project + - A dict of string/value properties that will be passed + to the Project constructor + + Supported dict properties: + + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + + Returns + ------- + plotly.graph_objs.surface.contours.x.Project + """ + return self['project'] + + @project.setter + def project(self, val): + self['project'] = val + + # show + # ---- + @property + def show(self): + """ + Determines whether or not contour lines about the x dimension + are drawn. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # usecolormap + # ----------- + @property + def usecolormap(self): + """ + An alternate to *color*. Determines whether or not the contour + lines are colored using the trace *colorscale*. + + The 'usecolormap' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['usecolormap'] + + @usecolormap.setter + def usecolormap(self, val): + self['usecolormap'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width of the contour lines. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the x + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.x.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the x + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + """ + + def __init__( + self, + arg=None, + color=None, + highlight=None, + highlightcolor=None, + highlightwidth=None, + project=None, + show=None, + usecolormap=None, + width=None, + **kwargs + ): + """ + Construct a new X object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.contours.X + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the x + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.x.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the x + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + X + """ + super(X, self).__init__('x') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.X +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.X""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours import (x as v_x) + + # Initialize validators + # --------------------- + self._validators['color'] = v_x.ColorValidator() + self._validators['highlight'] = v_x.HighlightValidator() + self._validators['highlightcolor'] = v_x.HighlightcolorValidator() + self._validators['highlightwidth'] = v_x.HighlightwidthValidator() + self._validators['project'] = v_x.ProjectValidator() + self._validators['show'] = v_x.ShowValidator() + self._validators['usecolormap'] = v_x.UsecolormapValidator() + self._validators['width'] = v_x.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('highlight', None) + self.highlight = highlight if highlight is not None else v + v = arg.pop('highlightcolor', None) + self.highlightcolor = highlightcolor if highlightcolor is not None else v + v = arg.pop('highlightwidth', None) + self.highlightwidth = highlightwidth if highlightwidth is not None else v + v = arg.pop('project', None) + self.project = project if project is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + v = arg.pop('usecolormap', None) + self.usecolormap = usecolormap if usecolormap is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/_y.py b/plotly/graph_objs/surface/contours/_y.py new file mode 100644 index 0000000000..319373a3d3 --- /dev/null +++ b/plotly/graph_objs/surface/contours/_y.py @@ -0,0 +1,406 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Y(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour lines. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # highlight + # --------- + @property + def highlight(self): + """ + Determines whether or not contour lines about the y dimension + are highlighted on hover. + + The 'highlight' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['highlight'] + + @highlight.setter + def highlight(self, val): + self['highlight'] = val + + # highlightcolor + # -------------- + @property + def highlightcolor(self): + """ + Sets the color of the highlighted contour lines. + + The 'highlightcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['highlightcolor'] + + @highlightcolor.setter + def highlightcolor(self, val): + self['highlightcolor'] = val + + # highlightwidth + # -------------- + @property + def highlightwidth(self): + """ + Sets the width of the highlighted contour lines. + + The 'highlightwidth' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['highlightwidth'] + + @highlightwidth.setter + def highlightwidth(self, val): + self['highlightwidth'] = val + + # project + # ------- + @property + def project(self): + """ + The 'project' property is an instance of Project + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.y.Project + - A dict of string/value properties that will be passed + to the Project constructor + + Supported dict properties: + + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + + Returns + ------- + plotly.graph_objs.surface.contours.y.Project + """ + return self['project'] + + @project.setter + def project(self, val): + self['project'] = val + + # show + # ---- + @property + def show(self): + """ + Determines whether or not contour lines about the y dimension + are drawn. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # usecolormap + # ----------- + @property + def usecolormap(self): + """ + An alternate to *color*. Determines whether or not the contour + lines are colored using the trace *colorscale*. + + The 'usecolormap' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['usecolormap'] + + @usecolormap.setter + def usecolormap(self, val): + self['usecolormap'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width of the contour lines. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the y + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.y.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the y + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + """ + + def __init__( + self, + arg=None, + color=None, + highlight=None, + highlightcolor=None, + highlightwidth=None, + project=None, + show=None, + usecolormap=None, + width=None, + **kwargs + ): + """ + Construct a new Y object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.contours.Y + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the y + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.y.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the y + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + Y + """ + super(Y, self).__init__('y') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.Y +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.Y""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours import (y as v_y) + + # Initialize validators + # --------------------- + self._validators['color'] = v_y.ColorValidator() + self._validators['highlight'] = v_y.HighlightValidator() + self._validators['highlightcolor'] = v_y.HighlightcolorValidator() + self._validators['highlightwidth'] = v_y.HighlightwidthValidator() + self._validators['project'] = v_y.ProjectValidator() + self._validators['show'] = v_y.ShowValidator() + self._validators['usecolormap'] = v_y.UsecolormapValidator() + self._validators['width'] = v_y.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('highlight', None) + self.highlight = highlight if highlight is not None else v + v = arg.pop('highlightcolor', None) + self.highlightcolor = highlightcolor if highlightcolor is not None else v + v = arg.pop('highlightwidth', None) + self.highlightwidth = highlightwidth if highlightwidth is not None else v + v = arg.pop('project', None) + self.project = project if project is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + v = arg.pop('usecolormap', None) + self.usecolormap = usecolormap if usecolormap is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/_z.py b/plotly/graph_objs/surface/contours/_z.py new file mode 100644 index 0000000000..b648716c3b --- /dev/null +++ b/plotly/graph_objs/surface/contours/_z.py @@ -0,0 +1,406 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Z(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of the contour lines. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # highlight + # --------- + @property + def highlight(self): + """ + Determines whether or not contour lines about the z dimension + are highlighted on hover. + + The 'highlight' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['highlight'] + + @highlight.setter + def highlight(self, val): + self['highlight'] = val + + # highlightcolor + # -------------- + @property + def highlightcolor(self): + """ + Sets the color of the highlighted contour lines. + + The 'highlightcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['highlightcolor'] + + @highlightcolor.setter + def highlightcolor(self, val): + self['highlightcolor'] = val + + # highlightwidth + # -------------- + @property + def highlightwidth(self): + """ + Sets the width of the highlighted contour lines. + + The 'highlightwidth' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['highlightwidth'] + + @highlightwidth.setter + def highlightwidth(self, val): + self['highlightwidth'] = val + + # project + # ------- + @property + def project(self): + """ + The 'project' property is an instance of Project + that may be specified as: + - An instance of plotly.graph_objs.surface.contours.z.Project + - A dict of string/value properties that will be passed + to the Project constructor + + Supported dict properties: + + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + + Returns + ------- + plotly.graph_objs.surface.contours.z.Project + """ + return self['project'] + + @project.setter + def project(self, val): + self['project'] = val + + # show + # ---- + @property + def show(self): + """ + Determines whether or not contour lines about the z dimension + are drawn. + + The 'show' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['show'] + + @show.setter + def show(self, val): + self['show'] = val + + # usecolormap + # ----------- + @property + def usecolormap(self): + """ + An alternate to *color*. Determines whether or not the contour + lines are colored using the trace *colorscale*. + + The 'usecolormap' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['usecolormap'] + + @usecolormap.setter + def usecolormap(self, val): + self['usecolormap'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width of the contour lines. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [1, 16] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the z + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.z.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the z + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + """ + + def __init__( + self, + arg=None, + color=None, + highlight=None, + highlightcolor=None, + highlightwidth=None, + project=None, + show=None, + usecolormap=None, + width=None, + **kwargs + ): + """ + Construct a new Z object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.surface.contours.Z + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about the z + dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour lines. + highlightwidth + Sets the width of the highlighted contour lines. + project + plotly.graph_objs.surface.contours.z.Project instance + or dict with compatible properties + show + Determines whether or not contour lines about the z + dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or not the + contour lines are colored using the trace *colorscale*. + width + Sets the width of the contour lines. + + Returns + ------- + Z + """ + super(Z, self).__init__('z') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.Z +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.Z""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours import (z as v_z) + + # Initialize validators + # --------------------- + self._validators['color'] = v_z.ColorValidator() + self._validators['highlight'] = v_z.HighlightValidator() + self._validators['highlightcolor'] = v_z.HighlightcolorValidator() + self._validators['highlightwidth'] = v_z.HighlightwidthValidator() + self._validators['project'] = v_z.ProjectValidator() + self._validators['show'] = v_z.ShowValidator() + self._validators['usecolormap'] = v_z.UsecolormapValidator() + self._validators['width'] = v_z.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('highlight', None) + self.highlight = highlight if highlight is not None else v + v = arg.pop('highlightcolor', None) + self.highlightcolor = highlightcolor if highlightcolor is not None else v + v = arg.pop('highlightwidth', None) + self.highlightwidth = highlightwidth if highlightwidth is not None else v + v = arg.pop('project', None) + self.project = project if project is not None else v + v = arg.pop('show', None) + self.show = show if show is not None else v + v = arg.pop('usecolormap', None) + self.usecolormap = usecolormap if usecolormap is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/x/__init__.py b/plotly/graph_objs/surface/contours/x/__init__.py new file mode 100644 index 0000000000..0bd829fdb1 --- /dev/null +++ b/plotly/graph_objs/surface/contours/x/__init__.py @@ -0,0 +1 @@ +from ._project import Project diff --git a/plotly/graph_objs/surface/contours/x/_project.py b/plotly/graph_objs/surface/contours/x/_project.py new file mode 100644 index 0000000000..b9eaf86cc0 --- /dev/null +++ b/plotly/graph_objs/surface/contours/x/_project.py @@ -0,0 +1,179 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Project(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Determines whether or not these contour lines are projected on + the x plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'x' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Determines whether or not these contour lines are projected on + the y plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'y' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Determines whether or not these contour lines are projected on + the z plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'z' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours.x' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Project object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.contours.x.Project + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + + Returns + ------- + Project + """ + super(Project, self).__init__('project') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.x.Project +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.x.Project""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours.x import (project as v_project) + + # Initialize validators + # --------------------- + self._validators['x'] = v_project.XValidator() + self._validators['y'] = v_project.YValidator() + self._validators['z'] = v_project.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/y/__init__.py b/plotly/graph_objs/surface/contours/y/__init__.py new file mode 100644 index 0000000000..0bd829fdb1 --- /dev/null +++ b/plotly/graph_objs/surface/contours/y/__init__.py @@ -0,0 +1 @@ +from ._project import Project diff --git a/plotly/graph_objs/surface/contours/y/_project.py b/plotly/graph_objs/surface/contours/y/_project.py new file mode 100644 index 0000000000..87c269342c --- /dev/null +++ b/plotly/graph_objs/surface/contours/y/_project.py @@ -0,0 +1,179 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Project(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Determines whether or not these contour lines are projected on + the x plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'x' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Determines whether or not these contour lines are projected on + the y plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'y' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Determines whether or not these contour lines are projected on + the z plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'z' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours.y' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Project object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.contours.y.Project + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + + Returns + ------- + Project + """ + super(Project, self).__init__('project') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.y.Project +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.y.Project""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours.y import (project as v_project) + + # Initialize validators + # --------------------- + self._validators['x'] = v_project.XValidator() + self._validators['y'] = v_project.YValidator() + self._validators['z'] = v_project.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/contours/z/__init__.py b/plotly/graph_objs/surface/contours/z/__init__.py new file mode 100644 index 0000000000..0bd829fdb1 --- /dev/null +++ b/plotly/graph_objs/surface/contours/z/__init__.py @@ -0,0 +1 @@ +from ._project import Project diff --git a/plotly/graph_objs/surface/contours/z/_project.py b/plotly/graph_objs/surface/contours/z/_project.py new file mode 100644 index 0000000000..750c24c67e --- /dev/null +++ b/plotly/graph_objs/surface/contours/z/_project.py @@ -0,0 +1,179 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Project(BaseTraceHierarchyType): + + # x + # - + @property + def x(self): + """ + Determines whether or not these contour lines are projected on + the x plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'x' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Determines whether or not these contour lines are projected on + the y plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'y' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # z + # - + @property + def z(self): + """ + Determines whether or not these contour lines are projected on + the z plane. If `highlight` is set to *true* (the default), the + projected lines are shown on hover. If `show` is set to *true*, + the projected lines are shown in permanence. + + The 'z' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['z'] + + @z.setter + def z(self, val): + self['z'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.contours.z' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + """ + + def __init__(self, arg=None, x=None, y=None, z=None, **kwargs): + """ + Construct a new Project object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.contours.z.Project + x + Determines whether or not these contour lines are + projected on the x plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + y + Determines whether or not these contour lines are + projected on the y plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + z + Determines whether or not these contour lines are + projected on the z plane. If `highlight` is set to + *true* (the default), the projected lines are shown on + hover. If `show` is set to *true*, the projected lines + are shown in permanence. + + Returns + ------- + Project + """ + super(Project, self).__init__('project') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.contours.z.Project +constructor must be a dict or +an instance of plotly.graph_objs.surface.contours.z.Project""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.contours.z import (project as v_project) + + # Initialize validators + # --------------------- + self._validators['x'] = v_project.XValidator() + self._validators['y'] = v_project.YValidator() + self._validators['z'] = v_project.ZValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + v = arg.pop('z', None) + self.z = z if z is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/surface/hoverlabel/__init__.py b/plotly/graph_objs/surface/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/surface/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/surface/hoverlabel/_font.py b/plotly/graph_objs/surface/hoverlabel/_font.py new file mode 100644 index 0000000000..2276a1f4ff --- /dev/null +++ b/plotly/graph_objs/surface/hoverlabel/_font.py @@ -0,0 +1,312 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'surface.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.surface.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.surface.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.surface.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.surface.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/__init__.py b/plotly/graph_objs/table/__init__.py new file mode 100644 index 0000000000..72c2c2da5a --- /dev/null +++ b/plotly/graph_objs/table/__init__.py @@ -0,0 +1,8 @@ +from ._stream import Stream +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.table import hoverlabel +from ._header import Header +from plotly.graph_objs.table import header +from ._domain import Domain +from ._cells import Cells +from plotly.graph_objs.table import cells diff --git a/plotly/graph_objs/table/_cells.py b/plotly/graph_objs/table/_cells.py new file mode 100644 index 0000000000..5578d40610 --- /dev/null +++ b/plotly/graph_objs/table/_cells.py @@ -0,0 +1,559 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Cells(BaseTraceHierarchyType): + + # align + # ----- + @property + def align(self): + """ + Sets the horizontal alignment of the `text` within the box. Has + an effect only if `text` spans more two or more lines (i.e. + `text` contains one or more
HTML tags) or if an explicit + width is set to override the text width. + + The 'align' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['align'] + + @align.setter + def align(self, val): + self['align'] = val + + # alignsrc + # -------- + @property + def alignsrc(self): + """ + Sets the source reference on plot.ly for align . + + The 'alignsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['alignsrc'] + + @alignsrc.setter + def alignsrc(self, val): + self['alignsrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + The 'fill' property is an instance of Fill + that may be specified as: + - An instance of plotly.graph_objs.table.cells.Fill + - A dict of string/value properties that will be passed + to the Fill constructor + + Supported dict properties: + + color + Sets the cell fill color. It accepts either a + specific color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color + . + + Returns + ------- + plotly.graph_objs.table.cells.Fill + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # font + # ---- + @property + def font(self): + """ + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.table.cells.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.table.cells.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # format + # ------ + @property + def format(self): + """ + Sets the cell value formatting rule using d3 formatting mini- + language which is similar to those of Python. See https://githu + b.com/d3/d3-format/blob/master/README.md#locale_format + + The 'format' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['format'] + + @format.setter + def format(self, val): + self['format'] = val + + # formatsrc + # --------- + @property + def formatsrc(self): + """ + Sets the source reference on plot.ly for format . + + The 'formatsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['formatsrc'] + + @formatsrc.setter + def formatsrc(self, val): + self['formatsrc'] = val + + # height + # ------ + @property + def height(self): + """ + The height of cells. + + The 'height' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['height'] + + @height.setter + def height(self, val): + self['height'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.table.cells.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + width + + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.table.cells.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # prefix + # ------ + @property + def prefix(self): + """ + Prefix for cell values. + + The 'prefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['prefix'] + + @prefix.setter + def prefix(self, val): + self['prefix'] = val + + # prefixsrc + # --------- + @property + def prefixsrc(self): + """ + Sets the source reference on plot.ly for prefix . + + The 'prefixsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['prefixsrc'] + + @prefixsrc.setter + def prefixsrc(self, val): + self['prefixsrc'] = val + + # suffix + # ------ + @property + def suffix(self): + """ + Suffix for cell values. + + The 'suffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['suffix'] + + @suffix.setter + def suffix(self, val): + self['suffix'] = val + + # suffixsrc + # --------- + @property + def suffixsrc(self): + """ + Sets the source reference on plot.ly for suffix . + + The 'suffixsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['suffixsrc'] + + @suffixsrc.setter + def suffixsrc(self, val): + self['suffixsrc'] = val + + # values + # ------ + @property + def values(self): + """ + Cell values. `values[m][n]` represents the value of the `n`th + point in column `m`, therefore the `values[m]` vector length + for all columns must be the same (longer vectors will be + truncated). Each value must be a finite number or a string. + + The 'values' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['values'] + + @values.setter + def values(self, val): + self['values'] = val + + # valuessrc + # --------- + @property + def valuessrc(self): + """ + Sets the source reference on plot.ly for values . + + The 'valuessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuessrc'] + + @valuessrc.setter + def valuessrc(self, val): + self['valuessrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + alignsrc + Sets the source reference on plot.ly for align . + fill + plotly.graph_objs.table.cells.Fill instance or dict + with compatible properties + font + plotly.graph_objs.table.cells.Font instance or dict + with compatible properties + format + Sets the cell value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + formatsrc + Sets the source reference on plot.ly for format . + height + The height of cells. + line + plotly.graph_objs.table.cells.Line instance or dict + with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for suffix . + values + Cell values. `values[m][n]` represents the value of the + `n`th point in column `m`, therefore the `values[m]` + vector length for all columns must be the same (longer + vectors will be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for values . + """ + + def __init__( + self, + arg=None, + align=None, + alignsrc=None, + fill=None, + font=None, + format=None, + formatsrc=None, + height=None, + line=None, + prefix=None, + prefixsrc=None, + suffix=None, + suffixsrc=None, + values=None, + valuessrc=None, + **kwargs + ): + """ + Construct a new Cells object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.Cells + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + alignsrc + Sets the source reference on plot.ly for align . + fill + plotly.graph_objs.table.cells.Fill instance or dict + with compatible properties + font + plotly.graph_objs.table.cells.Font instance or dict + with compatible properties + format + Sets the cell value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + formatsrc + Sets the source reference on plot.ly for format . + height + The height of cells. + line + plotly.graph_objs.table.cells.Line instance or dict + with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for suffix . + values + Cell values. `values[m][n]` represents the value of the + `n`th point in column `m`, therefore the `values[m]` + vector length for all columns must be the same (longer + vectors will be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for values . + + Returns + ------- + Cells + """ + super(Cells, self).__init__('cells') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.Cells +constructor must be a dict or +an instance of plotly.graph_objs.table.Cells""" + ) + + # Import validators + # ----------------- + from plotly.validators.table import (cells as v_cells) + + # Initialize validators + # --------------------- + self._validators['align'] = v_cells.AlignValidator() + self._validators['alignsrc'] = v_cells.AlignsrcValidator() + self._validators['fill'] = v_cells.FillValidator() + self._validators['font'] = v_cells.FontValidator() + self._validators['format'] = v_cells.FormatValidator() + self._validators['formatsrc'] = v_cells.FormatsrcValidator() + self._validators['height'] = v_cells.HeightValidator() + self._validators['line'] = v_cells.LineValidator() + self._validators['prefix'] = v_cells.PrefixValidator() + self._validators['prefixsrc'] = v_cells.PrefixsrcValidator() + self._validators['suffix'] = v_cells.SuffixValidator() + self._validators['suffixsrc'] = v_cells.SuffixsrcValidator() + self._validators['values'] = v_cells.ValuesValidator() + self._validators['valuessrc'] = v_cells.ValuessrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('align', None) + self.align = align if align is not None else v + v = arg.pop('alignsrc', None) + self.alignsrc = alignsrc if alignsrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('format', None) + self.format = format if format is not None else v + v = arg.pop('formatsrc', None) + self.formatsrc = formatsrc if formatsrc is not None else v + v = arg.pop('height', None) + self.height = height if height is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('prefix', None) + self.prefix = prefix if prefix is not None else v + v = arg.pop('prefixsrc', None) + self.prefixsrc = prefixsrc if prefixsrc is not None else v + v = arg.pop('suffix', None) + self.suffix = suffix if suffix is not None else v + v = arg.pop('suffixsrc', None) + self.suffixsrc = suffixsrc if suffixsrc is not None else v + v = arg.pop('values', None) + self.values = values if values is not None else v + v = arg.pop('valuessrc', None) + self.valuessrc = valuessrc if valuessrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/_domain.py b/plotly/graph_objs/table/_domain.py new file mode 100644 index 0000000000..e8d28c52bb --- /dev/null +++ b/plotly/graph_objs/table/_domain.py @@ -0,0 +1,198 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Domain(BaseTraceHierarchyType): + + # column + # ------ + @property + def column(self): + """ + If there is a layout grid, use the domain for this column in + the grid for this table trace . + + The 'column' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['column'] + + @column.setter + def column(self, val): + self['column'] = val + + # row + # --- + @property + def row(self): + """ + If there is a layout grid, use the domain for this row in the + grid for this table trace . + + The 'row' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [0, 9223372036854775807] + + Returns + ------- + int + """ + return self['row'] + + @row.setter + def row(self, val): + self['row'] = val + + # x + # - + @property + def x(self): + """ + Sets the horizontal domain of this table trace (in plot + fraction). + + The 'x' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'x[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'x[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['x'] + + @x.setter + def x(self, val): + self['x'] = val + + # y + # - + @property + def y(self): + """ + Sets the vertical domain of this table trace (in plot + fraction). + + The 'y' property is an info array that may be specified as a + list or tuple of 2 elements where: + + (0) The 'y[0]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + (1) The 'y[1]' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + list + """ + return self['y'] + + @y.setter + def y(self, val): + self['y'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + column + If there is a layout grid, use the domain for this + column in the grid for this table trace . + row + If there is a layout grid, use the domain for this row + in the grid for this table trace . + x + Sets the horizontal domain of this table trace (in plot + fraction). + y + Sets the vertical domain of this table trace (in plot + fraction). + """ + + def __init__( + self, arg=None, column=None, row=None, x=None, y=None, **kwargs + ): + """ + Construct a new Domain object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.Domain + column + If there is a layout grid, use the domain for this + column in the grid for this table trace . + row + If there is a layout grid, use the domain for this row + in the grid for this table trace . + x + Sets the horizontal domain of this table trace (in plot + fraction). + y + Sets the vertical domain of this table trace (in plot + fraction). + + Returns + ------- + Domain + """ + super(Domain, self).__init__('domain') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.Domain +constructor must be a dict or +an instance of plotly.graph_objs.table.Domain""" + ) + + # Import validators + # ----------------- + from plotly.validators.table import (domain as v_domain) + + # Initialize validators + # --------------------- + self._validators['column'] = v_domain.ColumnValidator() + self._validators['row'] = v_domain.RowValidator() + self._validators['x'] = v_domain.XValidator() + self._validators['y'] = v_domain.YValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('column', None) + self.column = column if column is not None else v + v = arg.pop('row', None) + self.row = row if row is not None else v + v = arg.pop('x', None) + self.x = x if x is not None else v + v = arg.pop('y', None) + self.y = y if y is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/_header.py b/plotly/graph_objs/table/_header.py new file mode 100644 index 0000000000..5400c49e7d --- /dev/null +++ b/plotly/graph_objs/table/_header.py @@ -0,0 +1,559 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Header(BaseTraceHierarchyType): + + # align + # ----- + @property + def align(self): + """ + Sets the horizontal alignment of the `text` within the box. Has + an effect only if `text` spans more two or more lines (i.e. + `text` contains one or more
HTML tags) or if an explicit + width is set to override the text width. + + The 'align' property is an enumeration that may be specified as: + - One of the following enumeration values: + ['left', 'center', 'right'] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + Any|numpy.ndarray + """ + return self['align'] + + @align.setter + def align(self, val): + self['align'] = val + + # alignsrc + # -------- + @property + def alignsrc(self): + """ + Sets the source reference on plot.ly for align . + + The 'alignsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['alignsrc'] + + @alignsrc.setter + def alignsrc(self, val): + self['alignsrc'] = val + + # fill + # ---- + @property + def fill(self): + """ + The 'fill' property is an instance of Fill + that may be specified as: + - An instance of plotly.graph_objs.table.header.Fill + - A dict of string/value properties that will be passed + to the Fill constructor + + Supported dict properties: + + color + Sets the cell fill color. It accepts either a + specific color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color + . + + Returns + ------- + plotly.graph_objs.table.header.Fill + """ + return self['fill'] + + @fill.setter + def fill(self, val): + self['fill'] = val + + # font + # ---- + @property + def font(self): + """ + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.table.header.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.table.header.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # format + # ------ + @property + def format(self): + """ + Sets the cell value formatting rule using d3 formatting mini- + language which is similar to those of Python. See https://githu + b.com/d3/d3-format/blob/master/README.md#locale_format + + The 'format' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['format'] + + @format.setter + def format(self, val): + self['format'] = val + + # formatsrc + # --------- + @property + def formatsrc(self): + """ + Sets the source reference on plot.ly for format . + + The 'formatsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['formatsrc'] + + @formatsrc.setter + def formatsrc(self, val): + self['formatsrc'] = val + + # height + # ------ + @property + def height(self): + """ + The height of cells. + + The 'height' property is a number and may be specified as: + - An int or float + + Returns + ------- + int|float + """ + return self['height'] + + @height.setter + def height(self, val): + self['height'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.table.header.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + width + + widthsrc + Sets the source reference on plot.ly for width + . + + Returns + ------- + plotly.graph_objs.table.header.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # prefix + # ------ + @property + def prefix(self): + """ + Prefix for cell values. + + The 'prefix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['prefix'] + + @prefix.setter + def prefix(self, val): + self['prefix'] = val + + # prefixsrc + # --------- + @property + def prefixsrc(self): + """ + Sets the source reference on plot.ly for prefix . + + The 'prefixsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['prefixsrc'] + + @prefixsrc.setter + def prefixsrc(self, val): + self['prefixsrc'] = val + + # suffix + # ------ + @property + def suffix(self): + """ + Suffix for cell values. + + The 'suffix' property is a string and must be specified as: + - A string + - A number that will be converted to a string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['suffix'] + + @suffix.setter + def suffix(self, val): + self['suffix'] = val + + # suffixsrc + # --------- + @property + def suffixsrc(self): + """ + Sets the source reference on plot.ly for suffix . + + The 'suffixsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['suffixsrc'] + + @suffixsrc.setter + def suffixsrc(self, val): + self['suffixsrc'] = val + + # values + # ------ + @property + def values(self): + """ + Header cell values. `values[m][n]` represents the value of the + `n`th point in column `m`, therefore the `values[m]` vector + length for all columns must be the same (longer vectors will be + truncated). Each value must be a finite number or a string. + + The 'values' property is an array that may be specified as a tuple, + list, numpy array, or pandas Series + + Returns + ------- + numpy.ndarray + """ + return self['values'] + + @values.setter + def values(self, val): + self['values'] = val + + # valuessrc + # --------- + @property + def valuessrc(self): + """ + Sets the source reference on plot.ly for values . + + The 'valuessrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['valuessrc'] + + @valuessrc.setter + def valuessrc(self, val): + self['valuessrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + alignsrc + Sets the source reference on plot.ly for align . + fill + plotly.graph_objs.table.header.Fill instance or dict + with compatible properties + font + plotly.graph_objs.table.header.Font instance or dict + with compatible properties + format + Sets the cell value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + formatsrc + Sets the source reference on plot.ly for format . + height + The height of cells. + line + plotly.graph_objs.table.header.Line instance or dict + with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for suffix . + values + Header cell values. `values[m][n]` represents the value + of the `n`th point in column `m`, therefore the + `values[m]` vector length for all columns must be the + same (longer vectors will be truncated). Each value + must be a finite number or a string. + valuessrc + Sets the source reference on plot.ly for values . + """ + + def __init__( + self, + arg=None, + align=None, + alignsrc=None, + fill=None, + font=None, + format=None, + formatsrc=None, + height=None, + line=None, + prefix=None, + prefixsrc=None, + suffix=None, + suffixsrc=None, + values=None, + valuessrc=None, + **kwargs + ): + """ + Construct a new Header object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.Header + align + Sets the horizontal alignment of the `text` within the + box. Has an effect only if `text` spans more two or + more lines (i.e. `text` contains one or more
HTML + tags) or if an explicit width is set to override the + text width. + alignsrc + Sets the source reference on plot.ly for align . + fill + plotly.graph_objs.table.header.Fill instance or dict + with compatible properties + font + plotly.graph_objs.table.header.Font instance or dict + with compatible properties + format + Sets the cell value formatting rule using d3 formatting + mini-language which is similar to those of Python. See + https://github.com/d3/d3-format/blob/master/README.md#l + ocale_format + formatsrc + Sets the source reference on plot.ly for format . + height + The height of cells. + line + plotly.graph_objs.table.header.Line instance or dict + with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for suffix . + values + Header cell values. `values[m][n]` represents the value + of the `n`th point in column `m`, therefore the + `values[m]` vector length for all columns must be the + same (longer vectors will be truncated). Each value + must be a finite number or a string. + valuessrc + Sets the source reference on plot.ly for values . + + Returns + ------- + Header + """ + super(Header, self).__init__('header') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.Header +constructor must be a dict or +an instance of plotly.graph_objs.table.Header""" + ) + + # Import validators + # ----------------- + from plotly.validators.table import (header as v_header) + + # Initialize validators + # --------------------- + self._validators['align'] = v_header.AlignValidator() + self._validators['alignsrc'] = v_header.AlignsrcValidator() + self._validators['fill'] = v_header.FillValidator() + self._validators['font'] = v_header.FontValidator() + self._validators['format'] = v_header.FormatValidator() + self._validators['formatsrc'] = v_header.FormatsrcValidator() + self._validators['height'] = v_header.HeightValidator() + self._validators['line'] = v_header.LineValidator() + self._validators['prefix'] = v_header.PrefixValidator() + self._validators['prefixsrc'] = v_header.PrefixsrcValidator() + self._validators['suffix'] = v_header.SuffixValidator() + self._validators['suffixsrc'] = v_header.SuffixsrcValidator() + self._validators['values'] = v_header.ValuesValidator() + self._validators['valuessrc'] = v_header.ValuessrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('align', None) + self.align = align if align is not None else v + v = arg.pop('alignsrc', None) + self.alignsrc = alignsrc if alignsrc is not None else v + v = arg.pop('fill', None) + self.fill = fill if fill is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('format', None) + self.format = format if format is not None else v + v = arg.pop('formatsrc', None) + self.formatsrc = formatsrc if formatsrc is not None else v + v = arg.pop('height', None) + self.height = height if height is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('prefix', None) + self.prefix = prefix if prefix is not None else v + v = arg.pop('prefixsrc', None) + self.prefixsrc = prefixsrc if prefixsrc is not None else v + v = arg.pop('suffix', None) + self.suffix = suffix if suffix is not None else v + v = arg.pop('suffixsrc', None) + self.suffixsrc = suffixsrc if suffixsrc is not None else v + v = arg.pop('values', None) + self.values = values if values is not None else v + v = arg.pop('valuessrc', None) + self.valuessrc = valuessrc if valuessrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/_hoverlabel.py b/plotly/graph_objs/table/_hoverlabel.py new file mode 100644 index 0000000000..4e33804de3 --- /dev/null +++ b/plotly/graph_objs/table/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.table.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.table.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.table.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.table import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/_stream.py b/plotly/graph_objs/table/_stream.py new file mode 100644 index 0000000000..a288ece076 --- /dev/null +++ b/plotly/graph_objs/table/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.Stream +constructor must be a dict or +an instance of plotly.graph_objs.table.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.table import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/cells/__init__.py b/plotly/graph_objs/table/cells/__init__.py new file mode 100644 index 0000000000..2ec886325a --- /dev/null +++ b/plotly/graph_objs/table/cells/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._font import Font +from ._fill import Fill diff --git a/plotly/graph_objs/table/cells/_fill.py b/plotly/graph_objs/table/cells/_fill.py new file mode 100644 index 0000000000..f66a63d596 --- /dev/null +++ b/plotly/graph_objs/table/cells/_fill.py @@ -0,0 +1,161 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Fill(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the cell fill color. It accepts either a specific color or + an array of colors. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.cells' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the cell fill color. It accepts either a specific + color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color . + """ + + def __init__(self, arg=None, color=None, colorsrc=None, **kwargs): + """ + Construct a new Fill object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.cells.Fill + color + Sets the cell fill color. It accepts either a specific + color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color . + + Returns + ------- + Fill + """ + super(Fill, self).__init__('fill') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.cells.Fill +constructor must be a dict or +an instance of plotly.graph_objs.table.cells.Fill""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.cells import (fill as v_fill) + + # Initialize validators + # --------------------- + self._validators['color'] = v_fill.ColorValidator() + self._validators['colorsrc'] = v_fill.ColorsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/cells/_font.py b/plotly/graph_objs/table/cells/_font.py new file mode 100644 index 0000000000..7d4d0f0945 --- /dev/null +++ b/plotly/graph_objs/table/cells/_font.py @@ -0,0 +1,309 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.cells' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.cells.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.cells.Font +constructor must be a dict or +an instance of plotly.graph_objs.table.cells.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.cells import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/cells/_line.py b/plotly/graph_objs/table/cells/_line.py new file mode 100644 index 0000000000..6daf022c7f --- /dev/null +++ b/plotly/graph_objs/table/cells/_line.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + The 'width' property is a number and may be specified as: + - An int or float + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.cells' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + width + + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.cells.Line + color + + colorsrc + Sets the source reference on plot.ly for color . + width + + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.cells.Line +constructor must be a dict or +an instance of plotly.graph_objs.table.cells.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.cells import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/header/__init__.py b/plotly/graph_objs/table/header/__init__.py new file mode 100644 index 0000000000..2ec886325a --- /dev/null +++ b/plotly/graph_objs/table/header/__init__.py @@ -0,0 +1,3 @@ +from ._line import Line +from ._font import Font +from ._fill import Fill diff --git a/plotly/graph_objs/table/header/_fill.py b/plotly/graph_objs/table/header/_fill.py new file mode 100644 index 0000000000..519d7c71fe --- /dev/null +++ b/plotly/graph_objs/table/header/_fill.py @@ -0,0 +1,161 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Fill(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the cell fill color. It accepts either a specific color or + an array of colors. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.header' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the cell fill color. It accepts either a specific + color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color . + """ + + def __init__(self, arg=None, color=None, colorsrc=None, **kwargs): + """ + Construct a new Fill object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.header.Fill + color + Sets the cell fill color. It accepts either a specific + color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color . + + Returns + ------- + Fill + """ + super(Fill, self).__init__('fill') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.header.Fill +constructor must be a dict or +an instance of plotly.graph_objs.table.header.Fill""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.header import (fill as v_fill) + + # Initialize validators + # --------------------- + self._validators['color'] = v_fill.ColorValidator() + self._validators['colorsrc'] = v_fill.ColorsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/header/_font.py b/plotly/graph_objs/table/header/_font.py new file mode 100644 index 0000000000..ac82c3df6b --- /dev/null +++ b/plotly/graph_objs/table/header/_font.py @@ -0,0 +1,309 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.header' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.header.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.header.Font +constructor must be a dict or +an instance of plotly.graph_objs.table.header.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.header import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/header/_line.py b/plotly/graph_objs/table/header/_line.py new file mode 100644 index 0000000000..31093e69bb --- /dev/null +++ b/plotly/graph_objs/table/header/_line.py @@ -0,0 +1,217 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # width + # ----- + @property + def width(self): + """ + The 'width' property is a number and may be specified as: + - An int or float + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # widthsrc + # -------- + @property + def widthsrc(self): + """ + Sets the source reference on plot.ly for width . + + The 'widthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['widthsrc'] + + @widthsrc.setter + def widthsrc(self, val): + self['widthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.header' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + width + + widthsrc + Sets the source reference on plot.ly for width . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + width=None, + widthsrc=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.header.Line + color + + colorsrc + Sets the source reference on plot.ly for color . + width + + widthsrc + Sets the source reference on plot.ly for width . + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.header.Line +constructor must be a dict or +an instance of plotly.graph_objs.table.header.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.header import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['colorsrc'] = v_line.ColorsrcValidator() + self._validators['width'] = v_line.WidthValidator() + self._validators['widthsrc'] = v_line.WidthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + v = arg.pop('widthsrc', None) + self.widthsrc = widthsrc if widthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/table/hoverlabel/__init__.py b/plotly/graph_objs/table/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/table/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/table/hoverlabel/_font.py b/plotly/graph_objs/table/hoverlabel/_font.py new file mode 100644 index 0000000000..6bee921e41 --- /dev/null +++ b/plotly/graph_objs/table/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'table.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.table.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.table.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.table.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.table.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/__init__.py b/plotly/graph_objs/violin/__init__.py new file mode 100644 index 0000000000..0cc26bb368 --- /dev/null +++ b/plotly/graph_objs/violin/__init__.py @@ -0,0 +1,13 @@ +from ._unselected import Unselected +from plotly.graph_objs.violin import unselected +from ._stream import Stream +from ._selected import Selected +from plotly.graph_objs.violin import selected +from ._meanline import Meanline +from ._marker import Marker +from plotly.graph_objs.violin import marker +from ._line import Line +from ._hoverlabel import Hoverlabel +from plotly.graph_objs.violin import hoverlabel +from ._box import Box +from plotly.graph_objs.violin import box diff --git a/plotly/graph_objs/violin/_box.py b/plotly/graph_objs/violin/_box.py new file mode 100644 index 0000000000..eea1e38f12 --- /dev/null +++ b/plotly/graph_objs/violin/_box.py @@ -0,0 +1,238 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Box(BaseTraceHierarchyType): + + # fillcolor + # --------- + @property + def fillcolor(self): + """ + Sets the inner box plot fill color. + + The 'fillcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['fillcolor'] + + @fillcolor.setter + def fillcolor(self, val): + self['fillcolor'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.violin.box.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the inner box plot bounding line color. + width + Sets the inner box plot bounding line width. + + Returns + ------- + plotly.graph_objs.violin.box.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines if an miniature box plot is drawn inside the + violins. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width of the inner box plots relative to the violins' + width. For example, with 1, the inner box plots are as wide as + the violins. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + fillcolor + Sets the inner box plot fill color. + line + plotly.graph_objs.violin.box.Line instance or dict with + compatible properties + visible + Determines if an miniature box plot is drawn inside the + violins. + width + Sets the width of the inner box plots relative to the + violins' width. For example, with 1, the inner box + plots are as wide as the violins. + """ + + def __init__( + self, + arg=None, + fillcolor=None, + line=None, + visible=None, + width=None, + **kwargs + ): + """ + Construct a new Box object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Box + fillcolor + Sets the inner box plot fill color. + line + plotly.graph_objs.violin.box.Line instance or dict with + compatible properties + visible + Determines if an miniature box plot is drawn inside the + violins. + width + Sets the width of the inner box plots relative to the + violins' width. For example, with 1, the inner box + plots are as wide as the violins. + + Returns + ------- + Box + """ + super(Box, self).__init__('box') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Box +constructor must be a dict or +an instance of plotly.graph_objs.violin.Box""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (box as v_box) + + # Initialize validators + # --------------------- + self._validators['fillcolor'] = v_box.FillcolorValidator() + self._validators['line'] = v_box.LineValidator() + self._validators['visible'] = v_box.VisibleValidator() + self._validators['width'] = v_box.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('fillcolor', None) + self.fillcolor = fillcolor if fillcolor is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_hoverlabel.py b/plotly/graph_objs/violin/_hoverlabel.py new file mode 100644 index 0000000000..98b4f2598a --- /dev/null +++ b/plotly/graph_objs/violin/_hoverlabel.py @@ -0,0 +1,404 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Hoverlabel(BaseTraceHierarchyType): + + # bgcolor + # ------- + @property + def bgcolor(self): + """ + Sets the background color of the hover labels for this trace + + The 'bgcolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bgcolor'] + + @bgcolor.setter + def bgcolor(self, val): + self['bgcolor'] = val + + # bgcolorsrc + # ---------- + @property + def bgcolorsrc(self): + """ + Sets the source reference on plot.ly for bgcolor . + + The 'bgcolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bgcolorsrc'] + + @bgcolorsrc.setter + def bgcolorsrc(self, val): + self['bgcolorsrc'] = val + + # bordercolor + # ----------- + @property + def bordercolor(self): + """ + Sets the border color of the hover labels for this trace. + + The 'bordercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['bordercolor'] + + @bordercolor.setter + def bordercolor(self, val): + self['bordercolor'] = val + + # bordercolorsrc + # -------------- + @property + def bordercolorsrc(self): + """ + Sets the source reference on plot.ly for bordercolor . + + The 'bordercolorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['bordercolorsrc'] + + @bordercolorsrc.setter + def bordercolorsrc(self, val): + self['bordercolorsrc'] = val + + # font + # ---- + @property + def font(self): + """ + Sets the font used in hover labels. + + The 'font' property is an instance of Font + that may be specified as: + - An instance of plotly.graph_objs.violin.hoverlabel.Font + - A dict of string/value properties that will be passed + to the Font constructor + + Supported dict properties: + + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + . + + Returns + ------- + plotly.graph_objs.violin.hoverlabel.Font + """ + return self['font'] + + @font.setter + def font(self, val): + self['font'] = val + + # namelength + # ---------- + @property + def namelength(self): + """ + Sets the length (in number of characters) of the trace name in + the hover labels for this trace. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is less than that + many characters, but if it is longer, will truncate to + `namelength - 3` characters and add an ellipsis. + + The 'namelength' property is a integer and may be specified as: + - An int (or float that will be cast to an int) + in the interval [-1, 9223372036854775807] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|numpy.ndarray + """ + return self['namelength'] + + @namelength.setter + def namelength(self, val): + self['namelength'] = val + + # namelengthsrc + # ------------- + @property + def namelengthsrc(self): + """ + Sets the source reference on plot.ly for namelength . + + The 'namelengthsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['namelengthsrc'] + + @namelengthsrc.setter + def namelengthsrc(self, val): + self['namelengthsrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + """ + + def __init__( + self, + arg=None, + bgcolor=None, + bgcolorsrc=None, + bordercolor=None, + bordercolorsrc=None, + font=None, + namelength=None, + namelengthsrc=None, + **kwargs + ): + """ + Construct a new Hoverlabel object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Hoverlabel + bgcolor + Sets the background color of the hover labels for this + trace + bgcolorsrc + Sets the source reference on plot.ly for bgcolor . + bordercolor + Sets the border color of the hover labels for this + trace. + bordercolorsrc + Sets the source reference on plot.ly for bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of the trace + name in the hover labels for this trace. -1 shows the + whole name regardless of length. 0-3 shows the first + 0-3 characters, and an integer >3 will show the whole + name if it is less than that many characters, but if it + is longer, will truncate to `namelength - 3` characters + and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for namelength . + + Returns + ------- + Hoverlabel + """ + super(Hoverlabel, self).__init__('hoverlabel') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Hoverlabel +constructor must be a dict or +an instance of plotly.graph_objs.violin.Hoverlabel""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (hoverlabel as v_hoverlabel) + + # Initialize validators + # --------------------- + self._validators['bgcolor'] = v_hoverlabel.BgcolorValidator() + self._validators['bgcolorsrc'] = v_hoverlabel.BgcolorsrcValidator() + self._validators['bordercolor'] = v_hoverlabel.BordercolorValidator() + self._validators['bordercolorsrc' + ] = v_hoverlabel.BordercolorsrcValidator() + self._validators['font'] = v_hoverlabel.FontValidator() + self._validators['namelength'] = v_hoverlabel.NamelengthValidator() + self._validators['namelengthsrc' + ] = v_hoverlabel.NamelengthsrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('bgcolor', None) + self.bgcolor = bgcolor if bgcolor is not None else v + v = arg.pop('bgcolorsrc', None) + self.bgcolorsrc = bgcolorsrc if bgcolorsrc is not None else v + v = arg.pop('bordercolor', None) + self.bordercolor = bordercolor if bordercolor is not None else v + v = arg.pop('bordercolorsrc', None) + self.bordercolorsrc = bordercolorsrc if bordercolorsrc is not None else v + v = arg.pop('font', None) + self.font = font if font is not None else v + v = arg.pop('namelength', None) + self.namelength = namelength if namelength is not None else v + v = arg.pop('namelengthsrc', None) + self.namelengthsrc = namelengthsrc if namelengthsrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_line.py b/plotly/graph_objs/violin/_line.py new file mode 100644 index 0000000000..759a741d34 --- /dev/null +++ b/plotly/graph_objs/violin/_line.py @@ -0,0 +1,157 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the color of line bounding the violin(s). + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of line bounding the violin(s). + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the color of line bounding the violin(s). + width + Sets the width (in px) of line bounding the violin(s). + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Line + color + Sets the color of line bounding the violin(s). + width + Sets the width (in px) of line bounding the violin(s). + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Line +constructor must be a dict or +an instance of plotly.graph_objs.violin.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_marker.py b/plotly/graph_objs/violin/_marker.py new file mode 100644 index 0000000000..bb2bc1c474 --- /dev/null +++ b/plotly/graph_objs/violin/_marker.py @@ -0,0 +1,416 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color. It accepts either a specific color or an + array of numbers that are mapped to the colorscale relative to + the max and min values of the array or relative to `cmin` and + `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # line + # ---- + @property + def line(self): + """ + The 'line' property is an instance of Line + that may be specified as: + - An instance of plotly.graph_objs.violin.marker.Line + - A dict of string/value properties that will be passed + to the Line constructor + + Supported dict properties: + + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier + sample points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the + outlier sample points. + width + Sets the width (in px) of the lines bounding + the marker points. + + Returns + ------- + plotly.graph_objs.violin.marker.Line + """ + return self['line'] + + @line.setter + def line(self, val): + self['line'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # outliercolor + # ------------ + @property + def outliercolor(self): + """ + Sets the color of the outlier sample points. + + The 'outliercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outliercolor'] + + @outliercolor.setter + def outliercolor(self, val): + self['outliercolor'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size (in px). + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # symbol + # ------ + @property + def symbol(self): + """ + Sets the marker symbol type. Adding 100 is equivalent to + appending *-open* to a symbol name. Adding 200 is equivalent to + appending *-dot* to a symbol name. Adding 300 is equivalent to + appending *-open-dot* or *dot-open* to a symbol name. + + The 'symbol' property is an enumeration that may be specified as: + - One of the following enumeration values: + [0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, + 'diamond-open-dot', 3, 'cross', 103, 'cross-open', 203, + 'cross-dot', 303, 'cross-open-dot', 4, 'x', 104, 'x-open', + 204, 'x-dot', 304, 'x-open-dot', 5, 'triangle-up', 105, + 'triangle-up-open', 205, 'triangle-up-dot', 305, + 'triangle-up-open-dot', 6, 'triangle-down', 106, + 'triangle-down-open', 206, 'triangle-down-dot', 306, + 'triangle-down-open-dot', 7, 'triangle-left', 107, + 'triangle-left-open', 207, 'triangle-left-dot', 307, + 'triangle-left-open-dot', 8, 'triangle-right', 108, + 'triangle-right-open', 208, 'triangle-right-dot', 308, + 'triangle-right-open-dot', 9, 'triangle-ne', 109, + 'triangle-ne-open', 209, 'triangle-ne-dot', 309, + 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, + 'pentagon-open', 213, 'pentagon-dot', 313, + 'pentagon-open-dot', 14, 'hexagon', 114, 'hexagon-open', + 214, 'hexagon-dot', 314, 'hexagon-open-dot', 15, + 'hexagon2', 115, 'hexagon2-open', 215, 'hexagon2-dot', + 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, + 'octagon-open-dot', 17, 'star', 117, 'star-open', 217, + 'star-dot', 317, 'star-open-dot', 18, 'hexagram', 118, + 'hexagram-open', 218, 'hexagram-dot', 318, + 'hexagram-open-dot', 19, 'star-triangle-up', 119, + 'star-triangle-up-open', 219, 'star-triangle-up-dot', 319, + 'star-triangle-up-open-dot', 20, 'star-triangle-down', + 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, + 'star-triangle-down-open-dot', 21, 'star-square', 121, + 'star-square-open', 221, 'star-square-dot', 321, + 'star-square-open-dot', 22, 'star-diamond', 122, + 'star-diamond-open', 222, 'star-diamond-dot', 322, + 'star-diamond-open-dot', 23, 'diamond-tall', 123, + 'diamond-tall-open', 223, 'diamond-tall-dot', 323, + 'diamond-tall-open-dot', 24, 'diamond-wide', 124, + 'diamond-wide-open', 224, 'diamond-wide-dot', 324, + 'diamond-wide-open-dot', 25, 'hourglass', 125, + 'hourglass-open', 26, 'bowtie', 126, 'bowtie-open', 27, + 'circle-cross', 127, 'circle-cross-open', 28, 'circle-x', + 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', + 31, 'diamond-cross', 131, 'diamond-cross-open', 32, + 'diamond-x', 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, + 'hash-open', 236, 'hash-dot', 336, 'hash-open-dot', 37, + 'y-up', 137, 'y-up-open', 38, 'y-down', 138, + 'y-down-open', 39, 'y-left', 139, 'y-left-open', 40, + 'y-right', 140, 'y-right-open', 41, 'line-ew', 141, + 'line-ew-open', 42, 'line-ns', 142, 'line-ns-open', 43, + 'line-ne', 143, 'line-ne-open', 44, 'line-nw', 144, + 'line-nw-open'] + + Returns + ------- + Any + """ + return self['symbol'] + + @symbol.setter + def symbol(self, val): + self['symbol'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + line + plotly.graph_objs.violin.marker.Line instance or dict + with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + """ + + def __init__( + self, + arg=None, + color=None, + line=None, + opacity=None, + outliercolor=None, + size=None, + symbol=None, + **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Marker + color + Sets the marker color. It accepts either a specific + color or an array of numbers that are mapped to the + colorscale relative to the max and min values of the + array or relative to `cmin` and `cmax` if set. + line + plotly.graph_objs.violin.marker.Line instance or dict + with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is equivalent + to appending *-open* to a symbol name. Adding 200 is + equivalent to appending *-dot* to a symbol name. Adding + 300 is equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Marker +constructor must be a dict or +an instance of plotly.graph_objs.violin.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['line'] = v_marker.LineValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['outliercolor'] = v_marker.OutliercolorValidator() + self._validators['size'] = v_marker.SizeValidator() + self._validators['symbol'] = v_marker.SymbolValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('line', None) + self.line = line if line is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('outliercolor', None) + self.outliercolor = outliercolor if outliercolor is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('symbol', None) + self.symbol = symbol if symbol is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_meanline.py b/plotly/graph_objs/violin/_meanline.py new file mode 100644 index 0000000000..2e21613c9b --- /dev/null +++ b/plotly/graph_objs/violin/_meanline.py @@ -0,0 +1,197 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Meanline(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the mean line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # visible + # ------- + @property + def visible(self): + """ + Determines if a line corresponding to the sample's mean is + shown inside the violins. If `box.visible` is turned on, the + mean line is drawn inside the inner box. Otherwise, the mean + line is drawn from one side of the violin to other. + + The 'visible' property must be specified as a bool + (either True, or False) + + Returns + ------- + bool + """ + return self['visible'] + + @visible.setter + def visible(self, val): + self['visible'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the mean line width. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the mean line color. + visible + Determines if a line corresponding to the sample's mean + is shown inside the violins. If `box.visible` is turned + on, the mean line is drawn inside the inner box. + Otherwise, the mean line is drawn from one side of the + violin to other. + width + Sets the mean line width. + """ + + def __init__( + self, arg=None, color=None, visible=None, width=None, **kwargs + ): + """ + Construct a new Meanline object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Meanline + color + Sets the mean line color. + visible + Determines if a line corresponding to the sample's mean + is shown inside the violins. If `box.visible` is turned + on, the mean line is drawn inside the inner box. + Otherwise, the mean line is drawn from one side of the + violin to other. + width + Sets the mean line width. + + Returns + ------- + Meanline + """ + super(Meanline, self).__init__('meanline') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Meanline +constructor must be a dict or +an instance of plotly.graph_objs.violin.Meanline""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (meanline as v_meanline) + + # Initialize validators + # --------------------- + self._validators['color'] = v_meanline.ColorValidator() + self._validators['visible'] = v_meanline.VisibleValidator() + self._validators['width'] = v_meanline.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('visible', None) + self.visible = visible if visible is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_selected.py b/plotly/graph_objs/violin/_selected.py new file mode 100644 index 0000000000..3f545f4949 --- /dev/null +++ b/plotly/graph_objs/violin/_selected.py @@ -0,0 +1,103 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Selected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.violin.selected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + plotly.graph_objs.violin.selected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.violin.selected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Selected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Selected + marker + plotly.graph_objs.violin.selected.Marker instance or + dict with compatible properties + + Returns + ------- + Selected + """ + super(Selected, self).__init__('selected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Selected +constructor must be a dict or +an instance of plotly.graph_objs.violin.Selected""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (selected as v_selected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_selected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_stream.py b/plotly/graph_objs/violin/_stream.py new file mode 100644 index 0000000000..cfc7e085cd --- /dev/null +++ b/plotly/graph_objs/violin/_stream.py @@ -0,0 +1,131 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Stream(BaseTraceHierarchyType): + + # maxpoints + # --------- + @property + def maxpoints(self): + """ + Sets the maximum number of points to keep on the plots from an + incoming stream. If `maxpoints` is set to *50*, only the newest + 50 points will be displayed on the plot. + + The 'maxpoints' property is a number and may be specified as: + - An int or float in the interval [0, 10000] + + Returns + ------- + int|float + """ + return self['maxpoints'] + + @maxpoints.setter + def maxpoints(self, val): + self['maxpoints'] = val + + # token + # ----- + @property + def token(self): + """ + The stream id number links a data trace on a plot with a + stream. See https://plot.ly/settings for more details. + + The 'token' property is a string and must be specified as: + - A non-empty string + + Returns + ------- + str + """ + return self['token'] + + @token.setter + def token(self, val): + self['token'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + """ + + def __init__(self, arg=None, maxpoints=None, token=None, **kwargs): + """ + Construct a new Stream object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Stream + maxpoints + Sets the maximum number of points to keep on the plots + from an incoming stream. If `maxpoints` is set to *50*, + only the newest 50 points will be displayed on the + plot. + token + The stream id number links a data trace on a plot with + a stream. See https://plot.ly/settings for more + details. + + Returns + ------- + Stream + """ + super(Stream, self).__init__('stream') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Stream +constructor must be a dict or +an instance of plotly.graph_objs.violin.Stream""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (stream as v_stream) + + # Initialize validators + # --------------------- + self._validators['maxpoints'] = v_stream.MaxpointsValidator() + self._validators['token'] = v_stream.TokenValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('maxpoints', None) + self.maxpoints = maxpoints if maxpoints is not None else v + v = arg.pop('token', None) + self.token = token if token is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/_unselected.py b/plotly/graph_objs/violin/_unselected.py new file mode 100644 index 0000000000..ed6cda1d24 --- /dev/null +++ b/plotly/graph_objs/violin/_unselected.py @@ -0,0 +1,106 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Unselected(BaseTraceHierarchyType): + + # marker + # ------ + @property + def marker(self): + """ + The 'marker' property is an instance of Marker + that may be specified as: + - An instance of plotly.graph_objs.violin.unselected.Marker + - A dict of string/value properties that will be passed + to the Marker constructor + + Supported dict properties: + + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists. + + Returns + ------- + plotly.graph_objs.violin.unselected.Marker + """ + return self['marker'] + + @marker.setter + def marker(self, val): + self['marker'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + marker + plotly.graph_objs.violin.unselected.Marker instance or + dict with compatible properties + """ + + def __init__(self, arg=None, marker=None, **kwargs): + """ + Construct a new Unselected object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.Unselected + marker + plotly.graph_objs.violin.unselected.Marker instance or + dict with compatible properties + + Returns + ------- + Unselected + """ + super(Unselected, self).__init__('unselected') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.Unselected +constructor must be a dict or +an instance of plotly.graph_objs.violin.Unselected""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin import (unselected as v_unselected) + + # Initialize validators + # --------------------- + self._validators['marker'] = v_unselected.MarkerValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('marker', None) + self.marker = marker if marker is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/box/__init__.py b/plotly/graph_objs/violin/box/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/violin/box/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/violin/box/_line.py b/plotly/graph_objs/violin/box/_line.py new file mode 100644 index 0000000000..e4ad25c073 --- /dev/null +++ b/plotly/graph_objs/violin/box/_line.py @@ -0,0 +1,157 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the inner box plot bounding line color. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the inner box plot bounding line width. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin.box' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the inner box plot bounding line color. + width + Sets the inner box plot bounding line width. + """ + + def __init__(self, arg=None, color=None, width=None, **kwargs): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.box.Line + color + Sets the inner box plot bounding line color. + width + Sets the inner box plot bounding line width. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.box.Line +constructor must be a dict or +an instance of plotly.graph_objs.violin.box.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin.box import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/hoverlabel/__init__.py b/plotly/graph_objs/violin/hoverlabel/__init__.py new file mode 100644 index 0000000000..c37b8b5cd2 --- /dev/null +++ b/plotly/graph_objs/violin/hoverlabel/__init__.py @@ -0,0 +1 @@ +from ._font import Font diff --git a/plotly/graph_objs/violin/hoverlabel/_font.py b/plotly/graph_objs/violin/hoverlabel/_font.py new file mode 100644 index 0000000000..c9f5d4aaa5 --- /dev/null +++ b/plotly/graph_objs/violin/hoverlabel/_font.py @@ -0,0 +1,311 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Font(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + - A list or array of any of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # colorsrc + # -------- + @property + def colorsrc(self): + """ + Sets the source reference on plot.ly for color . + + The 'colorsrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['colorsrc'] + + @colorsrc.setter + def colorsrc(self, val): + self['colorsrc'] = val + + # family + # ------ + @property + def family(self): + """ + HTML font family - the typeface that will be applied by the web + browser. The web browser will only be able to apply a font if + it is available on the system which it operates. Provide + multiple font families, separated by commas, to indicate the + preference in which to apply fonts if they aren't available on + the system. The plotly service (at https://plot.ly or on- + premise) generates images on a server, where only a select + number of fonts are installed and supported. These include + *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, + *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open + Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New + Roman*. + + The 'family' property is a string and must be specified as: + - A non-empty string + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + str|numpy.ndarray + """ + return self['family'] + + @family.setter + def family(self, val): + self['family'] = val + + # familysrc + # --------- + @property + def familysrc(self): + """ + Sets the source reference on plot.ly for family . + + The 'familysrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['familysrc'] + + @familysrc.setter + def familysrc(self, val): + self['familysrc'] = val + + # size + # ---- + @property + def size(self): + """ + The 'size' property is a number and may be specified as: + - An int or float in the interval [1, inf] + - A tuple, list, or one-dimensional numpy array of the above + + Returns + ------- + int|float|numpy.ndarray + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # sizesrc + # ------- + @property + def sizesrc(self): + """ + Sets the source reference on plot.ly for size . + + The 'sizesrc' property must be specified as a string or + as a plotly.grid_objs.Column object + + Returns + ------- + str + """ + return self['sizesrc'] + + @sizesrc.setter + def sizesrc(self, val): + self['sizesrc'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin.hoverlabel' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + """ + + def __init__( + self, + arg=None, + color=None, + colorsrc=None, + family=None, + familysrc=None, + size=None, + sizesrc=None, + **kwargs + ): + """ + Construct a new Font object + + Sets the font used in hover labels. + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.hoverlabel.Font + color + + colorsrc + Sets the source reference on plot.ly for color . + family + HTML font family - the typeface that will be applied by + the web browser. The web browser will only be able to + apply a font if it is available on the system which it + operates. Provide multiple font families, separated by + commas, to indicate the preference in which to apply + fonts if they aren't available on the system. The + plotly service (at https://plot.ly or on-premise) + generates images on a server, where only a select + number of fonts are installed and supported. These + include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, + *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for family . + size + + sizesrc + Sets the source reference on plot.ly for size . + + Returns + ------- + Font + """ + super(Font, self).__init__('font') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.hoverlabel.Font +constructor must be a dict or +an instance of plotly.graph_objs.violin.hoverlabel.Font""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin.hoverlabel import (font as v_font) + + # Initialize validators + # --------------------- + self._validators['color'] = v_font.ColorValidator() + self._validators['colorsrc'] = v_font.ColorsrcValidator() + self._validators['family'] = v_font.FamilyValidator() + self._validators['familysrc'] = v_font.FamilysrcValidator() + self._validators['size'] = v_font.SizeValidator() + self._validators['sizesrc'] = v_font.SizesrcValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('colorsrc', None) + self.colorsrc = colorsrc if colorsrc is not None else v + v = arg.pop('family', None) + self.family = family if family is not None else v + v = arg.pop('familysrc', None) + self.familysrc = familysrc if familysrc is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + v = arg.pop('sizesrc', None) + self.sizesrc = sizesrc if sizesrc is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/marker/__init__.py b/plotly/graph_objs/violin/marker/__init__.py new file mode 100644 index 0000000000..471a5835d7 --- /dev/null +++ b/plotly/graph_objs/violin/marker/__init__.py @@ -0,0 +1 @@ +from ._line import Line diff --git a/plotly/graph_objs/violin/marker/_line.py b/plotly/graph_objs/violin/marker/_line.py new file mode 100644 index 0000000000..c4884ba4b5 --- /dev/null +++ b/plotly/graph_objs/violin/marker/_line.py @@ -0,0 +1,275 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Line(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker.line color. It accepts either a specific color + or an array of numbers that are mapped to the colorscale + relative to the max and min values of the array or relative to + `cmin` and `cmax` if set. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # outliercolor + # ------------ + @property + def outliercolor(self): + """ + Sets the border line color of the outlier sample points. + Defaults to marker.color + + The 'outliercolor' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['outliercolor'] + + @outliercolor.setter + def outliercolor(self, val): + self['outliercolor'] = val + + # outlierwidth + # ------------ + @property + def outlierwidth(self): + """ + Sets the border line width (in px) of the outlier sample + points. + + The 'outlierwidth' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['outlierwidth'] + + @outlierwidth.setter + def outlierwidth(self, val): + self['outlierwidth'] = val + + # width + # ----- + @property + def width(self): + """ + Sets the width (in px) of the lines bounding the marker points. + + The 'width' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['width'] + + @width.setter + def width(self, val): + self['width'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin.marker' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier sample + points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the outlier + sample points. + width + Sets the width (in px) of the lines bounding the marker + points. + """ + + def __init__( + self, + arg=None, + color=None, + outliercolor=None, + outlierwidth=None, + width=None, + **kwargs + ): + """ + Construct a new Line object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.marker.Line + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are mapped + to the colorscale relative to the max and min values of + the array or relative to `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier sample + points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the outlier + sample points. + width + Sets the width (in px) of the lines bounding the marker + points. + + Returns + ------- + Line + """ + super(Line, self).__init__('line') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.marker.Line +constructor must be a dict or +an instance of plotly.graph_objs.violin.marker.Line""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin.marker import (line as v_line) + + # Initialize validators + # --------------------- + self._validators['color'] = v_line.ColorValidator() + self._validators['outliercolor'] = v_line.OutliercolorValidator() + self._validators['outlierwidth'] = v_line.OutlierwidthValidator() + self._validators['width'] = v_line.WidthValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('outliercolor', None) + self.outliercolor = outliercolor if outliercolor is not None else v + v = arg.pop('outlierwidth', None) + self.outlierwidth = outlierwidth if outlierwidth is not None else v + v = arg.pop('width', None) + self.width = width if width is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/selected/__init__.py b/plotly/graph_objs/violin/selected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/violin/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/violin/selected/_marker.py b/plotly/graph_objs/violin/selected/_marker.py new file mode 100644 index 0000000000..d0fe44d442 --- /dev/null +++ b/plotly/graph_objs/violin/selected/_marker.py @@ -0,0 +1,186 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of selected points. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of selected points. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of selected points. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin.selected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of plotly.graph_objs.violin.selected.Marker + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.selected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.violin.selected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin.selected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_objs/violin/unselected/__init__.py b/plotly/graph_objs/violin/unselected/__init__.py new file mode 100644 index 0000000000..0bda16c350 --- /dev/null +++ b/plotly/graph_objs/violin/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import Marker diff --git a/plotly/graph_objs/violin/unselected/_marker.py b/plotly/graph_objs/violin/unselected/_marker.py new file mode 100644 index 0000000000..18f4e37c4f --- /dev/null +++ b/plotly/graph_objs/violin/unselected/_marker.py @@ -0,0 +1,196 @@ +from plotly.basedatatypes import BaseTraceHierarchyType +import copy + + +class Marker(BaseTraceHierarchyType): + + # color + # ----- + @property + def color(self): + """ + Sets the marker color of unselected points, applied only when a + selection exists. + + The 'color' property is a color and may be specified as: + - A hex string (e.g. '#ff0000') + - An rgb/rgba string (e.g. 'rgb(255,0,0)') + - An hsl/hsla string (e.g. 'hsl(0,100%,50%)') + - An hsv/hsva string (e.g. 'hsv(0,100%,100%)') + - A named CSS color: + aliceblue, antiquewhite, aqua, aquamarine, azure, + beige, bisque, black, blanchedalmond, blue, + blueviolet, brown, burlywood, cadetblue, + chartreuse, chocolate, coral, cornflowerblue, + cornsilk, crimson, cyan, darkblue, darkcyan, + darkgoldenrod, darkgray, darkgrey, darkgreen, + darkkhaki, darkmagenta, darkolivegreen, darkorange, + darkorchid, darkred, darksalmon, darkseagreen, + darkslateblue, darkslategray, darkslategrey, + darkturquoise, darkviolet, deeppink, deepskyblue, + dimgray, dimgrey, dodgerblue, firebrick, + floralwhite, forestgreen, fuchsia, gainsboro, + ghostwhite, gold, goldenrod, gray, grey, green, + greenyellow, honeydew, hotpink, indianred, indigo, + ivory, khaki, lavender, lavenderblush, lawngreen, + lemonchiffon, lightblue, lightcoral, lightcyan, + lightgoldenrodyellow, lightgray, lightgrey, + lightgreen, lightpink, lightsalmon, lightseagreen, + lightskyblue, lightslategray, lightslategrey, + lightsteelblue, lightyellow, lime, limegreen, + linen, magenta, maroon, mediumaquamarine, + mediumblue, mediumorchid, mediumpurple, + mediumseagreen, mediumslateblue, mediumspringgreen, + mediumturquoise, mediumvioletred, midnightblue, + mintcream, mistyrose, moccasin, navajowhite, navy, + oldlace, olive, olivedrab, orange, orangered, + orchid, palegoldenrod, palegreen, paleturquoise, + palevioletred, papayawhip, peachpuff, peru, pink, + plum, powderblue, purple, red, rosybrown, + royalblue, saddlebrown, salmon, sandybrown, + seagreen, seashell, sienna, silver, skyblue, + slateblue, slategray, slategrey, snow, springgreen, + steelblue, tan, teal, thistle, tomato, turquoise, + violet, wheat, white, whitesmoke, yellow, + yellowgreen + + Returns + ------- + str + """ + return self['color'] + + @color.setter + def color(self, val): + self['color'] = val + + # opacity + # ------- + @property + def opacity(self): + """ + Sets the marker opacity of unselected points, applied only when + a selection exists. + + The 'opacity' property is a number and may be specified as: + - An int or float in the interval [0, 1] + + Returns + ------- + int|float + """ + return self['opacity'] + + @opacity.setter + def opacity(self, val): + self['opacity'] = val + + # size + # ---- + @property + def size(self): + """ + Sets the marker size of unselected points, applied only when a + selection exists. + + The 'size' property is a number and may be specified as: + - An int or float in the interval [0, inf] + + Returns + ------- + int|float + """ + return self['size'] + + @size.setter + def size(self, val): + self['size'] = val + + # property parent name + # -------------------- + @property + def _parent_path_str(self): + return 'violin.unselected' + + # Self properties description + # --------------------------- + @property + def _prop_descriptions(self): + return """\ + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + """ + + def __init__( + self, arg=None, color=None, opacity=None, size=None, **kwargs + ): + """ + Construct a new Marker object + + Parameters + ---------- + arg + dict of properties compatible with this constructor or + an instance of + plotly.graph_objs.violin.unselected.Marker + color + Sets the marker color of unselected points, applied + only when a selection exists. + opacity + Sets the marker opacity of unselected points, applied + only when a selection exists. + size + Sets the marker size of unselected points, applied only + when a selection exists. + + Returns + ------- + Marker + """ + super(Marker, self).__init__('marker') + + # Validate arg + # ------------ + if arg is None: + arg = {} + elif isinstance(arg, self.__class__): + arg = arg.to_plotly_json() + elif isinstance(arg, dict): + arg = copy.copy(arg) + else: + raise ValueError( + """\ +The first argument to the plotly.graph_objs.violin.unselected.Marker +constructor must be a dict or +an instance of plotly.graph_objs.violin.unselected.Marker""" + ) + + # Import validators + # ----------------- + from plotly.validators.violin.unselected import (marker as v_marker) + + # Initialize validators + # --------------------- + self._validators['color'] = v_marker.ColorValidator() + self._validators['opacity'] = v_marker.OpacityValidator() + self._validators['size'] = v_marker.SizeValidator() + + # Populate data dict with properties + # ---------------------------------- + v = arg.pop('color', None) + self.color = color if color is not None else v + v = arg.pop('opacity', None) + self.opacity = opacity if opacity is not None else v + v = arg.pop('size', None) + self.size = size if size is not None else v + + # Process unknown kwargs + # ---------------------- + self._process_kwargs(**dict(arg, **kwargs)) diff --git a/plotly/graph_reference.py b/plotly/graph_reference.py index dd78bb30d9..a9ae8df067 100644 --- a/plotly/graph_reference.py +++ b/plotly/graph_reference.py @@ -39,6 +39,8 @@ 'Histogram2d': {'object_name': 'histogram2d', 'base_type': dict}, 'Histogram2dContour': {'object_name': 'histogram2dcontour', 'base_type': dict}, + 'Histogram2dcontour': {'object_name': 'histogram2dcontour', + 'base_type': dict}, 'Layout': {'object_name': 'layout', 'base_type': dict}, 'Legend': {'object_name': 'legend', 'base_type': dict}, 'Line': {'object_name': 'line', 'base_type': dict}, @@ -66,7 +68,7 @@ def get_graph_reference(): :return: (dict) The graph reference. """ - path = os.path.join('package_data', 'default-schema.json') + path = os.path.join('package_data', 'plot-schema.json') s = resource_string('plotly', path).decode('utf-8') graph_reference = utils.decode_unicode(_json.loads(s)) @@ -557,8 +559,10 @@ def _get_classes(): # add all the objects we had before, but mark them if they no longer # exist in the graph reference + backwards_compat_object_names = set() for class_name, class_dict in _BACKWARDS_COMPAT_CLASS_NAMES.items(): object_name = class_dict['object_name'] + backwards_compat_object_names.add(object_name) base_type = class_dict['base_type'] if object_name in OBJECTS or object_name in ARRAYS: classes[class_name] = {'object_name': object_name, @@ -568,8 +572,10 @@ def _get_classes(): # always keep the trace dicts up to date for object_name in TRACE_NAMES: - class_name = string_to_class_name(object_name) - classes[class_name] = {'object_name': object_name, 'base_type': dict} + if object_name not in backwards_compat_object_names: + # Only add trace if it wasn't included in _BACKWARDS_COMPAT_CLASS_NAMES + class_name = string_to_class_name(object_name) + classes[class_name] = {'object_name': object_name, 'base_type': dict} return classes diff --git a/plotly/matplotlylib/mplexporter/exporter.py b/plotly/matplotlylib/mplexporter/exporter.py index be2530c83f..19a61eca33 100644 --- a/plotly/matplotlylib/mplexporter/exporter.py +++ b/plotly/matplotlylib/mplexporter/exporter.py @@ -162,8 +162,8 @@ def crawl_legend(self, ax, legend): if isinstance(child, matplotlib.patches.Patch): self.draw_patch(ax, child, force_trans=ax.transAxes) elif isinstance(child, matplotlib.text.Text): - if (child is not legend.get_children()[-1] - and child.get_text() != 'None'): + if not (child is legend.get_children()[-1] + and child.get_text() == 'None'): self.draw_text(ax, child, force_trans=ax.transAxes) elif isinstance(child, matplotlib.lines.Line2D): self.draw_line(ax, child, force_trans=ax.transAxes) diff --git a/plotly/matplotlylib/mpltools.py b/plotly/matplotlylib/mpltools.py index 2d78830a4a..c2ddb3b462 100644 --- a/plotly/matplotlylib/mpltools.py +++ b/plotly/matplotlylib/mpltools.py @@ -57,7 +57,7 @@ def convert_dash(mpl_dash): """Convert mpl line symbol to plotly line symbol and return symbol.""" if mpl_dash in DASH_MAP: return DASH_MAP[mpl_dash] - else: + else: dash_array = mpl_dash.split(',') if (len(dash_array) < 2): @@ -70,9 +70,19 @@ def convert_dash(mpl_dash): # If we can't find the dash pattern in the map, convert it # into custom values in px, e.g. '7,5' -> '7px,5px' - dashpx=','.join([x + 'px' for x in dash_array]) + dashpx = ','.join([x + 'px' for x in dash_array]) + + # TODO: rewrite the convert_dash code + # only strings 'solid', 'dashed', etc allowed + if dashpx == '7.4px,3.2px': + dashpx = 'dashed' + elif dashpx == '12.8px,3.2px,2.0px,3.2px': + dashpx = 'dashdot' + elif dashpx == '2.0px,3.3px': + dashpx = 'dotted' return dashpx + def convert_path(path): verts = path[0] # may use this later code = tuple(path[1]) @@ -92,7 +102,7 @@ def convert_symbol(mpl_symbol): elif mpl_symbol in SYMBOL_MAP: return SYMBOL_MAP[mpl_symbol] else: - return 'dot' # default + return 'circle' # default def hex_to_rgb(value): @@ -544,13 +554,14 @@ def mpl_dates_to_datestrings(dates, mpl_formatter): for date in dates] return time_stings - +# dashed is dash in matplotlib DASH_MAP = { '10,0': 'solid', '6,6': 'dash', - '2,2': 'dot', + '2,2': 'circle', '4,4,2,4': 'dashdot', - 'none': 'solid' + 'none': 'solid', + '7.4,3.2': 'dash', } PATH_MAP = { @@ -567,7 +578,7 @@ def mpl_dates_to_datestrings(dates, mpl_formatter): } SYMBOL_MAP = { - 'o': 'dot', + 'o': 'circle', 'v': 'triangle-down', '^': 'triangle-up', '<': 'triangle-left', @@ -575,7 +586,7 @@ def mpl_dates_to_datestrings(dates, mpl_formatter): 's': 'square', '+': 'cross', 'x': 'x', - '*': 'x', # no star yet in plotly!! + '*': 'star', 'D': 'diamond', 'd': 'diamond', } diff --git a/plotly/matplotlylib/renderer.py b/plotly/matplotlylib/renderer.py index 548ae7475c..315cfc51a1 100644 --- a/plotly/matplotlylib/renderer.py +++ b/plotly/matplotlylib/renderer.py @@ -8,6 +8,7 @@ """ from __future__ import absolute_import +import six import warnings import plotly.graph_objs as go @@ -83,7 +84,7 @@ def open_figure(self, fig, props): autosize=False, hovermode='closest') self.mpl_x_bounds, self.mpl_y_bounds = mpltools.get_axes_bounds(fig) - margin = go.Margin( + margin = go.layout.Margin( l=int(self.mpl_x_bounds[0] * self.plotly_fig['layout']['width']), r=int( (1-self.mpl_x_bounds[1]) * self.plotly_fig['layout']['width']), @@ -106,7 +107,6 @@ def close_figure(self, fig): fig -- a matplotlib.figure.Figure object. """ - self.plotly_fig.force_clean() self.plotly_fig['layout']['showlegend'] = False self.msg += "Closing figure\n" @@ -148,11 +148,11 @@ def open_axes(self, ax, props): self.current_bars = [] self.axis_ct += 1 # set defaults in axes - xaxis = go.XAxis( + xaxis = go.layout.XAxis( anchor='y{0}'.format(self.axis_ct), zeroline=False, ticks='inside') - yaxis = go.YAxis( + yaxis = go.layout.YAxis( anchor='x{0}'.format(self.axis_ct), zeroline=False, ticks='inside') @@ -178,9 +178,11 @@ def open_axes(self, ax, props): self.plotly_fig['layout']['yaxis{0}'.format(self.axis_ct)] = yaxis # let all subsequent dates be handled properly if required - if xaxis.get('type') == 'date': + + if 'type' in dir(xaxis) and xaxis['type'] == 'date': self.x_is_mpl_date = True + def close_axes(self, ax): """Close the axes object and clean up. @@ -283,12 +285,12 @@ def draw_bar(self, coll): xaxis='x{0}'.format(self.axis_ct), yaxis='y{0}'.format(self.axis_ct), opacity=trace[0]['alpha'], # TODO: get all alphas if array? - marker=go.Marker( + marker=go.bar.Marker( color=trace[0]['facecolor'], # TODO: get all - line=go.Line(width=trace[0]['edgewidth']))) # TODO ditto + line=dict(width=trace[0]['edgewidth']))) # TODO ditto if len(bar['x']) > 1: self.msg += " Heck yeah, I drew that bar chart\n" - self.plotly_fig['data'] += bar, + self.plotly_fig.add_trace(bar), if bar_gap is not None: self.plotly_fig['layout']['bargap'] = bar_gap else: @@ -344,18 +346,20 @@ def draw_marked_line(self, **props): color = \ mpltools.merge_color_and_opacity(props['linestyle']['color'], props['linestyle']['alpha']) - line = go.Line( + + #print(mpltools.convert_dash(props['linestyle']['dasharray'])) + line = go.scatter.Line( color=color, width=props['linestyle']['linewidth'], dash=mpltools.convert_dash(props['linestyle']['dasharray']) ) if props['markerstyle']: - marker = go.Marker( + marker = go.scatter.Marker( opacity=props['markerstyle']['alpha'], color=props['markerstyle']['facecolor'], symbol=mpltools.convert_symbol(props['markerstyle']['marker']), size=props['markerstyle']['markersize'], - line=go.Line( + line=dict( color=props['markerstyle']['edgecolor'], width=props['markerstyle']['edgewidth'] ) @@ -363,7 +367,9 @@ def draw_marked_line(self, **props): if props['coordinates'] == 'data': marked_line = go.Scatter( mode=mode, - name=props['label'], + name=(str(props['label']) if + isinstance(props['label'], six.string_types) else + props['label']), x=[xy_pair[0] for xy_pair in props['data']], y=[xy_pair[1] for xy_pair in props['data']], xaxis='x{0}'.format(self.axis_ct), @@ -376,7 +382,7 @@ def draw_marked_line(self, **props): marked_line['x'] = mpltools.mpl_dates_to_datestrings( marked_line['x'], formatter ) - self.plotly_fig['data'] += marked_line, + self.plotly_fig.add_trace(marked_line), self.msg += " Heck yeah, I drew that line\n" else: self.msg += " Line didn't have 'data' coordinates, " \ @@ -571,7 +577,9 @@ def draw_text(self, **props): xanchor = props['style']['halign'] # no difference here! yanchor = mpltools.convert_va(props['style']['valign']) annotation = go.Annotation( - text=props['text'], + text=(str(props['text']) if + isinstance(props['text'], six.string_types) else + props['text']), opacity=props['style']['alpha'], x=x, y=y, @@ -581,7 +589,7 @@ def draw_text(self, **props): xanchor=xanchor, yanchor=yanchor, showarrow=False, # change this later? - font=go.Font( + font=go.layout.annotation.Font( color=props['style']['color'], size=props['style']['fontsize'] ) @@ -625,7 +633,7 @@ def draw_title(self, **props): self.plotly_fig['layout']) annotation = go.Annotation( text=props['text'], - font=go.Font( + font=go.layout.annotation.Font( color=props['style']['color'], size=props['style']['fontsize'] ), @@ -642,7 +650,7 @@ def draw_title(self, **props): self.msg += " Only one subplot found, adding as a " \ "plotly title\n" self.plotly_fig['layout']['title'] = props['text'] - titlefont = go.Font( + titlefont = dict( size=props['style']['fontsize'], color=props['style']['color'] ) @@ -673,8 +681,8 @@ def draw_xlabel(self, **props): """ self.msg += " Adding xlabel\n" axis_key = 'xaxis{0}'.format(self.axis_ct) - self.plotly_fig['layout'][axis_key]['title'] = props['text'] - titlefont = go.Font( + self.plotly_fig['layout'][axis_key]['title'] = str(props['text']) + titlefont = dict( size=props['style']['fontsize'], color=props['style']['color']) self.plotly_fig['layout'][axis_key]['titlefont'] = titlefont @@ -705,7 +713,7 @@ def draw_ylabel(self, **props): self.msg += " Adding ylabel\n" axis_key = 'yaxis{0}'.format(self.axis_ct) self.plotly_fig['layout'][axis_key]['title'] = props['text'] - titlefont = go.Font( + titlefont = dict( size=props['style']['fontsize'], color=props['style']['color']) self.plotly_fig['layout'][axis_key]['titlefont'] = titlefont @@ -723,7 +731,7 @@ def resize(self): for key in ['width', 'height', 'autosize', 'margin']: try: del self.plotly_fig['layout'][key] - except KeyError: + except (KeyError, AttributeError): pass def strip_style(self): diff --git a/plotly/offline/offline.py b/plotly/offline/offline.py index 6ab5047644..16d2d14997 100644 --- a/plotly/offline/offline.py +++ b/plotly/offline/offline.py @@ -150,16 +150,8 @@ def init_notebook_mode(connected=False): def _plot_html(figure_or_data, config, validate, default_width, default_height, global_requirejs): - # force no validation if frames is in the call - # TODO - add validation for frames in call - #605 - if 'frames' in figure_or_data: - figure = tools.return_figure_from_figure_or_data( - figure_or_data, False - ) - else: - figure = tools.return_figure_from_figure_or_data( - figure_or_data, validate - ) + + figure = tools.return_figure_from_figure_or_data(figure_or_data, validate) width = figure.get('layout', {}).get('width', default_width) height = figure.get('layout', {}).get('height', default_height) diff --git a/plotly/package_data/default-schema.json b/plotly/package_data/plot-schema.json similarity index 81% rename from plotly/package_data/default-schema.json rename to plotly/package_data/plot-schema.json index b9b8d2825f..9bfd0ec110 100644 --- a/plotly/package_data/default-schema.json +++ b/plotly/package_data/plot-schema.json @@ -1,7671 +1,7897 @@ { - "animation": { - "direction": { - "description": "The direction in which to play the frames triggered by the animation call", - "dflt": "forward", - "role": "info", - "valType": "enumerated", - "values": [ - "forward", - "reverse" - ] - }, - "frame": { - "duration": { - "description": "The duration in milliseconds of each frame. If greater than the frame duration, it will be limited to the frame duration.", - "dflt": 500, - "min": 0, - "role": "info", - "valType": "number" - }, - "redraw": { - "description": "Redraw the plot at completion of the transition. This is desirable for transitions that include properties that cannot be transitioned, but may significantly slow down updates that do not require a full redraw of the plot", - "dflt": true, - "role": "info", - "valType": "boolean" - }, - "role": "object" - }, - "fromcurrent": { - "description": "Play frames starting at the current frame instead of the beginning.", - "dflt": false, - "role": "info", - "valType": "boolean" - }, - "mode": { - "description": "Describes how a new animate call interacts with currently-running animations. If `immediate`, current animations are interrupted and the new animation is started. If `next`, the current frame is allowed to complete, after which the new animation is started. If `afterall` all existing frames are animated to completion before the new animation is started.", - "dflt": "afterall", - "role": "info", - "valType": "enumerated", - "values": [ - "immediate", - "next", - "afterall" - ] - }, - "transition": { - "duration": { - "description": "The duration of the transition, in milliseconds. If equal to zero, updates are synchronous.", - "dflt": 500, - "min": 0, - "role": "info", - "valType": "number" - }, - "easing": { - "description": "The easing function used for the transition", - "dflt": "cubic-in-out", - "role": "info", - "valType": "enumerated", - "values": [ - "linear", - "quad", - "cubic", - "sin", - "exp", - "circle", - "elastic", - "back", - "bounce", - "linear-in", - "quad-in", - "cubic-in", - "sin-in", - "exp-in", - "circle-in", - "elastic-in", - "back-in", - "bounce-in", - "linear-out", - "quad-out", - "cubic-out", - "sin-out", - "exp-out", - "circle-out", - "elastic-out", - "back-out", - "bounce-out", - "linear-in-out", - "quad-in-out", - "cubic-in-out", - "sin-in-out", - "exp-in-out", - "circle-in-out", - "elastic-in-out", - "back-in-out", - "bounce-in-out" - ] - }, - "role": "object" - } - }, "defs": { - "editType": { - "layout": { - "description": "layout attributes should include an `editType` string matching this flaglist. *calc* is the most extensive: a full `Plotly.plot` starting by clearing `gd.calcdata` to force it to be regenerated *calcIfAutorange* does a full `Plotly.plot`, but only clears and redoes `gd.calcdata` if there is at least one autoranged axis. *plot* calls `Plotly.plot` but without first clearing `gd.calcdata`. *legend* only redraws the legend. *ticks* only redraws axis ticks, labels, and gridlines. *margins* recomputes ticklabel automargins. *axrange* minimal sequence when updating axis ranges. *layoutstyle* reapplies global and SVG cartesian axis styles. *modebar* just updates the modebar. *camera* just updates the camera settings for gl3d scenes. *arraydraw* allows component arrays to invoke the redraw routines just for the component(s) that changed.", - "extras": [ - "none" - ], - "flags": [ - "calc", - "calcIfAutorange", - "plot", - "legend", - "ticks", - "axrange", - "margins", - "layoutstyle", - "modebar", - "camera", - "arraydraw" - ], - "valType": "flaglist" - }, - "traces": { - "description": "trace attributes should include an `editType` string matching this flaglist. *calc* is the most extensive: a full `Plotly.plot` starting by clearing `gd.calcdata` to force it to be regenerated *calcIfAutorange* does a full `Plotly.plot`, but only clears and redoes `gd.calcdata` if there is at least one autoranged axis. *clearAxisTypes* resets the types of the axes this trace is on, because new data could cause the automatic axis type detection to change. Log type will not be cleared, as that is never automatically chosen so must have been user-specified. *plot* calls `Plotly.plot` but without first clearing `gd.calcdata`. *style* only calls `module.style` for all trace modules and redraws the legend. *colorbars* only redraws colorbars.", - "extras": [ - "none" - ], - "flags": [ - "calc", - "calcIfAutorange", - "clearAxisTypes", - "plot", - "style", - "colorbars" - ], - "valType": "flaglist" - } - }, - "impliedEdits": { - "description": "Sometimes when an attribute is changed, other attributes must be altered as well in order to achieve the intended result. For example, when `range` is specified, it is important to set `autorange` to `false` or the new `range` value would be lost in the redraw. `impliedEdits` is the mechanism to do this: `impliedEdits: {autorange: false}`. Each key is a relative paths to the attribute string to change, using *^* to ascend into the parent container, for example `range[0]` has `impliedEdits: {*^autorange*: false}`. A value of `undefined` means that the attribute will not be changed, but its previous value should be recorded in case we want to reverse this change later. For example, `autorange` has `impliedEdits: {*range[0]*: undefined, *range[1]*:undefined} because the range will likely be changed by redraw." - }, - "metaKeys": [ - "_isSubplotObj", - "_isLinkedToArray", - "_arrayAttrRegexps", - "_deprecated", - "description", - "role", - "editType", - "impliedEdits" - ], "valObjects": { - "angle": { - "description": "A number (in degree) between -180 and 180.", + "data_array": { + "description": "An {array} of data. The value MUST be an {array}, or we ignore it. Note that typed arrays (e.g. Float32Array) are supported.", + "requiredOpts": [], "otherOpts": [ "dflt" - ], - "requiredOpts": [] + ] }, - "any": { - "description": "Any type.", + "enumerated": { + "description": "Enumerated value type. The available values are listed in `values`.", + "requiredOpts": [ + "values" + ], "otherOpts": [ "dflt", - "values", + "coerceNumber", "arrayOk" - ], - "requiredOpts": [] + ] }, "boolean": { "description": "A boolean (true/false) value.", + "requiredOpts": [], "otherOpts": [ "dflt" - ], - "requiredOpts": [] + ] + }, + "number": { + "description": "A number or a numeric value (e.g. a number inside a string). When applicable, values greater (less) than `max` (`min`) are coerced to the `dflt`.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "min", + "max", + "arrayOk" + ] + }, + "integer": { + "description": "An integer or an integer inside a string. When applicable, values greater (less) than `max` (`min`) are coerced to the `dflt`.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "min", + "max", + "arrayOk" + ] + }, + "string": { + "description": "A string value. Numbers are converted to strings except for attributes with `strict` set to true.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "noBlank", + "strict", + "arrayOk", + "values" + ] }, "color": { "description": "A string describing color. Supported formats: - hex (e.g. '#d3d3d3') - rgb (e.g. 'rgb(255, 0, 0)') - rgba (e.g. 'rgb(255, 0, 0, 0.5)') - hsl (e.g. 'hsl(0, 100%, 50%)') - hsv (e.g. 'hsv(0, 100%, 100%)') - named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)", + "requiredOpts": [], "otherOpts": [ "dflt", "arrayOk" - ], - "requiredOpts": [] + ] }, "colorlist": { "description": "A list of colors. Must be an {array} containing valid colors.", + "requiredOpts": [], "otherOpts": [ "dflt" - ], - "requiredOpts": [] + ] }, "colorscale": { "description": "A Plotly colorscale either picked by a name: (any of Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis ) customized as an {array} of 2-element {arrays} where the first element is the normalized color level value (starting at *0* and ending at *1*), and the second item is a valid color string.", + "requiredOpts": [], "otherOpts": [ "dflt" - ], - "requiredOpts": [] + ] }, - "data_array": { - "description": "An {array} of data. The value MUST be an {array}, or we ignore it. Note that typed arrays (e.g. Float32Array) are supported.", + "angle": { + "description": "A number (in degree) between -180 and 180.", + "requiredOpts": [], "otherOpts": [ "dflt" - ], - "requiredOpts": [] + ] }, - "enumerated": { - "description": "Enumerated value type. The available values are listed in `values`.", - "otherOpts": [ - "dflt", - "coerceNumber", - "arrayOk" - ], + "subplotid": { + "description": "An id string of a subplot type (given by dflt), optionally followed by an integer >1. e.g. if dflt='geo', we can have 'geo', 'geo2', 'geo3', ...", "requiredOpts": [ - "values" + "dflt" + ], + "otherOpts": [ + "regex" ] }, "flaglist": { "description": "A string representing a combination of flags (order does not matter here). Combine any of the available `flags` with *+*. (e.g. ('lines+markers')). Values in `extras` cannot be combined.", + "requiredOpts": [ + "flags" + ], "otherOpts": [ "dflt", "extras", "arrayOk" - ], - "requiredOpts": [ - "flags" + ] + }, + "any": { + "description": "Any type.", + "requiredOpts": [], + "otherOpts": [ + "dflt", + "values", + "arrayOk" ] }, "info_array": { "description": "An {array} of plot information.", + "requiredOpts": [ + "items" + ], "otherOpts": [ "dflt", "freeLength", "dimensions" - ], - "requiredOpts": [ - "items" ] - }, - "integer": { - "description": "An integer or an integer inside a string. When applicable, values greater (less) than `max` (`min`) are coerced to the `dflt`.", - "otherOpts": [ - "dflt", - "min", - "max", - "arrayOk" + } + }, + "metaKeys": [ + "_isSubplotObj", + "_isLinkedToArray", + "_arrayAttrRegexps", + "_deprecated", + "description", + "role", + "editType", + "impliedEdits" + ], + "editType": { + "traces": { + "valType": "flaglist", + "extras": [ + "none" ], - "requiredOpts": [] - }, - "number": { - "description": "A number or a numeric value (e.g. a number inside a string). When applicable, values greater (less) than `max` (`min`) are coerced to the `dflt`.", - "otherOpts": [ - "dflt", - "min", - "max", - "arrayOk" + "flags": [ + "calc", + "calcIfAutorange", + "clearAxisTypes", + "plot", + "style", + "colorbars" ], - "requiredOpts": [] + "description": "trace attributes should include an `editType` string matching this flaglist. *calc* is the most extensive: a full `Plotly.plot` starting by clearing `gd.calcdata` to force it to be regenerated *calcIfAutorange* does a full `Plotly.plot`, but only clears and redoes `gd.calcdata` if there is at least one autoranged axis. *clearAxisTypes* resets the types of the axes this trace is on, because new data could cause the automatic axis type detection to change. Log type will not be cleared, as that is never automatically chosen so must have been user-specified. *plot* calls `Plotly.plot` but without first clearing `gd.calcdata`. *style* only calls `module.style` for all trace modules and redraws the legend. *colorbars* only redraws colorbars." }, - "string": { - "description": "A string value. Numbers are converted to strings except for attributes with `strict` set to true.", - "otherOpts": [ - "dflt", - "noBlank", - "strict", - "arrayOk", - "values" + "layout": { + "valType": "flaglist", + "extras": [ + "none" ], - "requiredOpts": [] - }, - "subplotid": { - "description": "An id string of a subplot type (given by dflt), optionally followed by an integer >1. e.g. if dflt='geo', we can have 'geo', 'geo2', 'geo3', ...", - "otherOpts": [ - "regex" + "flags": [ + "calc", + "calcIfAutorange", + "plot", + "legend", + "ticks", + "axrange", + "margins", + "layoutstyle", + "modebar", + "camera", + "arraydraw" ], - "requiredOpts": [ - "dflt" - ] + "description": "layout attributes should include an `editType` string matching this flaglist. *calc* is the most extensive: a full `Plotly.plot` starting by clearing `gd.calcdata` to force it to be regenerated *calcIfAutorange* does a full `Plotly.plot`, but only clears and redoes `gd.calcdata` if there is at least one autoranged axis. *plot* calls `Plotly.plot` but without first clearing `gd.calcdata`. *legend* only redraws the legend. *ticks* only redraws axis ticks, labels, and gridlines. *margins* recomputes ticklabel automargins. *axrange* minimal sequence when updating axis ranges. *layoutstyle* reapplies global and SVG cartesian axis styles. *modebar* just updates the modebar. *camera* just updates the camera settings for gl3d scenes. *arraydraw* allows component arrays to invoke the redraw routines just for the component(s) that changed." } + }, + "impliedEdits": { + "description": "Sometimes when an attribute is changed, other attributes must be altered as well in order to achieve the intended result. For example, when `range` is specified, it is important to set `autorange` to `false` or the new `range` value would be lost in the redraw. `impliedEdits` is the mechanism to do this: `impliedEdits: {autorange: false}`. Each key is a relative paths to the attribute string to change, using *^* to ascend into the parent container, for example `range[0]` has `impliedEdits: {*^autorange*: false}`. A value of `undefined` means that the attribute will not be changed, but its previous value should be recorded in case we want to reverse this change later. For example, `autorange` has `impliedEdits: {*range[0]*: undefined, *range[1]*:undefined} because the range will likely be changed by redraw." } }, - "frames": { - "items": { - "frames_entry": { - "baseframe": { - "description": "The name of the frame into which this frame's properties are merged before applying. This is used to unify properties and avoid needing to specify the same values for the same properties in multiple frames.", - "role": "info", - "valType": "string" - }, - "data": { - "description": "A list of traces this frame modifies. The format is identical to the normal trace definition.", - "role": "object", - "valType": "any" - }, - "group": { - "description": "An identifier that specifies the group to which the frame belongs, used by animate to select a subset of frames.", + "traces": { + "scatter": { + "meta": { + "description": "The scatter trace type encompasses line charts, scatter charts, text charts, and bubble charts. The data visualized as scatter point or lines is set in `x` and `y`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays." + }, + "attributes": { + "type": "scatter", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], "role": "info", - "valType": "string" - }, - "layout": { - "description": "Layout properties which this frame modifies. The format is identical to the normal layout definition.", - "role": "object", - "valType": "any" + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "name": { - "description": "A label by which to identify the frame", + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "role": "object", - "traces": { - "description": "A list of trace indices that identify the respective traces in the data attribute", - "role": "info", - "valType": "any" - } - } - }, - "role": "object" - }, - "layout": { - "layoutAttributes": { - "angularaxis": { - "domain": { - "description": "Polar chart subplots are not supported yet. This key has currently no effect.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], + "legendgroup": { + "valType": "string", "role": "info", - "valType": "info_array" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "editType": "plot", - "endpadding": { - "editType": "plot", + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." }, - "range": { - "description": "Defines the start and end point of this angular axis.", - "editType": "plot", - "items": [ - { - "dflt": 0, - "editType": "plot", - "valType": "number" - }, - { - "dflt": 360, - "editType": "plot", - "valType": "number" - } - ], + "name": { + "valType": "string", "role": "info", - "valType": "info_array" - }, - "role": "object", - "showline": { - "description": "Determines whether or not the line bounding this angular axis will be shown on the figure.", - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether or not the angular axis ticks will feature tick labels.", - "editType": "plot", - "role": "style", - "valType": "boolean" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "tickcolor": { - "description": "Sets the color of the tick lines on this angular axis.", - "editType": "plot", - "role": "style", - "valType": "color" + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" }, - "ticklen": { - "description": "Sets the length of the tick lines on this angular axis.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, - "tickorientation": { - "description": "Sets the orientation (from the paper perspective) of the angular axis tick labels.", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "horizontal", - "vertical" - ] + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "ticksuffix": { - "description": "Sets the length of the tick lines on this angular axis.", - "editType": "plot", - "role": "style", - "valType": "string" + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, - "visible": { - "description": "Determines whether or not this axis will be visible.", - "editType": "plot", + "hoverinfo": { + "valType": "flaglist", "role": "info", - "valType": "boolean" - } - }, - "annotations": { - "items": { - "annotation": { - "_deprecated": { - "ref": { - "description": "Obsolete. Set `xref` and `yref` separately instead.", - "editType": "calc", - "role": "info", - "valType": "string" - } - }, - "align": { - "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", - "dflt": "center", - "editType": "arraydraw", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" + }, + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "arrowcolor": { - "description": "Sets the color of the annotation arrow.", - "editType": "arraydraw", + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "none", + "arrayOk": true }, - "arrowhead": { - "description": "Sets the end annotation arrow head style.", - "dflt": 1, - "editType": "arraydraw", - "max": 8, - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "integer" - }, - "arrowside": { - "description": "Sets the annotation arrow head position.", - "dflt": "end", - "editType": "arraydraw", - "extras": [ - "none" - ], - "flags": [ - "end", - "start" - ], - "role": "style", - "valType": "flaglist" - }, - "arrowsize": { - "description": "Sets the size of the end annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line.", - "dflt": 1, - "editType": "calcIfAutorange+arraydraw", - "min": 0.3, - "role": "style", - "valType": "number" - }, - "arrowwidth": { - "description": "Sets the width (in px) of annotation arrow line.", - "editType": "calcIfAutorange+arraydraw", - "min": 0.1, - "role": "style", - "valType": "number" - }, - "ax": { - "description": "Sets the x component of the arrow tail about the arrow head. If `axref` is `pixel`, a positive (negative) component corresponds to an arrow pointing from right to left (left to right). If `axref` is an axis, this is an absolute value on that axis, like `x`, NOT a relative value.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" - }, - "axref": { - "description": "Indicates in what terms the tail of the annotation (ax,ay) is specified. If `pixel`, `ax` is a relative offset in pixels from `x`. If set to an x axis id (e.g. *x* or *x2*), `ax` is specified in the same terms as that axis. This is useful for trendline annotations which should continue to indicate the correct trend when zoomed.", - "dflt": "pixel", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "pixel", - "/^x([2-9]|[1-9][0-9]+)?$/" - ] - }, - "ay": { - "description": "Sets the y component of the arrow tail about the arrow head. If `ayref` is `pixel`, a positive (negative) component corresponds to an arrow pointing from bottom to top (top to bottom). If `ayref` is an axis, this is an absolute value on that axis, like `y`, NOT a relative value.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" - }, - "ayref": { - "description": "Indicates in what terms the tail of the annotation (ax,ay) is specified. If `pixel`, `ay` is a relative offset in pixels from `y`. If set to a y axis id (e.g. *y* or *y2*), `ay` is specified in the same terms as that axis. This is useful for trendline annotations which should continue to indicate the correct trend when zoomed.", - "dflt": "pixel", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "pixel", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "bgcolor": { - "description": "Sets the background color of the annotation.", - "dflt": "rgba(0,0,0,0)", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the color of the border enclosing the annotation `text`.", - "dflt": "rgba(0,0,0,0)", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "borderpad": { - "description": "Sets the padding (in px) between the `text` and the enclosing border.", - "dflt": 1, - "editType": "calcIfAutorange+arraydraw", - "min": 0, - "role": "style", - "valType": "number" - }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the annotation `text`.", - "dflt": 1, - "editType": "calcIfAutorange+arraydraw", - "min": 0, - "role": "style", - "valType": "number" - }, - "captureevents": { - "description": "Determines whether the annotation text box captures mouse move and click events, or allows those events to pass through to data points in the plot that may be behind the annotation. By default `captureevents` is *false* unless `hovertext` is provided. If you use the event `plotly_clickannotation` without `hovertext` you must explicitly enable `captureevents`.", - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "clicktoshow": { - "description": "Makes this annotation respond to clicks on the plot. If you click a data point that exactly matches the `x` and `y` values of this annotation, and it is hidden (visible: false), it will appear. In *onoff* mode, you must click the same point again to make it disappear, so if you click multiple points, you can show multiple annotations. In *onout* mode, a click anywhere else in the plot (on another data point or not) will hide this annotation. If you need to show/hide this annotation in response to different `x` or `y` values, you can set `xclick` and/or `yclick`. This is useful for example to label the side of a bar. To label markers though, `standoff` is preferred over `xclick` and `yclick`.", - "dflt": false, - "editType": "arraydraw", - "role": "style", - "valType": "enumerated", - "values": [ - false, - "onoff", - "onout" - ] - }, - "editType": "calc", - "font": { - "color": { - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "description": "Sets the annotation text font.", - "editType": "calcIfAutorange+arraydraw", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calcIfAutorange+arraydraw", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calcIfAutorange+arraydraw", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "height": { - "description": "Sets an explicit height for the text box. null (default) lets the text set the box height. Taller text will be clipped.", - "dflt": null, - "editType": "calcIfAutorange+arraydraw", - "min": 1, - "role": "style", - "valType": "number" - }, - "hoverlabel": { - "bgcolor": { - "description": "Sets the background color of the hover label. By default uses the annotation's `bgcolor` made opaque, or white if it was transparent.", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the border color of the hover label. By default uses either dark grey or white, for maximum contrast with `hoverlabel.bgcolor`.", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "editType": "arraydraw", - "font": { - "color": { - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "description": "Sets the hover label text font. By default uses the global hover font and size, with color from `hoverlabel.bordercolor`.", - "editType": "arraydraw", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "arraydraw", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "arraydraw", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "hovertext": { - "description": "Sets text to appear when hovering over this annotation. If omitted or blank, no hover label will appear.", - "editType": "arraydraw", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the annotation (text + arrow).", - "dflt": 1, - "editType": "arraydraw", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true }, + "editType": "none", + "description": "Sets the font used in hover labels.", "role": "object", - "showarrow": { - "description": "Determines whether or not the annotation is drawn with an arrow. If *true*, `text` is placed near the arrow's tail. If *false*, `text` lines up with the `x` and `y` provided.", - "dflt": true, - "editType": "calcIfAutorange+arraydraw", - "role": "style", - "valType": "boolean" - }, - "standoff": { - "description": "Sets a distance, in pixels, to move the end arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount.", - "dflt": 0, - "editType": "calcIfAutorange+arraydraw", - "min": 0, - "role": "style", - "valType": "number" - }, - "startarrowhead": { - "description": "Sets the start annotation arrow head style.", - "dflt": 1, - "editType": "arraydraw", - "max": 8, - "min": 0, - "role": "style", - "valType": "integer" - }, - "startarrowsize": { - "description": "Sets the size of the start annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line.", - "dflt": 1, - "editType": "calcIfAutorange+arraydraw", - "min": 0.3, - "role": "style", - "valType": "number" - }, - "startstandoff": { - "description": "Sets a distance, in pixels, to move the start arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount.", - "dflt": 0, - "editType": "calcIfAutorange+arraydraw", - "min": 0, - "role": "style", - "valType": "number" - }, - "text": { - "description": "Sets the text associated with this annotation. Plotly uses a subset of HTML tags to do things like newline (
), bold (), italics (), hyperlinks (). Tags , , are also supported.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "string" - }, - "textangle": { - "description": "Sets the angle at which the `text` is drawn with respect to the horizontal.", - "dflt": 0, - "editType": "calcIfAutorange+arraydraw", - "role": "style", - "valType": "angle" - }, - "valign": { - "description": "Sets the vertical alignment of the `text` within the box. Has an effect only if an explicit height is set to override the text height.", - "dflt": "middle", - "editType": "arraydraw", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "visible": { - "description": "Determines whether or not this annotation is visible.", - "dflt": true, - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets an explicit width for the text box. null (default) lets the text set the box width. Wider text will be clipped. There is no automatic wrapping; use
to start a new line.", - "dflt": null, - "editType": "calcIfAutorange+arraydraw", - "min": 1, - "role": "style", - "valType": "number" - }, - "x": { - "description": "Sets the annotation's x position. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" - }, - "xanchor": { - "description": "Sets the text box's horizontal position anchor This anchor binds the `x` position to the *left*, *center* or *right* of the annotation. For example, if `x` is set to 1, `xref` to *paper* and `xanchor` to *right* then the right-most portion of the annotation lines up with the right-most edge of the plotting area. If *auto*, the anchor is equivalent to *center* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side.", - "dflt": "auto", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "left", - "center", - "right" - ] - }, - "xclick": { - "description": "Toggle this annotation when clicking a data point whose `x` value is `xclick` rather than the annotation's `x` value.", - "editType": "arraydraw", - "role": "info", - "valType": "any" - }, - "xref": { - "description": "Sets the annotation's x coordinate axis. If set to an x axis id (e.g. *x* or *x2*), the `x` position refers to an x coordinate If set to *paper*, the `x` position refers to the distance from the left side of the plotting area in normalized coordinates where 0 (1) corresponds to the left (right) side.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "paper", - "/^x([2-9]|[1-9][0-9]+)?$/" - ] - }, - "xshift": { - "description": "Shifts the position of the whole annotation and arrow to the right (positive) or left (negative) by this many pixels.", - "dflt": 0, - "editType": "calcIfAutorange+arraydraw", - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the annotation's y position. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" - }, - "yanchor": { - "description": "Sets the text box's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the annotation. For example, if `y` is set to 1, `yref` to *paper* and `yanchor` to *top* then the top-most portion of the annotation lines up with the top-most edge of the plotting area. If *auto*, the anchor is equivalent to *middle* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side.", - "dflt": "auto", - "editType": "calcIfAutorange+arraydraw", + "familysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "top", - "middle", - "bottom" - ] + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "yclick": { - "description": "Toggle this annotation when clicking a data point whose `y` value is `yclick` rather than the annotation's `y` value.", - "editType": "arraydraw", + "sizesrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "yref": { - "description": "Sets the annotation's y coordinate axis. If set to an y axis id (e.g. *y* or *y2*), the `y` position refers to an y coordinate If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where 0 (1) corresponds to the bottom (top).", - "editType": "calc", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "paper", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "yshift": { - "description": "Shifts the position of the whole annotation and arrow up (positive) or down (negative) by this many pixels.", - "dflt": 0, - "editType": "calcIfAutorange+arraydraw", - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } - } - }, - "role": "object" - }, - "autosize": { - "description": "Determines whether or not a layout width or height that has been left undefined by the user is initialized on each relayout. Note that, regardless of this attribute, an undefined layout width or height is always initialized on the first call to plot.", - "dflt": false, - "editType": "none", - "role": "info", - "valType": "boolean" - }, - "calendar": { - "description": "Sets the default calendar system to use for interpreting and displaying dates throughout the plot.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "colorway": { - "description": "Sets the default trace colors.", - "dflt": [ - "#1f77b4", - "#ff7f0e", - "#2ca02c", - "#d62728", - "#9467bd", - "#8c564b", - "#e377c2", - "#7f7f7f", - "#bcbd22", - "#17becf" - ], - "editType": "calc", - "role": "style", - "valType": "colorlist" - }, - "datarevision": { - "description": "If provided, a changed value tells `Plotly.react` that one or more data arrays has changed. This way you can modify arrays in-place rather than making a complete new copy for an incremental change. If NOT provided, `Plotly.react` assumes that data arrays are being treated as immutable, thus any data array with a different identity from its predecessor contains new data.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "direction": { - "description": "For polar plots only. Sets the direction corresponding to positive angles.", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "clockwise", - "counterclockwise" - ] - }, - "dragmode": { - "description": "Determines the mode of drag interactions. *select* and *lasso* apply only to scatter traces with markers or text. *orbit* and *turntable* apply only to 3D scenes.", - "dflt": "zoom", - "editType": "modebar", - "role": "info", - "valType": "enumerated", - "values": [ - "zoom", - "pan", - "select", - "lasso", - "orbit", - "turntable" - ] - }, - "editType": "plot", - "font": { - "color": { - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the global font. Note that fonts used in traces and other layout components inherit from the global font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "dflt": "\"Open Sans\", verdana, arial, sans-serif", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "dflt": 12, + }, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "geo": { - "_isSubplotObj": true, - "bgcolor": { - "description": "Set the background color of the map", - "dflt": "#fff", - "editType": "plot", - "role": "style", - "valType": "color" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } }, - "center": { - "editType": "plot", - "lat": { - "description": "Sets the latitude of the map's center. For all projection types, the map's latitude center lies at the middle of the latitude range by default.", - "editType": "plot", + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "number" + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "lon": { - "description": "Sets the longitude of the map's center. By default, the map's longitude center lies at the middle of the longitude range for scoped projection and above `projection.rotation.lon` otherwise.", - "editType": "plot", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "number" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "coastlinecolor": { - "description": "Sets the coastline color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "coastlinewidth": { - "description": "Sets the coastline stroke width (in px).", + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "role": "data" + }, + "x0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step." + }, + "dx": { + "valType": "number", "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "role": "info", + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info." }, - "countrycolor": { - "description": "Sets line color of the country boundaries.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "role": "data" }, - "countrywidth": { - "description": "Sets line width (in px) of the country boundaries.", + "y0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step." + }, + "dy": { + "valType": "number", "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "role": "info", + "editType": "calc", + "description": "Sets the y coordinate step. See `y0` for more info." }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "editType": "plot", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this geo subplot (in plot fraction). Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this geo subplot (in plot fraction). Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "plot", - "framecolor": { - "description": "Sets the color the frame.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "framewidth": { - "description": "Sets the stroke width (in px) of the frame.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "hovertext": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "style", + "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." }, - "lakecolor": { - "description": "Sets the color of the lakes.", - "dflt": "#3399FF", - "editType": "plot", - "role": "style", - "valType": "color" + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], + "role": "info", + "editType": "calc", + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*." }, - "landcolor": { - "description": "Sets the land mass color.", - "dflt": "#F0DC82", - "editType": "plot", - "role": "style", - "valType": "color" + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], + "role": "info", + "editType": "style", + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." }, - "lataxis": { - "dtick": { - "description": "Sets the graticule's longitude/latitude tick step.", - "editType": "plot", - "role": "info", - "valType": "number" - }, - "editType": "plot", - "gridcolor": { - "description": "Sets the graticule's stroke color.", - "dflt": "#eee", - "editType": "plot", + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the line color." }, - "gridwidth": { - "description": "Sets the graticule's stroke width (in px).", - "dflt": 1, - "editType": "plot", + "width": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the line width (in px)." }, - "range": { - "description": "Sets the range of this axis (in degrees), sets the map's clipped coordinates.", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "number" - }, - { - "editType": "plot", - "valType": "number" - } + "shape": { + "valType": "enumerated", + "values": [ + "linear", + "spline", + "hv", + "vh", + "hvh", + "vhv" ], - "role": "info", - "valType": "info_array" - }, - "role": "object", - "showgrid": { - "description": "Sets whether or not graticule are shown on the map.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "tick0": { - "description": "Sets the graticule's starting tick longitude/latitude.", - "editType": "plot", - "role": "info", - "valType": "number" - } - }, - "lonaxis": { - "dtick": { - "description": "Sets the graticule's longitude/latitude tick step.", - "editType": "plot", - "role": "info", - "valType": "number" - }, - "editType": "plot", - "gridcolor": { - "description": "Sets the graticule's stroke color.", - "dflt": "#eee", - "editType": "plot", + "dflt": "linear", "role": "style", - "valType": "color" - }, - "gridwidth": { - "description": "Sets the graticule's stroke width (in px).", - "dflt": 1, "editType": "plot", + "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes." + }, + "smoothing": { + "valType": "number", "min": 0, + "max": 1.3, + "dflt": 1, "role": "style", - "valType": "number" - }, - "range": { - "description": "Sets the range of this axis (in degrees), sets the map's clipped coordinates.", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "number" - }, - { - "editType": "plot", - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "role": "object", - "showgrid": { - "description": "Sets whether or not graticule are shown on the map.", - "dflt": false, "editType": "plot", - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape)." }, - "tick0": { - "description": "Sets the graticule's starting tick longitude/latitude.", - "editType": "plot", - "role": "info", - "valType": "number" - } - }, - "oceancolor": { - "description": "Sets the ocean color", - "dflt": "#3399FF", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "projection": { - "editType": "plot", - "parallels": { - "description": "For conic projection types only. Sets the parallels (tangent, secant) where the cone intersects the sphere.", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "number" - }, - { - "editType": "plot", - "valType": "number" - } + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" ], - "role": "info", - "valType": "info_array" - }, - "role": "object", - "rotation": { - "editType": "plot", - "lat": { - "description": "Rotates the map along meridians (in degrees North).", - "editType": "plot", - "role": "info", - "valType": "number" - }, - "lon": { - "description": "Rotates the map along parallels (in degrees East). Defaults to the center of the `lonaxis.range` values.", - "editType": "plot", - "role": "info", - "valType": "number" - }, - "role": "object", - "roll": { - "description": "Roll the map (in degrees) For example, a roll of *180* makes the map appear upside down.", - "editType": "plot", - "role": "info", - "valType": "number" - } + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "scale": { - "description": "Zooms in or out on the map view. A scale of *1* corresponds to the largest zoom level that fits the map's lon and lat ranges. ", - "dflt": 1, - "editType": "plot", - "min": 0, + "simplify": { + "valType": "boolean", + "dflt": true, "role": "info", - "valType": "number" - }, - "type": { - "description": "Sets the projection type.", "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "equirectangular", - "mercator", - "orthographic", - "natural earth", - "kavrayskiy7", - "miller", - "robinson", - "eckert4", - "azimuthal equal area", - "azimuthal equidistant", - "conic equal area", - "conic conformal", - "conic equidistant", - "gnomonic", - "stereographic", - "mollweide", - "hammer", - "transverse mercator", - "albers usa", - "winkel tripel", - "aitoff", - "sinusoidal" - ] - } - }, - "resolution": { - "coerceNumber": true, - "description": "Sets the resolution of the base layers. The values have units of km/mm e.g. 110 corresponds to a scale ratio of 1:110,000,000.", - "dflt": 110, - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - 110, - 50 - ] - }, - "rivercolor": { - "description": "Sets color of the rivers.", - "dflt": "#3399FF", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "riverwidth": { - "description": "Sets the stroke width (in px) of the rivers.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "scope": { - "description": "Set the scope of the map.", - "dflt": "world", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "world", - "usa", - "europe", - "asia", - "africa", - "north america", - "south america" - ] - }, - "showcoastlines": { - "description": "Sets whether or not the coastlines are drawn.", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showcountries": { - "description": "Sets whether or not country boundaries are drawn.", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showframe": { - "description": "Sets whether or not a frame is drawn around the map.", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showlakes": { - "description": "Sets whether or not lakes are drawn.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showland": { - "description": "Sets whether or not land masses are filled in color.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showocean": { - "description": "Sets whether or not oceans are filled in color.", - "dflt": false, + "description": "Simplifies lines by removing nearly-collinear points. When transitioning lines, it may be desirable to disable this so that the number of points along the resulting SVG path is unaffected." + }, "editType": "plot", - "role": "info", - "valType": "boolean" + "role": "object" }, - "showrivers": { - "description": "Sets whether or not rivers are drawn.", + "connectgaps": { + "valType": "boolean", "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showsubunits": { - "description": "Sets whether or not boundaries of subunits within countries (e.g. states, provinces) are drawn.", - "editType": "plot", "role": "info", - "valType": "boolean" - }, - "subunitcolor": { - "description": "Sets the color of the subunits boundaries.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." }, - "subunitwidth": { - "description": "Sets the stroke width (in px) of the subunits boundaries.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "grid": { - "columns": { - "description": "The number of columns in the grid. If you provide a 2D `subplots` array, the length of its longest row is used as the default. If you give an `xaxes` array, its length is used as the default. But it's also possible to have a different length, if you want to leave a row at the end for non-cartesian subplots.", - "editType": "plot", - "min": 1, + "cliponaxis": { + "valType": "boolean", + "dflt": true, "role": "info", - "valType": "integer" - }, - "domain": { - "editType": "plot", - "role": "object", - "x": { - "description": "Sets the horizontal domain of this grid subplot (in plot fraction). The first and last cells end exactly at the domain edges, with no grout around the edges.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this grid subplot (in plot fraction). The first and last cells end exactly at the domain edges, with no grout around the edges.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "plot", - "pattern": { - "description": "If no `subplots`, `xaxes`, or `yaxes` are given but we do have `rows` and `columns`, we can generate defaults using consecutive axis IDs, in two ways: *coupled* gives one x axis per column and one y axis per row. *independent* uses a new xy pair for each cell, left-to-right across each row then iterating rows according to `roworder`.", - "dflt": "coupled", "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "independent", - "coupled" - ] + "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*." }, - "role": "object", - "roworder": { - "description": "Is the first row the top or the bottom? Note that columns are always enumerated from left to right.", - "dflt": "top to bottom", - "editType": "plot", - "role": "info", + "fill": { "valType": "enumerated", "values": [ - "top to bottom", - "bottom to top" - ] - }, - "rows": { - "description": "The number of rows in the grid. If you provide a 2D `subplots` array or a `yaxes` array, its length is used as the default. But it's also possible to have a different length, if you want to leave a row at the end for non-cartesian subplots.", - "editType": "plot", - "min": 1, - "role": "info", - "valType": "integer" - }, - "subplots": { - "description": "Used for freeform grids, where some axes may be shared across subplots but others are not. Each entry should be a cartesian subplot id, like *xy* or *x3y2*, or ** to leave that cell empty. You may reuse x axes within the same column, and y axes within the same row. Non-cartesian subplots and traces that support `domain` can place themselves in this grid separately using the `gridcell` attribute.", - "dimensions": 2, - "editType": "plot", - "freeLength": true, - "items": { - "editType": "plot", - "valType": "enumerated", - "values": [ - "/^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?$/", - "" - ] - }, - "role": "info", - "valType": "info_array" - }, - "xaxes": { - "description": "Used with `yaxes` when the x and y axes are shared across columns and rows. Each entry should be an x axis id like *x*, *x2*, etc., or ** to not put an x axis in that column. Entries other than ** must be unique. Ignored if `subplots` is present. If missing but `yaxes` is present, will generate consecutive IDs.", - "editType": "plot", - "freeLength": true, - "items": { - "editType": "plot", - "valType": "enumerated", - "values": [ - "/^x([2-9]|[1-9][0-9]+)?$/", - "" - ] - }, - "role": "info", - "valType": "info_array" - }, - "xgap": { - "description": "Horizontal space between grid cells, expressed as a fraction of the total width available to one cell. Defaults to 0.1 for coupled-axes grids and 0.2 for independent grids.", - "editType": "plot", - "max": 1, - "min": 0, - "role": "info", - "valType": "number" + "none", + "tozeroy", + "tozerox", + "tonexty", + "tonextx", + "toself", + "tonext" + ], + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." }, - "xside": { - "description": "Sets where the x axis labels and titles go. *bottom* means the very bottom of the grid. *bottom plot* is the lowest plot that each x axis is used in. *top* and *top plot* are similar.", - "dflt": "bottom plot", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "bottom", - "bottom plot", - "top plot", - "top" - ] + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, - "yaxes": { - "description": "Used with `yaxes` when the x and y axes are shared across columns and rows. Each entry should be an y axis id like *y*, *y2*, etc., or ** to not put a y axis in that row. Entries other than ** must be unique. Ignored if `subplots` is present. If missing but `xaxes` is present, will generate consecutive IDs.", - "editType": "plot", - "freeLength": true, - "items": { - "editType": "plot", + "marker": { + "symbol": { "valType": "enumerated", "values": [ - "/^y([2-9]|[1-9][0-9]+)?$/", - "" - ] - }, - "role": "info", - "valType": "info_array" - }, - "ygap": { - "description": "Vertical space between grid cells, expressed as a fraction of the total height available to one cell. Defaults to 0.1 for coupled-axes grids and 0.3 for independent grids.", - "editType": "plot", - "max": 1, - "min": 0, - "role": "info", - "valType": "number" - }, - "yside": { - "description": "Sets where the y axis labels and titles go. *left* means the very left edge of the grid. *left plot* is the leftmost plot that each y axis is used in. *right* and *right plot* are similar.", - "dflt": "left plot", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "left", - "left plot", - "right plot", - "right" - ] - } - }, - "height": { - "description": "Sets the plot's height (in px).", - "dflt": 450, - "editType": "plot", - "min": 10, - "role": "info", - "valType": "number" - }, - "hidesources": { - "description": "Determines whether or not a text link citing the data source is placed at the bottom-right cored of the figure. Has only an effect only on graphs that have been generated via forked graphs from the plotly service (at https://plot.ly or on-premise).", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "hoverdistance": { - "description": "Sets the default distance (in pixels) to look for data to add hover labels (-1 means no cutoff, 0 means no looking for data). This is only a real distance for hovering on point-like objects, like scatter points. For area-like objects (bars, scatter fills, etc) hovering is on inside the area and off outside, but these objects will not supersede hover on point-like objects in case of conflict.", - "dflt": 20, - "editType": "none", - "min": -1, - "role": "info", - "valType": "integer" - }, - "hoverlabel": { - "bgcolor": { - "description": "Sets the background color of all hover labels on graph", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the border color of all hover labels on graph.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "editType": "none", - "font": { - "color": { - "editType": "none", + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "description": "Sets the default hover label font used by all traces on the graph.", - "editType": "none", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "dflt": "Arial, sans-serif", - "editType": "none", - "noBlank": true, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, "role": "style", - "strict": true, - "valType": "string" + "editType": "style", + "description": "Sets the marker opacity." }, - "role": "object", "size": { - "dflt": 13, - "editType": "none", - "min": 1, + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, "role": "style", - "valType": "number" - } - }, - "namelength": { - "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "dflt": 15, - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "role": "object" - }, - "hovermode": { - "description": "Determines the mode of hover interactions.", - "editType": "modebar", - "role": "info", - "valType": "enumerated", - "values": [ - "x", - "y", - "closest", - false - ] - }, - "images": { - "items": { - "image": { - "editType": "arraydraw", - "layer": { - "description": "Specifies whether images are drawn below or above traces. When `xref` and `yref` are both set to `paper`, image is drawn below the entire plot area.", - "dflt": "above", - "editType": "arraydraw", - "role": "info", + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." + }, + "maxdisplayed": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit." + }, + "sizeref": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", + "role": "info", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." + }, + "colorbar": { + "thicknessmode": { "valType": "enumerated", "values": [ - "below", - "above" - ] + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "opacity": { - "description": "Sets the opacity of the image.", - "dflt": 1, - "editType": "arraydraw", - "max": 1, + "thickness": { + "valType": "number", + "role": "style", "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "sizex": { - "description": "Sets the image container size horizontally. The image will be sized based on the `position` value. When `xref` is set to `paper`, units are sized relative to the plot width.", - "dflt": 0, - "editType": "arraydraw", - "role": "info", - "valType": "number" - }, - "sizey": { - "description": "Sets the image container size vertically. The image will be sized based on the `position` value. When `yref` is set to `paper`, units are sized relative to the plot height.", - "dflt": 0, - "editType": "arraydraw", - "role": "info", - "valType": "number" + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "sizing": { - "description": "Specifies which dimension of the image to constrain.", - "dflt": "contain", - "editType": "arraydraw", - "role": "info", + "lenmode": { "valType": "enumerated", "values": [ - "fill", - "contain", - "stretch" - ] - }, - "source": { - "description": "Specifies the URL of the image to be used. The URL must be accessible from the domain where the plot code is run, and can be either relative or absolute.", - "editType": "arraydraw", + "fraction", + "pixels" + ], "role": "info", - "valType": "string" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "visible": { - "description": "Determines whether or not this image is visible.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, "x": { - "description": "Sets the image's x position. When `xref` is set to `paper`, units are sized relative to the plot height. See `xref` for more info", - "dflt": 0, - "editType": "arraydraw", - "role": "info", - "valType": "any" + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, "xanchor": { - "description": "Sets the anchor for the x position", - "dflt": "left", - "editType": "arraydraw", - "role": "info", "valType": "enumerated", "values": [ "left", "center", "right" - ] + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "xref": { - "description": "Sets the images's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to an x data coordinate If set to *paper*, the `x` position refers to the distance from the left of plot in normalized coordinates where *0* (*1*) corresponds to the left (right).", - "dflt": "paper", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "paper", - "/^x([2-9]|[1-9][0-9]+)?$/" - ] + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" }, "y": { - "description": "Sets the image's y position. When `yref` is set to `paper`, units are sized relative to the plot height. See `yref` for more info", - "dflt": 0, - "editType": "arraydraw", - "role": "info", - "valType": "any" - }, - "yanchor": { - "description": "Sets the anchor for the y position.", - "dflt": "top", - "editType": "arraydraw", - "role": "info", + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { "valType": "enumerated", "values": [ "top", "middle", "bottom" - ] + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "yref": { - "description": "Sets the images's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y data coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plot in normalized coordinates where *0* (*1*) corresponds to the bottom (top).", - "dflt": "paper", - "editType": "arraydraw", - "role": "info", + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "paper", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - } - } - }, - "role": "object" - }, - "legend": { - "bgcolor": { - "description": "Sets the legend background color.", - "editType": "legend", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the color of the border enclosing the legend.", - "dflt": "#444", - "editType": "legend", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the legend.", - "dflt": 0, - "editType": "legend", - "min": 0, - "role": "style", - "valType": "number" - }, - "editType": "legend", - "font": { - "color": { - "editType": "legend", - "role": "style", - "valType": "color" - }, - "description": "Sets the font used to text the legend items.", - "editType": "legend", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "legend", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "legend", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "orientation": { - "description": "Sets the orientation of the legend.", - "dflt": "v", - "editType": "legend", - "role": "info", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - }, - "role": "object", - "tracegroupgap": { - "description": "Sets the amount of vertical space (in px) between legend groups.", - "dflt": 10, - "editType": "legend", - "min": 0, - "role": "style", - "valType": "number" - }, - "traceorder": { - "description": "Determines the order at which the legend items are displayed. If *normal*, the items are displayed top-to-bottom in the same order as the input data. If *reversed*, the items are displayed in the opposite order as *normal*. If *grouped*, the items are displayed in groups (when a trace `legendgroup` is provided). if *grouped+reversed*, the items are displayed in the opposite order as *grouped*.", - "editType": "legend", - "extras": [ - "normal" - ], - "flags": [ - "reversed", - "grouped" - ], - "role": "style", - "valType": "flaglist" - }, - "x": { - "description": "Sets the x position (in normalized coordinates) of the legend.", - "dflt": 1.02, - "editType": "legend", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets the legend's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the legend.", - "dflt": "left", - "editType": "legend", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "left", - "center", - "right" - ] - }, - "y": { - "description": "Sets the y position (in normalized coordinates) of the legend.", - "dflt": 1, - "editType": "legend", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets the legend's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the legend.", - "dflt": "auto", - "editType": "legend", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "top", - "middle", - "bottom" - ] - } - }, - "mapbox": { - "_arrayAttrRegexps": [ - {} - ], - "_isSubplotObj": true, - "accesstoken": { - "description": "Sets the mapbox access token to be used for this mapbox map. Alternatively, the mapbox access token can be set in the configuration options under `mapboxAccessToken`.", - "editType": "plot", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - }, - "bearing": { - "description": "Sets the bearing angle of the map (in degrees counter-clockwise from North).", - "dflt": 0, - "editType": "plot", - "role": "info", - "valType": "number" - }, - "center": { - "editType": "plot", - "lat": { - "description": "Sets the latitude of the center of the map (in degrees North).", - "dflt": 0, - "editType": "plot", - "role": "info", - "valType": "number" - }, - "lon": { - "description": "Sets the longitude of the center of the map (in degrees East).", - "dflt": 0, - "editType": "plot", - "role": "info", - "valType": "number" - }, - "role": "object" - }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this mapbox subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "editType": "plot", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this mapbox subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this mapbox subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this mapbox subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "plot", - "layers": { - "items": { - "layer": { - "below": { - "description": "Determines if the layer will be inserted before the layer with the specified ID. If omitted or set to '', the layer will be inserted above every existing layer.", - "dflt": "", - "editType": "plot", - "role": "info", - "valType": "string" + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "circle": { - "editType": "plot", - "radius": { - "description": "Sets the circle radius. Has an effect only when `type` is set to *circle*.", - "dflt": 15, - "editType": "plot", - "role": "style", - "valType": "number" - }, - "role": "object" + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" }, "color": { - "description": "Sets the primary layer color. If `type` is *circle*, color corresponds to the circle color If `type` is *line*, color corresponds to the line color If `type` is *fill*, color corresponds to the fill color If `type` is *symbol*, color corresponds to the icon color", - "dflt": "#444", - "editType": "plot", + "valType": "color", "role": "style", - "valType": "color" - }, - "editType": "plot", - "fill": { - "editType": "plot", - "outlinecolor": { - "description": "Sets the fill outline color. Has an effect only when `type` is set to *fill*.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "role": "object" - }, - "line": { - "editType": "plot", - "role": "object", - "width": { - "description": "Sets the line width. Has an effect only when `type` is set to *line*.", - "dflt": 2, - "editType": "plot", - "role": "style", - "valType": "number" - } - }, - "opacity": { - "description": "Sets the opacity of the layer.", - "dflt": 1, - "editType": "plot", - "max": 1, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "source": { - "description": "Sets the source data for this layer. Source can be either a URL, a geojson object (with `sourcetype` set to *geojson*) or an array of tile URLS (with `sourcetype` set to *vector*).", - "editType": "plot", - "role": "info", - "valType": "any" - }, - "sourcelayer": { - "description": "Specifies the layer to use from a vector tile source. Required for *vector* source type that supports multiple layers.", - "dflt": "", - "editType": "plot", - "role": "info", - "valType": "string" - }, - "sourcetype": { - "description": "Sets the source type for this layer. Support for *raster*, *image* and *video* source types is coming soon.", - "dflt": "geojson", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "geojson", - "vector" - ] + "editType": "colorbars" }, - "symbol": { - "editType": "plot", - "icon": { - "description": "Sets the symbol icon image. Full list: https://www.mapbox.com/maki-icons/", - "dflt": "marker", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "iconsize": { - "description": "Sets the symbol icon size. Has an effect only when `type` is set to *symbol*.", - "dflt": 10, - "editType": "plot", - "role": "style", - "valType": "number" - }, - "role": "object", - "text": { - "description": "Sets the symbol text.", - "dflt": "", - "editType": "plot", - "role": "info", - "valType": "string" - }, - "textfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "description": "Sets the icon text font. Has an effect only when `type` is set to *symbol*.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "dflt": "Open Sans Regular, Arial Unicode MS Regular", - "editType": "plot", - "noBlank": true, + "value": { + "valType": "string", + "dflt": "", "role": "style", - "strict": true, - "valType": "string" + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "textposition": { - "arrayOk": false, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] + "editType": "colorbars", + "role": "object" } }, - "type": { - "description": "Sets the layer type. Support for *raster*, *background* types is coming soon. Note that *line* and *fill* are not compatible with Point GeoJSON geometries.", - "dflt": "circle", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "circle", - "line", - "fill", - "symbol" - ] - } - } - }, - "role": "object" - }, - "pitch": { - "description": "Sets the pitch angle of the map (in degrees, where *0* means perpendicular to the surface of the map).", - "dflt": 0, - "editType": "plot", - "role": "info", - "valType": "number" - }, - "role": "object", - "style": { - "description": "Sets the Mapbox map style. Either input one of the default Mapbox style names or the URL to a custom style or a valid Mapbox style JSON.", - "dflt": "basic", - "editType": "plot", - "role": "style", - "valType": "any", - "values": [ - "basic", - "streets", - "outdoors", - "light", - "dark", - "satellite", - "satellite-streets" - ] - }, - "zoom": { - "description": "Sets the zoom level of the map.", - "dflt": 1, - "editType": "plot", - "role": "info", - "valType": "number" - } - }, - "margin": { - "autoexpand": { - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "b": { - "description": "Sets the bottom margin (in px).", - "dflt": 80, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "editType": "plot", - "l": { - "description": "Sets the left margin (in px).", - "dflt": 80, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "pad": { - "description": "Sets the amount of padding (in px) between the plotting area and the axis lines", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "r": { - "description": "Sets the right margin (in px).", - "dflt": 80, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "t": { - "description": "Sets the top margin (in px).", - "dflt": 100, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - } - }, - "orientation": { - "description": "For polar plots only. Rotates the entire polar by the given angle.", - "editType": "plot", - "role": "info", - "valType": "angle" - }, - "paper_bgcolor": { - "description": "Sets the color of paper where the graph is drawn.", - "dflt": "#fff", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "plot_bgcolor": { - "description": "Sets the color of plotting area in-between x and y axes.", - "dflt": "#fff", - "editType": "layoutstyle", - "role": "style", - "valType": "color" - }, - "polar": { - "_isSubplotObj": true, - "angularaxis": { - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", - "role": "info", - "valType": "string" + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points." + }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", + "gradient": { + "type": { + "valType": "enumerated", + "values": [ + "radial", + "horizontal", + "vertical", + "none" + ], + "arrayOk": true, + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the type of gradient used to fill the markers" + }, + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical." + }, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] + "role": "object", + "typesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for type .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, + "editType": "calc", "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "direction": { - "description": "Sets the direction corresponding to positive angles.", - "dflt": "counterclockwise", + "colorscale": { + "valType": "colorscale", + "role": "style", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "counterclockwise", - "clockwise" - ] - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", "impliedEdits": { - "tickmode": "linear" + "autocolorscale": false }, - "role": "style", - "valType": "any" - }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] - }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "integer" - }, - "period": { - "description": "Set the angular period. Has an effect only when `angularaxis.type` is *category*.", + "dflt": true, "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "role": "object", - "rotation": { - "description": "Sets that start position (in degrees) of the angular axis By default, polar subplots with `direction` set to *counterclockwise* get a `rotation` of *0* which corresponds to due East (like what mathematicians prefer). In turn, polar with `direction` set to *clockwise* get a rotation of *90* which corresponds to due North (like on a compass),", - "editType": "calc", + "cmax": { + "valType": "number", "role": "info", - "valType": "angle" - }, - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, + "dflt": null, "editType": "plot", - "role": "style", - "valType": "boolean" + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "plot", + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "boolean" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "role": "object", + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" }, - "thetaunit": { - "description": "Sets the format unit of the formatted *theta* values. Has an effect only when `angularaxis.type` is *linear*.", - "dflt": "degrees", - "editType": "calc", + "sizesrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "radians", - "degrees" - ] + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "tickfont": { "color": { - "editType": "plot", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker color of selected points." }, - "description": "Sets the tick font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "size": { + "valType": "number", + "min": 0, "role": "style", - "strict": true, - "valType": "string" + "editType": "style", + "description": "Sets the marker size of selected points." }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "editType": "style", + "role": "object" }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of selected points." }, + "editType": "style", "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", + "editType": "style", + "role": "object" + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "textfont": { + "family": { + "valType": "string", "role": "style", - "valType": "string" + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] + "min": 1, + "editType": "calc", + "arrayOk": true }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "editType": "style", + "arrayOk": true }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "editType": "calc", + "description": "Sets the text font.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "type": { - "description": "Sets the angular axis type. If *linear*, set `thetaunit` to determine the unit in which axis value are shown. If *category, use `period` to set the number of integer coordinates around polar axis.", - "dflt": "-", - "editType": "calc", + "sizesrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "category" - ] + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "dflt": true, - "editType": "plot", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "bgcolor": { - "description": "Set the background color of the subplot", - "dflt": "#fff", - "editType": "plot", - "role": "style", - "valType": "color" + "r": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", + "role": "data" }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this polar subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "editType": "plot", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this polar subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, + "t": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", + "role": "data" + }, + "error_x": { + "visible": { + "valType": "boolean", "role": "info", - "valType": "integer" + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." }, - "x": { - "description": "Sets the horizontal domain of this polar subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } + "type": { + "valType": "enumerated", + "values": [ + "percent", + "constant", + "sqrt", + "data" ], "role": "info", - "valType": "info_array" + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "y": { - "description": "Sets the vertical domain of this polar subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "calc", - "radialaxis": { - "angle": { - "description": "Sets the angle (in degrees) from which the radial axis is drawn. Note that by default, radial axis line on the theta=0 line corresponds to a line pointing right (like what mathematicians prefer). Defaults to the first `polar.sector` angle.", - "editType": "plot", + "symmetric": { + "valType": "boolean", "role": "info", - "valType": "angle" - }, - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", - "dflt": "gregorian", + "array": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", + "arrayminus": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", + "value": { + "valType": "number", + "min": 0, + "dflt": 10, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" + }, + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] + "editType": "style" }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + "copy_ystyle": { + "valType": "boolean", "role": "style", - "valType": "any" + "editType": "plot" }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "plot", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", + "width": { + "valType": "number", "min": 0, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" + }, + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_y": { + "visible": { + "valType": "boolean", "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { "valType": "enumerated", "values": [ - "above traces", - "below traces" - ] + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" + }, + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "plot", + "valueminus": { + "valType": "number", "min": 0, - "role": "style", - "valType": "integer" + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "axrange+margins", - "impliedEdits": { - "autorange": false - }, - "items": [ - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "info_array" + "editType": "style" }, - "rangemode": { - "description": "If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data. If *normal*, the range is computed in relation to the extrema of the input data (same behavior as for cartesian axes).", - "dflt": "tozero", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "tozero", - "nonnegative", - "normal" - ] + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "plot", + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": true, "editType": "plot", - "role": "style", - "valType": "boolean" + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "side": { - "description": "Determines on which side of radial axis line the tick and tick labels appear.", - "dflt": "clockwise", - "editType": "plot", + "role": "object", + "arraysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "clockwise", - "counterclockwise" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "hovertextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" + }, + "textpositionsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + }, + "rsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for r .", + "editType": "none" + }, + "tsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for t .", + "editType": "none" + } + } + }, + "bar": { + "meta": { + "description": "The data visualized by the span of the bars is set in `y` if `orientation` is set th *v* (the default) and the labels are set in `x`. By setting `orientation` to *h*, the roles are interchanged." + }, + "attributes": { + "type": "bar", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "angle" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "plot", + "font": { "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "string" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "role": "data" + }, + "x0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step." + }, + "dx": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info." + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "role": "data" + }, + "y0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step." + }, + "dy": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the y coordinate step. See `y0` for more info." + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." + }, + "hovertext": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "style", + "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "textposition": { + "valType": "enumerated", + "role": "info", + "values": [ + "inside", + "outside", + "auto", + "none" + ], + "dflt": "none", + "arrayOk": true, + "editType": "calc", + "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed). *auto* positions `text` inside or outside so that `text` size is maximized." + }, + "textfont": { + "family": { + "valType": "string", "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", + "size": { + "valType": "number", "role": "style", - "valType": "string" + "min": 1, + "editType": "calc", + "arrayOk": true }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "arrayOk": true }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "editType": "calc", + "description": "Sets the font used for `text`.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "insidetextfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "calc", + "arrayOk": true }, - "title": { - "description": "Sets the title of this axis.", - "dflt": "", - "editType": "plot", + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "arrayOk": true + }, + "editType": "calc", + "description": "Sets the font used for `text` lying inside the bar.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" - } + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "outsidetextfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", "editType": "calc", + "arrayOk": true + }, + "editType": "calc", + "description": "Sets the font used for `text` lying outside the bar.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "log", - "date", - "category" - ] + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "dflt": true, - "editType": "plot", + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object", - "sector": { - "description": "Sets angular span of this polar subplot with two angles (in degrees). Sector are assumed to be spanned in the counterclockwise direction with *0* corresponding to rightmost limit of the polar subplot.", - "dflt": [ - 0, - 360 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "number" - }, - { - "editType": "plot", - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "radialaxis": { - "domain": { - "description": "Polar chart subplots are not supported yet. This key has currently no effect.", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } + "constraintext": { + "valType": "enumerated", + "values": [ + "inside", + "outside", + "both", + "none" ], "role": "info", - "valType": "info_array" + "dflt": "both", + "editType": "calc", + "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself." }, - "editType": "plot", - "endpadding": { + "cliponaxis": { + "valType": "boolean", + "dflt": true, + "role": "info", "editType": "plot", - "role": "style", - "valType": "number" + "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*." }, "orientation": { - "description": "Sets the orientation (an angle with respect to the origin) of the radial axis.", - "editType": "plot", - "role": "style", - "valType": "number" - }, - "range": { - "description": "Defines the start and end point of this radial axis.", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "number" - }, - { - "editType": "plot", - "valType": "number" - } - ], + "valType": "enumerated", "role": "info", - "valType": "info_array" - }, - "role": "object", - "showline": { - "description": "Determines whether or not the line bounding this radial axis will be shown on the figure.", - "editType": "plot", - "role": "style", - "valType": "boolean" + "values": [ + "v", + "h" + ], + "editType": "calc+clearAxisTypes", + "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal)." }, - "showticklabels": { - "description": "Determines whether or not the radial axis ticks will feature tick labels.", - "editType": "plot", - "role": "style", - "valType": "boolean" + "base": { + "valType": "any", + "dflt": null, + "arrayOk": true, + "role": "info", + "editType": "calc", + "description": "Sets where the bar base is drawn (in position axis units). In *stack* or *relative* barmode, traces that set *base* will be excluded and drawn in *overlay* mode instead." }, - "tickcolor": { - "description": "Sets the color of the tick lines on this radial axis.", - "editType": "plot", - "role": "style", - "valType": "color" + "offset": { + "valType": "number", + "dflt": null, + "arrayOk": true, + "role": "info", + "editType": "calc", + "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead." }, - "ticklen": { - "description": "Sets the length of the tick lines on this radial axis.", - "editType": "plot", + "width": { + "valType": "number", + "dflt": null, "min": 0, - "role": "style", - "valType": "number" - }, - "tickorientation": { - "description": "Sets the orientation (from the paper perspective) of the radial axis tick labels.", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "horizontal", - "vertical" - ] - }, - "ticksuffix": { - "description": "Sets the length of the tick lines on this radial axis.", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this axis will be visible.", - "editType": "plot", + "arrayOk": true, "role": "info", - "valType": "boolean" - } - }, - "scene": { - "_arrayAttrRegexps": [ - {} - ], - "_deprecated": { - "cameraposition": { - "description": "Obsolete. Use `camera` instead.", - "editType": "camera", - "role": "info", - "valType": "info_array" - } + "editType": "calc", + "description": "Sets the bar width (in position axis units)." }, - "_isSubplotObj": true, - "annotations": { - "items": { - "annotation": { - "align": { - "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", - "dflt": "center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "arrowcolor": { - "description": "Sets the color of the annotation arrow.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "arrowhead": { - "description": "Sets the end annotation arrow head style.", - "dflt": 1, - "editType": "calc", - "max": 8, - "min": 0, - "role": "style", - "valType": "integer" + "marker": { + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points.", + "dflt": 0 + }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false }, - "arrowside": { - "description": "Sets the annotation arrow head position.", - "dflt": "end", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "end", - "start" - ], - "role": "style", - "valType": "flaglist" + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "arrowsize": { - "description": "Sets the size of the end annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line.", - "dflt": 1, - "editType": "calc", - "min": 0.3, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "arrowwidth": { - "description": "Sets the width (in px) of annotation arrow line.", - "editType": "calc", - "min": 0.1, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" + }, + "thickness": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" + }, + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - "ax": { - "description": "Sets the x component of the arrow tail about the arrow head (in pixels).", - "editType": "calc", - "role": "info", - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - "ay": { - "description": "Sets the y component of the arrow tail about the arrow head (in pixels).", - "editType": "calc", - "role": "info", - "valType": "number" - }, - "bgcolor": { - "description": "Sets the background color of the annotation.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the color of the border enclosing the annotation `text`.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "borderpad": { - "description": "Sets the padding (in px) between the `text` and the enclosing border.", - "dflt": 1, - "editType": "calc", - "min": 0, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "number" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the annotation `text`.", - "dflt": 1, - "editType": "calc", - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" - }, - "captureevents": { - "description": "Determines whether the annotation text box captures mouse move and click events, or allows those events to pass through to data points in the plot that may be behind the annotation. By default `captureevents` is *false* unless `hovertext` is provided. If you use the event `plotly_clickannotation` without `hovertext` you must explicitly enable `captureevents`.", - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "editType": "calc", - "font": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the annotation text font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "height": { - "description": "Sets an explicit height for the text box. null (default) lets the text set the box height. Taller text will be clipped.", - "dflt": null, - "editType": "calc", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "hoverlabel": { - "bgcolor": { - "description": "Sets the background color of the hover label. By default uses the annotation's `bgcolor` made opaque, or white if it was transparent.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the border color of the hover label. By default uses either dark grey or white, for maximum contrast with `hoverlabel.bgcolor`.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "font": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "description": "Sets the hover label text font. By default uses the global hover font and size, with color from `hoverlabel.bordercolor`.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "value": { + "valType": "string", + "dflt": "", "role": "style", - "strict": true, - "valType": "string" + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "hovertext": { - "description": "Sets text to appear when hovering over this annotation. If omitted or blank, no hover label will appear.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the annotation (text + arrow).", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "showarrow": { - "description": "Determines whether or not the annotation is drawn with an arrow. If *true*, `text` is placed near the arrow's tail. If *false*, `text` lines up with the `x` and `y` provided.", - "dflt": true, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "standoff": { - "description": "Sets a distance, in pixels, to move the end arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "startarrowhead": { - "description": "Sets the start annotation arrow head style.", - "dflt": 1, - "editType": "calc", - "max": 8, - "min": 0, - "role": "style", - "valType": "integer" - }, - "startarrowsize": { - "description": "Sets the size of the start annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line.", - "dflt": 1, - "editType": "calc", - "min": 0.3, - "role": "style", - "valType": "number" - }, - "startstandoff": { - "description": "Sets a distance, in pixels, to move the start arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "text": { - "description": "Sets the text associated with this annotation. Plotly uses a subset of HTML tags to do things like newline (
), bold (), italics (), hyperlinks (). Tags , , are also supported.", - "editType": "calc", - "role": "info", - "valType": "string" + "editType": "colorbars", + "role": "object" + } }, - "textangle": { - "description": "Sets the angle at which the `text` is drawn with respect to the horizontal.", - "dflt": 0, - "editType": "calc", + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "angle" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "valign": { - "description": "Sets the vertical alignment of the `text` within the box. Has an effect only if an explicit height is set to override the text height.", - "dflt": "middle", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "visible": { - "description": "Determines whether or not this annotation is visible.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets an explicit width for the text box. null (default) lets the text set the box width. Wider text will be clipped. There is no automatic wrapping; use
to start a new line.", - "dflt": null, - "editType": "calc", "min": 1, - "role": "style", - "valType": "number" - }, - "x": { - "description": "Sets the annotation's x position.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "xanchor": { - "description": "Sets the text box's horizontal position anchor This anchor binds the `x` position to the *left*, *center* or *right* of the annotation. For example, if `x` is set to 1, `xref` to *paper* and `xanchor` to *right* then the right-most portion of the annotation lines up with the right-most edge of the plotting area. If *auto*, the anchor is equivalent to *center* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side.", - "dflt": "auto", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "left", - "center", - "right" - ] - }, - "xshift": { - "description": "Shifts the position of the whole annotation and arrow to the right (positive) or left (negative) by this many pixels.", - "dflt": 0, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the annotation's y position.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "yanchor": { - "description": "Sets the text box's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the annotation. For example, if `y` is set to 1, `yref` to *paper* and `yanchor` to *top* then the top-most portion of the annotation lines up with the top-most edge of the plotting area. If *auto*, the anchor is equivalent to *middle* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side.", - "dflt": "auto", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "top", - "middle", - "bottom" - ] + "editType": "colorbars" }, - "yshift": { - "description": "Shifts the position of the whole annotation and arrow up (positive) or down (negative) by this many pixels.", - "dflt": 0, - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "z": { - "description": "Sets the annotation's z position.", - "editType": "calc", - "role": "info", - "valType": "any" - } + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "role": "object" - }, - "aspectmode": { - "description": "If *cube*, this scene's axes are drawn as a cube, regardless of the axes' ranges. If *data*, this scene's axes are drawn in proportion with the axes' ranges. If *manual*, this scene's axes are drawn in proportion with the input of *aspectratio* (the default behavior if *aspectratio* is provided). If *auto*, this scene's axes are drawn using the results of *data* except when one axis is more than four times the size of the two others, where in that case the results of *cube* are used.", - "dflt": "auto", - "editType": "plot", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "cube", - "data", - "manual" - ] - }, - "aspectratio": { - "description": "Sets this scene's axis aspectratio.", - "editType": "plot", - "impliedEdits": { - "aspectmode": "manual", - "role": "object" - }, - "role": "object", - "x": { - "editType": "plot", - "impliedEdits": { - "^aspectmode": "manual" - }, + "opacity": { + "valType": "number", + "arrayOk": true, + "dflt": 1, "min": 0, - "role": "info", - "valType": "number" + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the opacity of the bars." }, - "y": { - "editType": "plot", - "impliedEdits": { - "^aspectmode": "manual" - }, - "min": 0, + "role": "object", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" }, - "z": { - "editType": "plot", - "impliedEdits": { - "^aspectmode": "manual" - }, - "min": 0, + "opacitysrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" } }, - "bgcolor": { - "dflt": "rgba(0,0,0,0)", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "camera": { - "center": { - "description": "Sets the (x,y,z) components of the 'center' camera vector This vector determines the translation (x,y,z) space about the center of this scene. By default, there is no such translation.", - "editType": "camera", - "role": "object", - "x": { - "dflt": 0, - "editType": "camera", - "role": "info", - "valType": "number" + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "y": { - "dflt": 0, - "editType": "camera", - "role": "info", - "valType": "number" + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of selected points." }, - "z": { - "dflt": 0, - "editType": "camera", - "role": "info", - "valType": "number" - } + "editType": "style", + "role": "object" }, - "editType": "camera", - "eye": { - "description": "Sets the (x,y,z) components of the 'eye' camera vector. This vector determines the view point about the origin of this scene.", - "editType": "camera", - "role": "object", - "x": { - "dflt": 1.25, - "editType": "camera", - "role": "info", - "valType": "number" - }, - "y": { - "dflt": 1.25, - "editType": "camera", - "role": "info", - "valType": "number" + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of selected points." }, - "z": { - "dflt": 1.25, - "editType": "camera", - "role": "info", - "valType": "number" - } + "editType": "style", + "role": "object" }, - "role": "object", - "up": { - "description": "Sets the (x,y,z) components of the 'up' camera vector. This vector determines the up direction of this scene with respect to the page. The default is *{x: 0, y: 0, z: 1}* which means that the z axis points up.", - "editType": "camera", - "role": "object", - "x": { - "dflt": 0, - "editType": "camera", - "role": "info", - "valType": "number" + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." }, - "y": { - "dflt": 0, - "editType": "camera", - "role": "info", - "valType": "number" + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, - "z": { - "dflt": 1, - "editType": "camera", - "role": "info", - "valType": "number" - } - } - }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this scene subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "editType": "plot", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this scene subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" + "editType": "style", + "role": "object" }, - "x": { - "description": "Sets the horizontal domain of this scene subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "y": { - "description": "Sets the vertical domain of this scene subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } + "editType": "style", + "role": "object" }, - "dragmode": { - "description": "Determines the mode of drag interactions for this scene.", - "dflt": "turntable", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "orbit", - "turntable", - "zoom", - "pan", - false - ] + "r": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", + "role": "data" }, - "editType": "plot", - "hovermode": { - "description": "Determines the mode of hover interactions for this scene.", - "dflt": "closest", - "editType": "modebar", - "role": "info", - "valType": "enumerated", - "values": [ - "closest", - false - ] + "t": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", + "role": "data" }, - "role": "object", - "xaxis": { - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, - "editType": "plot", - "impliedEdits": {}, - "role": "style", + "_deprecated": { + "bardir": { "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] - }, - "backgroundcolor": { - "description": "Sets the background color of this axis' wall.", - "dflt": "rgba(204, 204, 204, 0.5)", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", - "dflt": "gregorian", + "role": "info", "editType": "calc", + "values": [ + "v", + "h" + ], + "description": "Renamed to `orientation`." + } + }, + "error_x": { + "visible": { + "valType": "boolean", "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { "valType": "enumerated", "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "plot", - "role": "data", - "valType": "data_array" - }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", + "percent", + "constant", + "sqrt", + "data" + ], "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "plot", + "symmetric": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "value": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "rgb(204, 204, 204)", - "editType": "plot", - "role": "style", - "valType": "color" + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", + "traceref": { + "valType": "integer", "min": 0, - "role": "style", - "valType": "number" + "dflt": 0, + "role": "info", + "editType": "style" }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", + "copy_ystyle": { + "valType": "boolean", "role": "style", - "valType": "color" + "editType": "plot" }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "mirror": { - "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots.", - "dflt": false, - "editType": "plot", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "enumerated", - "values": [ - true, - "ticks", - false, - "all", - "allticks" - ] + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "plot", + "width": { + "valType": "number", "min": 0, "role": "style", - "valType": "integer" - }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", "editType": "plot", - "impliedEdits": { - "autorange": false - }, - "items": [ - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } }, "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showaxeslabels": { - "description": "Sets whether or not this axis is labeled", - "dflt": true, - "editType": "plot", + "arraysrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "showbackground": { - "description": "Sets whether or not this axis' wall has a background color.", - "dflt": false, - "editType": "plot", + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_y": { + "visible": { + "valType": "boolean", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", - "role": "style", + "type": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "showspikes": { - "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", - "dflt": true, - "editType": "plot", + "symmetric": { + "valType": "boolean", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "value": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "spikecolor": { - "description": "Sets the color of the spikes.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "spikesides": { - "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", - "dflt": true, - "editType": "plot", + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "boolean" + "editType": "style" }, - "spikethickness": { - "description": "Sets the thickness (in px) of the spikes.", - "dflt": 2, - "editType": "plot", + "tracerefminus": { + "valType": "integer", "min": 0, - "role": "style", - "valType": "number" + "dflt": 0, + "role": "info", + "editType": "style" }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + "color": { + "valType": "color", "role": "style", - "valType": "any" + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "angle" + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." + }, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, + "role": "object", + "arraysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "arrayminussrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "hovertextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" + }, + "textpositionsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + }, + "basesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for base .", + "editType": "none" + }, + "offsetsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for offset .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "rsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for r .", + "editType": "none" + }, + "tsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for t .", + "editType": "none" + } + }, + "layoutAttributes": { + "barmode": { + "valType": "enumerated", + "values": [ + "stack", + "group", + "overlay", + "relative" + ], + "dflt": "group", + "role": "info", + "editType": "calc", + "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to an *opacity* to see multiple bars." + }, + "barnorm": { + "valType": "enumerated", + "values": [ + "", + "fraction", + "percent" + ], + "dflt": "", + "role": "info", + "editType": "calc", + "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divide by the sum of the values at the location coordinate. With *percent*, the results form *fraction* are presented in percents." + }, + "bargap": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates." + }, + "bargroupgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between bars of the same location coordinate." + } + } + }, + "box": { + "meta": { + "description": "In vertical (horizontal) box plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one box per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single box is drawn. That box position is then positioned with with `name` or with `x0` (`y0`) if provided. Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second quartile (Q2) is marked by a line inside the box. By default, the whiskers correspond to the box' edges +/- 1.5 times the interquartile range (IQR = Q3-Q1), see *boxpoints* for other options." + }, + "attributes": { + "type": "box", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Sets the trace name. The trace name appear as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical" + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", - "min": 0, + "bordercolor": { + "valType": "color", "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "plot", - "role": "info", - "valType": "string" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", + "font": { "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "plot", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "log", - "date", - "category" - ] + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "editType": "plot", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "zeroline": { - "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines.", - "editType": "plot", - "role": "style", - "valType": "boolean" + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "zerolinecolor": { - "description": "Sets the line color of the zero line.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "zerolinewidth": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 1, - "editType": "plot", - "role": "style", - "valType": "number" - } + "editType": "calc", + "role": "object" }, - "yaxis": { - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, - "editType": "plot", - "impliedEdits": {}, - "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } }, - "backgroundcolor": { - "description": "Sets the background color of this axis' wall.", - "dflt": "rgba(204, 204, 204, 0.5)", - "editType": "plot", + "role": "object" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y sample data or coordinates. See overview for more info.", + "role": "data" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x sample data or coordinates. See overview for more info.", + "role": "data" + }, + "x0": { + "valType": "any", + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinate of the box. See overview for more info." + }, + "y0": { + "valType": "any", + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinate of the box. See overview for more info." + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "whiskerwidth": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.5, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the width of the whiskers relative to the box' width. For example, with 1, the whiskers are as wide as the box(es)." + }, + "notched": { + "valType": "boolean", + "role": "style", + "editType": "calcIfAutorange", + "description": "Determines whether or not notches should be drawn." + }, + "notchwidth": { + "valType": "number", + "min": 0, + "max": 0.5, + "dflt": 0.25, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the width of the notches relative to the box' width. For example, with 0, the notches are as wide as the box(es)." + }, + "boxpoints": { + "valType": "enumerated", + "values": [ + "all", + "outliers", + "suspectedoutliers", + false + ], + "dflt": "outliers", + "role": "style", + "editType": "calcIfAutorange", + "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the box(es) are shown with no sample points" + }, + "boxmean": { + "valType": "enumerated", + "values": [ + true, + "sd", + false + ], + "dflt": false, + "role": "style", + "editType": "calcIfAutorange", + "description": "If *true*, the mean of the box(es)' underlying distribution is drawn as a dashed line inside the box(es). If *sd* the standard deviation is also drawn." + }, + "jitter": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the box(es)." + }, + "pointpos": { + "valType": "number", + "min": -2, + "max": 2, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the position of the sample points in relation to the box(es). If *0*, the sample points are places over the center of the box(es). Positive (negative) values correspond to positions to the right (left) for vertical boxes and above (below) for horizontal boxes" + }, + "orientation": { + "valType": "enumerated", + "values": [ + "v", + "h" + ], + "role": "style", + "editType": "calc+clearAxisTypes", + "description": "Sets the orientation of the box(es). If *v* (*h*), the distribution is visualized along the vertical (horizontal)." + }, + "marker": { + "outliercolor": { + "valType": "color", + "dflt": "rgba(0, 0, 0, 0)", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the color of the outlier sample points." }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", - "dflt": "gregorian", - "editType": "calc", - "role": "info", + "symbol": { "valType": "enumerated", "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "plot", - "role": "data", - "valType": "data_array" - }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", + "arrayOk": false, "role": "style", - "valType": "any" - }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "rgb(204, 204, 204)", - "editType": "plot", + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": false, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker opacity.", + "dflt": 1 }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", + "size": { + "valType": "number", "min": 0, + "dflt": 6, + "arrayOk": false, "role": "style", - "valType": "number" + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", + "color": { + "valType": "color", + "arrayOk": false, "role": "style", - "valType": "string" + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "line": { + "color": { + "valType": "color", + "arrayOk": false, + "role": "style", + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "dflt": "#444" + }, + "width": { + "valType": "number", + "min": 0, + "arrayOk": false, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points.", + "dflt": 0 + }, + "outliercolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the border line color of the outlier sample points. Defaults to marker.color" + }, + "outlierwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "style", + "description": "Sets the border line width (in px) of the outlier sample points." + }, + "editType": "style", + "role": "object" }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, + "editType": "plot", + "role": "object" + }, + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the color of line bounding the box(es)." }, - "mirror": { - "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots.", - "dflt": false, - "editType": "plot", + "width": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - true, - "ticks", - false, - "all", - "allticks" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "plot", "min": 0, - "role": "style", - "valType": "integer" + "dflt": 2, + "editType": "style", + "description": "Sets the width (in px) of line bounding the box(es)." }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "autorange": false + "editType": "plot", + "role": "object" + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "items": [ - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of selected points." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of selected points." + }, + "editType": "style", + "role": "object" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "showaxeslabels": { - "description": "Sets whether or not this axis is labeled", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showbackground": { - "description": "Sets whether or not this axis' wall has a background color.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showspikes": { - "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "spikecolor": { - "description": "Sets the color of the spikes.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "spikesides": { - "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "spikethickness": { - "description": "Sets the thickness (in px) of the spikes.", - "dflt": 2, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", + "editType": "style", + "role": "object" + }, + "hoveron": { + "valType": "flaglist", + "flags": [ + "boxes", + "points" + ], + "dflt": "boxes+points", + "role": "info", + "editType": "style", + "description": "Do the hover effects highlight individual boxes or sample points or both?" + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + }, + "layoutAttributes": { + "boxmode": { + "valType": "enumerated", + "values": [ + "group", + "overlay" + ], + "dflt": "overlay", + "role": "info", + "editType": "calc", + "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes." + }, + "boxgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates." + }, + "boxgroupgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate." + } + } + }, + "heatmap": { + "meta": { + "description": "The data that describes the heatmap value-to-color mapping is set in `z`. Data in `z` can either be a {2D array} of values (ragged or not) or a 1D array of values. In the case where `z` is a {2D array}, say that `z` has N rows and M columns. Then, by default, the resulting heatmap will have N partitions along the y axis and M partitions along the x axis. In other words, the i-th row/ j-th column cell in `z` is mapped to the i-th partition of the y axis (starting from the bottom of the plot) and the j-th partition of the x-axis (starting from the left of the plot). This behavior can be flipped by using `transpose`. Moreover, `x` (`y`) can be provided with M or M+1 (N or N+1) elements. If M (N), then the coordinates correspond to the center of the heatmap cells and the cells have equal width. If M+1 (N+1), then the coordinates correspond to the edges of the heatmap cells. In the case where `z` is a 1D {array}, the x and y coordinates must be provided in `x` and `y` respectively to form data triplets." + }, + "attributes": { + "type": "heatmap", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "angle" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "plot", + "font": { "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } + "editType": "none", + "arrayOk": true }, - "role": "object" + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "string" + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "plot", + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "log", - "date", - "category" - ] - }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "zeroline": { - "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines.", - "editType": "plot", - "role": "style", - "valType": "boolean" + "role": "object" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the z data.", + "role": "data" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "impliedEdits": { + "xtype": "array" }, - "zerolinecolor": { - "description": "Sets the line color of the zero line.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "role": "data" + }, + "x0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", + "impliedEdits": { + "xtype": "scaled" + } + }, + "dx": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info.", + "impliedEdits": { + "xtype": "scaled" + } + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "impliedEdits": { + "ytype": "array" }, - "zerolinewidth": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 1, - "editType": "plot", - "role": "style", - "valType": "number" + "role": "data" + }, + "y0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", + "impliedEdits": { + "ytype": "scaled" } }, - "zaxis": { - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, - "editType": "plot", - "impliedEdits": {}, - "role": "style", + "dy": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the y coordinate step. See `y0` for more info.", + "impliedEdits": { + "ytype": "scaled" + } + }, + "text": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text elements associated with each z value.", + "role": "data" + }, + "transpose": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Transposes the z data." + }, + "xtype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided)." + }, + "ytype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)" + }, + "zsmooth": { + "valType": "enumerated", + "values": [ + "fast", + "best", + false + ], + "dflt": false, + "role": "style", + "editType": "calc", + "description": "Picks a smoothing algorithm use to smooth `z` data." + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in." + }, + "xgap": { + "valType": "number", + "dflt": 0, + "min": 0, + "role": "style", + "editType": "plot", + "description": "Sets the horizontal gap (in pixels) between bricks." + }, + "ygap": { + "valType": "number", + "dflt": 0, + "min": 0, + "role": "style", + "editType": "plot", + "description": "Sets the vertical gap (in pixels) between bricks." + }, + "zhoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format" + }, + "zauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." + }, + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." + }, + "zmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Reverses the colorscale." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." + }, + "colorbar": { + "thicknessmode": { "valType": "enumerated", "values": [ - true, - false, - "reversed" - ] + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "backgroundcolor": { - "description": "Sets the background color of this axis' wall.", - "dflt": "rgba(204, 204, 204, 0.5)", - "editType": "plot", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", - "dflt": "gregorian", - "editType": "calc", - "role": "info", + "lenmode": { "valType": "enumerated", "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", - "role": "info", - "valType": "string" + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "plot", - "role": "info", + "xanchor": { "valType": "enumerated", "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "color" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + "xpad": { + "valType": "number", "role": "style", - "valType": "any" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", + "y": { + "valType": "number", "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "rgb(204, 204, 204)", - "editType": "plot", + "top", + "middle", + "bottom" + ], "role": "style", - "valType": "color" + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", + "ypad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Sets the axis line color." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "linecolor": { - "description": "Sets the axis line color.", + "bordercolor": { + "valType": "color", "dflt": "#444", - "editType": "plot", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, + "borderwidth": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "mirror": { - "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots.", - "dflt": false, - "editType": "plot", + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - true, - "ticks", - false, - "all", - "allticks" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "plot", + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "integer" + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", "impliedEdits": { - "autorange": false + "tickmode": "linear" }, - "items": [ - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "plot", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", + "dtick": { + "valType": "any", "role": "style", - "valType": "boolean" + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "showaxeslabels": { - "description": "Sets whether or not this axis is labeled", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" }, - "showbackground": { - "description": "Sets whether or not this axis' wall has a background color.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", - "role": "style", + "ticks": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "editType": "plot", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the tick length (in px)." }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "plot", + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, - "showspikes": { - "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." }, "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", + "valType": "boolean", "dflt": true, - "editType": "plot", "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "spikecolor": { - "description": "Sets the color of the spikes.", - "dflt": "#444", - "editType": "plot", + "tickformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "color" - }, - "spikesides": { - "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "spikethickness": { - "description": "Sets the thickness (in px) of the spikes.", - "dflt": 2, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "plot", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "plot", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "plot", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of this axis.", - "editType": "plot", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "plot", - "role": "info", + "titleside": { "valType": "enumerated", "values": [ - "-", - "linear", - "log", - "date", - "category" - ] + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "editType": "plot", + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "zeroline": { - "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines.", - "editType": "plot", + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "histogram": { + "meta": { + "description": "The sample data from which statistics are computed is set in `x` for vertically spanning histograms and in `y` for horizontally spanning histograms. Binning options are set `xbins` and `ybins` respectively if no aggregation data is provided." + }, + "attributes": { + "type": "histogram", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "boolean" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, - "zerolinecolor": { - "description": "Sets the line color of the zero line.", - "dflt": "#444", - "editType": "plot", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "zerolinewidth": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 1, - "editType": "plot", - "role": "style", - "valType": "number" - } - } - }, - "selectdirection": { - "description": "When \"dragmode\" is set to \"select\", this limits the selection of the drag to horizontal, vertical or diagonal. \"h\" only allows horizontal selection, \"v\" only vertical, \"d\" only diagonal and \"any\" sets no limit.", - "dflt": "any", - "editType": "none", - "role": "info", - "valType": "enumerated", - "values": [ - "h", - "v", - "d", - "any" - ] - }, - "separators": { - "description": "Sets the decimal and thousand separators. For example, *. * puts a '.' before decimals and a space between thousands. In English locales, dflt is *.,* but other locales may alter this default.", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "shapes": { - "items": { - "shape": { - "editType": "arraydraw", - "fillcolor": { - "description": "Sets the color filling the shape's interior.", - "dflt": "rgba(0,0,0,0)", - "editType": "arraydraw", - "role": "info", - "valType": "color" - }, - "layer": { - "description": "Specifies whether shapes are drawn below or above traces.", - "dflt": "above", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "below", - "above" - ] - }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "arraydraw", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "calcIfAutorange+arraydraw", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "calcIfAutorange+arraydraw", - "min": 0, - "role": "style", - "valType": "number" - } + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "opacity": { - "description": "Sets the opacity of the shape.", - "dflt": 1, - "editType": "arraydraw", - "max": 1, - "min": 0, - "role": "info", - "valType": "number" + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true }, - "path": { - "description": "For `type` *path* - a valid SVG path with the pixel values replaced by data values in `xsizemode`/`ysizemode` being *scaled* and taken unmodified as pixels relative to `xanchor` and `yanchor` in case of *pixel* size mode. There are a few restrictions / quirks only absolute instructions, not relative. So the allowed segments are: M, L, H, V, Q, C, T, S, and Z arcs (A) are not allowed because radius rx and ry are relative. In the future we could consider supporting relative commands, but we would have to decide on how to handle date and log axes. Note that even as is, Q and C Bezier paths that are smooth on linear axes may not be smooth on log, and vice versa. no chained \"polybezier\" commands - specify the segment type for each one. On category axes, values are numbers scaled to the serial numbers of categories because using the categories themselves there would be no way to describe fractional positions On data axes: because space and T are both normal components of path strings, we can't use either to separate date from time parts. Therefore we'll use underscore for this purpose: 2015-02-21_13:45:56.789", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "string" + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true }, + "editType": "none", + "description": "Sets the font used in hover labels.", "role": "object", - "type": { - "description": "Specifies the shape type to be drawn. If *line*, a line is drawn from (`x0`,`y0`) to (`x1`,`y1`) with respect to the axes' sizing mode. If *circle*, a circle is drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) with respect to the axes' sizing mode. If *rect*, a rectangle is drawn linking (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) with respect to the axes' sizing mode. If *path*, draw a custom SVG path using `path`. with respect to the axes' sizing mode.", - "editType": "calcIfAutorange+arraydraw", + "familysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "circle", - "rect", - "path", - "line" - ] + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this shape is visible.", - "dflt": true, - "editType": "calcIfAutorange+arraydraw", + "sizesrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "x0": { - "description": "Sets the shape's starting x position. See `type` and `xsizemode` for more info.", - "editType": "calcIfAutorange+arraydraw", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the x axis.", + "role": "data" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the y axis.", + "role": "data" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." + }, + "orientation": { + "valType": "enumerated", + "role": "info", + "values": [ + "v", + "h" + ], + "editType": "calc+clearAxisTypes", + "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal)." + }, + "histfunc": { + "valType": "enumerated", + "values": [ + "count", + "sum", + "avg", + "min", + "max" + ], + "role": "style", + "dflt": "count", + "editType": "calc", + "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively." + }, + "histnorm": { + "valType": "enumerated", + "values": [ + "", + "percent", + "probability", + "density", + "probability density" + ], + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1)." + }, + "cumulative": { + "enabled": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "If true, display the cumulative distribution by summing the binned values. Use the `direction` and `centralbin` attributes to tune the accumulation method. Note: in this mode, the *density* `histnorm` settings behave the same as their equivalents without *density*: ** and *density* both rise to the number of data points, and *probability* and *probability density* both rise to the number of sample points." + }, + "direction": { + "valType": "enumerated", + "values": [ + "increasing", + "decreasing" + ], + "dflt": "increasing", + "role": "info", + "editType": "calc", + "description": "Only applies if cumulative is enabled. If *increasing* (default) we sum all prior bins, so the result increases from left to right. If *decreasing* we sum later bins so the result decreases from left to right." + }, + "currentbin": { + "valType": "enumerated", + "values": [ + "include", + "exclude", + "half" + ], + "dflt": "include", + "role": "info", + "editType": "calc", + "description": "Only applies if cumulative is enabled. Sets whether the current bin is included, excluded, or has half of its value included in the current cumulative value. *include* is the default for compatibility with various other tools, however it introduces a half-bin bias to the results. *exclude* makes the opposite half-bin bias, and *half* removes it." + }, + "editType": "calc", + "role": "object" + }, + "autobinx": { + "valType": "boolean", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins." + }, + "nbinsx": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." + }, + "xbins": { + "start": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false }, - "x1": { - "description": "Sets the shape's end x position. See `type` and `xsizemode` for more info.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" + "description": "Sets the starting value for the x axis bins." + }, + "end": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false }, - "xanchor": { - "description": "Only relevant in conjunction with `xsizemode` set to *pixel*. Specifies the anchor point on the x axis to which `x0`, `x1` and x coordinates within `path` are relative to. E.g. useful to attach a pixel sized shape to a certain data value. No effect when `xsizemode` not set to *pixel*.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" + "description": "Sets the end value for the x axis bins." + }, + "size": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false }, - "xref": { - "description": "Sets the shape's x coordinate axis. If set to an x axis id (e.g. *x* or *x2*), the `x` position refers to an x coordinate. If set to *paper*, the `x` position refers to the distance from the left side of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right) side. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, then you must convert the date to unix time in milliseconds.", + "description": "Sets the step in-between value each x axis bin." + }, + "editType": "calc", + "impliedEdits": { + "autobinx": false, + "role": "object" + }, + "role": "object" + }, + "autobiny": { + "valType": "boolean", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins." + }, + "nbinsy": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." + }, + "ybins": { + "start": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the starting value for the y axis bins." + }, + "end": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the end value for the y axis bins." + }, + "size": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the step in-between value each y axis bin." + }, + "editType": "calc", + "impliedEdits": { + "autobiny": false, + "role": "object" + }, + "role": "object" + }, + "marker": { + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points.", + "dflt": 0 + }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "paper", - "/^x([2-9]|[1-9][0-9]+)?$/" - ] + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "xsizemode": { - "description": "Sets the shapes's sizing mode along the x axis. If set to *scaled*, `x0`, `x1` and x coordinates within `path` refer to data values on the x axis or a fraction of the plot area's width (`xref` set to *paper*). If set to *pixel*, `xanchor` specifies the x position in terms of data or plot fraction but `x0`, `x1` and x coordinates within `path` are pixels relative to `xanchor`. This way, the shape can have a fixed width while maintaining a position relative to data or plot fraction.", - "dflt": "scaled", - "editType": "calcIfAutorange+arraydraw", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "scaled", - "pixel" - ] + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "y0": { - "description": "Sets the shape's starting y position. See `type` and `ysizemode` for more info.", - "editType": "calcIfAutorange+arraydraw", + "cmax": { + "valType": "number", "role": "info", - "valType": "any" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." }, - "y1": { - "description": "Sets the shape's end y position. See `type` and `ysizemode` for more info.", - "editType": "calcIfAutorange+arraydraw", + "cmin": { + "valType": "number", "role": "info", - "valType": "any" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." }, - "yanchor": { - "description": "Only relevant in conjunction with `ysizemode` set to *pixel*. Specifies the anchor point on the y axis to which `y0`, `y1` and y coordinates within `path` are relative to. E.g. useful to attach a pixel sized shape to a certain data value. No effect when `ysizemode` not set to *pixel*.", - "editType": "calcIfAutorange+arraydraw", - "role": "info", - "valType": "any" + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "yref": { - "description": "Sets the annotation's y coordinate axis. If set to an y axis id (e.g. *y* or *y2*), the `y` position refers to an y coordinate If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top).", + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "widthsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "paper", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" }, - "ysizemode": { - "description": "Sets the shapes's sizing mode along the y axis. If set to *scaled*, `y0`, `y1` and y coordinates within `path` refer to data values on the y axis or a fraction of the plot area's height (`yref` set to *paper*). If set to *pixel*, `yanchor` specifies the y position in terms of data or plot fraction but `y0`, `y1` and y coordinates within `path` are pixels relative to `yanchor`. This way, the shape can have a fixed height while maintaining a position relative to data or plot fraction.", - "dflt": "scaled", - "editType": "calcIfAutorange+arraydraw", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "scaled", - "pixel" - ] + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } - } - }, - "role": "object" - }, - "showlegend": { - "description": "Determines whether or not a legend is drawn.", - "editType": "legend", - "role": "info", - "valType": "boolean" - }, - "sliders": { - "items": { - "slider": { - "active": { - "description": "Determines which button (by index starting from 0) is considered active.", - "dflt": 0, - "editType": "arraydraw", - "min": 0, - "role": "info", - "valType": "number" + }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false }, - "activebgcolor": { - "description": "Sets the background color of the slider grip while dragging.", - "dflt": "#dbdde0", - "editType": "arraydraw", - "role": "style", - "valType": "color" + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "bgcolor": { - "description": "Sets the background color of the slider.", - "dflt": "#f8fafc", - "editType": "arraydraw", - "role": "style", - "valType": "color" + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "bordercolor": { - "description": "Sets the color of the border enclosing the slider.", - "dflt": "#bec8d9", - "editType": "arraydraw", + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the slider.", - "dflt": 1, - "editType": "arraydraw", - "min": 0, + "thickness": { + "valType": "number", "role": "style", - "valType": "number" - }, - "currentvalue": { - "editType": "arraydraw", - "font": { - "color": { - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "description": "Sets the font of the current value label text.", - "editType": "arraydraw", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "arraydraw", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "arraydraw", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "offset": { - "description": "The amount of space, in pixels, between the current value label and the slider.", - "dflt": 10, - "editType": "arraydraw", - "role": "info", - "valType": "number" - }, - "prefix": { - "description": "When currentvalue.visible is true, this sets the prefix of the label.", - "editType": "arraydraw", - "role": "info", - "valType": "string" - }, - "role": "object", - "suffix": { - "description": "When currentvalue.visible is true, this sets the suffix of the label.", - "editType": "arraydraw", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Shows the currently-selected value above the slider.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "xanchor": { - "description": "The alignment of the value readout relative to the length of the slider.", - "dflt": "left", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - } - }, - "editType": "arraydraw", - "font": { - "color": { - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "description": "Sets the font of the slider step labels.", - "editType": "arraydraw", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "arraydraw", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "arraydraw", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "len": { - "description": "Sets the length of the slider This measure excludes the padding of both ends. That is, the slider's length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "arraydraw", "min": 0, - "role": "style", - "valType": "number" + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, "lenmode": { - "description": "Determines whether this slider length is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "arraydraw", - "role": "info", "valType": "enumerated", "values": [ "fraction", "pixels" - ] + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "minorticklen": { - "description": "Sets the length in pixels of minor step tick marks", - "dflt": 4, - "editType": "arraydraw", + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "pad": { - "b": { - "description": "The amount of padding (in px) along the bottom of the component.", - "dflt": 0, - "editType": "arraydraw", - "role": "style", - "valType": "number" + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" + }, + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - "description": "Set the padding of the slider component along each side.", - "editType": "arraydraw", - "l": { - "description": "The amount of padding (in px) on the left side of the component.", - "dflt": 0, - "editType": "arraydraw", + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "number" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "r": { - "description": "The amount of padding (in px) on the right side of the component.", - "dflt": 0, - "editType": "arraydraw", + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "colorbars" }, - "role": "object", - "t": { - "description": "The amount of padding (in px) along the top of the component.", - "dflt": 20, - "editType": "arraydraw", + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" }, - "role": "object", - "steps": { + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { "items": { - "step": { - "args": { - "description": "Sets the arguments values to be passed to the Plotly method set in `method` on slide.", - "editType": "arraydraw", - "freeLength": true, + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", "items": [ { - "editType": "arraydraw", - "valType": "any" - }, - { - "editType": "arraydraw", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "arraydraw", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" - }, - "editType": "arraydraw", - "execute": { - "description": "When true, the API method is executed. When false, all other behaviors are the same and command execution is skipped. This may be useful when hooking into, for example, the `plotly_sliderchange` method and executing the API command manually without losing the benefit of the slider automatically binding to the state of the plot through the specification of `method` and `args`.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "label": { - "description": "Sets the text label to appear on the slider", - "editType": "arraydraw", - "role": "info", - "valType": "string" - }, - "method": { - "description": "Sets the Plotly method to be called when the slider value is changed. If the `skip` method is used, the API slider will function as normal but will perform no API calls and will not bind automatically to state updates. This may be used to create a component interface and attach to slider events manually via JavaScript.", - "dflt": "restyle", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "restyle", - "relayout", - "animate", - "update", - "skip" - ] + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "role": "object", "value": { - "description": "Sets the value of the slider step, used to refer to the step programatically. Defaults to the slider label if not provided.", - "editType": "arraydraw", - "role": "info", - "valType": "string" - } + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "tickcolor": { - "description": "Sets the color of the border enclosing the slider.", - "dflt": "#333", - "editType": "arraydraw", + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "ticklen": { - "description": "Sets the length in pixels of step tick marks", - "dflt": 7, - "editType": "arraydraw", - "min": 0, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "arraydraw", - "min": 0, + "ticksuffix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "number" - }, - "transition": { - "duration": { - "description": "Sets the duration of the slider transition", - "dflt": 150, - "editType": "arraydraw", - "min": 0, - "role": "info", - "valType": "number" - }, - "easing": { - "description": "Sets the easing function of the slider transition", - "dflt": "cubic-in-out", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "linear", - "quad", - "cubic", - "sin", - "exp", - "circle", - "elastic", - "back", - "bounce", - "linear-in", - "quad-in", - "cubic-in", - "sin-in", - "exp-in", - "circle-in", - "elastic-in", - "back-in", - "bounce-in", - "linear-out", - "quad-out", - "cubic-out", - "sin-out", - "exp-out", - "circle-out", - "elastic-out", - "back-out", - "bounce-out", - "linear-in-out", - "quad-in-out", - "cubic-in-out", - "sin-in-out", - "exp-in-out", - "circle-in-out", - "elastic-in-out", - "back-in-out", - "bounce-in-out" - ] - }, - "editType": "arraydraw", - "role": "object" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "visible": { - "description": "Determines whether or not the slider is visible.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "x": { - "description": "Sets the x position (in normalized coordinates) of the slider.", - "dflt": 0, - "editType": "arraydraw", - "max": 3, - "min": -2, + "separatethousands": { + "valType": "boolean", + "dflt": false, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "xanchor": { - "description": "Sets the slider's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector.", - "dflt": "left", - "editType": "arraydraw", - "role": "info", + "exponentformat": { "valType": "enumerated", "values": [ - "auto", - "left", - "center", - "right" - ] + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "y": { - "description": "Sets the y position (in normalized coordinates) of the slider.", - "dflt": 0, - "editType": "arraydraw", - "max": 3, - "min": -2, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, - "yanchor": { - "description": "Sets the slider's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector.", - "dflt": "top", - "editType": "arraydraw", + "title": { + "valType": "string", "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" + }, + "titleside": { "valType": "enumerated", "values": [ - "auto", + "right", "top", - "middle", "bottom" - ] - } - } - }, - "role": "object" - }, - "spikedistance": { - "description": "Sets the default distance (in pixels) to look for data to draw spikelines to (-1 means no cutoff, 0 means no looking for data). As with hoverdistance, distance does not apply to area-like objects. In addition, some objects can be hovered on but will not generate spikelines, such as scatter fills.", - "dflt": 20, - "editType": "none", - "min": -1, - "role": "info", - "valType": "integer" - }, - "ternary": { - "_isSubplotObj": true, - "aaxis": { - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "role": "style", - "valType": "any" - }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "plot", - "role": "style", - "valType": "color" + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", + "opacity": { + "valType": "number", + "arrayOk": true, "dflt": 1, - "editType": "plot", "min": 0, + "max": 1, "role": "style", - "valType": "number" - }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "editType": "style", + "description": "Sets the opacity of the bars." }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", + "role": "object", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] - }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" }, - "min": { - "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", - "dflt": 0, - "editType": "plot", - "min": 0, + "opacitysrc": { + "valType": "string", "role": "info", - "valType": "number" - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 6, - "editType": "plot", - "min": 1, - "role": "style", - "valType": "integer" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + } + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of selected points." + }, + "editType": "style", + "role": "object" }, - "tickfont": { + "textfont": { "color": { - "editType": "plot", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the text font color of selected points." }, - "description": "Sets the tick font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "role": "style", - "strict": true, - "valType": "string" + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, + "editType": "style", "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, - "role": "info", + "editType": "style", + "role": "object" + }, + "_deprecated": { + "bardir": { "valType": "enumerated", + "role": "info", + "editType": "calc", "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "v", + "h" + ], + "description": "Renamed to `orientation`." + } + }, + "error_x": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", - "role": "style", + "type": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "symmetric": { + "valType": "boolean", "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", + "min": 0, + "dflt": 10, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", + "valueminus": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "title": { - "description": "Sets the title of this axis.", - "editType": "plot", + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" + "editType": "style" }, - "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" - } - } - }, - "baxis": { - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + "copy_ystyle": { + "valType": "boolean", "role": "style", - "valType": "any" + "editType": "plot" }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "plot", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", + "width": { + "valType": "number", "min": 0, "role": "style", - "valType": "number" - }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", "editType": "plot", - "role": "style", - "valType": "string" + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_y": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." }, - "min": { - "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", - "dflt": 0, - "editType": "plot", - "min": 0, + "type": { + "valType": "enumerated", + "values": [ + "percent", + "constant", + "sqrt", + "data" + ], "role": "info", - "valType": "number" + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 6, - "editType": "plot", - "min": 1, - "role": "style", - "valType": "integer" + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "value": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "style" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "style", + "description": "Sets the stoke color of the error bars." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", - "impliedEdits": { - "tickmode": "linear" - }, + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "any" + "editType": "style", + "description": "Sets the thickness (in px) of the error bars." }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", "editType": "plot", - "role": "style", - "valType": "color" + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "editType": "style", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "plot", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, + "arrayminussrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + }, + "layoutAttributes": { + "barmode": { + "valType": "enumerated", + "values": [ + "stack", + "group", + "overlay", + "relative" + ], + "dflt": "group", + "role": "info", + "editType": "calc", + "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to an *opacity* to see multiple bars." + }, + "barnorm": { + "valType": "enumerated", + "values": [ + "", + "fraction", + "percent" + ], + "dflt": "", + "role": "info", + "editType": "calc", + "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divide by the sum of the values at the location coordinate. With *percent*, the results form *fraction* are presented in percents." + }, + "bargap": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates." + }, + "bargroupgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between bars of the same location coordinate." + } + } + }, + "histogram2d": { + "meta": { + "hrName": "histogram_2d", + "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a heatmap." + }, + "attributes": { + "type": "histogram2d", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "plot", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "string" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "plot", + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the x axis.", + "role": "data" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the y axis.", + "role": "data" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the aggregation data.", + "role": "data" + }, + "marker": { + "color": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the aggregation data.", + "role": "data" + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "bgcolor": { - "description": "Set the background color of the subplot", - "dflt": "#fff", - "editType": "plot", + "histnorm": { + "valType": "enumerated", + "values": [ + "", + "percent", + "probability", + "density", + "probability density" + ], + "dflt": "", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1)." }, - "caxis": { - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", + "histfunc": { + "valType": "enumerated", + "values": [ + "count", + "sum", + "avg", + "min", + "max" + ], + "role": "style", + "dflt": "count", + "editType": "calc", + "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively." + }, + "autobinx": { + "valType": "boolean", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins." + }, + "nbinsx": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." + }, + "xbins": { + "start": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "color" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "plot", + "editType": "calc", "impliedEdits": { - "tickmode": "linear" + "^autobinx": false }, - "role": "style", - "valType": "any" - }, - "editType": "plot", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "description": "Sets the starting value for the x axis bins." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "plot", + "end": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "^autobinx": false + }, + "description": "Sets the end value for the x axis bins." }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "plot", - "min": 0, + "size": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "number" + "editType": "calc", + "impliedEdits": { + "^autobinx": false + }, + "description": "Sets the step in-between value each x axis bin." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" + "editType": "calc", + "impliedEdits": { + "autobinx": false, + "role": "object" }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] + "role": "object" + }, + "autobiny": { + "valType": "boolean", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins." + }, + "nbinsy": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." + }, + "ybins": { + "start": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the starting value for the y axis bins." }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "plot", + "end": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the end value for the y axis bins." }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "plot", - "min": 0, + "size": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "number" + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the step in-between value each y axis bin." }, - "min": { - "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", - "dflt": 0, - "editType": "plot", + "editType": "calc", + "impliedEdits": { + "autobiny": false, + "role": "object" + }, + "role": "object" + }, + "xgap": { + "valType": "number", + "dflt": 0, + "min": 0, + "role": "style", + "editType": "plot", + "description": "Sets the horizontal gap (in pixels) between bricks." + }, + "ygap": { + "valType": "number", + "dflt": 0, + "min": 0, + "role": "style", + "editType": "plot", + "description": "Sets the vertical gap (in pixels) between bricks." + }, + "zsmooth": { + "valType": "enumerated", + "values": [ + "fast", + "best", + false + ], + "dflt": false, + "role": "style", + "editType": "calc", + "description": "Picks a smoothing algorithm use to smooth `z` data." + }, + "zhoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format" + }, + "zauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." + }, + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." + }, + "zmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Reverses the colorscale." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" + }, + "thickness": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "info", - "valType": "number" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 6, - "editType": "plot", - "min": 1, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "integer" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "plot", + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "boolean" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "plot", + "xpad": { + "valType": "number", "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "plot", + "ypad": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": true, - "editType": "plot", + "outlinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the axis line color." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "plot", + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "plot", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "colorbars", + "description": "Sets the axis line color." }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "plot", + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "plot", + "valType": "any", + "role": "style", + "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", "role": "style", - "valType": "any" + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "plot", + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "plot", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "plot", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "plot", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "plot", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "plot", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "plot", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "plot", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "plot", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "plot", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "plot", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "plot", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of this axis.", - "editType": "plot", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "plot", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } - } - }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this ternary subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, - "editType": "plot", + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this ternary subplot .", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this ternary subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "info_array" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "y": { - "description": "Sets the vertical domain of this ternary subplot (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot", - "items": [ - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "plot", - "role": "object", - "sum": { - "description": "The number each triplet should sum to, and the maximum range of each axis", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - } - }, - "title": { - "description": "Sets the plot's title.", - "editType": "layoutstyle", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "layoutstyle", - "role": "style", - "valType": "color" - }, - "description": "Sets the title font.", - "editType": "layoutstyle", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "layoutstyle", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "layoutstyle", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "updatemenus": { - "items": { - "updatemenu": { - "_arrayAttrRegexps": [ - {} - ], - "active": { - "description": "Determines which button (by index starting from 0) is considered active.", - "dflt": 0, - "editType": "arraydraw", - "min": -1, - "role": "info", - "valType": "integer" - }, - "bgcolor": { - "description": "Sets the background color of the update menu buttons.", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the color of the border enclosing the update menu.", - "dflt": "#BEC8D9", - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the update menu.", - "dflt": 1, - "editType": "arraydraw", - "min": 0, - "role": "style", - "valType": "number" - }, - "buttons": { - "items": { - "button": { - "args": { - "description": "Sets the arguments values to be passed to the Plotly method set in `method` on click.", - "editType": "arraydraw", - "freeLength": true, - "items": [ - { - "editType": "arraydraw", - "valType": "any" - }, - { - "editType": "arraydraw", - "valType": "any" - }, - { - "editType": "arraydraw", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "arraydraw", - "execute": { - "description": "When true, the API method is executed. When false, all other behaviors are the same and command execution is skipped. This may be useful when hooking into, for example, the `plotly_buttonclicked` method and executing the API command manually without losing the benefit of the updatemenu automatically binding to the state of the plot through the specification of `method` and `args`.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "label": { - "description": "Sets the text label to appear on the button.", - "dflt": "", - "editType": "arraydraw", - "role": "info", - "valType": "string" - }, - "method": { - "description": "Sets the Plotly method to be called on click. If the `skip` method is used, the API updatemenu will function as normal but will perform no API calls and will not bind automatically to state updates. This may be used to create a component interface and attach to updatemenu events manually via JavaScript.", - "dflt": "restyle", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "restyle", - "relayout", - "animate", - "update", - "skip" - ] - }, - "role": "object" - } - }, - "role": "object" - }, - "direction": { - "description": "Determines the direction in which the buttons are laid out, whether in a dropdown menu or a row/column of buttons. For `left` and `up`, the buttons will still appear in left-to-right or top-to-bottom order respectively.", - "dflt": "down", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "left", - "right", - "up", - "down" - ] - }, - "editType": "arraydraw", - "font": { - "color": { - "editType": "arraydraw", - "role": "style", - "valType": "color" - }, - "description": "Sets the font of the update menu button text.", - "editType": "arraydraw", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "arraydraw", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "arraydraw", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "pad": { - "b": { - "description": "The amount of padding (in px) along the bottom of the component.", - "dflt": 0, - "editType": "arraydraw", - "role": "style", - "valType": "number" - }, - "description": "Sets the padding around the buttons or dropdown menu.", - "editType": "arraydraw", - "l": { - "description": "The amount of padding (in px) on the left side of the component.", - "dflt": 0, - "editType": "arraydraw", - "role": "style", - "valType": "number" - }, - "r": { - "description": "The amount of padding (in px) on the right side of the component.", - "dflt": 0, - "editType": "arraydraw", - "role": "style", - "valType": "number" - }, - "role": "object", - "t": { - "description": "The amount of padding (in px) along the top of the component.", - "dflt": 0, - "editType": "arraydraw", - "role": "style", - "valType": "number" - } - }, - "role": "object", - "showactive": { - "description": "Highlights active dropdown item or active button if true.", - "dflt": true, - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "type": { - "description": "Determines whether the buttons are accessible via a dropdown menu or whether the buttons are stacked horizontally or vertically", - "dflt": "dropdown", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "dropdown", - "buttons" - ] - }, - "visible": { - "description": "Determines whether or not the update menu is visible.", - "editType": "arraydraw", - "role": "info", - "valType": "boolean" - }, - "x": { - "description": "Sets the x position (in normalized coordinates) of the update menu.", - "dflt": -0.05, - "editType": "arraydraw", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets the update menu's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector.", - "dflt": "right", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "left", - "center", - "right" - ] - }, - "y": { - "description": "Sets the y position (in normalized coordinates) of the update menu.", - "dflt": 1, - "editType": "arraydraw", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets the update menu's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector.", - "dflt": "top", - "editType": "arraydraw", - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "top", - "middle", - "bottom" - ] - } - } - }, - "role": "object" - }, - "width": { - "description": "Sets the plot's width (in px).", - "dflt": 700, - "editType": "plot", - "min": 10, - "role": "info", - "valType": "number" - }, - "xaxis": { - "_deprecated": { - "autotick": { - "description": "Obsolete. Set `tickmode` to *auto* for old `autotick` *true* behavior. Set `tickmode` to *linear* for `autotick` *false*.", - "editType": "ticks+margins", + "ticktextsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "_isSubplotObj": true, - "anchor": { - "description": "If set to an opposite-letter axis id (e.g. `x2`, `y`), this axis is bound to the corresponding opposite-letter axis. If set to *free*, this axis' position is determined by `position`.", - "editType": "plot+margins", - "role": "info", + "xcalendar": { "valType": "enumerated", "values": [ - "free", - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "automargin": { - "description": "Determines whether long tick labels automatically grow the figure margins.", - "dflt": false, - "editType": "ticks+margins", - "role": "style", - "valType": "boolean" - }, - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] - }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", "dflt": "gregorian", - "editType": "calc", - "role": "info", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { "valType": "enumerated", "values": [ "gregorian", @@ -7684,2501 +7910,1902 @@ "taiwan", "thai", "ummalqura" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "calc", + "yaxis": { + "valType": "subplotid", "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "constrain": { - "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines how that happens: by increasing the *range* (default), or by decreasing the *domain*.", - "dflt": "range", - "editType": "plot", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "range", - "domain" - ] + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "constraintoward": { - "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines which direction we push the originally specified plot area. Options are *left*, *center* (default), and *right* for x axes, and *top*, *middle* (default), and *bottom* for y axes.", - "editType": "plot", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "left", - "center", - "right", - "top", - "middle", - "bottom" - ] + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "domain": { - "description": "Sets the domain of this axis (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot+margins", - "items": [ - { - "editType": "plot+margins", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot+margins", - "max": 1, - "min": 0, - "valType": "number" - } - ], + "xsrc": { + "valType": "string", "role": "info", - "valType": "info_array" + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "ticks+margins", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "ticks+margins", - "role": "style", + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + } + } + }, + "histogram2dcontour": { + "meta": { + "hrName": "histogram_2d_contour", + "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a contour plot." + }, + "attributes": { + "type": "histogram2dcontour", + "visible": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "fixedrange": { - "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled.", - "dflt": false, + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "boolean" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "ticks", - "role": "style", - "valType": "color" + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "ticks", - "min": 0, + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", + "uid": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] + "dflt": "", + "editType": "calc" }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "layoutstyle", - "role": "style", - "valType": "color" + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "ticks+layoutstyle", - "min": 0, - "role": "style", - "valType": "number" - }, - "mirror": { - "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots.", - "dflt": false, - "editType": "ticks+layoutstyle", - "role": "style", - "valType": "enumerated", - "values": [ - true, - "ticks", - false, - "all", - "allticks" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "ticks+margins", - "min": 0, - "role": "style", - "valType": "integer" + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "overlaying": { - "description": "If set a same-letter axis id, this axis is overlaid on top of the corresponding same-letter axis. If *false*, this axis does not overlay any same-letter axes.", - "editType": "plot", + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "enumerated", - "values": [ - "free", - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "position": { - "description": "Sets the position of this axis in the plotting space (in normalized coordinates). Only has an effect if `anchor` is set to *free*.", - "dflt": 0, - "editType": "plot+margins", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "axrange+margins", - "impliedEdits": { - "autorange": false - }, - "items": [ - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], + "hoverinfo": { + "valType": "flaglist", "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, - "rangeselector": { - "activecolor": { - "description": "Sets the background color of the active range selector button.", - "editType": "plot", - "role": "style", - "valType": "color" - }, + "hoverlabel": { "bgcolor": { - "description": "Sets the background color of the range selector buttons.", - "dflt": "#eee", - "editType": "plot", + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "description": "Sets the color of the border enclosing the range selector.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) of the border enclosing the range selector.", - "dflt": 0, - "editType": "plot", - "min": 0, + "valType": "color", "role": "style", - "valType": "number" - }, - "buttons": { - "items": { - "button": { - "count": { - "description": "Sets the number of steps to take to update the range. Use with `step` to specify the update interval.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "description": "Sets the specifications for each buttons. By default, a range selector comes with no buttons.", - "editType": "plot", - "label": { - "description": "Sets the text label to appear on the button.", - "editType": "plot", - "role": "info", - "valType": "string" - }, - "role": "object", - "step": { - "description": "The unit of measurement that the `count` value will set the range by.", - "dflt": "month", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "month", - "year", - "day", - "hour", - "minute", - "second", - "all" - ] - }, - "stepmode": { - "description": "Sets the range update mode. If *backward*, the range update shifts the start of range back *count* times *step* milliseconds. If *todate*, the range update shifts the start of range back to the first timestamp from *count* times *step* milliseconds back. For example, with `step` set to *year* and `count` set to *1* the range update shifts the start of the range back to January 01 of the current year. Month and year *todate* are currently available only for the built-in (Gregorian) calendar.", - "dflt": "backward", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "backward", - "todate" - ] - } - } - }, - "role": "object" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "plot", "font": { - "color": { - "editType": "plot", - "role": "style", - "valType": "color" - }, - "description": "Sets the font of the range selector button text.", - "editType": "plot", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "plot", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object", - "visible": { - "description": "Determines whether or not this range selector is visible. Note that range selectors are only available for x axes of `type` set to or auto-typed to *date*.", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "x": { - "description": "Sets the x position (in normalized coordinates) of the range selector.", - "editType": "plot", - "max": 3, - "min": -2, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "xanchor": { - "description": "Sets the range selector's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector.", - "dflt": "left", - "editType": "plot", + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "left", - "center", - "right" - ] + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "y": { - "description": "Sets the y position (in normalized coordinates) of the range selector.", - "editType": "plot", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "yanchor": { - "description": "Sets the range selector's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector.", - "dflt": "bottom", - "editType": "plot", + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "top", - "middle", - "bottom" - ] + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" } }, - "rangeslider": { - "autorange": { - "description": "Determines whether or not the range slider range is computed in relation to the input data. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "bgcolor": { - "description": "Sets the background color of the range slider.", - "dflt": "#fff", - "editType": "plot", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the border color of the range slider.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "borderwidth": { - "description": "Sets the border color of the range slider.", - "dflt": 0, - "editType": "plot", + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "integer" + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, "editType": "calc", - "range": { - "description": "Sets the range of the range slider. If not set, defaults to the full xaxis range. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the x axis.", + "role": "data" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the sample data to be binned on the y axis.", + "role": "data" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the aggregation data.", + "role": "data" + }, + "marker": { + "color": { + "valType": "data_array", "editType": "calc", - "impliedEdits": { - "autorange": false - }, - "items": [ - { - "editType": "calc", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "calc", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" + "description": "Sets the aggregation data.", + "role": "data" }, + "editType": "calc", "role": "object", - "thickness": { - "description": "The height of the range slider as a fraction of the total plot area height.", - "dflt": 0.15, - "editType": "plot", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not the range slider will be visible. If visible, perpendicular axes will be set to `fixedrange`", - "dflt": true, - "editType": "calc", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "yaxis": { - "_isSubplotObj": true, - "editType": "calc", - "range": { - "description": "Sets the range of this axis for the rangeslider.", - "editType": "plot", - "items": [ - { - "editType": "plot", - "valType": "any" - }, - { - "editType": "plot", - "valType": "any" - } - ], - "role": "style", - "valType": "info_array" - }, - "rangemode": { - "description": "Determines whether or not the range of this axis in the rangeslider use the same value than in the main plot when zooming in/out. If *auto*, the autorange will be used. If *fixed*, the `range` is used. If *match*, the current range of the corresponding y-axis on the main subplot is used.", - "dflt": "match", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "auto", - "fixed", - "match" - ] - }, - "role": "object" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object", - "scaleanchor": { - "description": "If set to another axis id (e.g. `x2`, `y`), the range of this axis changes together with the range of the corresponding axis such that the scale of pixels per unit is in a constant ratio. Both axes are still zoomable, but when you zoom one, the other will zoom the same amount, keeping a fixed midpoint. `constrain` and `constraintoward` determine how we enforce the constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you can only link axes of the same `type`. The linked axis can have the opposite letter (to constrain the aspect ratio) or the same letter (to match scales across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: {scaleanchor: *y*}` or longer) are redundant and the last constraint encountered will be ignored to avoid possible inconsistent constraints via `scaleratio`.", - "editType": "plot", - "role": "info", + "histnorm": { "valType": "enumerated", "values": [ - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "scaleratio": { - "description": "If this axis is linked to another by `scaleanchor`, this determines the pixel to unit scale ratio. For example, if this value is 10, then every unit on this axis spans 10 times the number of pixels as a unit on the linked axis. Use this for example to create an elevation profile where the vertical scale is exaggerated a fixed amount with respect to the horizontal.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "ticks+margins", + "", + "percent", + "probability", + "density", + "probability density" + ], + "dflt": "", "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1)." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "ticks+margins", - "role": "style", + "histfunc": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "editType": "ticks", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "layoutstyle", - "role": "style", - "valType": "boolean" - }, - "showspikes": { - "description": "Determines whether or not spikes (aka droplines) are drawn for this axis. Note: This only takes affect when hovermode = closest", - "dflt": false, - "editType": "modebar", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "ticks+margins", + "count", + "sum", + "avg", + "min", + "max" + ], "role": "style", - "valType": "boolean" + "dflt": "count", + "editType": "calc", + "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "ticks+margins", + "autobinx": { + "valType": "boolean", + "dflt": null, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins." }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "ticks+margins", + "nbinsx": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." }, - "side": { - "description": "Determines whether a x (y) axis is positioned at the *bottom* (*left*) or *top* (*right*) of the plotting area.", - "editType": "plot+margins", - "role": "info", - "valType": "enumerated", - "values": [ - "top", - "bottom", - "left", - "right" - ] + "xbins": { + "start": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false + }, + "description": "Sets the starting value for the x axis bins." + }, + "end": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false + }, + "description": "Sets the end value for the x axis bins." + }, + "size": { + "valType": "any", + "dflt": null, + "role": "style", + "editType": "calc", + "impliedEdits": { + "^autobinx": false + }, + "description": "Sets the step in-between value each x axis bin." + }, + "editType": "calc", + "impliedEdits": { + "autobinx": false, + "role": "object" + }, + "role": "object" }, - "spikecolor": { - "description": "Sets the spike color. If undefined, will use the series color", + "autobiny": { + "valType": "boolean", "dflt": null, - "editType": "none", - "role": "style", - "valType": "color" - }, - "spikedash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "dash", - "editType": "none", "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins." }, - "spikemode": { - "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on", - "dflt": "toaxis", - "editType": "none", - "flags": [ - "toaxis", - "across", - "marker" - ], + "nbinsy": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "style", - "valType": "flaglist" + "editType": "calc", + "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data." }, - "spikesnap": { - "description": "Determines whether spikelines are stuck to the cursor or to the closest datapoints.", - "dflt": "data", - "editType": "none", - "role": "style", - "valType": "enumerated", - "values": [ - "data", - "cursor" - ] - }, - "spikethickness": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 3, - "editType": "none", - "role": "style", - "valType": "number" - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "ticks+margins", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "ticks+margins", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "ticks+margins", + "ybins": { + "start": { + "valType": "any", + "dflt": null, "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the starting value for the y axis bins." }, - "description": "Sets the tick font.", - "editType": "ticks+margins", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "ticks+margins", - "noBlank": true, + "end": { + "valType": "any", + "dflt": null, "role": "style", - "strict": true, - "valType": "string" + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the end value for the y axis bins." }, - "role": "object", "size": { - "editType": "ticks+margins", - "min": 1, + "valType": "any", + "dflt": null, "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "ticks+margins", - "items": [ - { - "editType": "ticks+margins", - "valType": "any" - }, - { - "editType": "ticks+margins", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "ticks+margins", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - } - } + "editType": "calc", + "impliedEdits": { + "^autobiny": false + }, + "description": "Sets the step in-between value each y axis bin." + }, + "editType": "calc", + "impliedEdits": { + "autobiny": false, + "role": "object" }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "ticks", - "min": 0, + "autocontour": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "ticks+margins", + "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "ticks+margins", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "ticks+margins", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "ticks+margins", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "ticks", - "min": 0, + "ncontours": { + "valType": "integer", + "dflt": 15, + "min": 1, "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "ticks+margins", - "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing." }, - "titlefont": { - "color": { - "editType": "ticks+margins", + "contours": { + "type": { + "valType": "enumerated", + "values": [ + "levels", + "constraint" + ], + "dflt": "levels", + "role": "info", + "editType": "calc", + "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters." + }, + "start": { + "valType": "number", + "dflt": null, "role": "style", - "valType": "color" + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the starting contour level value. Must be less than `contours.end`" }, - "description": "Sets this axis' title font.", - "editType": "ticks+margins", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "ticks+margins", - "noBlank": true, + "end": { + "valType": "number", + "dflt": null, "role": "style", - "strict": true, - "valType": "string" + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the end contour level value. Must be more than `contours.start`" }, - "role": "object", "size": { - "editType": "ticks+margins", - "min": 1, + "valType": "number", + "dflt": null, + "min": 0, "role": "style", - "valType": "number" - } - }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the step between each contour level. Must be positive." + }, + "coloring": { + "valType": "enumerated", + "values": [ + "fill", + "heatmap", + "lines", + "none" + ], + "dflt": "fill", + "role": "style", + "editType": "calc", + "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace." + }, + "showlines": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*." + }, + "showlabels": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether to label the contour lines with their values." + }, + "labelfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style" + }, + "editType": "plot", + "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", + "role": "object" + }, + "labelformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format." + }, + "operation": { + "valType": "enumerated", + "values": [ + "=", + "<", + ">=", + ">", + "<=", + "[]", + "()", + "[)", + "(]", + "][", + ")(", + "](", + ")[" + ], + "role": "info", + "dflt": "=", + "editType": "calc", + "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms." + }, + "value": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound." + }, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "log", - "date", - "category" - ] + "impliedEdits": { + "autocontour": false, + "role": "object" + }, + "role": "object" }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style+colorbars", + "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "style+colorbars", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "smoothing": { + "valType": "number", + "min": 0, + "max": 1.3, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing." + }, "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "zeroline": { - "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines.", - "editType": "ticks", - "role": "style", - "valType": "boolean" - }, - "zerolinecolor": { - "description": "Sets the line color of the zero line.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" + "role": "object" }, - "zerolinewidth": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 1, - "editType": "ticks", + "zhoverformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "number" - } - }, - "yaxis": { - "_deprecated": { - "autotick": { - "description": "Obsolete. Set `tickmode` to *auto* for old `autotick` *true* behavior. Set `tickmode` to *linear* for `autotick` *false*.", - "editType": "ticks+margins", - "role": "info", - "valType": "boolean" - } + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format" }, - "_isSubplotObj": true, - "anchor": { - "description": "If set to an opposite-letter axis id (e.g. `x2`, `y`), this axis is bound to the corresponding opposite-letter axis. If set to *free*, this axis' position is determined by `position`.", - "editType": "plot+margins", + "zauto": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "free", - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "automargin": { - "description": "Determines whether long tick labels automatically grow the figure margins.", - "dflt": false, - "editType": "ticks+margins", - "role": "style", - "valType": "boolean" - }, - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] + "description": "Determines the whether or not the color domain is computed with respect to the input data." }, - "calendar": { - "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`", - "dflt": "gregorian", - "editType": "calc", + "zmin": { + "valType": "number", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", + "dflt": null, "editType": "calc", - "role": "data", - "valType": "data_array" + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", + "zmax": { + "valType": "number", "role": "info", - "valType": "string" - }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", + "dflt": null, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" - }, - "constrain": { - "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines how that happens: by increasing the *range* (default), or by decreasing the *domain*.", - "dflt": "range", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "range", - "domain" - ] - }, - "constraintoward": { - "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines which direction we push the originally specified plot area. Options are *left*, *center* (default), and *right* for x axes, and *top*, *middle* (default), and *bottom* for y axes.", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "left", - "center", - "right", - "top", - "middle", - "bottom" - ] - }, - "domain": { - "description": "Sets the domain of this axis (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "plot+margins", - "items": [ - { - "editType": "plot+margins", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "plot+margins", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "ticks+margins", "impliedEdits": { - "tickmode": "linear" + "zauto": false }, - "role": "style", - "valType": "any" + "description": "Sets the upper bound of color domain." }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "ticks+margins", + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "fixedrange": { - "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled.", - "dflt": false, "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "gridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "ticks", - "role": "style", - "valType": "color" + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" }, - "gridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "ticks", - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." }, - "hoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "none", + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "string" + "dflt": false, + "editType": "calc", + "description": "Reverses the colorscale." }, - "layer": { - "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis.", - "dflt": "above traces", - "editType": "plot", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "above traces", - "below traces" - ] - }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "layoutstyle", - "role": "style", - "valType": "color" - }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "ticks+layoutstyle", - "min": 0, - "role": "style", - "valType": "number" - }, - "mirror": { - "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots.", - "dflt": false, - "editType": "ticks+layoutstyle", - "role": "style", - "valType": "enumerated", - "values": [ - true, - "ticks", - false, - "all", - "allticks" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "ticks+margins", - "min": 0, - "role": "style", - "valType": "integer" - }, - "overlaying": { - "description": "If set a same-letter axis id, this axis is overlaid on top of the corresponding same-letter axis. If *false*, this axis does not overlay any same-letter axes.", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "free", - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "position": { - "description": "Sets the position of this axis in the plotting space (in normalized coordinates). Only has an effect if `anchor` is set to *free*.", - "dflt": 0, - "editType": "plot+margins", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "axrange+margins", - "impliedEdits": { - "autorange": false - }, - "items": [ - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - }, - { - "editType": "axrange+margins", - "impliedEdits": { - "^autorange": false - }, - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] - }, - "role": "object", - "scaleanchor": { - "description": "If set to another axis id (e.g. `x2`, `y`), the range of this axis changes together with the range of the corresponding axis such that the scale of pixels per unit is in a constant ratio. Both axes are still zoomable, but when you zoom one, the other will zoom the same amount, keeping a fixed midpoint. `constrain` and `constraintoward` determine how we enforce the constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you can only link axes of the same `type`. The linked axis can have the opposite letter (to constrain the aspect ratio) or the same letter (to match scales across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: {scaleanchor: *y*}` or longer) are redundant and the last constraint encountered will be ignored to avoid possible inconsistent constraints via `scaleratio`.", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "/^x([2-9]|[1-9][0-9]+)?$/", - "/^y([2-9]|[1-9][0-9]+)?$/" - ] - }, - "scaleratio": { - "description": "If this axis is linked to another by `scaleanchor`, this determines the pixel to unit scale ratio. For example, if this value is 10, then every unit on this axis spans 10 times the number of pixels as a unit on the linked axis. Use this for example to create an elevation profile where the vertical scale is exaggerated a fixed amount with respect to the horizontal.", - "dflt": 1, - "editType": "plot", - "min": 0, - "role": "info", - "valType": "number" - }, - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "ticks+margins", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "ticks+margins", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "editType": "ticks", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "layoutstyle", - "role": "style", - "valType": "boolean" - }, - "showspikes": { - "description": "Determines whether or not spikes (aka droplines) are drawn for this axis. Note: This only takes affect when hovermode = closest", - "dflt": false, - "editType": "modebar", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", "dflt": true, - "editType": "ticks+margins", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "ticks+margins", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "ticks+margins", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "side": { - "description": "Determines whether a x (y) axis is positioned at the *bottom* (*left*) or *top* (*right*) of the plotting area.", - "editType": "plot+margins", - "role": "info", - "valType": "enumerated", - "values": [ - "top", - "bottom", - "left", - "right" - ] - }, - "spikecolor": { - "description": "Sets the spike color. If undefined, will use the series color", - "dflt": null, - "editType": "none", - "role": "style", - "valType": "color" - }, - "spikedash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "dash", - "editType": "none", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "spikemode": { - "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on", - "dflt": "toaxis", - "editType": "none", - "flags": [ - "toaxis", - "across", - "marker" - ], - "role": "style", - "valType": "flaglist" - }, - "spikesnap": { - "description": "Determines whether spikelines are stuck to the cursor or to the closest datapoints.", - "dflt": "data", - "editType": "none", - "role": "style", - "valType": "enumerated", - "values": [ - "data", - "cursor" - ] - }, - "spikethickness": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 3, - "editType": "none", - "role": "style", - "valType": "number" + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "ticks+margins", - "impliedEdits": { - "tickmode": "linear" + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "ticks+margins", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "ticks+margins", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "description": "Sets the tick font.", - "editType": "ticks+margins", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "ticks+margins", - "noBlank": true, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "strict": true, - "valType": "string" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "role": "object", - "size": { - "editType": "ticks+margins", - "min": 1, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "ticks+margins", - "items": [ - { - "editType": "ticks+margins", - "valType": "any" - }, - { - "editType": "ticks+margins", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "ticks+margins", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - } - } + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "ticks", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "ticks+margins", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "editType": "ticks+margins", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "ticks+margins", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "ticks+margins", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "ticks+margins", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "ticks", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "ticks+margins", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "ticks+margins", + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "color" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "description": "Sets this axis' title font.", - "editType": "ticks+margins", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "ticks+margins", - "noBlank": true, + "xpad": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" }, - "role": "object", - "size": { - "editType": "ticks+margins", - "min": 1, + "y": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "log", - "date", - "category" - ] - }, - "visible": { - "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "zeroline": { - "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines.", - "editType": "ticks", - "role": "style", - "valType": "boolean" - }, - "zerolinecolor": { - "description": "Sets the line color of the zero line.", - "dflt": "#444", - "editType": "ticks", - "role": "style", - "valType": "color" - }, - "zerolinewidth": { - "description": "Sets the width (in px) of the zero line.", - "dflt": 1, - "editType": "ticks", - "role": "style", - "valType": "number" - } - } - } - }, - "traces": { - "area": { - "attributes": { - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], "role": "style", - "valType": "color" + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "editType": "calc", - "font": { + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, "color": { - "arrayOk": true, - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" + "editType": "colorbars" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" + } }, - "description": "Sets the font used in hover labels.", - "editType": "none", + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], "role": "style", - "valType": "integer" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "role": "object" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, "idssrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + } + } + }, + "pie": { + "meta": { + "description": "A data visualized by the sectors of the pie is set in `values`. The sector labels are set in `labels`. The sector colors are set in `marker.colors`" + }, + "attributes": { + "type": "pie", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", + "valType": "string", + "role": "info", "dflt": "", "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "calc" }, - "marker": { - "color": { + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "label", + "text", + "value", + "percent", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" + }, + "bordercolor": { + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "editType": "calc", - "opacity": { + "namelength": { + "valType": "integer", + "min": -1, "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "style", - "max": 1, - "min": 0, "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, + "editType": "calc", "role": "object", - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, - "role": "style", - "valType": "number" + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "style", - "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] - }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" } }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "r": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", + "labels": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the sector labels. If `labels` entries are duplicated, we sum associated `values` or simply count occurrences if `values` is not provided. For other array attributes (including color) we use the first non-empty entry among all occurrences of the label.", + "role": "data" }, - "rsrc": { - "description": "Sets the source reference on plot.ly for r .", - "editType": "none", + "label0": { + "valType": "number", "role": "info", - "valType": "string" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "dflt": 0, "editType": "calc", - "role": "info", - "valType": "any" + "description": "Alternate to `labels`. Builds a numeric set of labels. Use with `dlabel` where `label0` is the starting label and `dlabel` the step." }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "dlabel": { + "valType": "number", "role": "info", - "valType": "boolean" + "dflt": 1, + "editType": "calc", + "description": "Sets the label step. See `label0` for more info." }, - "stream": { + "values": { + "valType": "data_array", "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "description": "Sets the values of the sectors of this pie chart. If omitted, we count occurrences of each label.", + "role": "data" + }, + "marker": { + "colors": { + "valType": "data_array", "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "description": "Sets the color of each sector of this pie chart. If not specified, the default trace color set is used to pick the sector colors.", + "role": "data" }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", + "line": { + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "arrayOk": true, + "editType": "style", + "description": "Sets the color of the line enclosing each sector." + }, + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "arrayOk": true, + "editType": "style", + "description": "Sets the width (in px) of the line enclosing each sector." + }, "editType": "calc", - "noBlank": true, + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + } + }, + "editType": "calc", + "role": "object", + "colorssrc": { + "valType": "string", "role": "info", - "strict": true, - "valType": "string" + "description": "Sets the source reference on plot.ly for colors .", + "editType": "none" } }, - "t": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", + "text": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", + "role": "data" }, - "tsrc": { - "description": "Sets the source reference on plot.ly for t .", - "editType": "none", + "hovertext": { + "valType": "string", "role": "info", - "valType": "string" - }, - "type": "area", - "uid": { "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": {} - }, - "bar": { - "attributes": { - "_deprecated": { - "bardir": { - "description": "Renamed to `orientation`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - } - }, - "base": { "arrayOk": true, - "description": "Sets where the bar base is drawn (in position axis units). In *stack* or *relative* barmode, traces that set *base* will be excluded and drawn in *overlay* mode instead.", - "dflt": null, - "editType": "calc", - "role": "info", - "valType": "any" + "editType": "style", + "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag." }, - "basesrc": { - "description": "Sets the source reference on plot.ly for base .", - "editType": "none", + "scalegroup": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "calc", + "description": "If there are multiple pies that should be sized according to their totals, link them by providing a non-empty group id here shared by every trace in the same group." }, - "cliponaxis": { - "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.", - "dflt": true, - "editType": "plot", + "textinfo": { + "valType": "flaglist", "role": "info", - "valType": "boolean" - }, - "constraintext": { - "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.", - "dflt": "both", + "flags": [ + "label", + "text", + "value", + "percent" + ], + "extras": [ + "none" + ], "editType": "calc", - "role": "info", + "description": "Determines which trace information appear on the graph." + }, + "textposition": { "valType": "enumerated", + "role": "info", "values": [ "inside", "outside", - "both", + "auto", "none" - ] - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", - "dflt": 1, + ], + "dflt": "auto", + "arrayOk": true, "editType": "calc", - "role": "info", - "valType": "number" + "description": "Specifies the location of the `textinfo`." }, - "error_x": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" + "color": { + "valType": "color", + "role": "style", + "editType": "style" }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the font used for `textinfo`.", + "role": "object" + }, + "insidetextfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "calc" }, - "copy_ystyle": { - "editType": "plot", + "color": { + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "style" }, "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", - "min": 0, + "description": "Sets the font used for `textinfo` lying inside the pie.", + "role": "object" + }, + "outsidetextfont": { + "family": { + "valType": "string", "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] - }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", + "noBlank": true, + "strict": true, "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "error_y": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" + "min": 1, + "editType": "calc" }, "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style" }, "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, + "description": "Sets the font used for `textinfo` lying outside the pie.", + "role": "object" + }, + "domain": { + "x": { + "valType": "info_array", "role": "info", - "valType": "integer" + "editType": "calc", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this pie trace (in plot fraction)." }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, + "y": { + "valType": "info_array", "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this pie trace (in plot fraction)." }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", + "editType": "calc", + "row": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "info", - "valType": "number" - }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, "editType": "calc", + "description": "If there is a layout grid, use the domain for this row in the grid for this pie trace ." + }, + "column": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "info", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "If there is a layout grid, use the domain for this column in the grid for this pie trace ." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - } + "role": "object" }, - "hoverinfo": { + "hole": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 0, + "editType": "calc", + "description": "Sets the fraction of the radius to cut out of the pie. Use this to make a donut chart." + }, + "sort": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not the sectors are reordered from largest to smallest." + }, + "direction": { + "valType": "enumerated", + "values": [ + "clockwise", + "counterclockwise" + ], + "role": "style", + "dflt": "counterclockwise", + "editType": "calc", + "description": "Specifies the direction at which succeeding sectors follow one another." + }, + "rotation": { + "valType": "number", + "role": "style", + "min": -360, + "max": 360, + "dflt": 0, + "editType": "calc", + "description": "Instead of the first slice starting at 12 o'clock, rotate to some other angle." + }, + "pull": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 0, "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" + "editType": "calc", + "description": "Sets the fraction of larger radius to pull the sectors out from the center. This can be a constant to pull all slices apart from each other equally or an array to highlight one or more slices." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "labelssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for labels .", + "editType": "none" + }, + "valuessrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for values .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "hovertextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" + }, + "textpositionsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + }, + "pullsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for pull .", + "editType": "none" + } + }, + "layoutAttributes": { + "hiddenlabels": { + "valType": "data_array", + "editType": "calc", + "role": "data" + }, + "hiddenlabelssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hiddenlabels .", + "editType": "none" + } + } + }, + "contour": { + "meta": { + "description": "The data from which contour lines are computed is set in `z`. Data in `z` must be a {2D array} of numbers. Say that `z` has N rows and M columns, then by default, these N rows correspond to N y coordinates (set in `y` or auto-generated) and the M columns correspond to M x coordinates (set in `x` or auto-generated). By setting `transpose` to *true*, the above behavior is flipped." + }, + "attributes": { + "type": "contour", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -10186,1130 +9813,936 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "insidetextfont": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "description": "Sets the font used for `text` lying inside the bar.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", "noBlank": true, - "role": "style", "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" - } + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the z data.", + "role": "data" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "impliedEdits": { + "xtype": "array" + }, + "role": "data" + }, + "x0": { + "valType": "any", + "dflt": 0, "role": "info", - "valType": "string" + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", + "impliedEdits": { + "xtype": "scaled" + } }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "dx": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info.", + "impliedEdits": { + "xtype": "scaled" + } + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "impliedEdits": { + "ytype": "array" }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "role": "data" + }, + "y0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", + "impliedEdits": { + "ytype": "scaled" + } + }, + "dy": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the y coordinate step. See `y0` for more info.", + "impliedEdits": { + "ytype": "scaled" + } + }, + "text": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text elements associated with each z value.", + "role": "data" + }, + "transpose": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Transposes the z data." + }, + "xtype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided)." + }, + "ytype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)" + }, + "zhoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in." + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the fill color if `contours.type` is *constraint*. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "autocontour": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`." + }, + "ncontours": { + "valType": "integer", + "dflt": 15, + "min": 1, + "role": "style", + "editType": "calc", + "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing." + }, + "contours": { + "type": { + "valType": "enumerated", + "values": [ + "levels", + "constraint" + ], + "dflt": "levels", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters." }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", + "start": { + "valType": "number", "dflt": null, + "role": "style", "editType": "plot", "impliedEdits": { - "cauto": false + "^autocontour": false }, - "role": "info", - "valType": "number" + "description": "Sets the starting contour level value. Must be less than `contours.end`" }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", + "end": { + "valType": "number", "dflt": null, + "role": "style", "editType": "plot", "impliedEdits": { - "cauto": false + "^autocontour": false }, - "role": "info", - "valType": "number" + "description": "Sets the end contour level value. Must be more than `contours.start`" }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", + "size": { + "valType": "number", + "dflt": null, + "min": 0, "role": "style", - "valType": "color" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" + "editType": "plot", + "impliedEdits": { + "^autocontour": false }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "description": "Sets the step between each contour level. Must be positive." + }, + "coloring": { + "valType": "enumerated", + "values": [ + "fill", + "heatmap", + "lines", + "none" + ], + "dflt": "fill", + "role": "style", + "editType": "calc", + "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace." + }, + "showlines": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*." + }, + "showlabels": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether to label the contour lines with their values." + }, + "labelfont": { + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "plot" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "color": { + "valType": "color", "role": "style", - "valType": "any" + "editType": "style" }, + "editType": "plot", + "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", + "role": "object" + }, + "labelformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format." + }, + "operation": { + "valType": "enumerated", + "values": [ + "=", + "<", + ">=", + ">", + "<=", + "[]", + "()", + "[)", + "(]", + "][", + ")(", + "](", + ")[" + ], + "role": "info", + "dflt": "=", + "editType": "calc", + "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms." + }, + "value": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound." + }, + "editType": "calc", + "impliedEdits": { + "autocontour": false, + "role": "object" + }, + "role": "object" + }, + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style+colorbars", + "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "style+colorbars", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "smoothing": { + "valType": "number", + "min": 0, + "max": 1.3, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing." + }, + "editType": "plot", + "role": "object" + }, + "zauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." + }, + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." + }, + "zmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Reverses the colorscale." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" + }, + "thickness": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" + }, + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "angle" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", + "size": { + "valType": "number", "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" - } + "min": 1, + "editType": "colorbars" }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", + "color": { + "valType": "color", "role": "style", - "valType": "string" + "editType": "colorbars" }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" + "role": "object" } }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } + "role": "object" }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "colorscale" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, - "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 1, + "editType": "colorbars" }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "dflt": 0, - "editType": "style", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, - "opacity": { - "arrayOk": true, - "description": "Sets the opacity of the bars.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "offset": { - "arrayOk": true, - "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.", - "dflt": null, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "offsetsrc": { - "description": "Sets the source reference on plot.ly for offset .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "orientation": { - "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - }, - "outsidetextfont": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used for `text` lying outside the bar.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "r": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "rsrc": { - "description": "Sets the source reference on plot.ly for r .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object" - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, + "editType": "colorbars", "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "t": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textfont": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used for `text`.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "ticktextsrc": { + "valType": "string", "role": "info", - "valType": "string" - } - }, - "textposition": { - "arrayOk": true, - "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed). *auto* positions `text` inside or outside so that `text` size is maximized.", - "dflt": "none", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "inside", - "outside", - "auto", - "none" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tsrc": { - "description": "Sets the source reference on plot.ly for t .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "bar", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object" - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "width": { - "arrayOk": true, - "description": "Sets the bar width (in position axis units).", - "dflt": null, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "gregorian", @@ -11328,39 +10761,13 @@ "taiwan", "thai", "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + ], "role": "info", - "valType": "subplotid" + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." }, "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "gregorian", @@ -11379,356 +10786,426 @@ "taiwan", "thai", "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + ], "role": "info", - "valType": "string" - } - }, - "layoutAttributes": { - "bargap": { - "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.", "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." }, - "bargroupgap": { - "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.", - "dflt": 0, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "barmode": { - "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to an *opacity* to see multiple bars.", - "dflt": "group", - "editType": "calc", + "yaxis": { + "valType": "subplotid", "role": "info", - "valType": "enumerated", - "values": [ - "stack", - "group", - "overlay", - "relative" - ] + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "barnorm": { - "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divide by the sum of the values at the location coordinate. With *percent*, the results form *fraction* are presented in percents.", - "dflt": "", - "editType": "calc", + "idssrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "", - "fraction", - "percent" - ] + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" } - }, - "meta": { - "description": "The data visualized by the span of the bars is set in `y` if `orientation` is set th *v* (the default) and the labels are set in `x`. By setting `orientation` to *h*, the roles are interchanged." } }, - "box": { + "scatterternary": { + "meta": { + "hrName": "scatter_ternary", + "description": "Provides similar functionality to the *scatter* type but on a ternary phase diagram. The data is provided by at least two arrays out of `a`, `b`, `c` triplets." + }, "attributes": { - "boxmean": { - "description": "If *true*, the mean of the box(es)' underlying distribution is drawn as a dashed line inside the box(es). If *sd* the standard deviation is also drawn.", - "dflt": false, - "editType": "calcIfAutorange", - "role": "style", + "type": "scatterternary", + "visible": { "valType": "enumerated", "values": [ true, - "sd", - false - ] + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "boxpoints": { - "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the box(es) are shown with no sample points", - "dflt": "outliers", - "editType": "calcIfAutorange", + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "outliers", - "suspectedoutliers", - false - ] + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "string" - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", + "valType": "flaglist", + "role": "info", + "flags": [ + "a", + "b", + "c", + "text", + "name" + ], "extras": [ "all", "none", "skip" ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "hoveron": { - "description": "Do the hover effects highlight individual boxes or sample points or both?", - "dflt": "boxes+points", - "editType": "style", + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "a": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "role": "data" + }, + "b": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "role": "data" + }, + "c": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "role": "data" + }, + "sum": { + "valType": "number", + "role": "info", + "dflt": 0, + "min": 0, + "editType": "calc", + "description": "The number each triplet should sum to, if only two of `a`, `b`, and `c` are provided. This overrides `ternary.sum` to normalize this specific trace, but does not affect the values displayed on the axes. 0 (or missing) means to use ternary.sum" + }, + "mode": { + "valType": "flaglist", "flags": [ - "boxes", - "points" + "lines", + "markers", + "text" + ], + "extras": [ + "none" ], "role": "info", - "valType": "flaglist" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", + "dflt": "markers" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "text": { + "valType": "string", "role": "info", - "valType": "string" - }, - "jitter": { - "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the box(es).", - "editType": "calcIfAutorange", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", + "hovertext": { + "valType": "string", + "role": "info", "dflt": "", + "arrayOk": true, "editType": "style", - "role": "info", - "valType": "string" + "description": "Sets hover text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). To be seen, trace `hoverinfo` must contain a *text* flag." }, "line": { "color": { - "description": "Sets the color of line bounding the box(es).", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the line color." }, - "editType": "plot", - "role": "object", "width": { - "description": "Sets the width (in px) of line bounding the box(es).", - "dflt": 2, - "editType": "style", + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" - } - }, - "marker": { - "color": { - "arrayOk": false, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "plot", - "line": { - "color": { - "arrayOk": false, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "dflt": "#444", - "editType": "style", - "role": "style", - "valType": "color" - }, "editType": "style", - "outliercolor": { - "description": "Sets the border line color of the outlier sample points. Defaults to marker.color", - "editType": "style", - "role": "style", - "valType": "color" - }, - "outlierwidth": { - "description": "Sets the border line width (in px) of the outlier sample points.", - "dflt": 1, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "width": { - "arrayOk": false, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "dflt": 0, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "description": "Sets the line width (in px)." }, - "opacity": { - "arrayOk": false, - "description": "Sets the marker opacity.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", "role": "style", - "valType": "number" - }, - "outliercolor": { - "description": "Sets the color of the outlier sample points.", - "dflt": "rgba(0, 0, 0, 0)", "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "shape": { + "valType": "enumerated", + "values": [ + "linear", + "spline" + ], + "dflt": "linear", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes." }, - "role": "object", - "size": { - "arrayOk": false, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", + "smoothing": { + "valType": "number", "min": 0, + "max": 1.3, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape)." }, + "editType": "calc", + "role": "object" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." + }, + "cliponaxis": { + "valType": "boolean", + "dflt": true, + "role": "info", + "editType": "plot", + "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*." + }, + "fill": { + "valType": "enumerated", + "values": [ + "none", + "toself", + "tonext" + ], + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterternary has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "marker": { "symbol": { - "arrayOk": false, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "plot", - "role": "style", "valType": "enumerated", "values": [ 0, @@ -12015,1906 +11492,1956 @@ "line-nw", 144, "line-nw-open" - ] - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "string" - }, - "notched": { - "description": "Determines whether or not notches should be drawn.", - "editType": "calcIfAutorange", - "role": "style", - "valType": "boolean" - }, - "notchwidth": { - "description": "Sets the width of the notches relative to the box' width. For example, with 0, the notches are as wide as the box(es).", - "dflt": 0.25, - "editType": "calcIfAutorange", - "max": 0.5, - "min": 0, - "role": "style", - "valType": "number" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "orientation": { - "description": "Sets the orientation of the box(es). If *v* (*h*), the distribution is visualized along the vertical (horizontal).", - "editType": "calc+clearAxisTypes", - "role": "style", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - }, - "pointpos": { - "description": "Sets the position of the sample points in relation to the box(es). If *0*, the sample points are places over the center of the box(es). Positive (negative) values correspond to positions to the right (left) for vertical boxes and above (below) for horizontal boxes", - "editType": "calcIfAutorange", - "max": 2, - "min": -2, - "role": "style", - "valType": "number" - }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, + ], + "dflt": "circle", + "arrayOk": true, + "role": "style", "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "role": "object" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity." + }, + "maxdisplayed": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit." + }, + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." + }, + "sizeref": { + "valType": "number", + "dflt": 1, + "role": "style", "editType": "calc", - "max": 10000, + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "number" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points." + }, "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "box", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", + "valType": "color", + "arrayOk": true, + "role": "style", "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, - "min": 0, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "whiskerwidth": { - "description": "Sets the width of the whiskers relative to the box' width. For example, with 1, the whiskers are as wide as the box(es).", - "dflt": 0.5, - "editType": "calcIfAutorange", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "x": { - "description": "Sets the x sample data or coordinates. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Sets the x coordinate of the box. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y sample data or coordinates. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Sets the y coordinate of the box. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "layoutAttributes": { - "boxgap": { - "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates.", - "dflt": 0.3, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "boxgroupgap": { - "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate.", - "dflt": 0.3, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "boxmode": { - "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes.", - "dflt": "overlay", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "group", - "overlay" - ] - } - }, - "meta": { - "description": "In vertical (horizontal) box plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one box per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single box is drawn. That box position is then positioned with with `name` or with `x0` (`y0`) if provided. Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second quartile (Q2) is marked by a line inside the box. By default, the whiskers correspond to the box' edges +/- 1.5 times the interquartile range (IQR = Q3-Q1), see *boxpoints* for other options." - } - }, - "candlestick": { - "attributes": { - "close": { - "description": "Sets the close values.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "closesrc": { - "description": "Sets the source reference on plot.ly for close .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "decreasing": { - "editType": "style", - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "line": { + "gradient": { + "type": { + "valType": "enumerated", + "values": [ + "radial", + "horizontal", + "vertical", + "none" + ], + "arrayOk": true, + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the type of gradient used to fill the markers" + }, "color": { - "description": "Sets the color of line bounding the box(es).", - "dflt": "#FF4136", - "editType": "style", + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical." }, - "editType": "style", + "editType": "calc", "role": "object", - "width": { - "description": "Sets the width (in px) of line bounding the box(es).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" + "typesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for type .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object" - }, - "high": { - "description": "Sets the high values.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "highsrc": { - "description": "Sets the source reference on plot.ly for high .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { + "color": { + "valType": "color", "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "color" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "thickness": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "info", - "valType": "string" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "strict": true, - "valType": "string" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "number" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" - } - }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "increasing": { - "editType": "style", - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "line": { - "color": { - "description": "Sets the color of line bounding the box(es).", - "dflt": "#3D9970", - "editType": "style", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "editType": "style", - "role": "object", - "width": { - "description": "Sets the width (in px) of line bounding the box(es).", - "dflt": 2, - "editType": "style", + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", "min": 0, + "dflt": 5, "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "editType": "style", - "role": "object", - "width": { - "description": "Sets the width (in px) of line bounding the box(es). Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "low": { - "description": "Sets the low values.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "lowsrc": { - "description": "Sets the source reference on plot.ly for low .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "open": { - "description": "Sets the open values.", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "role": "object", + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "arrayOk": true + }, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the text font.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "opensrc": { - "description": "Sets the source reference on plot.ly for open .", - "editType": "none", + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of selected points." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of selected points." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of selected points." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], "role": "info", - "valType": "string" + "editType": "style", + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "subplot": { + "valType": "subplotid", + "role": "info", + "dflt": "ternary", "editType": "calc", + "description": "Sets a reference between this trace's data coordinates and a ternary subplot. If *ternary* (the default value), the data refer to `layout.ternary`. If *ternary2*, the data refer to `layout.ternary2`, and so on." + }, + "idssrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "text": { - "arrayOk": true, - "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.", - "dflt": "", - "editType": "calc", + "asrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for a .", + "editType": "none" + }, + "bsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for b .", + "editType": "none" + }, + "csrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for c .", + "editType": "none" }, "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" }, - "type": "candlestick", - "uid": { - "dflt": "", - "editType": "calc", + "hovertextsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "textpositionsrc": { + "valType": "string", "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + } + } + }, + "violin": { + "meta": { + "description": "In vertical (horizontal) violin plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one violin per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single violin is drawn. That violin position is then positioned with with `name` or with `x0` (`y0`) if provided." + }, + "attributes": { + "type": "violin", + "visible": { "valType": "enumerated", "values": [ true, false, "legendonly" - ] - }, - "whiskerwidth": { - "description": "Sets the width of the whiskers relative to the box' width. For example, with 1, the whiskers are as wide as the box(es).", - "dflt": 0, - "editType": "calcIfAutorange", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "x": { - "description": "Sets the x coordinates. If absent, linear coordinate will be generated.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + ], "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", + "dflt": true, "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", + "legendgroup": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", "editType": "calc+clearAxisTypes", + "description": "Sets the trace name. The trace name appear as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical" + }, + "uid": { + "valType": "string", "role": "info", - "valType": "subplotid" - } - }, - "layoutAttributes": { - "boxgap": { - "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates.", - "dflt": 0.3, + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, - "boxgroupgap": { - "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate.", - "dflt": 0.3, + "customdata": { + "valType": "data_array", "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "boxmode": { - "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes.", - "dflt": "overlay", + "selectedpoints": { + "valType": "any", + "role": "info", "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", "role": "info", - "valType": "enumerated", - "values": [ - "group", - "overlay" - ] - } - }, - "meta": { - "description": "The candlestick is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The boxes represent the spread between the `open` and `close` values and the lines represent the spread between the `low` and `high` values Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing candles are drawn in green whereas decreasing are drawn in red." - } - }, - "carpet": { - "attributes": { - "a": { - "description": "An array containing values of the first parameter value", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "a0": { - "description": "Alternate to `a`. Builds a linear space of a coordinates. Use with `da` where `a0` is the starting coordinate and `da` the step.", - "dflt": 0, - "editType": "calc", - "role": "info", - "valType": "number" + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, - "aaxis": { - "arraydtick": { - "description": "The stride between grid lines along the axis", - "dflt": 1, - "editType": "calc", - "min": 1, - "role": "info", - "valType": "integer" - }, - "arraytick0": { - "description": "The starting index of grid lines along the axis", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, - "editType": "calc", + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" - }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] - }, - "cheatertype": { - "dflt": "value", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "index", - "value" - ] - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "dtick": { - "description": "The stride between grid lines along the axis", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "editType": "calc", - "endline": { - "description": "Determines whether or not a line is drawn at along the final value of this axis. If *true*, the end line is drawn on top of the grid lines.", - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "endlinecolor": { - "description": "Sets the line color of the end line.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "endlinewidth": { - "description": "Sets the width (in px) of the end line.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "fixedrange": { - "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "gridcolor": { - "description": "Sets the axis line color.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "gridwidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "labelpadding": { - "description": "Extra padding between label and the axis", - "dflt": 10, - "editType": "calc", - "role": "style", - "valType": "integer" - }, - "labelprefix": { - "description": "Sets a axis label prefix.", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "labelsuffix": { - "description": "Sets a axis label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "minorgridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "minorgridcount": { - "description": "Sets the number of minor grid ticks per major grid tick", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "minorgridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" - }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether axis labels are drawn on the low side, the high side, both, or neither side of the axis.", - "dflt": "start", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "start", - "end", - "both", - "none" - ] - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "smoothing": { - "dflt": 1, - "editType": "calc", - "max": 1.3, - "min": 0, - "role": "info", - "valType": "number" - }, - "startline": { - "description": "Determines whether or not a line is drawn at along the starting value of this axis. If *true*, the start line is drawn on top of the grid lines.", - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "startlinecolor": { - "description": "Sets the line color of the start line.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "startlinewidth": { - "description": "Sets the width (in px) of the start line.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "tick0": { - "description": "The starting index of grid lines along the axis", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "description": "Sets the background color of the hover labels for this trace" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "angle" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the tick font.", - "editType": "calc", + "font": { "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "tickmode": { - "dflt": "array", - "editType": "calc", + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" - }, - "title": { - "description": "Sets the title of this axis.", "editType": "calc", - "role": "info", - "valType": "string" + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this axis' title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, - "titleoffset": { - "description": "An additional amount by which to offset the title from the tick labels, given in pixels", - "dflt": 10, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "date", - "category" - ] - } + "role": "object" }, - "asrc": { - "description": "Sets the source reference on plot.ly for a .", - "editType": "none", + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y sample data or coordinates. See overview for more info.", + "role": "data" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x sample data or coordinates. See overview for more info.", + "role": "data" + }, + "x0": { + "valType": "any", "role": "info", - "valType": "string" + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinate of the box. See overview for more info." }, - "b": { - "description": "A two dimensional array of y coordinates at each carpet point.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "y0": { + "valType": "any", + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinate of the box. See overview for more info." }, - "b0": { - "description": "Alternate to `b`. Builds a linear space of a coordinates. Use with `db` where `b0` is the starting coordinate and `db` the step.", - "dflt": 0, - "editType": "calc", + "orientation": { + "valType": "enumerated", + "values": [ + "v", + "h" + ], + "role": "style", + "editType": "calc+clearAxisTypes", + "description": "Sets the orientation of the violin(s). If *v* (*h*), the distribution is visualized along the vertical (horizontal)." + }, + "bandwidth": { + "valType": "number", + "min": 0, "role": "info", - "valType": "number" + "editType": "calc", + "description": "Sets the bandwidth used to compute the kernel density estimate. By default, the bandwidth is determined by Silverman's rule of thumb." }, - "baxis": { - "arraydtick": { - "description": "The stride between grid lines along the axis", - "dflt": 1, - "editType": "calc", - "min": 1, - "role": "info", - "valType": "integer" + "scalegroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc", + "description": "If there are multiple violins that should be sized according to to some metric (see `scalemode`), link them by providing a non-empty group id here shared by every trace in the same group." + }, + "scalemode": { + "valType": "enumerated", + "values": [ + "width", + "count" + ], + "dflt": "width", + "role": "info", + "editType": "calc", + "description": "Sets the metric by which the width of each violin is determined.*width* means each violin has the same (max) width*count* means the violins are scaled by the number of sample points makingup each violin." + }, + "spanmode": { + "valType": "enumerated", + "values": [ + "soft", + "hard", + "manual" + ], + "dflt": "soft", + "role": "info", + "editType": "calc", + "description": "Sets the method by which the span in data space where the density function will be computed. *soft* means the span goes from the sample's minimum value minus two bandwidths to the sample's maximum value plus two bandwidths. *hard* means the span goes from the sample's minimum to its maximum value. For custom span settings, use mode *manual* and fill in the `span` attribute." + }, + "span": { + "valType": "info_array", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "role": "info", + "editType": "calc", + "description": "Sets the span in data space for which the density function will be computed. Has an effect only when `spanmode` is set to *manual*." + }, + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the color of line bounding the violin(s)." }, - "arraytick0": { - "description": "The starting index of grid lines along the axis", - "dflt": 0, - "editType": "calc", + "width": { + "valType": "number", + "role": "style", "min": 0, - "role": "info", - "valType": "integer" + "dflt": 2, + "editType": "style", + "description": "Sets the width (in px) of line bounding the violin(s)." }, - "autorange": { - "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*.", - "dflt": true, - "editType": "calc", + "editType": "plot", + "role": "object" + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "points": { + "valType": "enumerated", + "values": [ + "all", + "outliers", + "suspectedoutliers", + false + ], + "dflt": "outliers", + "role": "style", + "editType": "calcIfAutorange", + "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the violins are shown with no sample points" + }, + "jitter": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the violins." + }, + "pointpos": { + "valType": "number", + "min": -2, + "max": 2, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the position of the sample points in relation to the violins. If *0*, the sample points are places over the center of the violins. Positive (negative) values correspond to positions to the right (left) for vertical violins and above (below) for horizontal violins." + }, + "marker": { + "outliercolor": { + "valType": "color", + "dflt": "rgba(0, 0, 0, 0)", "role": "style", - "valType": "enumerated", - "values": [ - true, - false, - "reversed" - ] - }, - "categoryarray": { - "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "categoryarraysrc": { - "description": "Sets the source reference on plot.ly for categoryarray .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "categoryorder": { - "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.", - "dflt": "trace", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "trace", - "category ascending", - "category descending", - "array" - ] + "editType": "style", + "description": "Sets the color of the outlier sample points." }, - "cheatertype": { - "dflt": "value", - "editType": "calc", - "role": "info", + "symbol": { "valType": "enumerated", "values": [ - "index", - "value" - ] - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "editType": "calc", + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", + "arrayOk": false, "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "dtick": { - "description": "The stride between grid lines along the axis", - "dflt": 1, - "editType": "calc", + "opacity": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" - }, - "editType": "calc", - "endline": { - "description": "Determines whether or not a line is drawn at along the final value of this axis. If *true*, the end line is drawn on top of the grid lines.", - "editType": "calc", + "max": 1, + "arrayOk": false, "role": "style", - "valType": "boolean" + "editType": "style", + "description": "Sets the marker opacity.", + "dflt": 1 }, - "endlinecolor": { - "description": "Sets the line color of the end line.", - "editType": "calc", + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": false, "role": "style", - "valType": "color" + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." }, - "endlinewidth": { - "description": "Sets the width (in px) of the end line.", - "dflt": 1, - "editType": "calc", + "color": { + "valType": "color", + "arrayOk": false, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "line": { + "color": { + "valType": "color", + "arrayOk": false, + "role": "style", + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "dflt": "#444" + }, + "width": { + "valType": "number", + "min": 0, + "arrayOk": false, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points.", + "dflt": 0 + }, + "outliercolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the border line color of the outlier sample points. Defaults to marker.color" + }, + "outlierwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "style", + "description": "Sets the border line width (in px) of the outlier sample points." + }, + "editType": "style", + "role": "object" }, - "fixedrange": { - "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled.", + "editType": "plot", + "role": "object" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "box": { + "visible": { + "valType": "boolean", "dflt": false, - "editType": "calc", "role": "info", - "valType": "boolean" - }, - "gridcolor": { - "description": "Sets the axis line color.", - "editType": "calc", - "role": "style", - "valType": "color" + "editType": "plot", + "description": "Determines if an miniature box plot is drawn inside the violins. " }, - "gridwidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", + "width": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "max": 1, + "dflt": 0.25, + "role": "info", + "editType": "plot", + "description": "Sets the width of the inner box plots relative to the violins' width. For example, with 1, the inner box plots are as wide as the violins." }, - "labelpadding": { - "description": "Extra padding between label and the axis", - "dflt": 10, - "editType": "calc", - "role": "style", - "valType": "integer" - }, - "labelprefix": { - "description": "Sets a axis label prefix.", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "labelsuffix": { - "description": "Sets a axis label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "linecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "linewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "minorgridcolor": { - "description": "Sets the color of the grid lines.", - "dflt": "#eee", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "minorgridcount": { - "description": "Sets the number of minor grid ticks per major grid tick", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "minorgridwidth": { - "description": "Sets the width (in px) of the grid lines.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" - }, - "range": { - "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "rangemode": { - "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data.", - "dflt": "normal", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "normal", - "tozero", - "nonnegative" - ] - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "fillcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "style", + "description": "Sets the inner box plot fill color." }, - "showgrid": { - "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", - "dflt": true, - "editType": "calc", - "role": "style", - "valType": "boolean" + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the inner box plot bounding line color." + }, + "width": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the inner box plot bounding line width." + }, + "editType": "style", + "role": "object" }, - "showline": { - "description": "Determines whether or not a line bounding this axis is drawn.", + "editType": "plot", + "role": "object" + }, + "meanline": { + "visible": { + "valType": "boolean", "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showticklabels": { - "description": "Determines whether axis labels are drawn on the low side, the high side, both, or neither side of the axis.", - "dflt": "start", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "start", - "end", - "both", - "none" - ] - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "smoothing": { - "dflt": 1, - "editType": "calc", - "max": 1.3, - "min": 0, "role": "info", - "valType": "number" - }, - "startline": { - "description": "Determines whether or not a line is drawn at along the starting value of this axis. If *true*, the start line is drawn on top of the grid lines.", - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "startlinecolor": { - "description": "Sets the line color of the start line.", - "editType": "calc", - "role": "style", - "valType": "color" + "editType": "plot", + "description": "Determines if a line corresponding to the sample's mean is shown inside the violins. If `box.visible` is turned on, the mean line is drawn inside the inner box. Otherwise, the mean line is drawn from one side of the violin to other." }, - "startlinewidth": { - "description": "Sets the width (in px) of the start line.", - "dflt": 1, - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the mean line color." }, - "tick0": { - "description": "The starting index of grid lines along the axis", - "dflt": 0, - "editType": "calc", + "width": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", "role": "style", - "valType": "angle" + "editType": "style", + "description": "Sets the mean line width." }, - "tickfont": { - "color": { - "editType": "calc", + "editType": "plot", + "role": "object" + }, + "side": { + "valType": "enumerated", + "values": [ + "both", + "positive", + "negative" + ], + "dflt": "both", + "role": "info", + "editType": "plot", + "description": "Determines on which side of the position value the density function making up one half of a violin is plotted. Useful when comparing two violin traces under *overlay* mode, where one trace has `side` set to *positive* and the other to *negative*." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "description": "Sets the tick font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "color": { + "valType": "color", "role": "style", - "strict": true, - "valType": "string" + "editType": "style", + "description": "Sets the marker color of selected points." }, - "role": "object", "size": { - "editType": "calc", - "min": 1, + "valType": "number", + "min": 0, "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } + "editType": "style", + "description": "Sets the marker size of selected points." }, + "editType": "style", "role": "object" }, - "tickmode": { - "dflt": "array", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "title": { - "description": "Sets the title of this axis.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "calc", + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." }, - "description": "Sets this axis' title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "color": { + "valType": "color", "role": "style", - "strict": true, - "valType": "string" + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, - "role": "object", "size": { - "editType": "calc", - "min": 1, + "valType": "number", + "min": 0, "role": "style", - "valType": "number" - } - }, - "titleoffset": { - "description": "An additional amount by which to offset the title from the tick labels, given in pixels", - "dflt": 10, - "editType": "calc", - "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, - "type": { - "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question.", - "dflt": "-", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "-", - "linear", - "date", - "category" - ] - } + "editType": "style", + "role": "object" }, - "bsrc": { - "description": "Sets the source reference on plot.ly for b .", - "editType": "none", + "hoveron": { + "valType": "flaglist", + "flags": [ + "violins", + "points", + "kde" + ], + "dflt": "violins+points+kde", + "extras": [ + "all" + ], "role": "info", - "valType": "string" + "editType": "style", + "description": "Do the hover effects highlight individual violins or sample points or the kernel density estimate or any combination of them?" }, - "carpet": { - "description": "An identifier for this carpet, so that `scattercarpet` and `scattercontour` traces can specify a carpet plot on which they lie", - "editType": "calc", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "cheaterslope": { - "description": "The shift applied to each successive row of data in creating a cheater plot. Only used if `x` is been ommitted.", - "dflt": 1, - "editType": "calc", + "yaxis": { + "valType": "subplotid", "role": "info", - "valType": "number" - }, - "color": { - "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this.", - "dflt": "#444", - "editType": "plot", - "role": "style", - "valType": "color" + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "da": { - "description": "Sets the a coordinate step. See `a0` for more info.", - "dflt": 1, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + }, + "layoutAttributes": { + "violinmode": { + "valType": "enumerated", + "values": [ + "group", + "overlay" + ], + "dflt": "overlay", + "role": "info", + "editType": "calc", + "description": "Determines how violins at the same location coordinate are displayed on the graph. If *group*, the violins are plotted next to one another centered around the shared location. If *overlay*, the violins are plotted over one another, you might need to set *opacity* to see them multiple violins." + }, + "violingap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between violins of adjacent location coordinates." + }, + "violingroupgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between violins of the same location coordinate." + } + } + }, + "scatter3d": { + "meta": { + "hrName": "scatter_3d", + "description": "The data visualized as scatter point or lines in 3D dimension is set in `x`, `y`, `z`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` Projections are achieved via `projection`. Surface fills are achieved via `surfaceaxis`." + }, + "attributes": { + "type": "scatter3d", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "number" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "db": { - "description": "Sets the b coordinate step. See `b0` for more info.", + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, "dflt": 1, - "editType": "calc", + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "font": { - "color": { - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "The default font used for axis & tick labels on this carpet", + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "dflt": "\"Open Sans\", verdana, arial, sans-serif", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "dflt": 12, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -13922,1730 +13449,1675 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } }, "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "max": 10000, + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "type": "carpet", - "uid": { - "dflt": "", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, "editType": "calc", - "role": "info", - "valType": "string" + "role": "object" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, "x": { - "description": "A two dimensional array of x coordinates at each carpet point. If ommitted, the plot is a cheater plot and the xaxis is hidden by default.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", + "valType": "data_array", "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the x coordinates.", + "role": "data" }, "y": { - "description": "A two dimensional array of y coordinates at each carpet point.", + "valType": "data_array", "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets the y coordinates.", + "role": "data" }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", + "z": { + "valType": "data_array", + "description": "Sets the z coordinates.", "editType": "calc+clearAxisTypes", + "role": "data" + }, + "text": { + "valType": "string", "role": "info", - "valType": "subplotid" + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + "hovertext": { + "valType": "string", "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data describing carpet axis layout is set in `y` and (optionally) also `x`. If only `y` is present, `x` the plot is interpreted as a cheater plot and is filled in using the `y` values. `x` and `y` may either be 2D arrays matching with each dimension matching that of `a` and `b`, or they may be 1D arrays with total length equal to that of `a` and `b`." - } - }, - "choropleth": { - "attributes": { - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": true, + "dflt": "", + "arrayOk": true, "editType": "calc", - "impliedEdits": {}, + "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], + "role": "info", + "editType": "calc", + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", + "dflt": "lines+markers" + }, + "surfaceaxis": { + "valType": "enumerated", + "role": "info", + "values": [ + -1, + 0, + 1, + 2 + ], + "dflt": -1, + "description": "If *-1*, the scatter points are not fill with a surface If *0*, *1*, *2*, the scatter points are filled with a Delaunay surface about the x, y, z respectively.", + "editType": "calc" + }, + "surfacecolor": { + "valType": "color", "role": "style", - "valType": "boolean" + "description": "Sets the surface fill color.", + "editType": "calc" }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "projection": { + "x": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not projections are shown along the x axis.", + "editType": "calc" + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "description": "Sets the projection color.", + "editType": "calc" + }, + "scale": { + "valType": "number", + "role": "style", + "min": 0, + "max": 10, + "dflt": 0.6666666666666666, + "description": "Sets the scale factor determining the size of the projection marker points.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "y": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not projections are shown along the y axis.", + "editType": "calc" + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "description": "Sets the projection color.", + "editType": "calc" + }, + "scale": { + "valType": "number", + "role": "style", + "min": 0, + "max": 10, + "dflt": 0.6666666666666666, + "description": "Sets the scale factor determining the size of the projection marker points.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" + "z": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not projections are shown along the z axis.", + "editType": "calc" }, - "role": "style", - "valType": "any" + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "description": "Sets the projection color.", + "editType": "calc" + }, + "scale": { + "valType": "number", + "role": "style", + "min": 0, + "max": 10, + "dflt": 0.6666666666666666, + "description": "Sets the scale factor determining the size of the projection marker points.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", + "editType": "calc", + "role": "object" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." + }, + "line": { + "width": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", + "editType": "calc", + "description": "Sets the line width (in px)." + }, + "dash": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", "role": "style", - "valType": "number" + "description": "Sets the dash style of the lines.", + "editType": "calc" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "dflt": false, + "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", + "editType": "calc" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "calc", + "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "boolean" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "reversescale": { + "valType": "boolean", "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "marker": { + "symbol": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "circle", + "circle-open", + "square", + "square-open", + "diamond", + "diamond-open", + "cross", + "x" + ], "role": "style", - "valType": "boolean" + "dflt": "circle", + "arrayOk": true, + "description": "Sets the marker symbol type.", + "editType": "calc" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "size": { + "valType": "number", + "min": 0, + "dflt": 8, + "arrayOk": true, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Sets the marker size (in px)." }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", + "sizeref": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", + "sizemin": { + "valType": "number", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", + "sizemode": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" + "diameter", + "area" + ], + "dflt": "diameter", + "role": "info", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": false, "role": "style", - "valType": "angle" + "editType": "calc", + "description": "Sets the marker opacity. Note that the marker opacity for scatter3d traces must be a scalar value for performance reasons. To set a blending opacity value (i.e. which is not transparent), set *marker.color* to an rgba color and use its alpha channel." }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, - "tickfont": { - "color": { - "editType": "colorbars", + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "thickness": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "color" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "strict": true, - "valType": "string" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "xpad": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "geo": { - "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.", - "dflt": "geo", - "editType": "calc", - "role": "info", - "valType": "subplotid" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "location", - "z", - "text", - "name", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", "role": "style", - "valType": "color" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "ypad": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "locationmode": { - "description": "Determines the set of locations used to match entries in `locations` to regions on the map.", - "dflt": "ISO-3", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "ISO-3", - "USA-states", - "country names" - ] - }, - "locations": { - "description": "Sets the coordinates via location IDs or names. See `locationmode` for more info.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "locationssrc": { - "description": "Sets the source reference on plot.ly for locations .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "marker": { - "editType": "calc", - "line": { - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", "editType": "calc", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" }, - "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "dflt": 1, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "opacity": { - "arrayOk": true, - "description": "Sets the opacity of the locations.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "selected": { - "editType": "plot", - "marker": { - "editType": "plot", - "opacity": { - "description": "Sets the marker opacity of selected points.", + "tick0": { + "valType": "any", + "role": "style", "editType": "calc", - "max": 1, + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", "min": 0, + "dflt": 5, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "calc" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" }, - "role": "object" - }, - "role": "object" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets the text elements associated with each location.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "choropleth", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "plot", - "marker": { - "editType": "plot", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "calc", - "max": 1, + "line": { + "width": { + "valType": "number", "min": 0, + "arrayOk": false, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points." }, - "role": "object" - }, - "role": "object" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "z": { - "description": "Sets the color values.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data that describes the choropleth value-to-color mapping is set in `z`. The geographic locations corresponding to each value in `z` are set in `locations`." - } - }, - "contour": { - "attributes": { - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autocontour": { - "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", + "editType": "calc", "impliedEdits": { - "tickmode": "linear" + "autocolorscale": false }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", + "cmax": { + "valType": "number", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "color" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "role": "object", + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "top center", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "textfont": { + "family": { + "valType": "string", "role": "style", - "valType": "boolean" + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 1, + "editType": "calc", + "arrayOk": true }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", + "color": { + "valType": "color", "role": "style", + "editType": "calc", + "arrayOk": true + }, + "editType": "calc", + "description": "Sets the text font.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "error_x": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." + }, + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" + }, + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" + }, + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "copy_zstyle": { + "valType": "boolean", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "calc" }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "color": { + "valType": "color", "role": "style", - "valType": "any" + "editType": "calc", + "description": "Sets the stoke color of the error bars." }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "angle" + "editType": "calc", + "description": "Sets the thickness (in px) of the error bars." }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "editType": "calc", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_y": { + "visible": { + "valType": "boolean", "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { "valType": "enumerated", "values": [ - "auto", - "linear", - "array" - ] + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "value": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" + "editType": "calc" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", + "copy_zstyle": { + "valType": "boolean", + "role": "style", + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the stoke color of the error bars." + }, + "thickness": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the thickness (in px) of the error bars." }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" + "width": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "editType": "calc", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." } }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_z": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not this set of error bars is visible." }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", + "type": { "valType": "enumerated", "values": [ - "left", - "center", - "right" - ] + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." + }, + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" + }, + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", + "min": 0, "dflt": 10, - "editType": "colorbars", + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." + }, + "valueminus": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "editType": "calc", + "description": "Sets the stoke color of the error bars." }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", + "thickness": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "contours": { - "coloring": { - "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace.", - "dflt": "fill", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fill", - "heatmap", - "lines", - "none" - ] + "description": "Sets the thickness (in px) of the error bars." }, - "editType": "calc", - "end": { - "description": "Sets the end contour level value. Must be more than `contours.start`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false - }, + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." }, - "impliedEdits": { - "autocontour": false, - "role": "object" - }, - "labelfont": { - "color": { - "editType": "style", - "role": "style", - "valType": "color" - }, - "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "editType": "calc", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." } }, - "labelformat": { - "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "operation": { - "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.", - "dflt": "=", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "=", - "<", - ">=", - ">", - "<=", - "[]", - "()", - "[)", - "(]", - "][", - ")(", - "](", - ")[" - ] - }, "role": "object", - "showlabels": { - "description": "Determines whether to label the contour lines with their values.", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showlines": { - "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "size": { - "description": "Sets the step between each contour level. Must be positive.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false - }, - "min": 0, - "role": "style", - "valType": "number" - }, - "start": { - "description": "Sets the starting contour level value. Must be less than `contours.end`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false - }, - "role": "style", - "valType": "number" - }, - "type": { - "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters.", - "dflt": "levels", - "editType": "calc", + "arraysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "levels", - "constraint" - ] + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" }, - "value": { - "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound.", - "dflt": 0, - "editType": "calc", + "arrayminussrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" } }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "zcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `z` date data." + }, + "scene": { + "valType": "subplotid", + "role": "info", + "dflt": "scene", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "hovertextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" + }, + "textpositionsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + } + } + }, + "surface": { + "meta": { + "description": "The data the describes the coordinates of the surface is set in `z`. Data in `z` should be a {2D array}. Coordinates in `x` and `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph parametric surfaces). If not provided in `x` and `y`, the x and y coordinates are assumed to be linear starting at 0 with a unit step. The color scale corresponds to the `z` values by default. For custom color scales, use `surfacecolor` which should be a {2D array}, where its bounds can be controlled using `cmin` and `cmax`." + }, + "attributes": { + "type": "surface", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "impliedEdits": { - "xtype": "scaled" - }, + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", "role": "info", - "valType": "number" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, "dflt": 1, "editType": "calc", - "impliedEdits": { - "ytype": "scaled" - }, + "description": "Sets the opacity of the surface." + }, + "name": { + "valType": "string", "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "fillcolor": { - "description": "Sets the fill color if `contours.type` is *constraint*. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "style", - "valType": "color" + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -15653,1175 +15125,1228 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" + "z": { + "valType": "data_array", + "description": "Sets the z coordinates.", + "editType": "calc+clearAxisTypes", + "role": "data" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", + "x": { + "valType": "data_array", + "description": "Sets the x coordinates.", + "editType": "calc+clearAxisTypes", + "role": "data" + }, + "y": { + "valType": "data_array", + "description": "Sets the y coordinates.", + "editType": "calc+clearAxisTypes", + "role": "data" + }, + "text": { + "valType": "string", + "role": "info", "dflt": "", - "editType": "style", + "arrayOk": true, + "description": "Sets the text elements associated with each z value. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", + "editType": "calc" + }, + "surfacecolor": { + "valType": "data_array", + "description": "Sets the surface color values, used for setting a color scale independent of `z`.", + "editType": "calc", + "role": "data" + }, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." }, - "line": { - "color": { - "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*.", - "editType": "style+colorbars", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "plot", - "role": "object", - "smoothing": { - "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing.", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, - "role": "style", - "valType": "number" + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style+colorbars", - "min": 0, - "role": "style", - "valType": "number" - } + "description": "Sets the lower bound of color domain." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "cmax": { + "valType": "number", "role": "info", - "valType": "string" - }, - "ncontours": { - "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing.", - "dflt": 15, + "dflt": null, "editType": "calc", - "min": 1, + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "integer" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." }, "reversescale": { - "description": "Reverses the colorscale.", + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Reverses the colorscale." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "description": "Sets the text elements associated with each z value.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "transpose": { - "description": "Transposes the z data.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "type": "contour", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "xtype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "xtype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "xtype": { - "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided).", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "ytype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "ytype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ytype": { - "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "z": { - "description": "Sets the z data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "zhoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" - }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data from which contour lines are computed is set in `z`. Data in `z` must be a {2D array} of numbers. Say that `z` has N rows and M columns, then by default, these N rows correspond to N y coordinates (set in `y` or auto-generated) and the M columns correspond to M x coordinates (set in `x` or auto-generated). By setting `transpose` to *true*, the above behavior is flipped." - } - }, - "contourcarpet": { - "attributes": { - "a": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "xtype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "a0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "xtype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "asrc": { - "description": "Sets the source reference on plot.ly for a .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "atype": { - "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided).", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autocontour": { - "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "b": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "ytype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "b0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "ytype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "bsrc": { - "description": "Sets the source reference on plot.ly for b .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "btype": { - "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "carpet": { - "description": "The `carpet` of the carpet axes on which this contour trace lies", - "editType": "calc", - "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Sets the axis line color." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", + "tick0": { + "valType": "any", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "calc", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" } ], - "role": "info", - "valType": "info_array" + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "editType": "calc", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "calc" }, "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", + ], "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", "editType": "calc", - "impliedEdits": { - "autocolorscale": false + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "role": "style", - "valType": "colorscale" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, "contours": { - "coloring": { - "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace.", - "dflt": "fill", + "x": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not contour lines about the x dimension are drawn.", + "editType": "calc" + }, + "project": { + "x": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "y": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "z": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" + }, + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the contour lines.", + "editType": "calc" + }, + "usecolormap": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", + "editType": "calc" + }, + "width": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the contour lines.", + "editType": "calc" + }, + "highlight": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Determines whether or not contour lines about the x dimension are highlighted on hover.", + "editType": "calc" + }, + "highlightcolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the highlighted contour lines.", + "editType": "calc" + }, + "highlightwidth": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the highlighted contour lines.", + "editType": "calc" + }, "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fill", - "lines", - "none" - ] + "role": "object" }, - "editType": "calc", - "end": { - "description": "Sets the end contour level value. Must be more than `contours.start`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false + "y": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not contour lines about the y dimension are drawn.", + "editType": "calc" }, - "role": "style", - "valType": "number" - }, - "impliedEdits": { - "autocontour": false, + "project": { + "x": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "y": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "z": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" + }, + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the contour lines.", + "editType": "calc" + }, + "usecolormap": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", + "editType": "calc" + }, + "width": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the contour lines.", + "editType": "calc" + }, + "highlight": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Determines whether or not contour lines about the y dimension are highlighted on hover.", + "editType": "calc" + }, + "highlightcolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the highlighted contour lines.", + "editType": "calc" + }, + "highlightwidth": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the highlighted contour lines.", + "editType": "calc" + }, + "editType": "calc", "role": "object" }, - "labelfont": { + "z": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not contour lines about the z dimension are drawn.", + "editType": "calc" + }, + "project": { + "x": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "y": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "z": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" + }, "color": { - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "dflt": "#444", + "description": "Sets the color of the contour lines.", + "editType": "calc" }, - "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "usecolormap": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "plot", + "width": { + "valType": "number", + "role": "style", "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the contour lines.", + "editType": "calc" + }, + "highlight": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Determines whether or not contour lines about the z dimension are highlighted on hover.", + "editType": "calc" + }, + "highlightcolor": { + "valType": "color", "role": "style", - "valType": "number" - } + "dflt": "#444", + "description": "Sets the color of the highlighted contour lines.", + "editType": "calc" + }, + "highlightwidth": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the highlighted contour lines.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" }, - "labelformat": { - "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format.", - "dflt": "", - "editType": "plot", + "editType": "calc", + "role": "object" + }, + "hidesurface": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Determines whether or not a surface is drawn. For example, set `hidesurface` to *false* `contours.x.show` to *true* and `contours.y.show` to *true* to draw a wire frame plot.", + "editType": "calc" + }, + "lightposition": { + "x": { + "valType": "number", "role": "style", - "valType": "string" - }, - "operation": { - "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.", - "dflt": "=", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "=", - "<", - ">=", - ">", - "<=", - "[]", - "()", - "[)", - "(]", - "][", - ")(", - "](", - ")[" - ] + "min": -100000, + "max": 100000, + "dflt": 10, + "description": "Numeric vector, representing the X coordinate for each vertex.", + "editType": "calc" }, - "role": "object", - "showlabels": { - "description": "Determines whether to label the contour lines with their values.", - "dflt": false, - "editType": "plot", + "y": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": -100000, + "max": 100000, + "dflt": 10000, + "description": "Numeric vector, representing the Y coordinate for each vertex.", + "editType": "calc" }, - "showlines": { - "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*.", - "dflt": true, - "editType": "plot", + "z": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": -100000, + "max": 100000, + "dflt": 0, + "description": "Numeric vector, representing the Z coordinate for each vertex.", + "editType": "calc" }, - "size": { - "description": "Sets the step between each contour level. Must be positive.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false - }, + "editType": "calc", + "role": "object" + }, + "lighting": { + "ambient": { + "valType": "number", + "role": "style", "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Ambient light increases overall color visibility but can wash out the image.", + "editType": "calc" + }, + "diffuse": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Represents the extent that incident rays are reflected in a range of angles.", + "editType": "calc" }, - "start": { - "description": "Sets the starting contour level value. Must be less than `contours.end`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false - }, + "specular": { + "valType": "number", + "role": "style", + "min": 0, + "max": 2, + "dflt": 0.05, + "description": "Represents the level that incident rays are reflected in a single direction, causing shine.", + "editType": "calc" + }, + "roughness": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 0.5, + "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.", + "editType": "calc" }, - "type": { - "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters.", - "dflt": "levels", - "editType": "calc", + "fresnel": { + "valType": "number", + "role": "style", + "min": 0, + "max": 5, + "dflt": 0.2, + "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" + }, + "_deprecated": { + "zauto": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "levels", - "constraint" - ] + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Obsolete. Use `cauto` instead." }, - "value": { - "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound.", - "dflt": 0, + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Obsolete. Use `cmin` instead." + }, + "zmax": { + "valType": "number", "role": "info", - "valType": "any" + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Obsolete. Use `cmax` instead." } }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." + }, + "zcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `z` date data." + }, + "scene": { + "valType": "subplotid", + "role": "info", + "dflt": "scene", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "da": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "surfacecolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for surfacecolor .", + "editType": "none" + } + } + }, + "mesh3d": { + "meta": { + "description": "Draws sets of triangles with coordinates given by three 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha-shape algorithm or (4) the Convex-hull algorithm" + }, + "attributes": { + "type": "mesh3d", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "impliedEdits": { - "xtype": "scaled" - }, + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "number" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "db": { - "description": "Sets the y coordinate step. See `y0` for more info.", + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, "dflt": 1, "editType": "calc", - "impliedEdits": { - "ytype": "scaled" - }, + "description": "Sets the opacity of the surface." + }, + "name": { + "valType": "string", "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "fillcolor": { - "description": "Sets the fill color if `contours.type` is *constraint*. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "style", - "valType": "color" + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -16829,4079 +16354,4397 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "color": { + "valType": "color", + "role": "style", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the color of the whole mesh" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "line": { - "color": { - "description": "Sets the color of the contour level. Has no if `contours.coloring` is set to *lines*.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "plot", - "role": "object", - "smoothing": { - "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing.", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, - "role": "style", - "valType": "number" + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "description": "Has an effect only if `color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `color` array index, and if set, `cmin` must be set as well." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "cmin": { + "valType": "number", "role": "info", - "valType": "string" - }, - "ncontours": { - "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing.", - "dflt": 15, + "dflt": null, "editType": "calc", - "min": 1, - "role": "style", - "valType": "integer" + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `color` array index, and if set, `cmax` must be set as well." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, "reversescale": { - "description": "Reverses the colorscale.", + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Has an effect only if `color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the X coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", + "role": "data" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the Y coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", + "role": "data" }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, + "z": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the Z coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", + "role": "data" + }, + "i": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *first* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `i[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `i` represents a point in space, which is the first vertex of a triangle.", + "role": "data" }, - "stream": { + "j": { + "valType": "data_array", "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *second* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `j[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `j` represents a point in space, which is the second vertex of a triangle.", + "role": "data" }, - "text": { - "description": "Sets the text elements associated with each z value.", + "k": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *third* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `k[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `k` represents a point in space, which is the third vertex of a triangle.", + "role": "data" }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "transpose": { - "description": "Transposes the z data.", - "dflt": false, - "editType": "calc", + "text": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "type": "contourcarpet", - "uid": { "dflt": "", + "arrayOk": true, "editType": "calc", - "role": "info", - "valType": "string" + "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", + "delaunayaxis": { "valType": "enumerated", + "role": "info", "values": [ - true, - false, - "legendonly" - ] + "x", + "y", + "z" + ], + "dflt": "z", + "editType": "calc", + "description": "Sets the Delaunay axis, which is the axis that is perpendicular to the surface of the Delaunay triangulation. It has an effect if `i`, `j`, `k` are not provided and `alphahull` is set to indicate Delaunay triangulation." }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" + "alphahull": { + "valType": "number", + "role": "style", + "dflt": -1, + "editType": "calc", + "description": "Determines how the mesh surface triangles are derived from the set of vertices (points) represented by the `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays are not supplied. For general use of `mesh3d` it is preferred that `i`, `j`, `k` are supplied. If *-1*, Delaunay triangulation is used, which is mainly suitable if the mesh is a single, more or less layer surface that is perpendicular to `delaunayaxis`. In case the `delaunayaxis` intersects the mesh surface at more than one point it will result triangles that are very long in the dimension of `delaunayaxis`. If *>0*, the alpha-shape algorithm is used. In this case, the positive `alphahull` value signals the use of the alpha-shape algorithm, _and_ its value acts as the parameter for the mesh fitting. If *0*, the convex-hull algorithm is used. It is suitable for convex bodies or if the intention is to enclose the `x`, `y` and `z` point set into a convex hull." }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" + "intensity": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the vertex intensity values, used for plotting fields on meshes", + "role": "data" }, - "z": { - "description": "Sets the z data.", + "vertexcolor": { + "valType": "data_array", + "role": "data", "editType": "calc", + "description": "Sets the color of each vertex Overrides *color*." + }, + "facecolor": { + "valType": "data_array", "role": "data", - "valType": "data_array" + "editType": "calc", + "description": "Sets the color of each face Overrides *color* and *vertexcolor*." }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, + "flatshading": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections." }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false + "contour": { + "show": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not dynamic contours are shown on hover", + "editType": "calc" }, - "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the contour lines.", + "editType": "calc" }, - "role": "info", - "valType": "number" + "width": { + "valType": "number", + "role": "style", + "min": 1, + "max": 16, + "dflt": 2, + "description": "Sets the width of the contour lines.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "Plots contours on either the first carpet axis or the carpet axis with a matching `carpet` attribute. Data `z` is interpreted as matching that of the corresponding carpet axis.", - "hrName": "contour_carpet" - } - }, - "heatmap": { - "attributes": { - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, + "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Determines whether or not a colorbar is displayed for this trace." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, "editType": "colorbars", - "role": "style", - "valType": "boolean" + "description": "Sets the width (in px) of the axis line." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, "editType": "colorbars", - "role": "style", - "valType": "boolean" + "description": "Sets the axis line color." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, + "auto", + "linear", + "array" + ], + "role": "info", "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", + "role": "style", "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", "editType": "colorbars", - "role": "style", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets a tick label suffix." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", "editType": "colorbars", - "role": "data", - "valType": "data_array" + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", "editType": "colorbars", - "min": 0, + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, + ], "role": "style", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "lightposition": { + "x": { + "valType": "number", "role": "style", - "valType": "number" + "min": -100000, + "max": 100000, + "dflt": 100000, + "description": "Numeric vector, representing the X coordinate for each vertex.", + "editType": "calc" }, "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, + "valType": "number", "role": "style", - "valType": "number" + "min": -100000, + "max": 100000, + "dflt": 100000, + "description": "Numeric vector, representing the Y coordinate for each vertex.", + "editType": "calc" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", + "z": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "min": -100000, + "max": 100000, + "dflt": 0, + "description": "Numeric vector, representing the Z coordinate for each vertex.", + "editType": "calc" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", + "editType": "calc", + "role": "object" + }, + "lighting": { + "vertexnormalsepsilon": { + "valType": "number", + "role": "style", "min": 0, + "max": 1, + "dflt": 1e-12, + "editType": "calc", + "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry." + }, + "facenormalsepsilon": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", + "min": 0, + "max": 1, + "dflt": 0.000001, + "editType": "calc", + "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry." + }, "editType": "calc", - "impliedEdits": { - "autocolorscale": false + "ambient": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Ambient light increases overall color visibility but can wash out the image.", + "editType": "calc" }, - "role": "style", - "valType": "colorscale" + "diffuse": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Represents the extent that incident rays are reflected in a range of angles.", + "editType": "calc" + }, + "specular": { + "valType": "number", + "role": "style", + "min": 0, + "max": 2, + "dflt": 0.05, + "description": "Represents the level that incident rays are reflected in a single direction, causing shine.", + "editType": "calc" + }, + "roughness": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 0.5, + "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.", + "editType": "calc" + }, + "fresnel": { + "valType": "number", + "role": "style", + "min": 0, + "max": 5, + "dflt": 0.2, + "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.", + "editType": "calc" + }, + "role": "object" }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in.", - "dflt": false, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "ycalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], "role": "info", - "valType": "boolean" + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "zcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use with `z` date data." + }, + "scene": { + "valType": "subplotid", + "role": "info", + "dflt": "scene", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "isrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for i .", + "editType": "none" + }, + "jsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for j .", + "editType": "none" + }, + "ksrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for k .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "intensitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for intensity .", + "editType": "none" + }, + "vertexcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for vertexcolor .", + "editType": "none" + }, + "facecolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for facecolor .", + "editType": "none" + } + } + }, + "cone": { + "meta": { + "description": "Use cone traces to visualize vector fields. Specify a vector field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and 3 vector component arrays `u`, `v`, `w`. The cones are drawn exactly at the positions given by `x`, `y` and `z`." + }, + "attributes": { + "type": "cone", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "impliedEdits": { - "xtype": "scaled" - }, + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", "role": "info", - "valType": "number" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, "dflt": 1, "editType": "calc", - "impliedEdits": { - "ytype": "scaled" - }, + "description": "Sets the opacity of the surface." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "number" + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", "z", + "u", + "v", + "w", + "norm", "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "x+y+z+norm+text+name", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" + "x": { + "valType": "data_array", + "role": "data", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates of the vector field and of the displayed cones." }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" + "y": { + "valType": "data_array", + "role": "data", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates of the vector field and of the displayed cones." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "z": { + "valType": "data_array", + "role": "data", + "editType": "calc+clearAxisTypes", + "description": "Sets the z coordinates of the vector field and of the displayed cones." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "u": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the x components of the vector field.", + "role": "data" }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, + "v": { + "valType": "data_array", "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Sets the y components of the vector field.", + "role": "data" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "w": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "any" + "description": "Sets the z components of the vector field.", + "role": "data" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "sizemode": { + "valType": "enumerated", + "values": [ + "scaled", + "absolute" + ], "role": "info", - "valType": "boolean" - }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, "editType": "calc", + "dflt": "scaled", + "description": "Determines whether `sizeref` is set as a *scaled* (i.e unitless) scalar (normalized by the max u/v/w norm in the vector field) or as *absolute* value (in the same units as the vector field)." + }, + "sizeref": { + "valType": "number", "role": "info", - "valType": "boolean" + "editType": "calc", + "min": 0, + "description": "Adjusts the cone size scaling. The size of the cones is determined by their u/v/w norm multiplied a factor and `sizeref`. This factor (computed internally) corresponds to the minimum \"time\" to travel across two successive x/y/z positions at the average velocity of those two successive positions. All cones in a given trace use the same factor. With `sizemode` set to *scaled*, `sizeref` is unitless, its default value is *0.5* With `sizemode` set to *absolute*, `sizeref` has the same units as the u/v/w vector field, its the default value is half the sample's maximum vector norm." }, - "stream": { + "anchor": { + "valType": "enumerated", + "role": "info", "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "values": [ + "tip", + "tail", + "cm", + "center" + ], + "dflt": "cm", + "description": "Sets the cones' anchor with respect to their x/y/z positions. Note that *cm* denote the cone's center of mass which corresponds to 1/4 from the tail to tip." }, "text": { - "description": "Sets the text elements associated with each z value.", + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the text elements associated with the cones. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "transpose": { - "description": "Transposes the z data.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "type": "heatmap", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, + "colorscale": { + "valType": "colorscale", + "role": "style", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "xtype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", "impliedEdits": { - "xtype": "scaled" + "autocolorscale": false }, - "role": "info", - "valType": "any" + "description": "Sets the colorscale and only has an effect if `color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", + "dflt": true, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xgap": { - "description": "Sets the horizontal gap (in pixels) between bricks.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" + "impliedEdits": {}, + "description": "Has an effect only if `color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "xtype": { - "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided).", - "editType": "calc+clearAxisTypes", + "cmax": { + "valType": "number", "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "impliedEdits": { - "ytype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", + "dflt": null, + "editType": "calc", "impliedEdits": { - "ytype": "scaled" + "cauto": false }, - "role": "info", - "valType": "any" + "description": "Has an effect only if `color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `color` array index, and if set, `cmin` must be set as well." }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + "cmin": { + "valType": "number", "role": "info", - "valType": "subplotid" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", + "dflt": null, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `color` array index, and if set, `cmax` must be set as well." }, - "ygap": { - "description": "Sets the vertical gap (in pixels) between bricks.", - "dflt": 0, - "editType": "plot", - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ytype": { - "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "z": { - "description": "Sets the z data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "zhoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": "", - "editType": "none", + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "string" - }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zsmooth": { - "description": "Picks a smoothing algorithm use to smooth `z` data.", "dflt": false, "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fast", - "best", - false - ] + "description": "Has an effect only if `color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data that describes the heatmap value-to-color mapping is set in `z`. Data in `z` can either be a {2D array} of values (ragged or not) or a 1D array of values. In the case where `z` is a {2D array}, say that `z` has N rows and M columns. Then, by default, the resulting heatmap will have N partitions along the y axis and M partitions along the x axis. In other words, the i-th row/ j-th column cell in `z` is mapped to the i-th partition of the y axis (starting from the bottom of the plot) and the j-th partition of the x-axis (starting from the left of the plot). This behavior can be flipped by using `transpose`. Moreover, `x` (`y`) can be provided with M or M+1 (N or N+1) elements. If M (N), then the coordinates correspond to the center of the heatmap cells and the cells have equal width. If M+1 (N+1), then the coordinates correspond to the edges of the heatmap cells. In the case where `z` is a 1D {array}, the x and y coordinates must be provided in `x` and `y` respectively to form data triplets." - } - }, - "heatmapgl": { - "attributes": { - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, + "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Determines whether or not a colorbar is displayed for this trace." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "colorbars", + "description": "Sets the axis line color." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", + "tick0": { + "valType": "any", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "calc", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", + "showtickprefix": { "valType": "enumerated", "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "ticksuffix": { + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", + "editType": "colorbars", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "lightposition": { "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, + "valType": "number", "role": "style", - "valType": "number" + "min": -100000, + "max": 100000, + "dflt": 100000, + "description": "Numeric vector, representing the X coordinate for each vertex.", + "editType": "calc" }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", + "y": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "min": -100000, + "max": 100000, + "dflt": 100000, + "description": "Numeric vector, representing the Y coordinate for each vertex.", + "editType": "calc" }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, + "z": { + "valType": "number", + "role": "style", + "min": -100000, + "max": 100000, + "dflt": 0, + "description": "Numeric vector, representing the Z coordinate for each vertex.", + "editType": "calc" + }, + "editType": "calc", + "role": "object" + }, + "lighting": { + "vertexnormalsepsilon": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1e-12, "editType": "calc", + "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry." + }, + "facenormalsepsilon": { + "valType": "number", + "role": "style", "min": 0, + "max": 1, + "dflt": 0.000001, + "editType": "calc", + "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry." + }, + "editType": "calc", + "ambient": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Ambient light increases overall color visibility but can wash out the image.", + "editType": "calc" }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, + "diffuse": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 0.8, + "description": "Represents the extent that incident rays are reflected in a range of angles.", + "editType": "calc" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", + "specular": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "min": 0, + "max": 2, + "dflt": 0.05, + "description": "Represents the level that incident rays are reflected in a single direction, causing shine.", + "editType": "calc" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", + "roughness": { + "valType": "number", + "role": "style", "min": 0, + "max": 1, + "dflt": 0.5, + "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.", + "editType": "calc" + }, + "fresnel": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false + "min": 0, + "max": 5, + "dflt": 0.2, + "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.", + "editType": "calc" }, - "role": "style", - "valType": "colorscale" + "role": "object" }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "scene": { + "valType": "subplotid", + "role": "info", + "dflt": "scene", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "usrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for u .", + "editType": "none" + }, + "vsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for v .", + "editType": "none" + }, + "wsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for w .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "scattergeo": { + "meta": { + "hrName": "scatter_geo", + "description": "The data visualized as scatter point or lines on a geographic map is provided either by longitude/latitude pairs in `lon` and `lat` respectively or by geographic location IDs or names in `locations`." + }, + "attributes": { + "type": "scattergeo", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "impliedEdits": { - "xtype": "scaled" - }, + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "number" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "impliedEdits": { - "ytype": "scaled" - }, + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "number" + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", + "valType": "flaglist", + "role": "info", + "flags": [ + "lon", + "lat", + "location", + "text", + "name" + ], "extras": [ "all", "none", "skip" ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "string" + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "role": "object" }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, + "lon": { + "valType": "data_array", + "description": "Sets the longitude coordinates (in degrees East).", "editType": "calc", - "role": "style", - "valType": "boolean" + "role": "data" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "lat": { + "valType": "data_array", + "description": "Sets the latitude coordinates (in degrees North).", "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "role": "data" }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, + "locations": { + "valType": "data_array", + "description": "Sets the coordinates via location IDs or names. Coordinates correspond to the centroid of each location given. See `locationmode` for more info.", "editType": "calc", + "role": "data" + }, + "locationmode": { + "valType": "enumerated", + "values": [ + "ISO-3", + "USA-states", + "country names" + ], "role": "info", - "valType": "boolean" + "dflt": "ISO-3", + "description": "Determines the set of locations used to match entries in `locations` to regions on the map.", + "editType": "calc" }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "description": "Sets the text elements associated with each z value.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "transpose": { - "description": "Transposes the z data.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "type": "heatmapgl", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc", - "impliedEdits": { - "xtype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc", - "impliedEdits": { - "xtype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "xtype": { - "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided).", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc", - "impliedEdits": { - "ytype": "array" - }, - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc", - "impliedEdits": { - "ytype": "scaled" - }, - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ytype": { - "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)", - "editType": "calc", + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], "role": "info", - "valType": "enumerated", - "values": [ - "array", - "scaled" - ] - }, - "z": { - "description": "Sets the z data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", + "dflt": "markers" }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, + "text": { + "valType": "string", "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, + "dflt": "", + "arrayOk": true, "editType": "calc", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" + "description": "Sets text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", + "hovertext": { + "valType": "string", "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "WebGL version of the heatmap trace type." - } - }, - "histogram": { - "attributes": { - "_deprecated": { - "bardir": { - "description": "Renamed to `orientation`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - } - }, - "autobinx": { - "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins.", - "dflt": null, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autobiny": { - "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins.", - "dflt": null, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cumulative": { - "currentbin": { - "description": "Only applies if cumulative is enabled. Sets whether the current bin is included, excluded, or has half of its value included in the current cumulative value. *include* is the default for compatibility with various other tools, however it introduces a half-bin bias to the results. *exclude* makes the opposite half-bin bias, and *half* removes it.", - "dflt": "include", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "include", - "exclude", - "half" - ] - }, - "direction": { - "description": "Only applies if cumulative is enabled. If *increasing* (default) we sum all prior bins, so the result increases from left to right. If *decreasing* we sum later bins so the result decreases from left to right.", - "dflt": "increasing", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "increasing", - "decreasing" - ] - }, - "editType": "calc", - "enabled": { - "description": "If true, display the cumulative distribution by summing the binned values. Use the `direction` and `centralbin` attributes to tune the accumulation method. Note: in this mode, the *density* `histnorm` settings behave the same as their equivalents without *density*: ** and *density* both rise to the number of data points, and *probability* and *probability density* both rise to the number of sample points.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "role": "object" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "dflt": "", + "arrayOk": true, "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets hover text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." }, - "error_x": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "size": { + "valType": "number", + "role": "style", + "min": 1, "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" + "arrayOk": true }, "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "copy_ystyle": { - "editType": "plot", + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "calc", + "arrayOk": true }, "editType": "calc", + "description": "Sets the text font.", "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] - }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, + "familysrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", - "min": 0, + "sizesrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "error_y": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" - }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "line": { "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" - }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Sets the line color." }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", + "width": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] - }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "description": "Sets the line width (in px)." }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "histfunc": { - "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.", - "dflt": "count", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "count", - "sum", - "avg", - "min", - "max" - ] - }, - "histnorm": { - "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).", - "dflt": "", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "", - "percent", - "probability", - "density", - "probability density" - ] - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" + "role": "object" }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", + "connectgaps": { + "valType": "boolean", + "dflt": false, "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "namelength": { + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." + }, + "marker": { + "symbol": { + "valType": "enumerated", + "values": [ + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, "role": "style", - "valType": "integer" + "editType": "calc", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, + "role": "style", "editType": "calc", - "impliedEdits": {}, + "description": "Sets the marker size (in px)." + }, + "sizeref": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "number" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Sets the axis line color." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", + "tick0": { + "valType": "any", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "calc", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" } ], - "role": "info", - "valType": "info_array" + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "editType": "calc", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "calc" }, "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, + ], "role": "style", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "editType": "calc", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "line": { + "width": { + "valType": "number", "min": 0, + "arrayOk": true, "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points." }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "editType": "calc", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", + "valType": "boolean", + "role": "info", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." }, "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", + "dflt": true, "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "editType": "calc", "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, + "editType": "calc", "role": "object", - "width": { + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "gradient": { + "type": { + "valType": "enumerated", + "values": [ + "radial", + "horizontal", + "vertical", + "none" + ], + "arrayOk": true, + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the type of gradient used to fill the markers" + }, + "color": { + "valType": "color", "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "dflt": 0, - "editType": "style", - "min": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical." }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", + "editType": "calc", + "role": "object", + "typesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for type .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "opacity": { + "color": { + "valType": "color", "arrayOk": true, - "description": "Sets the opacity of the bars.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "boolean" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", + "reversescale": { + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "editType": "calc", + "role": "object", + "symbolsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "nbinsx": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "nbinsy": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", - "dflt": 0, - "editType": "calc", - "min": 0, + "fill": { + "valType": "enumerated", + "values": [ + "none", + "toself" + ], + "dflt": "none", "role": "style", - "valType": "integer" + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.", + "editType": "calc" }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "fillcolor": { + "valType": "color", "role": "style", - "valType": "number" - }, - "orientation": { - "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "enumerated", - "values": [ - "v", - "h" - ] + "editType": "calc", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, "selected": { - "editType": "style", "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of selected points." + }, "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker color of selected points." }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, + "size": { + "valType": "number", "min": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker size of selected points." }, + "editType": "calc", "role": "object" }, - "role": "object", "textfont": { "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the text font color of selected points." }, - "editType": "style", - "role": "object" - } - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "role": "object" }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "histogram", - "uid": { - "dflt": "", "editType": "calc", - "role": "info", - "valType": "string" + "role": "object" }, "unselected": { - "editType": "style", "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, + "size": { + "valType": "number", "min": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker size of unselected points, applied only when a selection exists." }, + "editType": "calc", "role": "object" }, - "role": "object", "textfont": { "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the text font color of unselected points, applied only when a selection exists." }, - "editType": "style", + "editType": "calc", "role": "object" - } - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, + }, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] + "role": "object" }, - "x": { - "description": "Sets the sample data to be binned on the x axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "geo": { + "valType": "subplotid", + "role": "info", + "dflt": "geo", + "editType": "calc", + "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on." }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + "idssrc": { + "valType": "string", "role": "info", - "valType": "subplotid" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "xbins": { - "editType": "calc", - "end": { - "description": "Sets the end value for the x axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, - "role": "style", - "valType": "any" - }, - "impliedEdits": { - "autobinx": false, - "role": "object" - }, - "role": "object", - "size": { - "description": "Sets the step in-between value each x axis bin.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, - "role": "style", - "valType": "any" - }, - "start": { - "description": "Sets the starting value for the x axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, - "role": "style", - "valType": "any" - } + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", + "lonsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for lon .", + "editType": "none" }, - "y": { - "description": "Sets the sample data to be binned on the y axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "latsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for lat .", + "editType": "none" }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + "locationssrc": { + "valType": "string", "role": "info", - "valType": "subplotid" + "description": "Sets the source reference on plot.ly for locations .", + "editType": "none" }, - "ybins": { - "editType": "calc", - "end": { - "description": "Sets the end value for the y axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - }, - "impliedEdits": { - "autobiny": false, - "role": "object" - }, - "role": "object", - "size": { - "description": "Sets the step in-between value each y axis bin.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - }, - "start": { - "description": "Sets the starting value for the y axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - } + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", + "hovertextsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + "textpositionsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" } + } + }, + "choropleth": { + "meta": { + "description": "The data that describes the choropleth value-to-color mapping is set in `z`. The geographic locations corresponding to each value in `z` are set in `locations`." }, - "layoutAttributes": { - "bargap": { - "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.", + "attributes": { + "type": "choropleth", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "bargroupgap": { - "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.", - "dflt": 0, - "editType": "calc", - "max": 1, - "min": 0, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." }, - "barmode": { - "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to an *opacity* to see multiple bars.", - "dflt": "group", - "editType": "calc", + "name": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "stack", - "group", - "overlay", - "relative" - ] + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "barnorm": { - "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divide by the sum of the values at the location coordinate. With *percent*, the results form *fraction* are presented in percents.", + "uid": { + "valType": "string", + "role": "info", "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "", - "fraction", - "percent" - ] - } - }, - "meta": { - "description": "The sample data from which statistics are computed is set in `x` for vertically spanning histograms and in `y` for horizontally spanning histograms. Binning options are set `xbins` and `ybins` respectively if no aggregation data is provided." - } - }, - "histogram2d": { - "attributes": { - "autobinx": { - "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins.", - "dflt": null, + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "autobiny": { - "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins.", - "dflt": null, + "selectedpoints": { + "valType": "any", + "role": "info", "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "location", + "z", + "text", + "name", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, - "colorbar": { + "hoverlabel": { "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "valType": "color", "role": "style", - "valType": "number" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "integer" + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "role": "object" + }, + "locations": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the coordinates via location IDs or names. See `locationmode` for more info.", + "role": "data" + }, + "locationmode": { + "valType": "enumerated", + "values": [ + "ISO-3", + "USA-states", + "country names" + ], + "role": "info", + "dflt": "ISO-3", + "description": "Determines the set of locations used to match entries in `locations` to regions on the map.", + "editType": "calc" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the color values.", + "role": "data" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets the text elements associated with each location." + }, + "marker": { + "line": { + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points.", + "dflt": 1 + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + } + }, + "opacity": { + "valType": "number", + "arrayOk": true, "min": 0, + "max": 1, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the opacity of the locations." }, + "editType": "calc", "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + } + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of selected points." + }, + "editType": "plot", + "role": "object" + }, + "editType": "plot", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "editType": "plot", + "role": "object" + }, + "editType": "plot", + "role": "object" + }, + "zauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." + }, + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." + }, + "zmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Reverses the colorscale." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "boolean" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" + }, + "lenmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "boolean" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "xanchor": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", "editType": "colorbars", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", + "valType": "any", + "role": "style", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", "role": "style", - "valType": "any" + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", + "role": "style", "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", "editType": "colorbars", - "role": "style", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", "editType": "colorbars", - "role": "data", - "valType": "data_array" + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", "editType": "colorbars", - "role": "data", - "valType": "data_array" + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", "editType": "colorbars", - "min": 0, + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "colorbars", + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, + ], "role": "style", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", + "geo": { + "valType": "subplotid", + "role": "info", + "dflt": "geo", "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" + "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on." }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, "customdatasrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "histfunc": { - "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.", - "dflt": "count", - "editType": "calc", - "role": "style", + "locationssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for locations .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "scattergl": { + "meta": { + "hrName": "scatter_gl", + "description": "The data visualized as scatter point or lines is set in `x` and `y` using the WebGL plotting engine. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to a numerical arrays." + }, + "attributes": { + "type": "scattergl", + "visible": { "valType": "enumerated", "values": [ - "count", - "sum", - "avg", - "min", - "max" - ] + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "histnorm": { - "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).", + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", "dflt": "", - "editType": "calc", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "", - "percent", - "probability", - "density", - "probability density" - ] + "min": 0, + "max": 1, + "dflt": 1, + "editType": "calc", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -20909,1484 +20752,1498 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } }, - "marker": { - "color": { - "description": "Sets the aggregation data.", + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, "editType": "calc", "role": "object" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "nbinsx": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "role": "data" }, - "nbinsy": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", + "x0": { + "valType": "any", "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step." }, - "opacity": { - "description": "Sets the opacity of the trace.", + "dx": { + "valType": "number", "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, + "role": "info", "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Sets the x coordinate step. See `x0` for more info." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "role": "data" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "y0": { + "valType": "any", + "dflt": 0, "role": "info", - "valType": "boolean" + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step." }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, - "editType": "calc", + "dy": { + "valType": "number", + "dflt": 1, "role": "info", - "valType": "boolean" - }, - "stream": { "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "description": "Sets the y coordinate step. See `y0` for more info." }, - "type": "histogram2d", - "uid": { - "dflt": "", - "editType": "calc", + "text": { + "valType": "string", "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, + "dflt": "", + "arrayOk": true, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the sample data to be binned on the x axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets text elements associated with each (x,y) pair to appear on hover. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates." }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers" + ], + "extras": [ + "none" + ], "role": "info", - "valType": "subplotid" + "description": "Determines the drawing mode for this scatter trace.", + "editType": "calc" }, - "xbins": { + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the line color." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "calc", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "enumerated", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "description": "Sets the style of the lines.", + "editType": "calc" + }, "editType": "calc", - "end": { - "description": "Sets the end value for the x axis bins.", - "dflt": null, + "role": "object" + }, + "marker": { + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", "editType": "calc", "impliedEdits": { - "^autobinx": false + "autocolorscale": false }, - "role": "style", - "valType": "any" + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "impliedEdits": { - "autobinx": false, - "role": "object" + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "role": "object", - "size": { - "description": "Sets the step in-between value each x axis bin.", + "cmax": { + "valType": "number", + "role": "info", "dflt": null, "editType": "calc", "impliedEdits": { - "^autobinx": false + "cauto": false }, - "role": "style", - "valType": "any" + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "start": { - "description": "Sets the starting value for the x axis bins.", + "cmin": { + "valType": "number", + "role": "info", "dflt": null, "editType": "calc", "impliedEdits": { - "^autobinx": false + "cauto": false }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "any" - } - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xgap": { - "description": "Sets the horizontal gap (in pixels) between bricks.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the sample data to be binned on the y axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ybins": { - "editType": "calc", - "end": { - "description": "Sets the end value for the y axis bins.", - "dflt": null, + "dflt": true, "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - }, - "impliedEdits": { - "autobiny": false, - "role": "object" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "role": "object", - "size": { - "description": "Sets the step in-between value each y axis bin.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "any" - }, - "start": { - "description": "Sets the starting value for the y axis bins.", - "dflt": null, + "dflt": false, "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - } - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ygap": { - "description": "Sets the vertical gap (in pixels) between bricks.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "z": { - "description": "Sets the aggregation data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "zhoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" - }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "zauto": false - }, - "role": "info", - "valType": "number" - }, - "zsmooth": { - "description": "Picks a smoothing algorithm use to smooth `z` data.", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fast", - "best", - false - ] - }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a heatmap.", - "hrName": "histogram_2d" - } - }, - "histogram2dcontour": { - "attributes": { - "autobinx": { - "description": "Determines whether or not the x axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in xbins.", - "dflt": null, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autobiny": { - "description": "Determines whether or not the y axis bin attributes are picked by an algorithm. Note that this should be set to false if you want to manually set the number of bins using the attributes in ybins.", - "dflt": null, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "autocontour": { - "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "symbol": { + "valType": "enumerated", + "values": [ + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", + "size": { + "valType": "number", "min": 0, + "dflt": 6, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker size (in px)." }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "sizeref": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "any" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "opacity": { + "valType": "number", "min": 0, + "max": 1, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker opacity." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", + "showscale": { + "valType": "boolean", + "role": "info", "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "strict": true, - "valType": "string" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "color" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "xpad": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, + "y": { + "valType": "number", "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "contours": { - "coloring": { - "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace.", - "dflt": "fill", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fill", - "heatmap", - "lines", - "none" - ] - }, - "editType": "calc", - "end": { - "description": "Sets the end contour level value. Must be more than `contours.start`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "role": "style", - "valType": "number" - }, - "impliedEdits": { - "autocontour": false, - "role": "object" - }, - "labelfont": { - "color": { - "editType": "style", + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], "role": "style", - "valType": "color" + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", - "editType": "plot", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "plot", - "noBlank": true, + "ypad": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, - "role": "object", - "size": { - "editType": "plot", - "min": 1, + "outlinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "number" - } - }, - "labelformat": { - "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format.", - "dflt": "", - "editType": "plot", - "role": "style", - "valType": "string" - }, - "operation": { - "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.", - "dflt": "=", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "=", - "<", - ">=", - ">", - "<=", - "[]", - "()", - "[)", - "(]", - "][", - ")(", - "](", - ")[" - ] - }, - "role": "object", - "showlabels": { - "description": "Determines whether to label the contour lines with their values.", - "dflt": false, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "showlines": { - "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*.", - "dflt": true, - "editType": "plot", - "role": "style", - "valType": "boolean" - }, - "size": { - "description": "Sets the step between each contour level. Must be positive.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false + "editType": "calc", + "description": "Sets the axis line color." }, - "min": 0, - "role": "style", - "valType": "number" - }, - "start": { - "description": "Sets the starting contour level value. Must be less than `contours.end`", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "^autocontour": false + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, - "role": "style", - "valType": "number" - }, - "type": { - "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters.", - "dflt": "levels", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "levels", - "constraint" - ] - }, - "value": { - "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound.", - "dflt": 0, - "editType": "calc", - "role": "info", - "valType": "any" - } - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "histfunc": { - "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.", - "dflt": "count", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "count", - "sum", - "avg", - "min", - "max" - ] - }, - "histnorm": { - "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "", - "percent", - "probability", - "density", - "probability density" - ] - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "calc" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" + }, + "editType": "calc", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "editType": "calc", - "font": { + "line": { "color": { + "valType": "color", "arrayOk": true, - "editType": "none", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "cmin": { + "valType": "number", "role": "info", - "valType": "string" + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." }, - "role": "object", - "size": { + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "width": { + "valType": "number", + "min": 0, "arrayOk": true, - "editType": "none", - "min": 1, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" } }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "color": { - "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*.", - "editType": "style+colorbars", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "plot", "role": "object", - "smoothing": { - "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing.", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, - "role": "style", - "valType": "number" - }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style+colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "marker": { - "color": { - "description": "Sets the aggregation data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, "colorsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "editType": "none" + }, + "symbolsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" }, - "editType": "calc", - "role": "object" + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + } }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "connectgaps": { + "valType": "boolean", + "dflt": false, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." }, - "nbinsx": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", - "dflt": 0, + "fill": { + "valType": "enumerated", + "values": [ + "none", + "tozeroy", + "tozerox", + "tonexty", + "tonextx", + "toself", + "tonext" + ], + "dflt": "none", + "role": "style", "editType": "calc", - "min": 0, + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." + }, + "fillcolor": { + "valType": "color", "role": "style", - "valType": "integer" + "editType": "calc", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, - "nbinsy": { - "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" - }, - "ncontours": { - "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing.", - "dflt": 15, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "integer" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], + "role": "info", "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of selected points." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of selected points." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the marker size of selected points." + }, + "editType": "calc", + "role": "object" + }, "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "role": "object" }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "calc", + "role": "object" + }, "editType": "calc", - "role": "info", - "valType": "boolean" + "role": "object" }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "error_x": { + "visible": { + "valType": "boolean", + "role": "info", "editType": "calc", - "max": 10000, + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { + "valType": "enumerated", + "values": [ + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." + }, + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." + }, + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" + }, + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", "min": 0, + "dflt": 10, "role": "info", - "valType": "number" + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", "editType": "calc", - "noBlank": true, + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" + }, + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "strict": true, - "valType": "string" - } - }, - "type": "histogram2dcontour", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the sample data to be binned on the x axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xbins": { - "editType": "calc", - "end": { - "description": "Sets the end value for the x axis bins.", - "dflt": null, + "editType": "calc" + }, + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "copy_ystyle": { + "valType": "boolean", + "role": "style", + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, + "description": "Sets the stoke color of the error bars." + }, + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "any" + "editType": "calc", + "description": "Sets the thickness (in px) of the error bars." }, - "impliedEdits": { - "autobinx": false, - "role": "object" + "width": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." + }, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "calc", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } }, "role": "object", - "size": { - "description": "Sets the step in-between value each x axis bin.", - "dflt": null, + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" + }, + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" + } + }, + "error_y": { + "visible": { + "valType": "boolean", + "role": "info", "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, + "description": "Determines whether or not this set of error bars is visible." + }, + "type": { + "valType": "enumerated", + "values": [ + "percent", + "constant", + "sqrt", + "data" + ], + "role": "info", + "editType": "calc", + "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`." + }, + "symmetric": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars." + }, + "array": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "role": "data" + }, + "arrayminus": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "role": "data" + }, + "value": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars." + }, + "valueminus": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "info", + "editType": "calc", + "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars" + }, + "traceref": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "tracerefminus": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "any" + "editType": "calc", + "description": "Sets the stoke color of the error bars." }, - "start": { - "description": "Sets the starting value for the x axis bins.", - "dflt": null, + "thickness": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", "editType": "calc", - "impliedEdits": { - "^autobinx": false - }, + "description": "Sets the thickness (in px) of the error bars." + }, + "width": { + "valType": "number", + "min": 0, "role": "style", - "valType": "any" + "editType": "calc", + "description": "Sets the width (in px) of the cross-bar at both ends of the error bars." + }, + "editType": "calc", + "_deprecated": { + "opacity": { + "valType": "number", + "role": "style", + "editType": "calc", + "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity." + } + }, + "role": "object", + "arraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for array .", + "editType": "none" + }, + "arrayminussrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for arrayminus .", + "editType": "none" } }, "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "gregorian", @@ -22405,70 +22262,13 @@ "taiwan", "thai", "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the sample data to be binned on the y axis.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + ], "role": "info", - "valType": "subplotid" - }, - "ybins": { "editType": "calc", - "end": { - "description": "Sets the end value for the y axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - }, - "impliedEdits": { - "autobiny": false, - "role": "object" - }, - "role": "object", - "size": { - "description": "Sets the step in-between value each y axis bin.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - }, - "start": { - "description": "Sets the starting value for the y axis bins.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "^autobiny": false - }, - "role": "style", - "valType": "any" - } + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." }, "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "gregorian", @@ -22487,1781 +22287,1467 @@ "taiwan", "thai", "ummalqura" - ] + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `y` date data." }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "z": { - "description": "Sets the aggregation data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "zauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "idssrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "zhoverformat": { - "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. See: https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": "", - "editType": "none", - "role": "style", - "valType": "string" + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "zmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" }, - "zmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, + "ysrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", + "textsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" } - }, - "meta": { - "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a contour plot.", - "hrName": "histogram_2d_contour" } }, - "mesh3d": { + "splom": { + "meta": { + "description": "Splom traces generate scatter plot matrix visualizations. Each splom `dimensions` items correspond to a generated axis. Values for each of those dimensions are set in `dimensions[i].values`. Splom traces support all `scattergl` marker style attributes. Specify `layout.grid` attributes and/or layout x-axis and y-axis attributes for more control over the axis positioning and style. " + }, "attributes": { - "alphahull": { - "description": "Determines how the mesh surface triangles are derived from the set of vertices (points) represented by the `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays are not supplied. For general use of `mesh3d` it is preferred that `i`, `j`, `k` are supplied. If *-1*, Delaunay triangulation is used, which is mainly suitable if the mesh is a single, more or less layer surface that is perpendicular to `delaunayaxis`. In case the `delaunayaxis` intersects the mesh surface at more than one point it will result triangles that are very long in the dimension of `delaunayaxis`. If *>0*, the alpha-shape algorithm is used. In this case, the positive `alphahull` value signals the use of the alpha-shape algorithm, _and_ its value acts as the parameter for the mesh fitting. If *0*, the convex-hull algorithm is used. It is suitable for convex bodies or if the intention is to enclose the `x`, `y` and `z` point set into a convex hull.", - "dflt": -1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "autocolorscale": { - "description": "Has an effect only if `color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": false, + "type": "splom", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "cauto": { - "description": "Has an effect only if `color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", + "showlegend": { + "valType": "boolean", + "role": "info", "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", "role": "info", - "valType": "boolean" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "cmax": { - "description": "Has an effect only if `color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `color` array index, and if set, `cmin` must be set as well.", - "dflt": null, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "cmin": { - "description": "Has an effect only if `color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `color` array index, and if set, `cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "uid": { + "valType": "string", "role": "info", - "valType": "number" + "dflt": "", + "editType": "calc" }, - "color": { - "description": "Sets the color of the whole mesh", + "ids": { + "valType": "data_array", "editType": "calc", - "role": "style", - "valType": "color" + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, - "colorbar": { + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", + "font": { "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } + "editType": "none", + "arrayOk": true }, - "role": "object" + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "string" + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] + "role": "object" + }, + "dimensions": { + "items": { + "dimension": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this dimension is shown on the graph. Note that even visible false dimension contribute to the default grid generate by this splom trace." + }, + "label": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "Sets the label corresponding to this splom dimension." + }, + "values": { + "valType": "data_array", + "role": "data", + "editType": "calc+clearAxisTypes", + "description": "Sets the dimension values to be plotted." + }, + "editType": "calc+clearAxisTypes", + "role": "object", + "valuessrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for values .", + "editType": "none" + } + } }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, + "role": "object" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair to appear on hover. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates." + }, + "marker": { + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "contour": { - "color": { - "description": "Sets the color of the contour lines.", - "dflt": "#444", + "dflt": true, "editType": "calc", - "role": "style", - "valType": "color" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "editType": "calc", - "role": "object", - "show": { - "description": "Sets whether or not dynamic contours are shown on hover", + "reversescale": { + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "width": { - "description": "Sets the width of the contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, - "role": "style", - "valType": "number" - } - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "delaunayaxis": { - "description": "Sets the Delaunay axis, which is the axis that is perpendicular to the surface of the Delaunay triangulation. It has an effect if `i`, `j`, `k` are not provided and `alphahull` is set to indicate Delaunay triangulation.", - "dflt": "z", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "x", - "y", - "z" - ] - }, - "facecolor": { - "description": "Sets the color of each face Overrides *color* and *vertexcolor*.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "facecolorsrc": { - "description": "Sets the source reference on plot.ly for facecolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "flatshading": { - "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { + "symbol": { + "valType": "enumerated", + "values": [ + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "calc", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "namelength": { + "size": { + "valType": "number", + "min": 0, + "dflt": 6, "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "i": { - "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *first* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `i[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `i` represents a point in space, which is the first vertex of a triangle.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "intensity": { - "description": "Sets the vertex intensity values, used for plotting fields on meshes", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "intensitysrc": { - "description": "Sets the source reference on plot.ly for intensity .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "isrc": { - "description": "Sets the source reference on plot.ly for i .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "j": { - "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *second* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `j[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `j` represents a point in space, which is the second vertex of a triangle.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "jsrc": { - "description": "Sets the source reference on plot.ly for j .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "k": { - "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *third* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `k[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `k` represents a point in space, which is the third vertex of a triangle.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ksrc": { - "description": "Sets the source reference on plot.ly for k .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "lighting": { - "ambient": { - "description": "Ambient light increases overall color visibility but can wash out the image.", - "dflt": 0.8, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the marker size (in px)." }, - "diffuse": { - "description": "Represents the extent that incident rays are reflected in a range of angles.", - "dflt": 0.8, - "editType": "calc", - "max": 1, - "min": 0, + "sizeref": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "number" - }, - "editType": "calc", - "facenormalsepsilon": { - "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.", - "dflt": 1e-06, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." }, - "fresnel": { - "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.", - "dflt": 0.2, - "editType": "calc", - "max": 5, + "sizemin": { + "valType": "number", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" - }, - "role": "object", - "roughness": { - "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.", - "dflt": 0.5, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." }, - "specular": { - "description": "Represents the level that incident rays are reflected in a single direction, causing shine.", - "dflt": 0.05, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", + "role": "info", "editType": "calc", - "max": 2, - "min": 0, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "vertexnormalsepsilon": { - "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.", - "dflt": 1e-12, - "editType": "calc", - "max": 1, + "opacity": { + "valType": "number", "min": 0, + "max": 1, + "arrayOk": true, "role": "style", - "valType": "number" - } - }, - "lightposition": { - "editType": "calc", - "role": "object", - "x": { - "description": "Numeric vector, representing the X coordinate for each vertex.", - "dflt": 100000, "editType": "calc", - "max": 100000, - "min": -100000, - "role": "style", - "valType": "number" + "description": "Sets the marker opacity." }, - "y": { - "description": "Numeric vector, representing the Y coordinate for each vertex.", - "dflt": 100000, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, "editType": "calc", - "max": 100000, - "min": -100000, - "role": "style", - "valType": "number" + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, - "z": { - "description": "Numeric vector, representing the Z coordinate for each vertex.", - "dflt": 0, - "editType": "calc", - "max": 100000, - "min": -100000, - "role": "style", - "valType": "number" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the surface.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "reversescale": { - "description": "Has an effect only if `color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "scene": { - "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.", - "dflt": "scene", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "mesh3d", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "vertexcolor": { - "description": "Sets the color of each vertex Overrides *color*.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "vertexcolorsrc": { - "description": "Sets the source reference on plot.ly for vertexcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the X coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the Y coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "z": { - "description": "Sets the Z coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "zcalendar": { - "description": "Sets the calendar system to use with `z` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "Draws sets of triangles with coordinates given by three 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha-shape algorithm or (4) the Convex-hull algorithm" - } - }, - "ohlc": { - "attributes": { - "close": { - "description": "Sets the close values.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "closesrc": { - "description": "Sets the source reference on plot.ly for close .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "decreasing": { - "editType": "style", - "line": { - "color": { - "description": "Sets the line color.", - "dflt": "#FF4136", - "editType": "style", + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", + "thickness": { + "valType": "number", "role": "style", - "valType": "string", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" + }, + "lenmode": { + "valType": "enumerated", "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" }, - "editType": "style", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "high": { - "description": "Sets the high values.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "highsrc": { - "description": "Sets the source reference on plot.ly for high .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "color" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "xpad": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], "role": "style", - "valType": "number" + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "increasing": { - "editType": "style", - "line": { - "color": { - "description": "Sets the line color.", - "dflt": "#3D9970", - "editType": "style", + "ypad": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", + "outlinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "string", + "editType": "calc", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" + }, + "tickmode": { + "valType": "enumerated", "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "editType": "style", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*). Note that this style setting can also be set per direction via `increasing.line.dash` and `decreasing.line.dash`.", - "dflt": "solid", - "editType": "style", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "style", - "role": "object", - "width": { - "description": "[object Object] Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "low": { - "description": "Sets the low values.", + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "calc" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" + }, + "editType": "calc", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "line": { + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points." + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + } + }, "editType": "calc", - "role": "data", - "valType": "data_array" + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + } }, - "lowsrc": { - "description": "Sets the source reference on plot.ly for low .", - "editType": "none", + "xaxes": { + "valType": "info_array", + "freeLength": true, "role": "info", - "valType": "string" + "editType": "calc", + "items": { + "valType": "subplotid", + "regex": "/^x([2-9]|[1-9][0-9]+)?$/", + "editType": "plot" + }, + "description": "Sets the list of x axes corresponding to this splom trace. By default, a splom will match the first N xaxes where N is the number of input dimensions." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "yaxes": { + "valType": "info_array", + "freeLength": true, "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "editType": "calc", + "items": { + "valType": "subplotid", + "regex": "/^y([2-9]|[1-9][0-9]+)?$/", + "editType": "plot" + }, + "description": "Sets the list of y axes corresponding to this splom trace. By default, a splom will match the first N yaxes where N is the number of input dimensions." }, - "open": { - "description": "Sets the open values.", + "diagonal": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not subplots on the diagonal are displayed." + }, "editType": "calc", - "role": "data", - "valType": "data_array" + "role": "object" }, - "opensrc": { - "description": "Sets the source reference on plot.ly for open .", - "editType": "none", + "showupperhalf": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "dflt": true, "editType": "calc", - "role": "info", - "valType": "any" + "description": "Determines whether or not subplots on the upper half from the diagonal are displayed." }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "showlowerhalf": { + "valType": "boolean", "role": "info", - "valType": "boolean" - }, - "stream": { + "dflt": true, "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "description": "Determines whether or not subplots on the lower half from the diagonal are displayed." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of selected points." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of selected points." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the marker size of selected points." + }, "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "role": "object" }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "editType": "calc", + "role": "object" }, - "text": { - "arrayOk": true, - "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.", - "dflt": "", + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "calc", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "calc", + "role": "object" + }, "editType": "calc", - "role": "info", - "valType": "string" + "role": "object" }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "idssrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "tickwidth": { - "description": "Sets the width of the open/close tick marks relative to the *x* minimal interval.", - "dflt": 0.3, - "editType": "calcIfAutorange", - "max": 0.5, - "min": 0, - "role": "style", - "valType": "number" + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "type": "ohlc", - "uid": { - "dflt": "", - "editType": "calc", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "textsrc": { + "valType": "string", "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "pointcloud": { + "meta": { + "description": "The data visualized as a point cloud set in `x` and `y` using the WebGl plotting engine." + }, + "attributes": { + "type": "pointcloud", + "visible": { "valType": "enumerated", "values": [ true, false, "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates. If absent, linear coordinate will be generated.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + ], "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", + "dflt": true, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + "legendgroup": { + "valType": "string", "role": "info", - "valType": "subplotid" - } - }, - "meta": { - "description": "The ohlc (short for Open-High-Low-Close) is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The tip of the lines represent the `low` and `high` values and the horizontal segments represent the `open` and `close` values. Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing items are drawn in green whereas decreasing are drawn in red." - } - }, - "parcoords": { - "attributes": { - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", "role": "info", - "valType": "string" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "dimensions": { - "items": { - "dimension": { - "constraintrange": { - "description": "The domain range to which the filter on the dimension is constrained. Must be an array of `[fromValue, toValue]` with `fromValue <= toValue`, or if `multiselect` is not disabled, you may give an array of arrays, where each inner array is `[fromValue, toValue]`.", - "dimensions": "1-2", - "editType": "calc", - "freeLength": true, - "items": [ - { - "editType": "calc", - "valType": "number" - }, - { - "editType": "calc", - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "description": "The dimensions (variables) of the parallel coordinates chart. 2..60 dimensions are supported.", - "editType": "calc", - "label": { - "description": "The shown name of the dimension.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "multiselect": { - "description": "Do we allow multiple selection ranges or just a single range?", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "range": { - "description": "The domain range that represents the full, shown axis extent. Defaults to the `values` extent. Must be an array of `[fromValue, toValue]` with finite numbers as elements.", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "number" - }, - { - "editType": "calc", - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "role": "object", - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": "3s", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "values": { - "description": "Dimension values. `values[n]` represents the value of the `n`th point in the dataset, therefore the `values` vector for all dimensions must be the same (longer vectors will be truncated). Each value must be a finite number.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "valuessrc": { - "description": "Sets the source reference on plot.ly for values .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Shows the dimension when set to `true` (the default). Hides the dimension for `false`.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - } - }, - "role": "object" + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this parcoords trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this parcoords trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this parcoords trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this parcoords trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -24269,4595 +23755,3870 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } }, "role": "object" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "role": "data" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "role": "data" + }, + "xy": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Faster alternative to specifying `x` and `y` separately. If supplied, it must be a typed `Float32Array` array that represents points such that `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]`", + "role": "data" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" + "indices": { + "valType": "data_array", + "editType": "calc", + "description": "A sequential value, 0..n, supply it to avoid creating this array inside plotting. If specified, it must be a typed `Int32Array` array. Its length must be equal to or greater than the number of points. For the best performance and memory use, create one large `indices` typed array that is guaranteed to be at least as long as the largest number of points during use, and reuse it on each `Plotly.restyle()` call.", + "role": "data" }, - "labelfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the font for the `dimension` labels.", + "xbounds": { + "valType": "data_array", "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "description": "Specify `xbounds` in the shape of `[xMin, xMax] to avoid looping through the `xy` typed array. Use it in conjunction with `xy` and `ybounds` for the performance benefits.", + "role": "data" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "ybounds": { + "valType": "data_array", + "editType": "calc", + "description": "Specify `ybounds` in the shape of `[yMin, yMax] to avoid looping through the `xy` typed array. Use it in conjunction with `xy` and `xbounds` for the performance benefits.", + "role": "data" + }, + "text": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, - "line": { - "autocolorscale": { - "description": "Has an effect only if line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed. The default value is false, so that `parcoords` colorscale can default to `Viridis`.", - "dflt": false, - "editType": "calc", - "impliedEdits": {}, + "marker": { + "color": { + "valType": "color", + "arrayOk": false, "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Sets the marker fill color. It accepts a specific color.If the color is not fully opaque and there are hundreds of thousandsof points, it may cause slower zooming and panning." }, - "cmax": { - "description": "Has an effect only if `line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmin` must be set as well.", - "dflt": null, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 1, + "arrayOk": false, + "role": "style", "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "description": "Sets the marker opacity. The default value is `1` (fully opaque). If the markers are not fully opaque and there are hundreds of thousands of points, it may cause slower zooming and panning. Opacity fades the color even if `blend` is left on `false` even if there is no translucency effect in that case." }, - "cmin": { - "description": "Has an effect only if `line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmax` must be set as well.", + "blend": { + "valType": "boolean", "dflt": null, + "role": "style", "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "description": "Determines if colors are blended together for a translucency effect in case `opacity` is specified as a value less then `1`. Setting `blend` to `true` reduces zoom/pan speed if used with large numbers of points." }, - "color": { - "arrayOk": true, - "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "sizemin": { + "valType": "number", + "min": 0.1, + "max": 2, + "dflt": 0.5, + "role": "style", "editType": "calc", + "description": "Sets the minimum size (in px) of the rendered marker points, effective when the `pointcloud` shows a million or more points." + }, + "sizemax": { + "valType": "number", + "min": 0.1, + "dflt": 20, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the maximum size (in px) of the rendered marker points. Effective when the `pointcloud` shows only few points." }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", + "border": { + "color": { + "valType": "color", + "arrayOk": false, "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "editType": "calc", + "description": "Sets the stroke color. It accepts a specific color. If the color is not fully opaque and there are hundreds of thousands of points, it may cause slower zooming and panning." }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "arearatio": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", + "max": 1, "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Specifies what fraction of the marker area is covered with the border." }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "dflt": [ - [ - 0, - "#440154" - ], - [ - 0.06274509803921569, - "#48186a" - ], - [ - 0.12549019607843137, - "#472d7b" - ], - [ - 0.18823529411764706, - "#424086" - ], - [ - 0.25098039215686274, - "#3b528b" - ], - [ - 0.3137254901960784, - "#33638d" - ], - [ - 0.3764705882352941, - "#2c728e" - ], - [ - 0.4392156862745098, - "#26828e" - ], - [ - 0.5019607843137255, - "#21918c" - ], - [ - 0.5647058823529412, - "#1fa088" - ], - [ - 0.6274509803921569, - "#28ae80" - ], - [ - 0.6901960784313725, - "#3fbc73" - ], - [ - 0.7529411764705882, - "#5ec962" - ], - [ - 0.8156862745098039, - "#84d44b" - ], - [ - 0.8784313725490196, - "#addc30" - ], - [ - 0.9411764705882353, - "#d8e219" - ], - [ - 1, - "#fde725" - ] - ], "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "role": "object" }, "editType": "calc", - "reversescale": { - "description": "Has an effect only if `line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } + "role": "object" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "rangefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the font for the `dimension` range values.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "xsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the font for the `dimension` tick values.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "xysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for xy .", + "editType": "none" }, - "type": "parcoords", - "uid": { - "dflt": "", - "editType": "calc", + "indicessrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for indices .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "xboundssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for xbounds .", + "editType": "none" + }, + "yboundssrc": { + "valType": "string", "role": "info", + "description": "Sets the source reference on plot.ly for ybounds .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "heatmapgl": { + "meta": { + "description": "WebGL version of the heatmap trace type." + }, + "attributes": { + "type": "heatmapgl", + "visible": { "valType": "enumerated", "values": [ true, false, "legendonly" - ] - } - }, - "meta": { - "description": "Parallel coordinates for multidimensional exploratory data analysis. The samples are specified in `dimensions`. The colors are set in `line.color`." - } - }, - "pie": { - "attributes": { - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + ], + "role": "info", + "dflt": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "direction": { - "description": "Specifies the direction at which succeeding sectors follow one another.", - "dflt": "counterclockwise", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "clockwise", - "counterclockwise" - ] + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "dlabel": { - "description": "Sets the label step. See `label0` for more info.", - "dflt": 1, - "editType": "calc", + "legendgroup": { + "valType": "string", "role": "info", - "valType": "number" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this pie trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this pie trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this pie trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this pie trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, - "hole": { - "description": "Sets the fraction of the radius to cut out of the pie. Use this to make a donut chart.", - "dflt": 0, + "customdata": { + "valType": "data_array", "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], "extras": [ "all", "none", "skip" ], - "flags": [ - "label", - "text", - "value", - "percent", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "insidetextfont": { - "color": { - "editType": "style", - "role": "style", - "valType": "color" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "description": "Sets the font used for `textinfo` lying inside the pie.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" } }, - "label0": { - "description": "Alternate to `labels`. Builds a numeric set of labels. Use with `dlabel` where `label0` is the starting label and `dlabel` the step.", - "dflt": 0, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "labels": { - "description": "Sets the sector labels. If `labels` entries are duplicated, we sum associated `values` or simply count occurrences if `values` is not provided. For other array attributes (including color) we use the first non-empty entry among all occurrences of the label.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "labelssrc": { - "description": "Sets the source reference on plot.ly for labels .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "marker": { - "colors": { - "description": "Sets the color of each sector of this pie chart. If not specified, the default trace color set is used to pick the sector colors.", + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "colorssrc": { - "description": "Sets the source reference on plot.ly for colors .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, "editType": "calc", - "line": { - "color": { - "arrayOk": true, - "description": "Sets the color of the line enclosing each sector.", - "dflt": "#444", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the line enclosing each sector.", - "dflt": 0, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, "role": "object" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the z data.", + "role": "data" }, - "outsidetextfont": { - "color": { - "editType": "style", - "role": "style", - "valType": "color" - }, - "description": "Sets the font used for `textinfo` lying outside the pie.", + "x": { + "valType": "data_array", "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "description": "Sets the x coordinates.", + "impliedEdits": { + "xtype": "array" }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "role": "data" }, - "pull": { - "arrayOk": true, - "description": "Sets the fraction of larger radius to pull the sectors out from the center. This can be a constant to pull all slices apart from each other equally or an array to highlight one or more slices.", + "x0": { + "valType": "any", "dflt": 0, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "pullsrc": { - "description": "Sets the source reference on plot.ly for pull .", - "editType": "none", "role": "info", - "valType": "string" - }, - "rotation": { - "description": "Instead of the first slice starting at 12 o'clock, rotate to some other angle.", - "dflt": 0, "editType": "calc", - "max": 360, - "min": -360, - "role": "style", - "valType": "number" + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", + "impliedEdits": { + "xtype": "scaled" + } }, - "scalegroup": { - "description": "If there are multiple pies that should be sized according to their totals, link them by providing a non-empty group id here shared by every trace in the same group.", - "dflt": "", - "editType": "calc", + "dx": { + "valType": "number", + "dflt": 1, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info.", + "impliedEdits": { + "xtype": "scaled" + } }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "y": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "any" + "description": "Sets the y coordinates.", + "impliedEdits": { + "ytype": "array" + }, + "role": "data" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "y0": { + "valType": "any", + "dflt": 0, "role": "info", - "valType": "boolean" - }, - "sort": { - "description": "Determines whether or not the sectors are reordered from largest to smallest.", - "dflt": true, "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", + "impliedEdits": { + "ytype": "scaled" + } }, - "stream": { + "dy": { + "valType": "number", + "dflt": 1, + "role": "info", "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" + "description": "Sets the y coordinate step. See `y0` for more info.", + "impliedEdits": { + "ytype": "scaled" } }, "text": { - "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the text elements associated with each z value.", + "role": "data" }, - "textfont": { - "color": { - "editType": "style", - "role": "style", - "valType": "color" - }, - "description": "Sets the font used for `textinfo`.", + "transpose": { + "valType": "boolean", + "dflt": false, + "role": "info", "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "description": "Transposes the z data." }, - "textinfo": { - "description": "Determines which trace information appear on the graph.", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "label", - "text", - "value", - "percent" + "xtype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" ], "role": "info", - "valType": "flaglist" - }, - "textposition": { - "arrayOk": true, - "description": "Specifies the location of the `textinfo`.", - "dflt": "auto", "editType": "calc", - "role": "info", + "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided)." + }, + "ytype": { "valType": "enumerated", "values": [ - "inside", - "outside", - "auto", - "none" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", + "array", + "scaled" + ], "role": "info", - "valType": "string" + "editType": "calc", + "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)" }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "zauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." }, - "type": "pie", - "uid": { - "dflt": "", + "zmin": { + "valType": "number", + "role": "info", + "dflt": null, "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." + }, + "zmax": { + "valType": "number", "role": "info", - "valType": "string" + "dflt": null, + "editType": "calc", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." }, - "values": { - "description": "Sets the values of the sectors of this pie chart. If omitted, we count occurrences of each label.", + "colorscale": { + "valType": "colorscale", + "role": "style", "editType": "calc", - "role": "data", - "valType": "data_array" + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" }, - "valuessrc": { - "description": "Sets the source reference on plot.ly for values .", - "editType": "none", - "role": "info", - "valType": "string" + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", + "description": "Reverses the colorscale." + }, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "layoutAttributes": { - "hiddenlabels": { - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "hiddenlabelssrc": { - "description": "Sets the source reference on plot.ly for hiddenlabels .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "A data visualized by the sectors of the pie is set in `values`. The sector labels are set in `labels`. The sector colors are set in `marker.colors`" - } - }, - "pointcloud": { - "attributes": { - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "dflt": true, "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines whether or not a colorbar is displayed for this trace." }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" + }, + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "info", - "valType": "string" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" + }, + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the axis line color." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" }, - "description": "Sets the font used in hover labels.", - "editType": "none", + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "calc" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "integer" + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "indices": { - "description": "A sequential value, 0..n, supply it to avoid creating this array inside plotting. If specified, it must be a typed `Int32Array` array. Its length must be equal to or greater than the number of points. For the best performance and memory use, create one large `indices` typed array that is guaranteed to be at least as long as the largest number of points during use, and reuse it on each `Plotly.restyle()` call.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "indicessrc": { - "description": "Sets the source reference on plot.ly for indices .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "marker": { - "blend": { - "description": "Determines if colors are blended together for a translucency effect in case `opacity` is specified as a value less then `1`. Setting `blend` to `true` reduces zoom/pan speed if used with large numbers of points.", - "dflt": null, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Sets a tick label suffix." }, - "border": { - "arearatio": { - "description": "Specifies what fraction of the marker area is covered with the border.", - "dflt": 0, - "editType": "calc", - "max": 1, - "min": 0, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "calc" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "calc" }, "color": { - "arrayOk": false, - "description": "Sets the stroke color. It accepts a specific color. If the color is not fully opaque and there are hundreds of thousands of points, it may cause slower zooming and panning.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc" }, + "description": "Sets this color bar's title font.", "editType": "calc", "role": "object" }, - "color": { - "arrayOk": false, - "description": "Sets the marker fill color. It accepts a specific color.If the color is not fully opaque and there are hundreds of thousandsof points, it may cause slower zooming and panning.", - "editType": "calc", + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], "role": "style", - "valType": "color" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" }, "editType": "calc", - "opacity": { - "arrayOk": false, - "description": "Sets the marker opacity. The default value is `1` (fully opaque). If the markers are not fully opaque and there are hundreds of thousands of points, it may cause slower zooming and panning. Opacity fades the color even if `blend` is left on `false` even if there is no translucency effect in that case.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, "role": "object", - "sizemax": { - "description": "Sets the maximum size (in px) of the rendered marker points. Effective when the `pointcloud` shows only few points.", - "dflt": 20, - "editType": "calc", - "min": 0.1, - "role": "style", - "valType": "number" + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "sizemin": { - "description": "Sets the minimum size (in px) of the rendered marker points, effective when the `pointcloud` shows a million or more points.", - "dflt": 0.5, - "editType": "calc", - "max": 2, - "min": 0.1, - "role": "style", - "valType": "number" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "yaxis": { + "valType": "subplotid", "role": "info", - "valType": "any" + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "idssrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "zsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" }, - "type": "pointcloud", - "uid": { - "dflt": "", - "editType": "calc", + "xsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "ysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" + }, + "textsrc": { + "valType": "string", "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "parcoords": { + "meta": { + "description": "Parallel coordinates for multidimensional exploratory data analysis. The samples are specified in `dimensions`. The colors are set in `line.color`." + }, + "attributes": { + "type": "parcoords", + "visible": { "valType": "enumerated", "values": [ true, false, "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + ], "role": "info", - "valType": "subplotid" - }, - "xbounds": { - "description": "Specify `xbounds` in the shape of `[xMin, xMax] to avoid looping through the `xy` typed array. Use it in conjunction with `xy` and `ybounds` for the performance benefits.", + "dflt": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "xboundssrc": { - "description": "Sets the source reference on plot.ly for xbounds .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "xy": { - "description": "Faster alternative to specifying `x` and `y` separately. If supplied, it must be a typed `Float32Array` array that represents points such that `xy[i * 2] = x[i]` and `xy[i * 2 + 1] = y[i]`", - "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "xysrc": { - "description": "Sets the source reference on plot.ly for xy .", - "editType": "none", + "legendgroup": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + "name": { + "valType": "string", "role": "info", - "valType": "subplotid" - }, - "ybounds": { - "description": "Specify `ybounds` in the shape of `[yMin, yMax] to avoid looping through the `xy` typed array. Use it in conjunction with `xy` and `xbounds` for the performance benefits.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "yboundssrc": { - "description": "Sets the source reference on plot.ly for ybounds .", - "editType": "none", + "uid": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "calc" }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data visualized as a point cloud set in `x` and `y` using the WebGl plotting engine." - } - }, - "sankey": { - "attributes": { - "arrangement": { - "description": "If value is `snap` (the default), the node arrangement is assisted by automatic snapping of elements to preserve space between nodes specified via `nodepad`. If value is `perpendicular`, the nodes can only move along a line perpendicular to the flow. If value is `freeform`, the nodes can freely move on the plane. If value is `fixed`, the nodes are stationary.", - "dflt": "snap", + "ids": { + "valType": "data_array", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "snap", - "perpendicular", - "freeform", - "fixed" - ] + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "string" - }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this sankey trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, "editType": "calc", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this sankey trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" - }, - "x": { - "description": "Sets the horizontal domain of this sankey trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - }, - "y": { - "description": "Sets the vertical domain of this sankey trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } - ], - "role": "info", - "valType": "info_array" - } + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], "extras": [ "all", "none", "skip" ], - "flags": [ - "label", - "text", - "value", - "percent", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "calc", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "calc", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "link": { - "color": { - "arrayOk": true, - "description": "Sets the `link` color. It can be a single value, or an array for specifying color for each `link`. If `link.color` is omitted, then by default, a translucent grey link will be used.", - "editType": "calc", - "role": "style", - "valType": "color" + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "description": "The links of the Sankey plot.", - "editType": "calc", - "label": { - "description": "The shown name of the link.", - "dflt": [], + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "labelsrc": { - "description": "Sets the source reference on plot.ly for label .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" - }, - "line": { - "color": { - "arrayOk": true, - "description": "Sets the color of the `line` around each `link`.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the `line` around each `link`.", - "dflt": 0, + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, - "role": "object", - "source": { - "description": "An integer number `[0..nodes.length - 1]` that represents the source node.", - "dflt": [], + "role": "object" + }, + "domain": { + "x": { + "valType": "info_array", + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this parcoords trace (in plot fraction)." }, - "sourcesrc": { - "description": "Sets the source reference on plot.ly for source .", - "editType": "none", + "y": { + "valType": "info_array", "role": "info", - "valType": "string" - }, - "target": { - "description": "An integer number `[0..nodes.length - 1]` that represents the target node.", - "dflt": [], "editType": "calc", - "role": "data", - "valType": "data_array" + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this parcoords trace (in plot fraction)." }, - "targetsrc": { - "description": "Sets the source reference on plot.ly for target .", - "editType": "none", + "editType": "calc", + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" - }, - "value": { - "description": "A numeric value representing the flow volume value.", - "dflt": [], "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "If there is a layout grid, use the domain for this row in the grid for this parcoords trace ." }, - "valuesrc": { - "description": "Sets the source reference on plot.ly for value .", - "editType": "none", + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "editType": "calc", + "description": "If there is a layout grid, use the domain for this column in the grid for this parcoords trace ." + }, + "role": "object" }, - "node": { + "labelfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, "color": { - "arrayOk": true, - "description": "Sets the `node` color. It can be a single value, or an array for specifying color for each `node`. If `node.color` is omitted, then the default `Plotly` color palette will be cycled through to have a variety of colors. These defaults are not fully opaque, to allow some visibility of what is beneath the node.", + "valType": "color", + "role": "style", + "editType": "calc" + }, + "editType": "calc", + "description": "Sets the font for the `dimension` labels.", + "role": "object" + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "calc" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "color": { + "valType": "color", + "role": "style", + "editType": "calc" }, - "description": "The nodes of the Sankey plot.", "editType": "calc", - "label": { - "description": "The shown name of the node.", - "dflt": [], + "description": "Sets the font for the `dimension` tick values.", + "role": "object" + }, + "rangefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "labelsrc": { - "description": "Sets the source reference on plot.ly for label .", - "editType": "none", - "role": "info", - "valType": "string" + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" }, - "line": { - "color": { - "arrayOk": true, - "description": "Sets the color of the `line` around each `node`.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the `line` around each `node`.", - "dflt": 0.5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "pad": { - "arrayOk": false, - "description": "Sets the padding (in px) between the `nodes`.", - "dflt": 20, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "thickness": { - "arrayOk": false, - "description": "Sets the thickness (in px) of the `nodes`.", - "dflt": 20, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "orientation": { - "description": "Sets the orientation of the Sankey diagram.", - "dflt": "h", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "v", - "h" - ] - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "textfont": { "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the font for node labels", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "color", "role": "style", - "strict": true, - "valType": "string" + "editType": "calc" }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "type": "sankey", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "valueformat": { - "description": "Sets the value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": ".3s", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "valuesuffix": { - "description": "Adds a unit to follow the value in the hover tooltip. Add a space if a separation is necessary from the value.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "Sankey plots for network flow data analysis. The nodes are specified in `nodes` and the links between sources and targets in `links`. The colors are set in `nodes[i].color` and `links[i].color`; otherwise defaults are used." - } - }, - "scatter": { - "attributes": { - "cliponaxis": { - "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", - "dflt": 1, "editType": "calc", - "role": "info", - "valType": "number" + "description": "Sets the font for the `dimension` range values.", + "role": "object" }, - "error_x": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" + "dimensions": { + "items": { + "dimension": { + "label": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "The shown name of the dimension." + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "tickformat": { + "valType": "string", + "dflt": "3s", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format" + }, + "visible": { + "valType": "boolean", + "dflt": true, + "role": "info", + "editType": "calc", + "description": "Shows the dimension when set to `true` (the default). Hides the dimension for `false`." + }, + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "editType": "calc" + }, + { + "valType": "number", + "editType": "calc" + } + ], + "editType": "calc", + "description": "The domain range that represents the full, shown axis extent. Defaults to the `values` extent. Must be an array of `[fromValue, toValue]` with finite numbers as elements." + }, + "constraintrange": { + "valType": "info_array", + "role": "info", + "freeLength": true, + "dimensions": "1-2", + "items": [ + { + "valType": "number", + "editType": "calc" + }, + { + "valType": "number", + "editType": "calc" + } + ], + "editType": "calc", + "description": "The domain range to which the filter on the dimension is constrained. Must be an array of `[fromValue, toValue]` with `fromValue <= toValue`, or if `multiselect` is not disabled, you may give an array of arrays, where each inner array is `[fromValue, toValue]`." + }, + "multiselect": { + "valType": "boolean", + "dflt": true, + "role": "info", + "editType": "calc", + "description": "Do we allow multiple selection ranges or just a single range?" + }, + "values": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Dimension values. `values[n]` represents the value of the `n`th point in the dataset, therefore the `values` vector for all dimensions must be the same (longer vectors will be truncated). Each value must be a finite number." + }, + "editType": "calc", + "description": "The dimensions (variables) of the parallel coordinates chart. 2..60 dimensions are supported.", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + }, + "valuessrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for values .", + "editType": "none" + } } }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" - }, + "role": "object" + }, + "line": { "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "copy_ystyle": { - "editType": "plot", + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "boolean" - }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", - "min": 0, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", + "dflt": [ + [ + 0, + "#440154" + ], + [ + 0.06274509803921569, + "#48186a" + ], + [ + 0.12549019607843137, + "#472d7b" + ], + [ + 0.18823529411764706, + "#424086" + ], + [ + 0.25098039215686274, + "#3b528b" + ], + [ + 0.3137254901960784, + "#33638d" + ], + [ + 0.3764705882352941, + "#2c728e" + ], + [ + 0.4392156862745098, + "#26828e" + ], + [ + 0.5019607843137255, + "#21918c" + ], + [ + 0.5647058823529412, + "#1fa088" + ], + [ + 0.6274509803921569, + "#28ae80" + ], + [ + 0.6901960784313725, + "#3fbc73" + ], + [ + 0.7529411764705882, + "#5ec962" + ], + [ + 0.8156862745098039, + "#84d44b" + ], + [ + 0.8784313725490196, + "#addc30" + ], + [ + 0.9411764705882353, + "#d8e219" + ], + [ + 1, + "#fde725" + ] ] }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "number" - }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, + "dflt": true, "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "impliedEdits": {}, + "description": "Has an effect only if `line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", + "cmax": { + "valType": "number", "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "error_y": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "style", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "dflt": null, "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmin` must be set as well." }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", + "cmin": { + "valType": "number", "role": "info", - "valType": "string" - }, - "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", + "dflt": null, "editType": "calc", - "role": "info", - "valType": "boolean" + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmax` must be set as well." }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "style", - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "tracerefminus": { - "dflt": 0, - "editType": "style", - "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", + "dflt": false, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] + "impliedEdits": {}, + "description": "Has an effect only if line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed. The default value is false, so that `parcoords` colorscale can default to `Viridis`." }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "description": "Has an effect only if `line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", - "min": 0, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", + "dflt": false, "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "tozeroy", - "tozerox", - "tonexty", - "tonextx", - "toself", - "tonext" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, + "thickness": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "info", - "valType": "string" - } - }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "style", - "flags": [ - "points", - "fills" - ], - "role": "info", - "valType": "flaglist" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "plot", - "role": "object", - "shape": { - "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes.", - "dflt": "linear", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "linear", - "spline", - "hv", - "vh", - "hvh", - "vhv" - ] - }, - "simplify": { - "description": "Simplifies lines by removing nearly-collinear points. When transitioning lines, it may be desirable to disable this so that the number of points along the resulting SVG path is unaffected.", - "dflt": true, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "smoothing": { - "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape).", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, - "role": "style", - "valType": "number" - }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, "editType": "colorbars", - "role": "style", - "valType": "boolean" + "description": "Sets the width (in px) of the axis line." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, "editType": "colorbars", - "role": "style", - "valType": "boolean" + "description": "Sets the axis line color." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, + "auto", + "linear", + "array" + ], + "role": "info", "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", + "valType": "any", + "role": "style", "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", "role": "style", - "valType": "any" + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", + "role": "style", "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", "editType": "colorbars", - "impliedEdits": {}, - "role": "info", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ - "auto", - "linear", - "array" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, - "tickprefix": { - "description": "Sets a tick label prefix.", + "ticksuffix": { + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", "editType": "colorbars", - "role": "style", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "If \"true\", even 4-digit integers are separated" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", "editType": "colorbars", - "min": 0, + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, + ], "role": "style", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, + "editType": "calc", + "role": "object", "colorsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + } + } + }, + "scattermapbox": { + "meta": { + "hrName": "scatter_mapbox", + "description": "The data visualized as scatter point, lines or marker symbols on a Mapbox GL geographic map is provided by longitude/latitude pairs in `lon` and `lat`." + }, + "attributes": { + "type": "scattermapbox", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "lon", + "lat", + "text", + "name", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, - "editType": "calc", - "gradient": { - "color": { - "arrayOk": true, - "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.", - "editType": "calc", + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", + "noBlank": true, + "strict": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "editType": "calc", - "role": "object", - "type": { - "arrayOk": true, - "description": "Sets the type of gradient used to fill the markers", - "dflt": "none", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "radial", - "horizontal", - "vertical", - "none" - ] - }, - "typesrc": { - "description": "Sets the source reference on plot.ly for type .", + "min": 1, "editType": "none", - "role": "info", - "valType": "string" - } - }, - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "arrayOk": true }, "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "valType": "color", "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "arrayOk": true }, + "editType": "none", + "description": "Sets the font used in hover labels.", "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "maxdisplayed": { - "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "opacity": { + "namelength": { + "valType": "integer", + "min": -1, "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "style", - "max": 1, - "min": 0, "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", "editType": "none", - "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, + "editType": "calc", "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, - "role": "style", - "valType": "number" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] - }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, "editType": "calc", - "role": "style", - "valType": "number" + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "style", + "role": "object" + }, + "lon": { + "valType": "data_array", + "description": "Sets the longitude coordinates (in degrees East).", + "editType": "calc", + "role": "data" + }, + "lat": { + "valType": "data_array", + "description": "Sets the latitude coordinates (in degrees North).", + "editType": "calc", + "role": "data" + }, + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], + "role": "info", + "editType": "calc", + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover.", + "dflt": "markers" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." + }, + "hovertext": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] + "editType": "calc", + "description": "Sets the line color." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "calc", + "description": "Sets the line width (in px)." }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], - "role": "info", - "valType": "flaglist" + "role": "object" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "connectgaps": { + "valType": "boolean", + "dflt": false, "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "r": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "rsrc": { - "description": "Sets the source reference on plot.ly for r .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "marker": { + "symbol": { + "valType": "string", + "dflt": "circle", + "role": "style", + "arrayOk": true, + "description": "Sets the marker symbol. Full list: https://www.mapbox.com/maki-icons/ Note that the array `marker.color` and `marker.size` are only available for *circle* symbols.", + "editType": "calc" }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, + "role": "style", "editType": "calc", - "max": 10000, + "description": "Sets the marker opacity." + }, + "size": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" + "dflt": 6, + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker size (in px)." }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", + "sizeref": { + "valType": "number", + "dflt": 1, + "role": "style", "editType": "calc", - "noBlank": true, + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "strict": true, - "valType": "string" - } - }, - "t": { - "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textfont": { + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." + }, "color": { + "valType": "color", "arrayOk": true, - "editType": "style", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "colorscale": { + "valType": "colorscale", + "role": "style", + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" + }, + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "cmin": { + "valType": "number", "role": "info", - "valType": "string" + "dflt": null, + "editType": "calc", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "role": "object", - "size": { - "arrayOk": true, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, "editType": "calc", - "min": 1, + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "string" - } - }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." + }, + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" + }, + "thickness": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" + }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" + }, + "xpad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" + }, + "ypad": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" + }, + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "outlinewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "calc" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" + }, + "editType": "calc", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "editType": "calc", + "role": "object", + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "tsrc": { - "description": "Sets the source reference on plot.ly for t .", - "editType": "none", - "role": "info", - "valType": "string" + "fill": { + "valType": "enumerated", + "values": [ + "none", + "toself" + ], + "dflt": "none", + "role": "style", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.", + "editType": "calc" }, - "type": "scatter", - "uid": { - "dflt": "", + "fillcolor": { + "valType": "color", + "role": "style", "editType": "calc", - "role": "info", - "valType": "string" + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, - "unselected": { - "editType": "style", + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": "Open Sans Regular, Arial Unicode MS Regular", + "editType": "calc" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "description": "Sets the icon text font. Has an effect only when `type` is set to *symbol*.", + "editType": "calc", + "role": "object" + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": false, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "selected": { "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, + "valType": "number", "min": 0, + "max": 1, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the marker opacity of selected points." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of selected points." }, - "role": "object", "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", + "valType": "number", "min": 0, "role": "style", - "valType": "number" - } + "editType": "calc", + "description": "Sets the marker size of selected points." + }, + "editType": "calc", + "role": "object" }, - "role": "object", - "textfont": { + "editType": "calc", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "calc", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker size of unselected points, applied only when a selection exists." }, - "editType": "style", + "editType": "calc", "role": "object" - } - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, + }, "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] + "role": "object" }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "subplot": { + "valType": "subplotid", + "role": "info", + "dflt": "mapbox", + "editType": "calc", + "description": "Sets a reference between this trace's data coordinates and a mapbox subplot. If *mapbox* (the default value), the data refer to `layout.mapbox`. If *mapbox2*, the data refer to `layout.mapbox2`, and so on." }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", + "idssrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "subplotid" + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", + "lonsrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for lon .", + "editType": "none" }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", + "latsrc": { + "valType": "string", "role": "info", - "valType": "subplotid" + "description": "Sets the source reference on plot.ly for lat .", + "editType": "none" }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", + "textsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + "hovertextsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" } - }, - "meta": { - "description": "The scatter trace type encompasses line charts, scatter charts, text charts, and bubble charts. The data visualized as scatter point or lines is set in `x` and `y`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays." } }, - "scatter3d": { + "sankey": { + "meta": { + "description": "Sankey plots for network flow data analysis. The nodes are specified in `nodes` and the links between sources and targets in `links`. The colors are set in `nodes[i].color` and `links[i].color`; otherwise defaults are used." + }, "attributes": { - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, + "type": "sankey", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", "role": "info", - "valType": "boolean" + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, "customdata": { + "valType": "data_array", + "editType": "calc", "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "hoverinfo": { + "valType": "flaglist", "role": "info", - "valType": "string" + "flags": [ + "label", + "text", + "value", + "percent", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "calc", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, - "error_x": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "calc", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the background color of the hover labels for this trace" }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "color": { - "description": "Sets the stoke color of the error bars.", + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "arrayOk": true + }, "editType": "calc", - "role": "style", - "valType": "color" + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "copy_zstyle": { - "editType": "calc", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, "editType": "calc", "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "traceref": { - "dflt": 0, - "editType": "calc", - "min": 0, + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "integer" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "tracerefminus": { - "dflt": 0, - "editType": "calc", - "min": 0, + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] - }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", + "maxpoints": { + "valType": "number", "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "calc", + "role": "object" }, - "error_y": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", + "transforms": { + "items": { + "transform": { "editType": "calc", - "role": "style", - "valType": "number" + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" } }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "role": "object" + }, + "domain": { + "x": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this sankey trace (in plot fraction).", + "editType": "calc" }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "y": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this sankey trace (in plot fraction).", + "editType": "calc" }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" + "description": "If there is a layout grid, use the domain for this row in the grid for this sankey trace .", + "editType": "calc" }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" + "description": "If there is a layout grid, use the domain for this column in the grid for this sankey trace .", + "editType": "calc" }, - "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "calc", + "editType": "calc", + "role": "object" + }, + "orientation": { + "valType": "enumerated", + "values": [ + "v", + "h" + ], + "dflt": "h", + "role": "style", + "description": "Sets the orientation of the Sankey diagram.", + "editType": "calc" + }, + "valueformat": { + "valType": "string", + "dflt": ".3s", + "role": "style", + "description": "Sets the value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", + "editType": "calc" + }, + "valuesuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "description": "Adds a unit to follow the value in the hover tooltip. Add a space if a separation is necessary from the value.", + "editType": "calc" + }, + "arrangement": { + "valType": "enumerated", + "values": [ + "snap", + "perpendicular", + "freeform", + "fixed" + ], + "dflt": "snap", + "role": "style", + "description": "If value is `snap` (the default), the node arrangement is assisted by automatic snapping of elements to preserve space between nodes specified via `nodepad`. If value is `perpendicular`, the nodes can only move along a line perpendicular to the flow. If value is `freeform`, the nodes can freely move on the plane. If value is `fixed`, the nodes are stationary.", + "editType": "calc" + }, + "textfont": { + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "copy_zstyle": { - "editType": "calc", + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "calc" }, + "description": "Sets the font for node labels", "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" + "role": "object" + }, + "node": { + "label": { + "valType": "data_array", + "dflt": [], + "role": "data", + "description": "The shown name of the node.", + "editType": "calc" }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "arrayOk": true, + "description": "Sets the `node` color. It can be a single value, or an array for specifying color for each `node`. If `node.color` is omitted, then the default `Plotly` color palette will be cycled through to have a variety of colors. These defaults are not fully opaque, to allow some visibility of what is beneath the node.", + "editType": "calc" }, - "traceref": { - "dflt": 0, + "line": { + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "arrayOk": true, + "description": "Sets the color of the `line` around each `node`.", + "editType": "calc" + }, + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0.5, + "arrayOk": true, + "description": "Sets the width (in px) of the `line` around each `node`.", + "editType": "calc" + }, "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + } }, - "tracerefminus": { - "dflt": 0, - "editType": "calc", + "pad": { + "valType": "number", + "arrayOk": false, "min": 0, - "role": "info", - "valType": "integer" - }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] + "dflt": 20, + "role": "style", + "description": "Sets the padding (in px) between the `nodes`.", + "editType": "calc" }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "thickness": { + "valType": "number", + "arrayOk": false, + "min": 1, + "dflt": 20, + "role": "style", + "description": "Sets the thickness (in px) of the `nodes`.", + "editType": "calc" }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", - "min": 0, + "description": "The nodes of the Sankey plot.", + "editType": "calc", + "role": "object", + "labelsrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for label .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "error_z": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "calc", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", + "link": { + "label": { + "valType": "data_array", + "dflt": [], "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "The shown name of the link.", + "editType": "calc" }, "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" + "arrayOk": true, + "description": "Sets the `link` color. It can be a single value, or an array for specifying color for each `link`. If `link.color` is omitted, then by default, a translucent grey link will be used.", + "editType": "calc" }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", + "line": { + "color": { + "valType": "color", + "role": "style", + "dflt": "#444", + "arrayOk": true, + "description": "Sets the color of the `line` around each `link`.", + "editType": "calc" + }, + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "arrayOk": true, + "description": "Sets the width (in px) of the `line` around each `link`.", + "editType": "calc" + }, "editType": "calc", - "role": "info", - "valType": "boolean" + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + } }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "source": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "An integer number `[0..nodes.length - 1]` that represents the source node.", + "editType": "calc" }, - "traceref": { - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "target": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "An integer number `[0..nodes.length - 1]` that represents the target node.", + "editType": "calc" }, - "tracerefminus": { - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "value": { + "valType": "data_array", + "dflt": [], + "role": "data", + "description": "A numeric value representing the flow volume value.", + "editType": "calc" }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", + "description": "The links of the Sankey plot.", + "editType": "calc", + "role": "object", + "labelsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "percent", - "constant", - "sqrt", - "data" - ] + "description": "Sets the source reference on plot.ly for label .", + "editType": "none" }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", - "min": 0, + "sourcesrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for source .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", + "targetsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for target .", + "editType": "none" }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "valuesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for value .", + "editType": "none" } }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + } + } + }, + "table": { + "meta": { + "description": "Table view for detailed data viewing. The data are arranged in a grid of rows and columns. Most styling can be specified for columns, rows or individual cells. Table is using a column-major order, ie. the grid is represented as a vector of column vectors." + }, + "attributes": { + "type": "table", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", "flags": [ "x", "y", @@ -28865,1371 +27626,2060 @@ "text", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "role": "object" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "autocolorscale": { - "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "cmax": { - "description": "Has an effect only if `line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "number" + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "cmin": { - "description": "Has an effect only if `line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `line.color` array index, and if set, `line.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" - }, - "dash": { - "description": "Sets the dash style of the lines.", - "dflt": "solid", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, "editType": "calc", - "reversescale": { - "description": "Has an effect only if `line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } }, - "role": "object", - "showscale": { - "description": "Has an effect only if `line.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "role": "object" + }, + "domain": { + "x": { + "valType": "info_array", "role": "info", - "valType": "boolean" + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this table trace (in plot fraction).", + "editType": "calc" }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "y": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "calc" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this table trace (in plot fraction).", + "editType": "calc" }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "boolean" + "description": "If there is a layout grid, use the domain for this row in the grid for this table trace .", + "editType": "calc" }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "number" + "description": "If there is a layout grid, use the domain for this column in the grid for this table trace .", + "editType": "calc" }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", + "editType": "calc", + "role": "object" + }, + "columnwidth": { + "valType": "number", + "arrayOk": true, + "dflt": null, + "role": "style", + "description": "The width of columns expressed as a ratio. Columns fill the available width in proportion of their specified column widths.", + "editType": "calc" + }, + "columnorder": { + "valType": "data_array", + "role": "data", + "description": "Specifies the rendered order of the data columns; for example, a value `2` at position `0` means that column index `0` in the data will be rendered as the third column, as columns have an index base of zero.", + "editType": "calc" + }, + "header": { + "values": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "Header cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.", + "editType": "calc" + }, + "format": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "Sets the cell value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", + "editType": "calc" + }, + "prefix": { + "valType": "string", + "arrayOk": true, "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "role": "style", + "description": "Prefix for cell values.", + "editType": "calc" }, - "color": { + "suffix": { + "valType": "string", "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "dflt": null, "role": "style", - "valType": "color" + "description": "Suffix for cell values.", + "editType": "calc" }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", + "height": { + "valType": "number", + "dflt": 28, + "role": "style", + "description": "The height of cells.", + "editType": "calc" + }, + "align": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "center", + "role": "style", + "editType": "calc", + "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", + "arrayOk": true + }, + "line": { + "width": { + "valType": "number", + "arrayOk": true, + "dflt": 1, "role": "style", - "valType": "color" + "editType": "calc" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "dflt": "grey", "role": "style", - "valType": "color" + "editType": "calc" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object", + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "fill": { + "color": { + "valType": "color", + "arrayOk": true, + "dflt": "white", "role": "style", - "valType": "any" + "description": "Sets the cell fill color. It accepts either a specific color or an array of colors.", + "editType": "calc" }, "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true, + "editType": "calc" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "arrayOk": true, + "editType": "calc" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", + "color": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "calc" + }, + "description": "", + "editType": "calc", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "editType": "calc", + "role": "object", + "valuessrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for values .", + "editType": "none" + }, + "formatsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for format .", + "editType": "none" + }, + "prefixsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for prefix .", + "editType": "none" + }, + "suffixsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for suffix .", + "editType": "none" + }, + "alignsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for align .", + "editType": "none" + } + }, + "cells": { + "values": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "Cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.", + "editType": "calc" + }, + "format": { + "valType": "data_array", + "role": "data", + "dflt": [], + "description": "Sets the cell value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", + "editType": "calc" + }, + "prefix": { + "valType": "string", + "arrayOk": true, + "dflt": null, + "role": "style", + "description": "Prefix for cell values.", + "editType": "calc" + }, + "suffix": { + "valType": "string", + "arrayOk": true, + "dflt": null, + "role": "style", + "description": "Suffix for cell values.", + "editType": "calc" + }, + "height": { + "valType": "number", + "dflt": 20, + "role": "style", + "description": "The height of cells.", + "editType": "calc" + }, + "align": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "center", + "role": "style", + "editType": "calc", + "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", + "arrayOk": true + }, + "line": { + "width": { + "valType": "number", + "arrayOk": true, + "dflt": 1, "role": "style", - "valType": "color" + "editType": "calc" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", + "arrayOk": true, + "dflt": "grey", "role": "style", - "valType": "number" + "editType": "calc" }, + "editType": "calc", "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "fill": { + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "dflt": "white", + "description": "Sets the cell fill color. It accepts either a specific color or an array of colors.", + "editType": "calc" }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "boolean" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true, + "editType": "calc" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 1, + "arrayOk": true, + "editType": "calc" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "arrayOk": true, + "editType": "calc" }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "", + "editType": "calc", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "editType": "calc", + "role": "object", + "valuessrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for values .", + "editType": "none" + }, + "formatsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for format .", + "editType": "none" + }, + "prefixsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for prefix .", + "editType": "none" + }, + "suffixsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for suffix .", + "editType": "none" + }, + "alignsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for align .", + "editType": "none" + } + }, + "editType": "calc", + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "columnwidthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for columnwidth .", + "editType": "none" + }, + "columnordersrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for columnorder .", + "editType": "none" + } + } + }, + "carpet": { + "meta": { + "description": "The data describing carpet axis layout is set in `y` and (optionally) also `x`. If only `y` is present, `x` the plot is interpreted as a cheater plot and is filled in using the `y` values. `x` and `y` may either be 2D arrays matching with each dimension matching that of `a` and `b`, or they may be 1D arrays with total length equal to that of `a` and `b`." + }, + "attributes": { + "type": "carpet", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" + }, + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "any" + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "angle" + "min": 1, + "editType": "none", + "arrayOk": true }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "color" + "editType": "none", + "arrayOk": true }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "sizesrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, + "role": "object" + }, + "transforms": { + "items": { + "transform": { "editType": "calc", - "impliedEdits": {}, + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "carpet": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "An identifier for this carpet, so that `scattercarpet` and `scattercontour` traces can specify a carpet plot on which they lie" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "A two dimensional array of x coordinates at each carpet point. If ommitted, the plot is a cheater plot and the xaxis is hidden by default.", + "role": "data" + }, + "y": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "A two dimensional array of y coordinates at each carpet point.", + "role": "data" + }, + "a": { + "valType": "data_array", + "editType": "calc", + "description": "An array containing values of the first parameter value", + "role": "data" + }, + "a0": { + "valType": "number", + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Alternate to `a`. Builds a linear space of a coordinates. Use with `da` where `a0` is the starting coordinate and `da` the step." + }, + "da": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the a coordinate step. See `a0` for more info." + }, + "b": { + "valType": "data_array", + "editType": "calc", + "description": "A two dimensional array of y coordinates at each carpet point.", + "role": "data" + }, + "b0": { + "valType": "number", + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Alternate to `b`. Builds a linear space of a coordinates. Use with `db` where `b0` is the starting coordinate and `db` the step." + }, + "db": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the b coordinate step. See `b0` for more info." + }, + "cheaterslope": { + "valType": "number", + "role": "info", + "dflt": 1, + "editType": "calc", + "description": "The shift applied to each successive row of data in creating a cheater plot. Only used if `x` is been ommitted." + }, + "aaxis": { + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "smoothing": { + "valType": "number", + "dflt": 1, + "min": 0, + "max": 1.3, + "role": "info", + "editType": "calc" + }, + "title": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "Sets the title of this axis." + }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, + "noBlank": true, + "strict": true, "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "calc" }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "color": { + "valType": "color", "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "calc" }, "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "width": { - "arrayOk": false, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "description": "Sets this axis' title font.", + "role": "object" }, - "opacity": { - "arrayOk": false, - "description": "Sets the marker opacity. Note that the marker opacity for scatter3d traces must be a scalar value for performance reasons. To set a blending opacity value (i.e. which is not transparent), set *marker.color* to an rgba color and use its alpha channel.", + "titleoffset": { + "valType": "number", + "role": "info", + "dflt": 10, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "An additional amount by which to offset the title from the tick labels, given in pixels" }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "calc", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, + "role": "style", "editType": "calc", + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." + }, + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", + "range": { + "valType": "info_array", + "role": "info", + "editType": "calc", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "fixedrange": { + "valType": "boolean", "dflt": false, + "role": "info", "editType": "calc", + "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled." + }, + "cheatertype": { + "valType": "enumerated", + "values": [ + "index", + "value" + ], + "dflt": "value", "role": "info", - "valType": "boolean" + "editType": "calc" }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 8, - "editType": "calc", + "tickmode": { + "valType": "enumerated", + "values": [ + "linear", + "array" + ], + "dflt": "array", + "role": "info", + "editType": "calc" + }, + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, + "tickvals": { + "valType": "data_array", "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", + "ticktext": { + "valType": "data_array", "editType": "calc", - "role": "info", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "showticklabels": { "valType": "enumerated", "values": [ - "diameter", - "area" - ] - }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", + "start", + "end", + "both", + "none" + ], + "dflt": "start", "role": "style", - "valType": "number" + "editType": "calc", + "description": "Determines whether axis labels are drawn on the low side, the high side, both, or neither side of the axis." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "editType": "calc", + "description": "Sets the tick font.", + "role": "object" }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type.", - "dflt": "circle", + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ - "circle", - "circle-open", - "square", - "square-open", - "diamond", - "diamond-open", - "cross", - "x" - ] - }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", "role": "info", - "valType": "string" - } - }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "dflt": "lines+markers", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], - "role": "info", - "valType": "flaglist" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "projection": { + "editType": "calc", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "labelpadding": { + "valType": "integer", + "role": "style", + "dflt": 10, + "editType": "calc", + "description": "Extra padding between label and the axis" + }, + "labelprefix": { + "valType": "string", + "role": "style", + "editType": "calc", + "description": "Sets a axis label prefix." + }, + "labelsuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a axis label suffix." + }, + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "gridcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." + }, + "minorgridcount": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Sets the number of minor grid ticks per major grid tick" + }, + "minorgridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the grid lines." + }, + "minorgridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "calc", + "description": "Sets the color of the grid lines." + }, + "startline": { + "valType": "boolean", + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line is drawn at along the starting value of this axis. If *true*, the start line is drawn on top of the grid lines." + }, + "startlinecolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the line color of the start line." + }, + "startlinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the start line." + }, + "endline": { + "valType": "boolean", + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line is drawn at along the final value of this axis. If *true*, the end line is drawn on top of the grid lines." + }, + "endlinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the end line." + }, + "endlinecolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the line color of the end line." + }, + "tick0": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "The starting index of grid lines along the axis" + }, + "dtick": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "The stride between grid lines along the axis" + }, + "arraytick0": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "The starting index of grid lines along the axis" + }, + "arraydtick": { + "valType": "integer", + "min": 1, + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "The stride between grid lines along the axis" + }, "editType": "calc", "role": "object", - "x": { + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + }, + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + } + }, + "baxis": { + "color": { + "valType": "color", + "role": "style", "editType": "calc", - "opacity": { - "description": "Sets the projection color.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "scale": { - "description": "Sets the scale factor determining the size of the projection marker points.", - "dflt": 0.6666666666666666, - "editType": "calc", - "max": 10, - "min": 0, - "role": "style", - "valType": "number" - }, - "show": { - "description": "Sets whether or not projections are shown along the x axis.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "y": { + "smoothing": { + "valType": "number", + "dflt": 1, + "min": 0, + "max": 1.3, + "role": "info", + "editType": "calc" + }, + "title": { + "valType": "string", + "role": "info", "editType": "calc", - "opacity": { - "description": "Sets the projection color.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, + "description": "Sets the title of this axis." + }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "number" - }, - "role": "object", - "scale": { - "description": "Sets the scale factor determining the size of the projection marker points.", - "dflt": 0.6666666666666666, + "noBlank": true, + "strict": true, "editType": "calc", - "max": 10, - "min": 0, - "role": "style", - "valType": "number" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "show": { - "description": "Sets whether or not projections are shown along the y axis.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "z": { - "editType": "calc", - "opacity": { - "description": "Sets the projection color.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, + "size": { + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "calc" }, - "role": "object", - "scale": { - "description": "Sets the scale factor determining the size of the projection marker points.", - "dflt": 0.6666666666666666, - "editType": "calc", - "max": 10, - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "calc" }, - "show": { - "description": "Sets whether or not projections are shown along the z axis.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - } - }, - "scene": { - "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.", - "dflt": "scene", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "description": "Sets this axis' title font.", + "role": "object" }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", + "titleoffset": { + "valType": "number", + "role": "info", + "dflt": 10, "editType": "calc", - "noBlank": true, + "description": "An additional amount by which to offset the title from the tick labels, given in pixels" + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "date", + "category" + ], + "dflt": "-", "role": "info", - "strict": true, - "valType": "string" - } - }, - "surfaceaxis": { - "description": "If *-1*, the scatter points are not fill with a surface If *0*, *1*, *2*, the scatter points are filled with a Delaunay surface about the x, y, z respectively.", - "dflt": -1, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - -1, - 0, - 1, - 2 - ] - }, - "surfacecolor": { - "description": "Sets the surface fill color.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textfont": { - "color": { - "arrayOk": true, "editType": "calc", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", + "role": "style", + "editType": "calc", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." + }, + "range": { + "valType": "info_array", "role": "info", - "valType": "string" + "editType": "calc", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "fixedrange": { + "valType": "boolean", + "dflt": false, + "role": "info", "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled." }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "cheatertype": { + "valType": "enumerated", + "values": [ + "index", + "value" + ], + "dflt": "value", "role": "info", - "valType": "string" + "editType": "calc" }, - "role": "object", - "size": { - "arrayOk": true, + "tickmode": { + "valType": "enumerated", + "values": [ + "linear", + "array" + ], + "dflt": "array", + "role": "info", + "editType": "calc" + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", "editType": "calc", - "min": 1, + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "showticklabels": { + "valType": "enumerated", + "values": [ + "start", + "end", + "both", + "none" + ], + "dflt": "start", "role": "style", - "valType": "number" + "editType": "calc", + "description": "Determines whether axis labels are drawn on the low side, the high side, both, or neither side of the axis." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "editType": "calc", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "calc" + }, + { + "valType": "any", + "editType": "calc" + } + ], + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "calc", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "labelpadding": { + "valType": "integer", + "role": "style", + "dflt": 10, + "editType": "calc", + "description": "Extra padding between label and the axis" + }, + "labelprefix": { + "valType": "string", + "role": "style", + "editType": "calc", + "description": "Sets a axis label prefix." + }, + "labelsuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "calc", + "description": "Sets a axis label suffix." + }, + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "gridcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the axis line color." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." + }, + "minorgridcount": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Sets the number of minor grid ticks per major grid tick" + }, + "minorgridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the grid lines." + }, + "minorgridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "calc", + "description": "Sets the color of the grid lines." + }, + "startline": { + "valType": "boolean", + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line is drawn at along the starting value of this axis. If *true*, the start line is drawn on top of the grid lines." + }, + "startlinecolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the line color of the start line." + }, + "startlinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the start line." + }, + "endline": { + "valType": "boolean", + "role": "style", + "editType": "calc", + "description": "Determines whether or not a line is drawn at along the final value of this axis. If *true*, the end line is drawn on top of the grid lines." + }, + "endlinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the end line." + }, + "endlinecolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the line color of the end line." + }, + "tick0": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "The starting index of grid lines along the axis" + }, + "dtick": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "The stride between grid lines along the axis" + }, + "arraytick0": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "The starting index of grid lines along the axis" + }, + "arraydtick": { + "valType": "integer", + "min": 1, + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "The stride between grid lines along the axis" + }, + "editType": "calc", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + }, + "categoryarraysrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" } }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "top center", + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": "\"Open Sans\", verdana, arial, sans-serif" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc", + "dflt": 12 + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc", + "dflt": "#444" + }, "editType": "calc", + "description": "The default font used for axis & tick labels on this carpet", + "role": "object" + }, + "color": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", + "xaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "yaxis": { + "valType": "subplotid", "role": "info", - "valType": "string" + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." }, - "type": "scatter3d", - "uid": { - "dflt": "", - "editType": "calc", + "idssrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" }, "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" - }, - "z": { - "description": "Sets the z coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for y .", + "editType": "none" }, - "zcalendar": { - "description": "Sets the calendar system to use with `z` date data.", - "dflt": "gregorian", - "editType": "calc", + "asrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] + "description": "Sets the source reference on plot.ly for a .", + "editType": "none" }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", + "bsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for b .", + "editType": "none" } - }, - "meta": { - "description": "The data visualized as scatter point or lines in 3D dimension is set in `x`, `y`, `z`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` Projections are achieved via `projection`. Surface fills are achieved via `surfaceaxis`.", - "hrName": "scatter_3d" } }, "scattercarpet": { + "meta": { + "hrName": "scatter_carpet", + "description": "Plots a scatter trace on either the first carpet axis or the carpet axis with a matching `carpet` attribute." + }, "attributes": { - "a": { - "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "type": "scattercarpet", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "asrc": { - "description": "Sets the source reference on plot.ly for a .", - "editType": "none", + "showlegend": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "b": { - "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "bsrc": { - "description": "Sets the source reference on plot.ly for b .", - "editType": "none", + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", "role": "info", - "valType": "string" + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." }, - "carpet": { - "description": "An identifier for this carpet, so that `scattercarpet` and `scattercontour` traces can specify a carpet plot on which they lie", - "editType": "calc", + "uid": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "calc" }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, + "ids": { + "valType": "data_array", "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" }, "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "selectedpoints": { + "valType": "any", "role": "info", - "valType": "string" - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterternary has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "toself", - "tonext" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "a", "b", @@ -30237,145 +29687,193 @@ "name", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, "namelengthsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, + "editType": "calc", "role": "object" }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "style", - "flags": [ - "points", - "fills" - ], + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "carpet": { + "valType": "string", "role": "info", - "valType": "flaglist" + "editType": "calc", + "description": "An identifier for this carpet, so that `scattercarpet` and `scattercontour` traces can specify a carpet plot on which they lie" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "a": { + "valType": "data_array", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "role": "data" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "b": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", + "role": "data" + }, + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", + "dflt": "markers" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "text": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c)." }, "line": { "color": { - "description": "Sets the line color.", + "valType": "color", + "role": "style", "editType": "style", + "description": "Sets the line color." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the line width (in px)." }, "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", "valType": "string", "values": [ "solid", @@ -30384,732 +29882,62 @@ "longdash", "dashdot", "longdashdot" - ] + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "editType": "calc", - "role": "object", "shape": { - "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes.", - "dflt": "linear", - "editType": "plot", - "role": "style", "valType": "enumerated", "values": [ "linear", "spline" - ] + ], + "dflt": "linear", + "role": "style", + "editType": "plot", + "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes." }, "smoothing": { - "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape).", - "dflt": 1, - "editType": "plot", - "max": 1.3, + "valType": "number", "min": 0, + "max": 1.3, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape)." }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "calc", + "role": "object" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." + }, + "fill": { + "valType": "enumerated", + "values": [ + "none", + "toself", + "tonext" + ], + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterternary has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "gradient": { - "color": { - "arrayOk": true, - "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object", - "type": { - "arrayOk": true, - "description": "Sets the type of gradient used to fill the markers", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "radial", - "horizontal", - "vertical", - "none" - ] - }, - "typesrc": { - "description": "Sets the source reference on plot.ly for type .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "line": { - "autocolorscale": { - "description": "Has an effect only if `color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `color` array index, and if set, `cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `color` array index, and if set, `cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "maxdisplayed": { - "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, - "role": "style", - "valType": "number" - }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] - }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - }, "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "style", - "role": "style", "valType": "enumerated", "values": [ 0, @@ -31396,2894 +30224,3214 @@ "line-nw", 144, "line-nw-open" - ] + ], + "dflt": "circle", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity." + }, + "maxdisplayed": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit." + }, + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." + }, + "sizeref": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "string" - } - }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "dflt": "markers", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], - "role": "info", - "valType": "flaglist" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selected": { - "editType": "style", - "marker": { + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." + }, + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points." + }, + "editType": "calc", "color": { - "description": "Sets the marker color of selected points.", + "valType": "color", + "arrayOk": true, + "role": "style", "editType": "style", + "description": "Sets the color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." + }, + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `color` array index, and if set, `cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `color` array index, and if set, `cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, + "reversescale": { + "valType": "boolean", "role": "style", - "valType": "number" + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "role": "object", - "textfont": { + "gradient": { + "type": { + "valType": "enumerated", + "values": [ + "radial", + "horizontal", + "vertical", + "none" + ], + "arrayOk": true, + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the type of gradient used to fill the markers" + }, "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical." }, - "editType": "style", - "role": "object" - } - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "role": "object", + "typesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for type .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c).", - "dflt": "", "editType": "calc", - "role": "info", - "valType": "string" - }, - "textfont": { "color": { + "valType": "color", "arrayOk": true, + "role": "style", "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "color" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": true, "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "cmax": { + "valType": "number", "role": "info", - "valType": "string" - } - }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "scattercarpet", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "editType": "style", - "role": "object" - } - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - } - }, - "meta": { - "description": "Plots a scatter trace on either the first carpet axis or the carpet axis with a matching `carpet` attribute.", - "hrName": "scatter_carpet" - } - }, - "scattergeo": { - "attributes": { - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "toself" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "geo": { - "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.", - "dflt": "geo", - "editType": "calc", - "role": "info", - "valType": "subplotid" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "lon", - "lat", - "location", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", - "role": "style", - "valType": "color" + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", + "cmin": { + "valType": "number", "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "lat": { - "description": "Sets the latitude coordinates (in degrees North).", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "latsrc": { - "description": "Sets the source reference on plot.ly for lat .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "calc", - "role": "style", - "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "editType": "calc", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "locationmode": { - "description": "Determines the set of locations used to match entries in `locations` to regions on the map.", - "dflt": "ISO-3", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "ISO-3", - "USA-states", - "country names" - ] - }, - "locations": { - "description": "Sets the coordinates via location IDs or names. Coordinates correspond to the centroid of each location given. See `locationmode` for more info.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "locationssrc": { - "description": "Sets the source reference on plot.ly for locations .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "lon": { - "description": "Sets the longitude coordinates (in degrees East).", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "lonsrc": { - "description": "Sets the source reference on plot.ly for lon .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "marker": { "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "valType": "boolean", "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "dflt": false, "editType": "calc", - "role": "style", - "valType": "color" + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" + }, + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "any" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets the axis line color." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + "bgcolor": { + "valType": "color", "role": "style", - "valType": "boolean" + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", - "role": "style", + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", + "tick0": { + "valType": "any", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, "role": "style", - "valType": "any" + "editType": "colorbars", + "description": "Sets the tick length (in px)." }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "calc", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, + ], "role": "style", - "valType": "number" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" + "role": "object", + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, "colorsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "editType": "none" + } + }, + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "arrayOk": true + }, + "editType": "calc", + "description": "Sets the text font.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": true, + "role": "style", "editType": "calc", - "gradient": { - "color": { - "arrayOk": true, - "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.", - "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "style", + "description": "Sets the marker opacity of selected points." }, - "editType": "calc", - "role": "object", - "type": { - "arrayOk": true, - "description": "Sets the type of gradient used to fill the markers", - "dflt": "none", - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "radial", - "horizontal", - "vertical", - "none" - ] + "editType": "style", + "description": "Sets the marker color of selected points." }, - "typesrc": { - "description": "Sets the source reference on plot.ly for type .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "size": { + "valType": "number", + "min": 0, "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "editType": "style", + "description": "Sets the marker size of selected points." }, + "editType": "style", + "role": "object" + }, + "textfont": { "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the text font color of selected points." }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "calc", + "size": { + "valType": "number", "min": 0, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "opacity": { + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], + "role": "info", + "editType": "style", + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "asrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for a .", + "editType": "none" + }, + "bsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for b .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + }, + "textpositionsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + } + } + }, + "contourcarpet": { + "meta": { + "hrName": "contour_carpet", + "description": "Plots contours on either the first carpet axis or the carpet axis with a matching `carpet` attribute. Data `z` is interpreted as matching that of the corresponding carpet axis." + }, + "attributes": { + "type": "contourcarpet", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "calc", - "max": 1, - "min": 0, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" + }, + "bordercolor": { + "valType": "color", "role": "style", - "valType": "number" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, "role": "style", - "valType": "boolean" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, + "editType": "calc", "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "carpet": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "The `carpet` of the carpet axes on which this contour trace lies" + }, + "z": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the z data.", + "role": "data" + }, + "a": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates.", + "impliedEdits": { + "xtype": "array" + }, + "role": "data" + }, + "a0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", + "impliedEdits": { + "xtype": "scaled" + } + }, + "da": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the x coordinate step. See `x0` for more info.", + "impliedEdits": { + "xtype": "scaled" + } + }, + "b": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the y coordinates.", + "impliedEdits": { + "ytype": "array" + }, + "role": "data" + }, + "b0": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", + "impliedEdits": { + "ytype": "scaled" + } + }, + "db": { + "valType": "number", + "dflt": 1, + "role": "info", + "editType": "calc", + "description": "Sets the y coordinate step. See `y0` for more info.", + "impliedEdits": { + "ytype": "scaled" + } + }, + "text": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text elements associated with each z value.", + "role": "data" + }, + "transpose": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Transposes the z data." + }, + "atype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided)." + }, + "btype": { + "valType": "enumerated", + "values": [ + "array", + "scaled" + ], + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)" + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the fill color if `contours.type` is *constraint*. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "autocontour": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`." + }, + "ncontours": { + "valType": "integer", + "dflt": 15, + "min": 1, + "role": "style", + "editType": "calc", + "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing." + }, + "contours": { + "type": { + "valType": "enumerated", + "values": [ + "levels", + "constraint" + ], + "dflt": "levels", + "role": "info", "editType": "calc", + "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters." + }, + "start": { + "valType": "number", + "dflt": null, + "role": "style", + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the starting contour level value. Must be less than `contours.end`" + }, + "end": { + "valType": "number", + "dflt": null, + "role": "style", + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the end contour level value. Must be more than `contours.start`" + }, + "size": { + "valType": "number", + "dflt": null, "min": 0, "role": "style", - "valType": "number" + "editType": "plot", + "impliedEdits": { + "^autocontour": false + }, + "description": "Sets the step between each contour level. Must be positive." }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", - "role": "info", + "coloring": { "valType": "enumerated", "values": [ - "diameter", - "area" - ] - }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, + "fill", + "lines", + "none" + ], + "dflt": "fill", + "role": "style", "editType": "calc", + "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace." + }, + "showlines": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "showlabels": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether to label the contour lines with their values." + }, + "labelfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style" + }, + "editType": "plot", + "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.", + "role": "object" + }, + "labelformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the contour label formatting rule using d3 formatting mini-language which is very similar to Python, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format." + }, + "operation": { + "valType": "enumerated", + "values": [ + "=", + "<", + ">=", + ">", + "<=", + "[]", + "()", + "[)", + "(]", + "][", + ")(", + "](", + ")[" + ], "role": "info", - "valType": "string" + "dflt": "=", + "editType": "calc", + "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms." }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", + "value": { + "valType": "any", + "dflt": 0, + "role": "info", "editType": "calc", + "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (=,<,>=,>,<=) *value* is expected to be a number. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound." + }, + "editType": "calc", + "impliedEdits": { + "autocontour": false, + "role": "object" + }, + "role": "object" + }, + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", + "editType": "style", + "description": "Sets the color of the contour level. Has no if `contours.coloring` is set to *lines*." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "style", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "string", "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" - } + "smoothing": { + "valType": "number", + "min": 0, + "max": 1.3, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing." + }, + "editType": "plot", + "role": "object" }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "dflt": "markers", + "zauto": { + "valType": "boolean", + "role": "info", + "dflt": true, "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], + "impliedEdits": {}, + "description": "Determines the whether or not the color domain is computed with respect to the input data." + }, + "zmin": { + "valType": "number", "role": "info", - "valType": "flaglist" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the lower bound of color domain." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "zmax": { + "valType": "number", "role": "info", - "valType": "string" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "zauto": false + }, + "description": "Sets the upper bound of color domain." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "number" - }, - "selected": { "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "impliedEdits": { + "autocolorscale": false }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "role": "object" - } + "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "impliedEdits": {}, + "description": "Determines whether or not the colorscale is picked using the sign of the input z values." }, - "stream": { + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "description": "Reverses the colorscale." }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", + "showscale": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "editType": "calc", + "description": "Determines whether or not a colorbar is displayed for this trace." }, - "textfont": { - "color": { - "arrayOk": true, - "editType": "calc", + "colorbar": { + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "thickness": { + "valType": "number", "role": "style", - "strict": true, - "valType": "string" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "info", - "valType": "string" + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "scattergeo", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, + "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "role": "object" - } - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "The data visualized as scatter point or lines on a geographic map is provided either by longitude/latitude pairs in `lon` and `lat` respectively or by geographic location IDs or names in `locations`.", - "hrName": "scatter_geo" - } - }, - "scattergl": { - "attributes": { - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "dx": { - "description": "Sets the x coordinate step. See `x0` for more info.", - "dflt": 1, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "dy": { - "description": "Sets the y coordinate step. See `y0` for more info.", - "dflt": 1, - "editType": "calc", - "role": "info", - "valType": "number" - }, - "error_x": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "calc", - "role": "style", - "valType": "number" - } - }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "copy_ystyle": { - "editType": "calc", + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "boolean" - }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "calc", - "min": 0, + "xpad": { + "valType": "number", "role": "style", - "valType": "number" - }, - "traceref": { - "dflt": 0, - "editType": "calc", "min": 0, - "role": "info", - "valType": "integer" + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" }, - "tracerefminus": { - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "y": { + "valType": "number", + "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "percent", - "constant", - "sqrt", - "data" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", + "ypad": { + "valType": "number", + "role": "style", "min": 0, - "role": "info", - "valType": "number" - }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", - "role": "info", - "valType": "boolean" + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "calc", + "outlinewidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "error_y": { - "_deprecated": { - "opacity": { - "description": "Obsolete. Use the alpha channel in error bar `color` to set the opacity.", - "editType": "calc", - "role": "style", - "valType": "number" - } + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "array": { - "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." }, - "arrayminus": { - "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" }, - "arrayminussrc": { - "description": "Sets the source reference on plot.ly for arrayminus .", - "editType": "none", - "role": "info", - "valType": "string" + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" }, - "arraysrc": { - "description": "Sets the source reference on plot.ly for array .", - "editType": "none", + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "color": { - "description": "Sets the stoke color of the error bars.", - "editType": "calc", + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "editType": "calc", - "role": "object", - "symmetric": { - "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.", - "editType": "calc", - "role": "info", - "valType": "boolean" + "tick0": { + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "thickness": { - "description": "Sets the thickness (in px) of the error bars.", - "dflt": 2, - "editType": "calc", - "min": 0, + "dtick": { + "valType": "any", "role": "style", - "valType": "number" + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "traceref": { - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" }, - "tracerefminus": { - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" }, - "type": { - "description": "Determines the rule used to generate the error bars. If *constant`, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the sqaure of the underlying data. If *array*, the bar lengths are set with data set `array`.", - "editType": "calc", - "role": "info", + "ticks": { "valType": "enumerated", "values": [ - "percent", - "constant", - "sqrt", - "data" - ] - }, - "value": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" + "outside", + "inside", + "" + ], + "role": "style", + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "valueminus": { - "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars", - "dflt": 10, - "editType": "calc", + "ticklen": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" - }, - "visible": { - "description": "Determines whether or not this set of error bars is visible.", - "editType": "calc", - "role": "info", - "valType": "boolean" + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." }, - "width": { - "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.", - "editType": "calc", + "tickwidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "tozeroy", - "tozerox", - "tonexty", - "tonextx", - "toself", - "tonext" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "tickcolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick color." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", + "tickfont": { "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "role": "object" - }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "calc", - "flags": [ - "points", - "fills" - ], - "role": "info", - "valType": "flaglist" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "calc", + "tickformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "dash": { - "description": "Sets the style of the lines.", - "dflt": "solid", - "editType": "calc", + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "colorbars" + }, + { + "valType": "any", + "editType": "colorbars" + } + ], + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" + } + }, + "role": "object" + }, + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", + "editType": "colorbars", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "calc", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "calc", - "min": 0, + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" - } - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "boolean" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", + "title": { + "valType": "string", + "role": "info", + "description": "Sets the title of the color bar.", + "editType": "colorbars" + }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "colorbars" }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "colorbars" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" + }, + "titleside": { + "valType": "enumerated", + "values": [ + "right", + "top", + "bottom" + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" + }, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "zsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for z .", + "editType": "none" + }, + "asrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for a .", + "editType": "none" + }, + "bsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for b .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "ohlc": { + "meta": { + "description": "The ohlc (short for Open-High-Low-Close) is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The tip of the lines represent the `low` and `high` values and the horizontal segments represent the `open` and `close` values. Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing items are drawn in green whereas decreasing are drawn in red." + }, + "attributes": { + "type": "ohlc", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" + }, + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." + }, + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "any" + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "min": 1, + "editType": "none", + "arrayOk": true }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates. If absent, linear coordinate will be generated.", + "role": "data" + }, + "open": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the open values.", + "role": "data" + }, + "high": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the high values.", + "role": "data" + }, + "low": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the low values.", + "role": "data" + }, + "close": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the close values.", + "role": "data" + }, + "line": { + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "style", + "description": "[object Object] Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`." + }, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*). Note that this style setting can also be set per direction via `increasing.line.dash` and `decreasing.line.dash`." + }, + "editType": "style", + "role": "object" + }, + "increasing": { + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the line color.", + "dflt": "#3D9970" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", + "width": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "editType": "style", + "description": "Sets the line width (in px)." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", + "dash": { + "valType": "string", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "decreasing": { + "line": { + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "style", + "description": "Sets the line color.", + "dflt": "#FF4136" }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", + "width": { + "valType": "number", "min": 0, + "dflt": 2, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the line width (in px)." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", - "role": "style", - "valType": "enumerated", + "dash": { + "valType": "string", "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "calc", + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "style", + "role": "object" }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "editType": "style", + "role": "object" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "max": 0.5, + "dflt": 0.3, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the width of the open/close tick marks relative to the *x* minimal interval." + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "opensrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for open .", + "editType": "none" + }, + "highsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for high .", + "editType": "none" + }, + "lowsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for low .", + "editType": "none" + }, + "closesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for close .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "candlestick": { + "meta": { + "description": "The candlestick is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The boxes represent the spread between the `open` and `close` values and the lines represent the spread between the `low` and `high` values Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing candles are drawn in green whereas decreasing are drawn in red." + }, + "attributes": { + "type": "candlestick", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "colorscale" + "arrayOk": true, + "editType": "none", + "description": "Sets the background color of the hover labels for this trace" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", + "bordercolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, + "size": { + "valType": "number", "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", + "min": 1, "editType": "none", - "role": "info", - "valType": "string" + "arrayOk": true }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "boolean" + "editType": "none", + "arrayOk": true }, + "editType": "none", + "description": "Sets the font used in hover labels.", "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "opacity": { + "namelength": { + "valType": "integer", + "min": -1, "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "calc", - "max": 1, - "min": 0, "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", "editType": "none", - "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, + "editType": "calc", "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "boolean" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", + "namelengthsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the x coordinates. If absent, linear coordinate will be generated.", + "role": "data" + }, + "open": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the open values.", + "role": "data" + }, + "high": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the high values.", + "role": "data" + }, + "low": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the low values.", + "role": "data" + }, + "close": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the close values.", + "role": "data" + }, + "line": { + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 2, + "editType": "style", + "description": "Sets the width (in px) of line bounding the box(es). Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`." + }, + "editType": "style", + "role": "object" + }, + "increasing": { + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the color of line bounding the box(es).", + "dflt": "#3D9970" + }, + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 2, + "editType": "style", + "description": "Sets the width (in px) of line bounding the box(es)." + }, + "editType": "style", + "role": "object" + }, + "fillcolor": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", + "editType": "style", + "role": "object" + }, + "decreasing": { + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the color of line bounding the box(es).", + "dflt": "#FF4136" + }, + "width": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 2, + "editType": "style", + "description": "Sets the width (in px) of line bounding the box(es)." + }, + "editType": "style", + "role": "object" + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "editType": "style", + "role": "object" + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points." + }, + "whiskerwidth": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the width of the whiskers relative to the box' width. For example, with 1, the whiskers are as wide as the box(es)." + }, + "xcalendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use with `x` date data." + }, + "xaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "x", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on." + }, + "yaxis": { + "valType": "subplotid", + "role": "info", + "dflt": "y", + "editType": "calc+clearAxisTypes", + "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "xsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for x .", + "editType": "none" + }, + "opensrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for open .", + "editType": "none" + }, + "highsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for high .", + "editType": "none" + }, + "lowsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for low .", + "editType": "none" + }, + "closesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for close .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + }, + "layoutAttributes": { + "boxmode": { + "valType": "enumerated", + "values": [ + "group", + "overlay" + ], + "dflt": "overlay", + "role": "info", + "editType": "calc", + "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes." + }, + "boxgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates." + }, + "boxgroupgap": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0.3, + "role": "style", + "editType": "calc", + "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate." + } + } + }, + "scatterpolar": { + "meta": { + "hrName": "scatter_polar", + "description": "The scatterpolar trace type encompasses line charts, scatter charts, text charts, and bubble charts in polar coordinates. The data visualized as scatter point or lines is set in `r` (radial) and `theta` (angular) coordinates Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays." + }, + "attributes": { + "type": "scatterpolar", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "r", + "theta", + "text", + "name", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, - "symbol": { + "bordercolor": { + "valType": "color", + "role": "style", "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "namelength": { + "valType": "integer", + "min": -1, + "arrayOk": true, + "role": "style", + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" + }, + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], + "role": "info", + "editType": "calc", + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*." + }, + "r": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the radial coordinates", + "role": "data" + }, + "theta": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the angular coordinates", + "role": "data" + }, + "thetaunit": { + "valType": "enumerated", + "values": [ + "radians", + "degrees", + "gradians" + ], + "dflt": "degrees", + "role": "info", + "editType": "calc+clearAxisTypes", + "description": "Sets the unit of input *theta* values. Has an effect only when on *linear* angular axes." + }, + "text": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." + }, + "hovertext": { + "valType": "string", + "role": "info", + "dflt": "", + "arrayOk": true, + "editType": "style", + "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag." + }, + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the line color." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "style", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "style", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "shape": { + "valType": "enumerated", + "values": [ + "linear", + "spline" + ], + "dflt": "linear", + "role": "style", + "editType": "plot", + "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes." + }, + "smoothing": { + "valType": "number", + "min": 0, + "max": 1.3, + "dflt": 1, "role": "style", + "editType": "plot", + "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape)." + }, + "editType": "calc", + "role": "object" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." + }, + "marker": { + "symbol": { "valType": "enumerated", "values": [ 0, @@ -34570,1346 +33718,1015 @@ "line-nw", 144, "line-nw-open" - ] + ], + "dflt": "circle", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "mode": { - "description": "Determines the drawing mode for this scatter trace.", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers" - ], - "role": "info", - "valType": "flaglist" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, + "opacity": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair to appear on hover. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "scattergl", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", - "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.", - "dflt": 0, - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data visualized as scatter point or lines is set in `x` and `y` using the WebGL plotting engine. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to a numerical arrays.", - "hrName": "scatter_gl" - } - }, - "scattermapbox": { - "attributes": { - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "toself" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "lon", - "lat", - "text", - "name", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { + "max": 1, "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "style", + "description": "Sets the marker opacity." }, - "bordercolor": { + "size": { + "valType": "number", + "min": 0, + "dflt": 6, "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "maxdisplayed": { + "valType": "number", + "min": 0, + "dflt": 0, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit." }, - "role": "object" - }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "lat": { - "description": "Sets the latitude coordinates (in degrees North).", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "latsrc": { - "description": "Sets the source reference on plot.ly for lat .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "calc", + "sizeref": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "color" - }, - "editType": "calc", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" - } - }, - "lon": { - "description": "Sets the longitude coordinates (in degrees East).", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "lonsrc": { - "description": "Sets the source reference on plot.ly for lon .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "showscale": { + "valType": "boolean", "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", + "dflt": false, "editType": "calc", - "role": "style", - "valType": "color" + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", + "thicknessmode": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "fraction", + "pixels" + ], + "role": "style", + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "colorbars" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, + "thickness": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "colorbars" }, "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "fraction", "pixels" - ] + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "colorbars" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", + "len": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "integer" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "colorbars" }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", - "valType": "color" + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "colorbars" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", "role": "style", - "valType": "number" + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "colorbars" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", + "xpad": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "colorbars" }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "y": { + "valType": "number", "role": "style", + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "colorbars" + }, + "yanchor": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + "top", + "middle", + "bottom" + ], "role": "style", - "valType": "boolean" + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "colorbars" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "ypad": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "colorbars" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", + "outlinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "colorbars", + "description": "Sets the axis line color." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", + "outlinewidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "Sets the width (in px) of the axis line." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "colorbars", + "description": "Sets the axis line color." + }, + "borderwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "colorbars" + }, + "bgcolor": { + "valType": "color", "role": "style", + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "colorbars" + }, + "tickmode": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "colorbars", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "colorbars", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", + "valType": "any", + "role": "style", + "editType": "colorbars", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "colorbars", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "colorbars", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "colorbars", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "colorbars", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "colorbars", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "colorbars", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "colorbars", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets the color bar's tick label font", + "editType": "colorbars", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "colorbars", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" }, { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "colorbars" } ], - "role": "info", - "valType": "info_array" + "editType": "colorbars", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "calc", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - } + "editType": "colorbars", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "colorbars", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "colorbars", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "editType": "colorbars", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "colorbars", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "colorbars", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "colorbars", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "colorbars", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "colorbars" }, "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "colorbars" }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "colorbars" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "colorbars" + }, + "description": "Sets this color bar's title font.", + "editType": "colorbars", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] + ], + "role": "style", + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "colorbars" }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, + "editType": "colorbars", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "line": { + "width": { + "valType": "number", + "min": 0, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the width (in px) of the lines bounding the marker points." }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "editType": "style", + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "number" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, + "cauto": { + "valType": "boolean", + "role": "info", + "dflt": true, "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", + "cmax": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." + }, + "cmin": { + "valType": "number", + "role": "info", + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "widthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "gradient": { + "type": { "valType": "enumerated", "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, + "radial", + "horizontal", + "vertical", + "none" + ], + "arrayOk": true, + "dflt": "none", + "role": "style", "editType": "calc", - "min": 0, + "description": "Sets the type of gradient used to fill the markers" + }, + "color": { + "valType": "color", + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical." + }, + "editType": "calc", + "role": "object", + "typesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for type .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, + "editType": "calc", + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", + "valType": "colorscale", + "role": "style", "editType": "calc", "impliedEdits": { "autocolorscale": false }, - "role": "style", - "valType": "colorscale" + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "cauto": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "editType": "calc", - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", + "dflt": true, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", + "cmax": { + "valType": "number", "role": "info", - "valType": "string" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "cmin": { + "valType": "number", "role": "info", - "valType": "boolean" + "dflt": null, + "editType": "plot", + "impliedEdits": { + "cauto": false + }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calc", - "min": 0, + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "number" - }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, + "dflt": true, "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "role": "object", + "symbolsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" + "opacitysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } + }, + "cliponaxis": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "plot", + "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*." + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol. Full list: https://www.mapbox.com/maki-icons/ Note that the array `marker.color` and `marker.size` are only available for *circle* symbols.", - "dflt": "circle", + "size": { + "valType": "number", + "role": "style", + "min": 1, "editType": "calc", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "string" + "editType": "style", + "arrayOk": true }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", + "editType": "calc", + "description": "Sets the text font.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover.", - "dflt": "markers", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" + "fill": { + "valType": "enumerated", + "values": [ + "none", + "toself", + "tonext" ], - "role": "info", - "valType": "flaglist" + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterpolar has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", + "fillcolor": { + "valType": "color", + "role": "style", "editType": "style", - "role": "info", - "valType": "string" + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], + "role": "info", "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." }, "selected": { - "editType": "calc", "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." + }, "color": { - "description": "Sets the marker color of selected points.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" + "editType": "style", + "description": "Sets the marker color of selected points." }, - "editType": "calc", + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of selected points." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of selected points." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "calc", - "max": 1, + "valType": "number", "min": 0, + "max": 1, "role": "style", - "valType": "number" + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." }, - "role": "object", "size": { - "description": "Sets the marker size of selected points.", - "editType": "calc", + "valType": "number", "min": 0, "role": "style", - "valType": "number" - } + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" }, + "editType": "style", "role": "object" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "subplot": { + "valType": "subplotid", "role": "info", - "valType": "any" + "dflt": "polar", + "editType": "calc", + "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on." }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "idssrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "subplot": { - "description": "Sets a reference between this trace's data coordinates and a mapbox subplot. If *mapbox* (the default value), the data refer to `layout.mapbox`. If *mapbox2*, the data refer to `layout.mapbox2`, and so on.", - "dflt": "mapbox", - "editType": "calc", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "subplotid" + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "textfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the icon text font. Has an effect only when `type` is set to *symbol*.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "dflt": "Open Sans Regular, Arial Unicode MS Regular", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "rsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for r .", + "editType": "none" }, - "textposition": { - "arrayOk": false, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] + "thetasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for theta .", + "editType": "none" }, "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" }, - "type": "scattermapbox", - "uid": { - "dflt": "", - "editType": "calc", + "hovertextsrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object" + "description": "Sets the source reference on plot.ly for hovertext .", + "editType": "none" }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", + "textpositionsrc": { + "valType": "string", "role": "info", + "description": "Sets the source reference on plot.ly for textposition .", + "editType": "none" + } + } + }, + "scatterpolargl": { + "meta": { + "hrName": "scatter_polar_gl", + "description": "The scatterpolargl trace type encompasses line charts, scatter charts, and bubble charts in polar coordinates using the WebGL plotting engine. The data visualized as scatter point or lines is set in `r` (radial) and `theta` (angular) coordinates Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays." + }, + "attributes": { + "type": "scatterpolargl", + "visible": { "valType": "enumerated", "values": [ true, false, "legendonly" - ] - } - }, - "meta": { - "description": "The data visualized as scatter point, lines or marker symbols on a Mapbox GL geographic map is provided by longitude/latitude pairs in `lon` and `lat`.", - "hrName": "scatter_mapbox" - } - }, - "scatterpolar": { - "attributes": { - "cliponaxis": { - "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.", - "dflt": false, - "editType": "plot", + ], "role": "info", - "valType": "boolean" - }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, + "dflt": true, "editType": "calc", - "role": "info", - "valType": "boolean" + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "legendgroup": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterpolar has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", - "editType": "calc", + "opacity": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "none", - "toself", - "tonext" - ] + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", + "name": { + "valType": "string", + "role": "info", "editType": "style", - "role": "style", - "valType": "color" + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." }, "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], + "valType": "flaglist", + "role": "info", "flags": [ "r", "theta", @@ -35917,160 +34734,199 @@ "name", "name" ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", "editType": "none", - "role": "info", - "valType": "string" + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." }, "hoverlabel": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "valType": "color", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of the hover labels for this trace." }, - "editType": "calc", "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" }, "sizesrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "editType": "none" + }, + "colorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" } }, "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", + "valType": "integer", "min": -1, + "arrayOk": true, "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." + }, + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "role": "object" - }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "style", - "flags": [ - "points", - "fills" - ], - "role": "info", - "valType": "flaglist" + "bordercolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" + }, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "editType": "calc", + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." + }, + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, + "role": "info", + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." + }, + "editType": "calc", + "role": "object" }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", - "role": "info", - "valType": "string" + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "mode": { + "valType": "flaglist", + "flags": [ + "lines", + "markers", + "text" + ], + "extras": [ + "none" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*." }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "r": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the radial coordinates", + "role": "data" + }, + "theta": { + "valType": "data_array", + "editType": "calc+clearAxisTypes", + "description": "Sets the angular coordinates", + "role": "data" + }, + "thetaunit": { + "valType": "enumerated", + "values": [ + "radians", + "degrees", + "gradians" + ], + "dflt": "degrees", "role": "info", - "valType": "string" + "editType": "calc+clearAxisTypes", + "description": "Sets the unit of input *theta* values. Has an effect only when on *linear* angular axes." }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "text": { + "valType": "string", "role": "info", - "valType": "string" + "dflt": "", + "arrayOk": true, + "editType": "calc", + "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels." }, "line": { "color": { - "description": "Sets the line color.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the line color." }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", + "width": { + "valType": "number", + "min": 0, + "dflt": 2, "role": "style", - "valType": "string", + "editType": "calc", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "enumerated", "values": [ "solid", "dot", @@ -36078,732 +34934,1359 @@ "longdash", "dashdot", "longdashdot" - ] - }, - "editType": "calc", - "role": "object", - "shape": { - "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes.", - "dflt": "linear", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "linear", - "spline" - ] - }, - "smoothing": { - "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape).", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, + ], + "dflt": "solid", "role": "style", - "valType": "number" + "description": "Sets the style of the lines.", + "editType": "calc" }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "calc", + "role": "object" + }, + "connectgaps": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected." }, "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", "editType": "calc", - "impliedEdits": {}, + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "boolean" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", + "valType": "boolean", + "role": "info", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well." }, "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, + "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well." + }, + "autocolorscale": { + "valType": "boolean", + "role": "style", + "dflt": true, + "editType": "calc", + "impliedEdits": {}, + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." + }, + "reversescale": { + "valType": "boolean", + "role": "style", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." + }, + "symbol": { + "valType": "enumerated", + "values": [ + 0, + "circle", + 100, + "circle-open", + 200, + "circle-dot", + 300, + "circle-open-dot", + 1, + "square", + 101, + "square-open", + 201, + "square-dot", + 301, + "square-open-dot", + 2, + "diamond", + 102, + "diamond-open", + 202, + "diamond-dot", + 302, + "diamond-open-dot", + 3, + "cross", + 103, + "cross-open", + 203, + "cross-dot", + 303, + "cross-open-dot", + 4, + "x", + 104, + "x-open", + 204, + "x-dot", + 304, + "x-open-dot", + 5, + "triangle-up", + 105, + "triangle-up-open", + 205, + "triangle-up-dot", + 305, + "triangle-up-open-dot", + 6, + "triangle-down", + 106, + "triangle-down-open", + 206, + "triangle-down-dot", + 306, + "triangle-down-open-dot", + 7, + "triangle-left", + 107, + "triangle-left-open", + 207, + "triangle-left-dot", + 307, + "triangle-left-open-dot", + 8, + "triangle-right", + 108, + "triangle-right-open", + 208, + "triangle-right-dot", + 308, + "triangle-right-open-dot", + 9, + "triangle-ne", + 109, + "triangle-ne-open", + 209, + "triangle-ne-dot", + 309, + "triangle-ne-open-dot", + 10, + "triangle-se", + 110, + "triangle-se-open", + 210, + "triangle-se-dot", + 310, + "triangle-se-open-dot", + 11, + "triangle-sw", + 111, + "triangle-sw-open", + 211, + "triangle-sw-dot", + 311, + "triangle-sw-open-dot", + 12, + "triangle-nw", + 112, + "triangle-nw-open", + 212, + "triangle-nw-dot", + 312, + "triangle-nw-open-dot", + 13, + "pentagon", + 113, + "pentagon-open", + 213, + "pentagon-dot", + 313, + "pentagon-open-dot", + 14, + "hexagon", + 114, + "hexagon-open", + 214, + "hexagon-dot", + 314, + "hexagon-open-dot", + 15, + "hexagon2", + 115, + "hexagon2-open", + 215, + "hexagon2-dot", + 315, + "hexagon2-open-dot", + 16, + "octagon", + 116, + "octagon-open", + 216, + "octagon-dot", + 316, + "octagon-open-dot", + 17, + "star", + 117, + "star-open", + 217, + "star-dot", + 317, + "star-open-dot", + 18, + "hexagram", + 118, + "hexagram-open", + 218, + "hexagram-dot", + 318, + "hexagram-open-dot", + 19, + "star-triangle-up", + 119, + "star-triangle-up-open", + 219, + "star-triangle-up-dot", + 319, + "star-triangle-up-open-dot", + 20, + "star-triangle-down", + 120, + "star-triangle-down-open", + 220, + "star-triangle-down-dot", + 320, + "star-triangle-down-open-dot", + 21, + "star-square", + 121, + "star-square-open", + 221, + "star-square-dot", + 321, + "star-square-open-dot", + 22, + "star-diamond", + 122, + "star-diamond-open", + 222, + "star-diamond-dot", + 322, + "star-diamond-open-dot", + 23, + "diamond-tall", + 123, + "diamond-tall-open", + 223, + "diamond-tall-dot", + 323, + "diamond-tall-open-dot", + 24, + "diamond-wide", + 124, + "diamond-wide-open", + 224, + "diamond-wide-dot", + 324, + "diamond-wide-open-dot", + 25, + "hourglass", + 125, + "hourglass-open", + 26, + "bowtie", + 126, + "bowtie-open", + 27, + "circle-cross", + 127, + "circle-cross-open", + 28, + "circle-x", + 128, + "circle-x-open", + 29, + "square-cross", + 129, + "square-cross-open", + 30, + "square-x", + 130, + "square-x-open", + 31, + "diamond-cross", + 131, + "diamond-cross-open", + 32, + "diamond-x", + 132, + "diamond-x-open", + 33, + "cross-thin", + 133, + "cross-thin-open", + 34, + "x-thin", + 134, + "x-thin-open", + 35, + "asterisk", + 135, + "asterisk-open", + 36, + "hash", + 136, + "hash-open", + 236, + "hash-dot", + 336, + "hash-open-dot", + 37, + "y-up", + 137, + "y-up-open", + 38, + "y-down", + 138, + "y-down-open", + 39, + "y-left", + 139, + "y-left-open", + 40, + "y-right", + 140, + "y-right-open", + 41, + "line-ew", + 141, + "line-ew-open", + 42, + "line-ns", + 142, + "line-ns-open", + 43, + "line-ne", + 143, + "line-ne-open", + 44, + "line-nw", + 144, + "line-nw-open" + ], + "dflt": "circle", + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." + }, + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, + "role": "style", + "editType": "calc", + "description": "Sets the marker size (in px)." + }, + "sizeref": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`." + }, + "sizemin": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points." + }, + "sizemode": { + "valType": "enumerated", + "values": [ + "diameter", + "area" + ], + "dflt": "diameter", "role": "info", - "valType": "number" + "editType": "calc", + "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels." }, - "color": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the marker opacity." + }, + "showscale": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "calc", + "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed." }, "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", + "thicknessmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], "role": "style", - "valType": "color" + "dflt": "pixels", + "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", + "editType": "calc" }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", + "thickness": { + "valType": "number", "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", "min": 0, - "role": "style", - "valType": "number" + "dflt": 30, + "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", + "editType": "calc" }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "calc" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "any" + "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", + "editType": "calc" }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", + "x": { + "valType": "number", + "dflt": 1.02, + "min": -2, + "max": 3, "role": "style", + "description": "Sets the x position of the color bar (in plot fraction).", + "editType": "calc" + }, + "xanchor": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] + "left", + "center", + "right" + ], + "dflt": "left", + "role": "style", + "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", + "editType": "calc" }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", + "xpad": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the x direction.", + "editType": "calc" + }, + "y": { + "valType": "number", "role": "style", - "valType": "number" + "dflt": 0.5, + "min": -2, + "max": 3, + "description": "Sets the y position of the color bar (in plot fraction).", + "editType": "calc" }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", + "yanchor": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + "top", + "middle", + "bottom" + ], + "role": "style", + "dflt": "middle", + "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", + "editType": "calc" }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, + "ypad": { + "valType": "number", "role": "style", - "valType": "integer" + "min": 0, + "dflt": 10, + "description": "Sets the amount of padding (in px) along the y direction.", + "editType": "calc" }, "outlinecolor": { - "description": "Sets the axis line color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the axis line color." }, "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" + "editType": "calc", + "description": "Sets the width (in px) of the axis line." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "calc", + "description": "Sets the axis line color." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", + "borderwidth": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 0, + "dflt": 0, + "description": "Sets the width (in px) or the border enclosing this color bar.", + "editType": "calc" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", + "bgcolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "dflt": "rgba(0,0,0,0)", + "description": "Sets the color of padded area.", + "editType": "calc" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", + "tickmode": { "valType": "enumerated", "values": [ - "all", - "first", - "last", - "none" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "calc", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", + "tick0": { + "valType": "any", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "editType": "calc", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", + "dtick": { + "valType": "any", + "role": "style", + "editType": "calc", "impliedEdits": { "tickmode": "linear" }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "calc", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "any" + "editType": "calc", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", + "dflt": "" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "calc", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "angle" + "editType": "calc", + "description": "Sets the tick width (in px)." }, "tickcolor": { - "description": "Sets the tick color.", + "valType": "color", "dflt": "#444", - "editType": "colorbars", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the tick labels are drawn." }, "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets the color bar's tick label font", + "editType": "calc", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "calc", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" }, { - "editType": "colorbars", - "valType": "any" + "valType": "any", + "editType": "calc" } ], - "role": "info", - "valType": "info_array" + "editType": "calc", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "colorbars", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - } + "editType": "calc", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "calc", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, "tickprefix": { - "description": "Sets a tick label prefix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" + "editType": "calc", + "description": "Sets a tick label prefix." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", + "showtickprefix": { "valType": "enumerated", "values": [ - "outside", - "inside", - "" - ] + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, "ticksuffix": { - "description": "Sets a tick label suffix.", + "valType": "string", "dflt": "", - "editType": "colorbars", "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "editType": "calc", + "description": "Sets a tick label suffix." }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "calc", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "calc", + "description": "If \"true\", even 4-digit integers are separated" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "calc", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "calc", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the title of the color bar.", + "editType": "calc" }, "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "calc" }, - "role": "object", "size": { - "editType": "colorbars", + "valType": "number", + "role": "style", "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "calc" + }, + "description": "Sets this color bar's title font.", + "editType": "calc", + "role": "object" }, "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", "valType": "enumerated", "values": [ "right", "top", "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "gradient": { - "color": { - "arrayOk": true, - "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.", - "editType": "calc", + ], "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "dflt": "top", + "description": "Determines the location of the colorbar title with respect to the color bar.", + "editType": "calc" }, "editType": "calc", "role": "object", - "type": { - "arrayOk": true, - "description": "Sets the type of gradient used to fill the markers", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "radial", - "horizontal", - "vertical", - "none" - ] + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "typesrc": { - "description": "Sets the source reference on plot.ly for type .", - "editType": "none", + "ticktextsrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, + "color": { + "valType": "color", + "arrayOk": true, + "role": "style", "editType": "calc", - "impliedEdits": {}, + "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "colorscale": { + "valType": "colorscale", "role": "style", - "valType": "boolean" + "editType": "calc", + "impliedEdits": { + "autocolorscale": false + }, + "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis" }, "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", + "valType": "boolean", + "role": "info", "dflt": true, "editType": "calc", "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user." }, "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well." }, "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", + "valType": "number", + "role": "info", "dflt": null, - "editType": "plot", + "editType": "calc", "impliedEdits": { "cauto": false }, - "role": "info", - "valType": "number" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well." }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", + "autocolorscale": { + "valType": "boolean", "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", + "dflt": true, "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "impliedEdits": {}, + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed." }, - "editType": "calc", "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", + "valType": "boolean", + "role": "style", "dflt": false, "editType": "calc", - "role": "style", - "valType": "boolean" + "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color)." }, - "role": "object", "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "style", + "valType": "number", "min": 0, + "arrayOk": true, "role": "style", - "valType": "number" + "editType": "calc", + "description": "Sets the width (in px) of the lines bounding the marker points." + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" }, "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for width .", + "editType": "none" } }, - "maxdisplayed": { - "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" }, - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "symbolsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for symbol .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, "opacitysrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" + } + }, + "fill": { + "valType": "enumerated", + "values": [ + "none", + "tozeroy", + "tozerox", + "tonexty", + "tonextx", + "toself", + "tonext" + ], + "dflt": "none", + "role": "style", + "editType": "calc", + "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other." + }, + "fillcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available." + }, + "hoveron": { + "valType": "flaglist", + "flags": [ + "points", + "fills" + ], + "role": "info", + "editType": "style", + "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*." + }, + "selected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of selected points." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of selected points." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of selected points." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of selected points." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "unselected": { + "marker": { + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity of unselected points, applied only when a selection exists." + }, + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the marker color of unselected points, applied only when a selection exists." + }, + "size": { + "valType": "number", + "min": 0, + "role": "style", + "editType": "style", + "description": "Sets the marker size of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "textfont": { + "color": { + "valType": "color", + "role": "style", + "editType": "style", + "description": "Sets the text font color of unselected points, applied only when a selection exists." + }, + "editType": "style", + "role": "object" + }, + "editType": "style", + "role": "object" + }, + "subplot": { + "valType": "subplotid", + "role": "info", + "dflt": "polar", + "editType": "calc", + "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on." + }, + "idssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" + }, + "customdatasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" + }, + "hoverinfosrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" + }, + "rsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for r .", + "editType": "none" + }, + "thetasrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for theta .", + "editType": "none" + }, + "textsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for text .", + "editType": "none" + } + } + }, + "area": { + "meta": {}, + "attributes": { + "type": "area", + "visible": { + "valType": "enumerated", + "values": [ + true, + false, + "legendonly" + ], + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "style", + "description": "Determines whether or not an item corresponding to this trace is shown in the legend." + }, + "legendgroup": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "style", + "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items." + }, + "opacity": { + "valType": "number", + "role": "style", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "style", + "description": "Sets the opacity of the trace." + }, + "name": { + "valType": "string", + "role": "info", + "editType": "style", + "description": "Sets the trace name. The trace name appear as the legend item and on hover." + }, + "uid": { + "valType": "string", + "role": "info", + "dflt": "", + "editType": "calc" + }, + "ids": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", + "role": "data" + }, + "customdata": { + "valType": "data_array", + "editType": "calc", + "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", + "role": "data" + }, + "selectedpoints": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect." + }, + "hoverinfo": { + "valType": "flaglist", + "role": "info", + "flags": [ + "x", + "y", + "z", + "text", + "name" + ], + "extras": [ + "all", + "none", + "skip" + ], + "arrayOk": true, + "dflt": "all", + "editType": "none", + "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "arrayOk": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the background color of the hover labels for this trace" }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "bordercolor": { + "valType": "color", "role": "style", - "valType": "boolean" + "arrayOk": true, + "editType": "none", + "description": "Sets the border color of the hover labels for this trace." }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "none", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "arrayOk": true + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "none", + "arrayOk": true + }, + "color": { + "valType": "color", + "role": "style", + "editType": "none", + "arrayOk": true + }, + "editType": "none", + "description": "Sets the font used in hover labels.", + "role": "object", + "familysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for family .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" + }, + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + } }, - "size": { + "namelength": { + "valType": "integer", + "min": -1, "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, "role": "style", - "valType": "number" + "editType": "none", + "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "editType": "calc", + "role": "object", + "bgcolorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for bgcolor .", + "editType": "none" }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", + "bordercolorsrc": { + "valType": "string", "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] + "description": "Sets the source reference on plot.ly for bordercolor .", + "editType": "none" }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, + "namelengthsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for namelength .", + "editType": "none" + } + }, + "stream": { + "token": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", "editType": "calc", - "role": "style", - "valType": "number" + "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "maxpoints": { + "valType": "number", + "min": 0, + "max": 10000, + "dflt": 500, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot." }, - "symbol": { + "editType": "calc", + "role": "object" + }, + "transforms": { + "items": { + "transform": { + "editType": "calc", + "description": "An array of operations that manipulate the trace data, for example filtering or sorting the data arrays.", + "role": "object" + } + }, + "role": "object" + }, + "r": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the radial coordinates.", + "role": "data" + }, + "t": { + "valType": "data_array", + "editType": "calc", + "description": "For legacy polar chart only.Please switch to *scatterpolar* trace type.Sets the angular coordinates.", + "role": "data" + }, + "marker": { + "color": { + "valType": "color", "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", + "role": "style", "editType": "style", + "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set." + }, + "size": { + "valType": "number", + "min": 0, + "dflt": 6, + "arrayOk": true, "role": "style", + "editType": "calcIfAutorange", + "description": "Sets the marker size (in px)." + }, + "symbol": { "valType": "enumerated", "values": [ 0, @@ -37090,7419 +36573,9074 @@ "line-nw", 144, "line-nw-open" - ] + ], + "dflt": "circle", + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name." + }, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "arrayOk": true, + "role": "style", + "editType": "style", + "description": "Sets the marker opacity." + }, + "editType": "calc", + "role": "object", + "colorsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for color .", + "editType": "none" + }, + "sizesrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for size .", + "editType": "none" }, "symbolsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", + "editType": "none" + }, + "opacitysrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for opacity .", + "editType": "none" } }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], + "idssrc": { + "valType": "string", "role": "info", - "valType": "flaglist" + "description": "Sets the source reference on plot.ly for ids .", + "editType": "none" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "customdatasrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "r": { - "description": "Sets the radial coordinates", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for customdata .", + "editType": "none" }, - "rsrc": { - "description": "Sets the source reference on plot.ly for r .", - "editType": "none", + "hoverinfosrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } + "description": "Sets the source reference on plot.ly for hoverinfo .", + "editType": "none" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "rsrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for r .", + "editType": "none" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "tsrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "stream": { + "description": "Sets the source reference on plot.ly for t .", + "editType": "none" + } + } + } + }, + "layout": { + "layoutAttributes": { + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": "\"Open Sans\", verdana, arial, sans-serif" }, - "subplot": { - "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on.", - "dflt": "polar", + "size": { + "valType": "number", + "role": "style", + "min": 1, "editType": "calc", - "role": "info", - "valType": "subplotid" + "dflt": 12 }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", + "color": { + "valType": "color", + "role": "style", "editType": "calc", - "role": "info", - "valType": "string" + "dflt": "#444" }, - "textfont": { - "color": { - "arrayOk": true, - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "calc", + "description": "Sets the global font. Note that fonts used in traces and other layout components inherit from the global font.", + "role": "object" + }, + "title": { + "valType": "string", + "role": "info", + "editType": "layoutstyle", + "description": "Sets the plot's title." + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "layoutstyle", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] + "min": 1, + "editType": "layoutstyle" }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" + "color": { + "valType": "color", + "role": "style", + "editType": "layoutstyle" }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "editType": "layoutstyle", + "description": "Sets the title font.", + "role": "object" + }, + "autosize": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "none", + "description": "Determines whether or not a layout width or height that has been left undefined by the user is initialized on each relayout. Note that, regardless of this attribute, an undefined layout width or height is always initialized on the first call to plot." + }, + "width": { + "valType": "number", + "role": "info", + "min": 10, + "dflt": 700, + "editType": "plot", + "description": "Sets the plot's width (in px)." + }, + "height": { + "valType": "number", + "role": "info", + "min": 10, + "dflt": 450, + "editType": "plot", + "description": "Sets the plot's height (in px)." + }, + "margin": { + "l": { + "valType": "number", "role": "info", - "valType": "string" - }, - "theta": { - "description": "Sets the angular coordinates", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "min": 0, + "dflt": 80, + "editType": "plot", + "description": "Sets the left margin (in px)." }, - "thetasrc": { - "description": "Sets the source reference on plot.ly for theta .", - "editType": "none", + "r": { + "valType": "number", "role": "info", - "valType": "string" + "min": 0, + "dflt": 80, + "editType": "plot", + "description": "Sets the right margin (in px)." }, - "thetaunit": { - "description": "Sets the unit of input *theta* values. Has an effect only when on *linear* angular axes.", - "dflt": "degrees", - "editType": "calc+clearAxisTypes", + "t": { + "valType": "number", "role": "info", - "valType": "enumerated", - "values": [ - "radians", - "degrees", - "gradians" - ] + "min": 0, + "dflt": 100, + "editType": "plot", + "description": "Sets the top margin (in px)." }, - "type": "scatterpolar", - "uid": { - "dflt": "", - "editType": "calc", + "b": { + "valType": "number", "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } + "min": 0, + "dflt": 80, + "editType": "plot", + "description": "Sets the bottom margin (in px)." }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "The scatterpolar trace type encompasses line charts, scatter charts, text charts, and bubble charts in polar coordinates. The data visualized as scatter point or lines is set in `r` (radial) and `theta` (angular) coordinates Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays.", - "hrName": "scatter_polar" - } - }, - "scatterpolargl": { - "attributes": { - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, - "editType": "calc", + "pad": { + "valType": "number", "role": "info", - "valType": "boolean" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" + "min": 0, + "dflt": 0, + "editType": "plot", + "description": "Sets the amount of padding (in px) between the plotting area and the axis lines" }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", + "autoexpand": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. *tonextx* and *tonexty* fill between the endpoints of this trace and the endpoints of the trace before it, connecting those endpoints with straight lines (to make a stacked area graph); if there is no trace before it, they behave like *tozerox* and *tozeroy*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "tozeroy", - "tozerox", - "tonexty", - "tonextx", - "toself", - "tonext" - ] + "dflt": true, + "editType": "plot" }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "calc", + "editType": "plot", + "role": "object" + }, + "paper_bgcolor": { + "valType": "color", + "role": "style", + "dflt": "#fff", + "editType": "plot", + "description": "Sets the color of paper where the graph is drawn." + }, + "plot_bgcolor": { + "valType": "color", + "role": "style", + "dflt": "#fff", + "editType": "layoutstyle", + "description": "Sets the color of plotting area in-between x and y axes." + }, + "separators": { + "valType": "string", + "role": "style", + "editType": "plot", + "description": "Sets the decimal and thousand separators. For example, *. * puts a '.' before decimals and a space between thousands. In English locales, dflt is *.,* but other locales may alter this default." + }, + "hidesources": { + "valType": "boolean", + "role": "info", + "dflt": false, + "editType": "plot", + "description": "Determines whether or not a text link citing the data source is placed at the bottom-right cored of the figure. Has only an effect only on graphs that have been generated via forked graphs from the plotly service (at https://plot.ly or on-premise)." + }, + "showlegend": { + "valType": "boolean", + "role": "info", + "editType": "legend", + "description": "Determines whether or not a legend is drawn." + }, + "colorway": { + "valType": "colorlist", + "dflt": [ + "#1f77b4", + "#ff7f0e", + "#2ca02c", + "#d62728", + "#9467bd", + "#8c564b", + "#e377c2", + "#7f7f7f", + "#bcbd22", + "#17becf" + ], + "role": "style", + "editType": "calc", + "description": "Sets the default trace colors." + }, + "datarevision": { + "valType": "any", + "role": "info", + "editType": "calc", + "description": "If provided, a changed value tells `Plotly.react` that one or more data arrays has changed. This way you can modify arrays in-place rather than making a complete new copy for an incremental change. If NOT provided, `Plotly.react` assumes that data arrays are being treated as immutable, thus any data array with a different identity from its predecessor contains new data." + }, + "dragmode": { + "valType": "enumerated", + "role": "info", + "values": [ + "zoom", + "pan", + "select", + "lasso", + "orbit", + "turntable" + ], + "dflt": "zoom", + "editType": "modebar", + "description": "Determines the mode of drag interactions. *select* and *lasso* apply only to scatter traces with markers or text. *orbit* and *turntable* apply only to 3D scenes." + }, + "hovermode": { + "valType": "enumerated", + "role": "info", + "values": [ + "x", + "y", + "closest", + false + ], + "editType": "modebar", + "description": "Determines the mode of hover interactions." + }, + "hoverdistance": { + "valType": "integer", + "min": -1, + "dflt": 20, + "role": "info", + "editType": "none", + "description": "Sets the default distance (in pixels) to look for data to add hover labels (-1 means no cutoff, 0 means no looking for data). This is only a real distance for hovering on point-like objects, like scatter points. For area-like objects (bars, scatter fills, etc) hovering is on inside the area and off outside, but these objects will not supersede hover on point-like objects in case of conflict." + }, + "spikedistance": { + "valType": "integer", + "min": -1, + "dflt": 20, + "role": "info", + "editType": "none", + "description": "Sets the default distance (in pixels) to look for data to draw spikelines to (-1 means no cutoff, 0 means no looking for data). As with hoverdistance, distance does not apply to area-like objects. In addition, some objects can be hovered on but will not generate spikelines, such as scatter fills." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "r", - "theta", - "text", - "name", - "name" - ], - "role": "info", - "valType": "flaglist" + "description": "Sets the background color of all hover labels on graph" }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", + "bordercolor": { + "valType": "color", + "role": "style", "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the border color of all hover labels on graph." }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "font": { + "family": { + "valType": "string", "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", + "noBlank": true, + "strict": true, "editType": "none", - "role": "info", - "valType": "string" + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": "Arial, sans-serif" }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "size": { + "valType": "number", "role": "style", - "valType": "color" - }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", + "min": 1, "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "dflt": 13 }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "color": { + "valType": "color", "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "none" }, + "editType": "none", + "description": "Sets the default hover label font used by all traces on the graph.", "role": "object" }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "style", - "flags": [ - "points", - "fills" - ], - "role": "info", - "valType": "flaglist" + "namelength": { + "valType": "integer", + "min": -1, + "dflt": 15, + "role": "style", + "editType": "none", + "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis." }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "editType": "none", + "role": "object" + }, + "selectdirection": { + "valType": "enumerated", + "role": "info", + "values": [ + "h", + "v", + "d", + "any" + ], + "dflt": "any", + "description": "When \"dragmode\" is set to \"select\", this limits the selection of the drag to horizontal, vertical or diagonal. \"h\" only allows horizontal selection, \"v\" only vertical, \"d\" only diagonal and \"any\" sets no limit.", + "editType": "none" + }, + "grid": { + "rows": { + "valType": "integer", + "min": 1, + "role": "info", + "editType": "plot", + "description": "The number of rows in the grid. If you provide a 2D `subplots` array or a `yaxes` array, its length is used as the default. But it's also possible to have a different length, if you want to leave a row at the end for non-cartesian subplots." }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "roworder": { + "valType": "enumerated", + "values": [ + "top to bottom", + "bottom to top" + ], + "dflt": "top to bottom", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Is the first row the top or the bottom? Note that columns are always enumerated from left to right." }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "columns": { + "valType": "integer", + "min": 1, "role": "info", - "valType": "string" + "editType": "plot", + "description": "The number of columns in the grid. If you provide a 2D `subplots` array, the length of its longest row is used as the default. If you give an `xaxes` array, its length is used as the default. But it's also possible to have a different length, if you want to leave a row at the end for non-cartesian subplots." }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the style of the lines.", - "dflt": "solid", - "editType": "calc", - "role": "style", + "subplots": { + "valType": "info_array", + "freeLength": true, + "dimensions": 2, + "items": { "valType": "enumerated", "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] + "/^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?$/", + "" + ], + "editType": "plot" }, - "editType": "calc", - "role": "object", - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "role": "info", + "editType": "plot", + "description": "Used for freeform grids, where some axes may be shared across subplots but others are not. Each entry should be a cartesian subplot id, like *xy* or *x3y2*, or ** to leave that cell empty. You may reuse x axes within the same column, and y axes within the same row. Non-cartesian subplots and traces that support `domain` can place themselves in this grid separately using the `gridcell` attribute." }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "xaxes": { + "valType": "info_array", + "freeLength": true, + "items": { + "valType": "enumerated", + "values": [ + "/^x([2-9]|[1-9][0-9]+)?$/", + "" + ], + "editType": "plot" }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "role": "info", + "editType": "plot", + "description": "Used with `yaxes` when the x and y axes are shared across columns and rows. Each entry should be an x axis id like *x*, *x2*, etc., or ** to not put an x axis in that column. Entries other than ** must be unique. Ignored if `subplots` is present. If missing but `yaxes` is present, will generate consecutive IDs." + }, + "yaxes": { + "valType": "info_array", + "freeLength": true, + "items": { + "valType": "enumerated", + "values": [ + "/^y([2-9]|[1-9][0-9]+)?$/", + "" + ], + "editType": "plot" }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "role": "info", + "editType": "plot", + "description": "Used with `yaxes` when the x and y axes are shared across columns and rows. Each entry should be an y axis id like *y*, *y2*, etc., or ** to not put a y axis in that row. Entries other than ** must be unique. Ignored if `subplots` is present. If missing but `xaxes` is present, will generate consecutive IDs." + }, + "pattern": { + "valType": "enumerated", + "values": [ + "independent", + "coupled" + ], + "dflt": "coupled", + "role": "info", + "editType": "plot", + "description": "If no `subplots`, `xaxes`, or `yaxes` are given but we do have `rows` and `columns`, we can generate defaults using consecutive axis IDs, in two ways: *coupled* gives one x axis per column and one y axis per row. *independent* uses a new xy pair for each cell, left-to-right across each row then iterating rows according to `roworder`." + }, + "xgap": { + "valType": "number", + "min": 0, + "max": 1, + "role": "info", + "editType": "plot", + "description": "Horizontal space between grid cells, expressed as a fraction of the total width available to one cell. Defaults to 0.1 for coupled-axes grids and 0.2 for independent grids." + }, + "ygap": { + "valType": "number", + "min": 0, + "max": 1, + "role": "info", + "editType": "plot", + "description": "Vertical space between grid cells, expressed as a fraction of the total height available to one cell. Defaults to 0.1 for coupled-axes grids and 0.3 for independent grids." + }, + "domain": { + "x": { + "valType": "info_array", "role": "info", - "valType": "number" + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this grid subplot (in plot fraction). The first and last cells end exactly at the domain edges, with no grout around the edges." }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "y": { + "valType": "info_array", "role": "info", - "valType": "number" + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this grid subplot (in plot fraction). The first and last cells end exactly at the domain edges, with no grout around the edges." + }, + "editType": "plot", + "role": "object" + }, + "xside": { + "valType": "enumerated", + "values": [ + "bottom", + "bottom plot", + "top plot", + "top" + ], + "dflt": "bottom plot", + "role": "info", + "editType": "plot", + "description": "Sets where the x axis labels and titles go. *bottom* means the very bottom of the grid. *bottom plot* is the lowest plot that each x axis is used in. *top* and *top plot* are similar." + }, + "yside": { + "valType": "enumerated", + "values": [ + "left", + "left plot", + "right plot", + "right" + ], + "dflt": "left plot", + "role": "info", + "editType": "plot", + "description": "Sets where the y axis labels and titles go. *left* means the very left edge of the grid. *left plot* is the leftmost plot that each y axis is used in. *right* and *right plot* are similar." + }, + "editType": "plot", + "role": "object" + }, + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the default calendar system to use for interpreting and displaying dates throughout the plot." + }, + "xaxis": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false" + }, + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "title": { + "valType": "string", + "role": "info", + "editType": "ticks+margins", + "description": "Sets the title of this axis." + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "ticks+margins", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "ticks+margins" }, "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", + "valType": "color", "role": "style", - "valType": "color" + "editType": "ticks+margins" }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", + "editType": "ticks+margins", + "description": "Sets this axis' title font.", + "role": "object" + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "log", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "calc", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." + }, + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", + "role": "style", + "editType": "plot", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." + }, + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "axrange+margins", "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "^autorange": false + } }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", + { + "valType": "any", + "editType": "axrange+margins", "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "^autorange": false } - }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" } + ], + "editType": "axrange+margins", + "impliedEdits": { + "autorange": false }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "fixedrange": { + "valType": "boolean", + "dflt": false, + "role": "info", "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled." + }, + "scaleanchor": { + "valType": "enumerated", + "values": [ + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "plot", + "description": "If set to another axis id (e.g. `x2`, `y`), the range of this axis changes together with the range of the corresponding axis such that the scale of pixels per unit is in a constant ratio. Both axes are still zoomable, but when you zoom one, the other will zoom the same amount, keeping a fixed midpoint. `constrain` and `constraintoward` determine how we enforce the constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you can only link axes of the same `type`. The linked axis can have the opposite letter (to constrain the aspect ratio) or the same letter (to match scales across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: {scaleanchor: *y*}` or longer) are redundant and the last constraint encountered will be ignored to avoid possible inconsistent constraints via `scaleratio`." + }, + "scaleratio": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "info", + "editType": "plot", + "description": "If this axis is linked to another by `scaleanchor`, this determines the pixel to unit scale ratio. For example, if this value is 10, then every unit on this axis spans 10 times the number of pixels as a unit on the linked axis. Use this for example to create an elevation profile where the vertical scale is exaggerated a fixed amount with respect to the horizontal." + }, + "constrain": { + "valType": "enumerated", + "values": [ + "range", + "domain" + ], + "dflt": "range", + "role": "info", + "editType": "plot", + "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines how that happens: by increasing the *range* (default), or by decreasing the *domain*." + }, + "constraintoward": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right", + "top", + "middle", + "bottom" + ], + "role": "info", + "editType": "plot", + "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines which direction we push the originally specified plot area. Options are *left*, *center* (default), and *right* for x axes, and *top*, *middle* (default), and *bottom* for y axes." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "ticks+margins", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "ticks+margins", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "ticks+margins", + "impliedEdits": { + "tickmode": "linear" }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "ticks+margins", + "impliedEdits": { + "tickmode": "linear" }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "ticks+margins", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "ticks+margins", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "mirror": { + "valType": "enumerated", + "values": [ + true, + "ticks", + false, + "all", + "allticks" + ], + "dflt": false, + "role": "style", + "editType": "ticks+layoutstyle", + "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "ticks", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether or not the tick labels are drawn." + }, + "automargin": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether long tick labels automatically grow the figure margins." + }, + "showspikes": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "modebar", + "description": "Determines whether or not spikes (aka droplines) are drawn for this axis. Note: This only takes affect when hovermode = closest" + }, + "spikecolor": { + "valType": "color", + "dflt": null, + "role": "style", + "editType": "none", + "description": "Sets the spike color. If undefined, will use the series color" + }, + "spikethickness": { + "valType": "number", + "dflt": 3, + "role": "style", + "editType": "none", + "description": "Sets the width (in px) of the zero line." + }, + "spikedash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "dash", + "role": "style", + "editType": "none", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "spikemode": { + "valType": "flaglist", + "flags": [ + "toaxis", + "across", + "marker" + ], + "role": "style", + "dflt": "toaxis", + "editType": "none", + "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on" + }, + "spikesnap": { + "valType": "enumerated", + "values": [ + "data", + "cursor" + ], + "dflt": "data", + "role": "style", + "editType": "none", + "description": "Determines whether spikelines are stuck to the cursor or to the closest datapoints." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" + "noBlank": true, + "strict": true, + "editType": "ticks+margins", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calc", - "min": 0, + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "ticks+margins" }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "ticks+margins" }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] + "editType": "ticks+margins", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "ticks+margins", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "ticks+margins", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "ticks+margins", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "ticks+margins" + }, + { + "valType": "any", + "editType": "ticks+margins" + } + ], + "editType": "ticks+margins", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "ticks+margins", + "role": "object" + } }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] - }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" - } + "role": "object" }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" - ], - "role": "info", - "valType": "flaglist" + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "layoutstyle", + "description": "Determines whether or not a line bounding this axis is drawn." }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, + "linecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "number" + "editType": "layoutstyle", + "description": "Sets the axis line color." }, - "r": { - "description": "Sets the radial coordinates", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks+layoutstyle", + "description": "Sets the width (in px) of the axis line." }, - "rsrc": { - "description": "Sets the source reference on plot.ly for r .", - "editType": "none", - "role": "info", - "valType": "string" + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "ticks", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "ticks", + "description": "Sets the color of the grid lines." }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the width (in px) of the grid lines." }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" + "zeroline": { + "valType": "boolean", + "role": "style", + "editType": "ticks", + "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines." }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } + "zerolinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets the line color of the zero line." }, - "subplot": { - "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on.", - "dflt": "polar", - "editType": "calc", - "role": "info", - "valType": "subplotid" + "zerolinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the width (in px) of the zero line." }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", + "anchor": { + "valType": "enumerated", + "values": [ + "free", + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], "role": "info", - "valType": "string" + "editType": "plot+margins", + "description": "If set to an opposite-letter axis id (e.g. `x2`, `y`), this axis is bound to the corresponding opposite-letter axis. If set to *free*, this axis' position is determined by `position`." }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", + "side": { + "valType": "enumerated", + "values": [ + "top", + "bottom", + "left", + "right" + ], "role": "info", - "valType": "string" - }, - "theta": { - "description": "Sets the angular coordinates", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" + "editType": "plot+margins", + "description": "Determines whether a x (y) axis is positioned at the *bottom* (*left*) or *top* (*right*) of the plotting area." }, - "thetasrc": { - "description": "Sets the source reference on plot.ly for theta .", - "editType": "none", + "overlaying": { + "valType": "enumerated", + "values": [ + "free", + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], "role": "info", - "valType": "string" + "editType": "plot", + "description": "If set a same-letter axis id, this axis is overlaid on top of the corresponding same-letter axis. If *false*, this axis does not overlay any same-letter axes." }, - "thetaunit": { - "description": "Sets the unit of input *theta* values. Has an effect only when on *linear* angular axes.", - "dflt": "degrees", - "editType": "calc+clearAxisTypes", - "role": "info", + "layer": { "valType": "enumerated", "values": [ - "radians", - "degrees", - "gradians" - ] - }, - "type": "scatterpolargl", - "uid": { - "dflt": "", - "editType": "calc", + "above traces", + "below traces" + ], + "dflt": "above traces", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, + "domain": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "max": 1, + "editType": "plot+margins" }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", + { + "valType": "number", "min": 0, - "role": "style", - "valType": "number" + "max": 1, + "editType": "plot+margins" } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } + ], + "dflt": [ + 0, + 1 + ], + "editType": "plot+margins", + "description": "Sets the domain of this axis (in plot fraction)." }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", + "position": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0, + "role": "style", + "editType": "plot+margins", + "description": "Sets the position of this axis in the plotting space (in normalized coordinates). Only has an effect if `anchor` is set to *free*." + }, + "categoryorder": { "valType": "enumerated", "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "The scatterpolargl trace type encompasses line charts, scatter charts, and bubble charts in polar coordinates using the WebGL plotting engine. The data visualized as scatter point or lines is set in `r` (radial) and `theta` (angular) coordinates Bubble charts are achieved by setting `marker.size` and/or `marker.color` to numerical arrays.", - "hrName": "scatter_polar_gl" - } - }, - "scatterternary": { - "attributes": { - "a": { - "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "asrc": { - "description": "Sets the source reference on plot.ly for a .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "b": { - "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "bsrc": { - "description": "Sets the source reference on plot.ly for b .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "c": { - "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary.sum`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "cliponaxis": { - "description": "Determines whether or not markers and text nodes are clipped about the subplot axes. To show markers and text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.", - "dflt": true, - "editType": "plot", + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", "role": "info", - "valType": "boolean" - }, - "connectgaps": { - "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.", - "dflt": false, "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "csrc": { - "description": "Sets the source reference on plot.ly for c .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", + "categoryarray": { + "valType": "data_array", "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "fill": { - "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. scatterternary has a subset of the options available to scatter. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape. *tonext* fills the space between two traces if one completely encloses the other (eg consecutive contour lines), and behaves like *toself* if there is no trace before it. *tonext* should not be used if one trace does not enclose the other.", - "dflt": "none", "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "toself", - "tonext" - ] - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "a", - "b", - "c", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "calc", + "_deprecated": { + "autotick": { + "valType": "boolean", + "role": "info", + "editType": "ticks+margins", + "description": "Obsolete. Set `tickmode` to *auto* for old `autotick` *true* behavior. Set `tickmode` to *linear* for `autotick` *false*." + } }, - "hoverlabel": { + "rangeslider": { "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "valType": "color", + "dflt": "#fff", + "role": "style", + "editType": "plot", + "description": "Sets the background color of the range slider." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the border color of the range slider." }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", + "borderwidth": { + "valType": "integer", + "dflt": 0, + "min": 0, + "role": "style", + "editType": "plot", + "description": "Sets the border color of the range slider." + }, + "autorange": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the range slider range is computed in relation to the input data. If `range` is provided, then `autorange` is set to *false*." + }, + "range": { + "valType": "info_array", "role": "info", - "valType": "string" + "items": [ + { + "valType": "any", + "editType": "calc", + "impliedEdits": { + "^autorange": false + } + }, + { + "valType": "any", + "editType": "calc", + "impliedEdits": { + "^autorange": false + } + } + ], + "editType": "calc", + "impliedEdits": { + "autorange": false + }, + "description": "Sets the range of the range slider. If not set, defaults to the full xaxis range. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "thickness": { + "valType": "number", + "dflt": 0.15, + "min": 0, + "max": 1, "role": "style", - "valType": "color" + "editType": "plot", + "description": "The height of the range slider as a fraction of the total plot area height." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", + "visible": { + "valType": "boolean", + "dflt": true, "role": "info", - "valType": "string" + "editType": "calc", + "description": "Determines whether or not the range slider will be visible. If visible, perpendicular axes will be set to `fixedrange`" }, "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", + "yaxis": { + "_isSubplotObj": true, + "rangemode": { + "valType": "enumerated", + "values": [ + "auto", + "fixed", + "match" + ], + "dflt": "match", "role": "style", - "valType": "color" + "editType": "calc", + "description": "Determines whether or not the range of this axis in the rangeslider use the same value than in the main plot when zooming in/out. If *auto*, the autorange will be used. If *fixed*, the `range` is used. If *match*, the current range of the corresponding y-axis on the main subplot is used." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "range": { + "valType": "info_array", + "role": "style", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "Sets the range of this axis for the rangeslider." }, - "description": "Sets the font used in hover labels.", - "editType": "none", + "editType": "calc", + "role": "object" + }, + "role": "object" + }, + "rangeselector": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "plot", + "description": "Determines whether or not this range selector is visible. Note that range selectors are only available for x axes of `type` set to or auto-typed to *date*." + }, + "buttons": { + "items": { + "button": { + "step": { + "valType": "enumerated", + "role": "info", + "values": [ + "month", + "year", + "day", + "hour", + "minute", + "second", + "all" + ], + "dflt": "month", + "editType": "plot", + "description": "The unit of measurement that the `count` value will set the range by." + }, + "stepmode": { + "valType": "enumerated", + "role": "info", + "values": [ + "backward", + "todate" + ], + "dflt": "backward", + "editType": "plot", + "description": "Sets the range update mode. If *backward*, the range update shifts the start of range back *count* times *step* milliseconds. If *todate*, the range update shifts the start of range back to the first timestamp from *count* times *step* milliseconds back. For example, with `step` set to *year* and `count` set to *1* the range update shifts the start of the range back to January 01 of the current year. Month and year *todate* are currently available only for the built-in (Gregorian) calendar." + }, + "count": { + "valType": "number", + "role": "info", + "min": 0, + "dflt": 1, + "editType": "plot", + "description": "Sets the number of steps to take to update the range. Use with `step` to specify the update interval." + }, + "label": { + "valType": "string", + "role": "info", + "editType": "plot", + "description": "Sets the text label to appear on the button." + }, + "editType": "plot", + "description": "Sets the specifications for each buttons. By default, a range selector comes with no buttons.", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "number", + "min": -2, + "max": 3, + "role": "style", + "editType": "plot", + "description": "Sets the x position (in normalized coordinates) of the range selector." + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "left", + "role": "info", + "editType": "plot", + "description": "Sets the range selector's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector." + }, + "y": { + "valType": "number", + "min": -2, + "max": 3, + "role": "style", + "editType": "plot", + "description": "Sets the y position (in normalized coordinates) of the range selector." + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "bottom", + "role": "info", + "editType": "plot", + "description": "Sets the range selector's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector." + }, + "font": { "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "plot" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "plot", + "description": "Sets the font of the range selector button text.", + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "bgcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the background color of the range selector buttons." + }, + "activecolor": { + "valType": "color", "role": "style", - "valType": "integer" + "editType": "plot", + "description": "Sets the background color of the active range selector button." }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the color of the border enclosing the range selector." + }, + "borderwidth": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the border enclosing the range selector." }, + "editType": "plot", "role": "object" }, - "hoveron": { - "description": "Do the hover effects highlight individual points (markers or line points) or do they highlight filled regions? If the fill is *toself* or *tonext* and there are no markers or text, then the default is *fills*, otherwise it is *points*.", - "editType": "style", - "flags": [ - "points", - "fills" + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" ], "role": "info", - "valType": "flaglist" + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" }, - "hovertext": { - "arrayOk": true, - "description": "Sets hover text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "style", + "_isSubplotObj": true, + "role": "object", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "hovertextsrc": { - "description": "Sets the source reference on plot.ly for hovertext .", - "editType": "none", + "ticktextsrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + } + }, + "yaxis": { + "visible": { + "valType": "boolean", "role": "info", - "valType": "string" + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false" }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "title": { + "valType": "string", "role": "info", - "valType": "string" + "editType": "ticks+margins", + "description": "Sets the title of this axis." }, - "line": { - "color": { - "description": "Sets the line color.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "dash": { - "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).", - "dflt": "solid", - "editType": "style", - "role": "style", + "titlefont": { + "family": { "valType": "string", - "values": [ - "solid", - "dot", - "dash", - "longdash", - "dashdot", - "longdashdot" - ] - }, - "editType": "calc", - "role": "object", - "shape": { - "description": "Determines the line shape. With *spline* the lines are drawn using spline interpolation. The other available values correspond to step-wise line shapes.", - "dflt": "linear", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - "linear", - "spline" - ] - }, - "smoothing": { - "description": "Has an effect only if `shape` is set to *spline* Sets the amount of smoothing. *0* corresponds to no smoothing (equivalent to a *linear* shape).", - "dflt": 1, - "editType": "plot", - "max": 1.3, - "min": 0, "role": "style", - "valType": "number" + "noBlank": true, + "strict": true, + "editType": "ticks+margins", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "width": { - "description": "Sets the line width (in px).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "size": { + "valType": "number", "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" + "min": 1, + "editType": "ticks+margins" }, "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "ticks+margins" }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "colorbars", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "colorbars", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "colorbars", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "integer" - }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "colorbars", - "role": "style", - "valType": "boolean" - }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "colorbars", + "editType": "ticks+margins", + "description": "Sets this axis' title font.", + "role": "object" + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "log", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "calc", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." + }, + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", + "role": "style", + "editType": "plot", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." + }, + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "axrange+margins", "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "colorbars", - "role": "style", - "valType": "angle" - }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" + "^autorange": false } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "colorbars", - "items": [ - { - "editType": "colorbars", - "valType": "any" - }, - { - "editType": "colorbars", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "colorbars", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "colorbars", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "colorbars", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "colorbars", - "role": "data", - "valType": "data_array" - }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "colorbars", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "colorbars", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "colorbars", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "colorbars", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "colorbars", - "min": 1, - "role": "style", - "valType": "number" + { + "valType": "any", + "editType": "axrange+margins", + "impliedEdits": { + "^autorange": false } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] - }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" - }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "colorbars", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "colorbars", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "colorbars", - "min": 0, - "role": "style", - "valType": "number" } + ], + "editType": "axrange+margins", + "impliedEdits": { + "autorange": false }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "fixedrange": { + "valType": "boolean", + "dflt": false, + "role": "info", + "editType": "calc", + "description": "Determines whether or not this axis is zoom-able. If true, then zoom is disabled." + }, + "scaleanchor": { + "valType": "enumerated", + "values": [ + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "plot", + "description": "If set to another axis id (e.g. `x2`, `y`), the range of this axis changes together with the range of the corresponding axis such that the scale of pixels per unit is in a constant ratio. Both axes are still zoomable, but when you zoom one, the other will zoom the same amount, keeping a fixed midpoint. `constrain` and `constraintoward` determine how we enforce the constraint. You can chain these, ie `yaxis: {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` but you can only link axes of the same `type`. The linked axis can have the opposite letter (to constrain the aspect ratio) or the same letter (to match scales across subplots). Loops (`yaxis: {scaleanchor: *x*}, xaxis: {scaleanchor: *y*}` or longer) are redundant and the last constraint encountered will be ignored to avoid possible inconsistent constraints via `scaleratio`." + }, + "scaleratio": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "info", + "editType": "plot", + "description": "If this axis is linked to another by `scaleanchor`, this determines the pixel to unit scale ratio. For example, if this value is 10, then every unit on this axis spans 10 times the number of pixels as a unit on the linked axis. Use this for example to create an elevation profile where the vertical scale is exaggerated a fixed amount with respect to the horizontal." + }, + "constrain": { + "valType": "enumerated", + "values": [ + "range", + "domain" + ], + "dflt": "range", + "role": "info", + "editType": "plot", + "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines how that happens: by increasing the *range* (default), or by decreasing the *domain*." + }, + "constraintoward": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right", + "top", + "middle", + "bottom" + ], + "role": "info", + "editType": "plot", + "description": "If this axis needs to be compressed (either due to its own `scaleanchor` and `scaleratio` or those of the other axis), determines which direction we push the originally specified plot area. Options are *left*, *center* (default), and *right* for x axes, and *top*, *middle* (default), and *bottom* for y axes." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "ticks+margins", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "ticks+margins", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "ticks+margins", + "impliedEdits": { + "tickmode": "linear" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "ticks+margins", + "impliedEdits": { + "tickmode": "linear" }, - "editType": "calc", - "gradient": { - "color": { - "arrayOk": true, - "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object", - "type": { - "arrayOk": true, - "description": "Sets the type of gradient used to fill the markers", - "dflt": "none", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "radial", - "horizontal", - "vertical", - "none" - ] - }, - "typesrc": { - "description": "Sets the source reference on plot.ly for type .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "plot", - "impliedEdits": { - "cauto": false - }, - "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "maxdisplayed": { - "description": "Sets a maximum number of points to be drawn on the graph. *0* corresponds to no limit.", - "dflt": 0, - "editType": "plot", - "min": 0, - "role": "style", - "valType": "number" - }, - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "ticks+margins", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "ticks+margins", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "mirror": { + "valType": "enumerated", + "values": [ + true, + "ticks", + false, + "all", + "allticks" + ], + "dflt": false, + "role": "style", + "editType": "ticks+layoutstyle", + "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "ticks", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether or not the tick labels are drawn." + }, + "automargin": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "ticks+margins", + "description": "Determines whether long tick labels automatically grow the figure margins." + }, + "showspikes": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "modebar", + "description": "Determines whether or not spikes (aka droplines) are drawn for this axis. Note: This only takes affect when hovermode = closest" + }, + "spikecolor": { + "valType": "color", + "dflt": null, + "role": "style", + "editType": "none", + "description": "Sets the spike color. If undefined, will use the series color" + }, + "spikethickness": { + "valType": "number", + "dflt": 3, + "role": "style", + "editType": "none", + "description": "Sets the width (in px) of the zero line." + }, + "spikedash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "dash", + "role": "style", + "editType": "none", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "spikemode": { + "valType": "flaglist", + "flags": [ + "toaxis", + "across", + "marker" + ], + "role": "style", + "dflt": "toaxis", + "editType": "none", + "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on" + }, + "spikesnap": { + "valType": "enumerated", + "values": [ + "data", + "cursor" + ], + "dflt": "data", + "role": "style", + "editType": "none", + "description": "Determines whether spikelines are stuck to the cursor or to the closest datapoints." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "boolean" - }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" + "noBlank": true, + "strict": true, + "editType": "ticks+margins", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, + "valType": "number", "role": "style", - "valType": "number" + "min": 1, + "editType": "ticks+margins" }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", - "dflt": 0, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" - }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] + "editType": "ticks+margins" }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" + "editType": "ticks+margins", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "ticks+margins", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "ticks+margins", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "ticks+margins", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "ticks+margins", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "ticks+margins" + }, + { + "valType": "any", + "editType": "ticks+margins" + } + ], + "editType": "ticks+margins", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "ticks+margins", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "ticks+margins", + "role": "object" + } }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "role": "object" + }, + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "layoutstyle", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "layoutstyle", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks+layoutstyle", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "ticks", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "ticks", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the width (in px) of the grid lines." + }, + "zeroline": { + "valType": "boolean", + "role": "style", + "editType": "ticks", + "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines." + }, + "zerolinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "ticks", + "description": "Sets the line color of the zero line." + }, + "zerolinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "ticks", + "description": "Sets the width (in px) of the zero line." + }, + "anchor": { + "valType": "enumerated", + "values": [ + "free", + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "plot+margins", + "description": "If set to an opposite-letter axis id (e.g. `x2`, `y`), this axis is bound to the corresponding opposite-letter axis. If set to *free*, this axis' position is determined by `position`." + }, + "side": { + "valType": "enumerated", + "values": [ + "top", + "bottom", + "left", + "right" + ], + "role": "info", + "editType": "plot+margins", + "description": "Determines whether a x (y) axis is positioned at the *bottom* (*left*) or *top* (*right*) of the plotting area." + }, + "overlaying": { + "valType": "enumerated", + "values": [ + "free", + "/^x([2-9]|[1-9][0-9]+)?$/", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "plot", + "description": "If set a same-letter axis id, this axis is overlaid on top of the corresponding same-letter axis. If *false*, this axis does not overlay any same-letter axes." + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", + "role": "info", + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." + }, + "domain": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot+margins" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot+margins" + } + ], + "dflt": [ + 0, + 1 + ], + "editType": "plot+margins", + "description": "Sets the domain of this axis (in plot fraction)." + }, + "position": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 0, + "role": "style", + "editType": "plot+margins", + "description": "Sets the position of this axis in the plotting space (in normalized coordinates). Only has an effect if `anchor` is set to *free*." + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "calc", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "editType": "calc", + "_deprecated": { + "autotick": { + "valType": "boolean", "role": "info", - "valType": "string" - }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "style", - "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] - }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "ticks+margins", + "description": "Obsolete. Set `tickmode` to *auto* for old `autotick` *true* behavior. Set `tickmode` to *linear* for `autotick` *false*." } }, - "mode": { - "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points, then the default is *lines+markers*. Otherwise, *lines*.", - "dflt": "markers", - "editType": "calc", - "extras": [ - "none" - ], - "flags": [ - "lines", - "markers", - "text" + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" ], "role": "info", - "valType": "flaglist" + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", + "_isSubplotObj": true, + "role": "object", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { - "color": { - "description": "Sets the text font color of selected points.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object" - } + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", + "ticktextsrc": { + "valType": "string", "role": "info", - "valType": "any" + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", + "categoryarraysrc": { + "valType": "string", "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + } + }, + "ternary": { + "domain": { + "x": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this ternary subplot (in plot fraction).", + "editType": "plot" + }, + "y": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this ternary subplot (in plot fraction).", + "editType": "plot" + }, + "row": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "info", - "valType": "number" + "description": "If there is a layout grid, use the domain for this row in the grid for this ternary subplot .", + "editType": "plot" }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "strict": true, - "valType": "string" - } + "description": "If there is a layout grid, use the domain for this column in the grid for this ternary subplot .", + "editType": "plot" + }, + "editType": "plot", + "role": "object" }, - "subplot": { - "description": "Sets a reference between this trace's data coordinates and a ternary subplot. If *ternary* (the default value), the data refer to `layout.ternary`. If *ternary2*, the data refer to `layout.ternary2`, and so on.", - "dflt": "ternary", - "editType": "calc", - "role": "info", - "valType": "subplotid" + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "#fff", + "description": "Set the background color of the subplot", + "editType": "plot" }, "sum": { - "description": "The number each triplet should sum to, if only two of `a`, `b`, and `c` are provided. This overrides `ternary.sum` to normalize this specific trace, but does not affect the values displayed on the axes. 0 (or missing) means to use ternary.sum", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", + "valType": "number", "role": "info", - "valType": "string" + "dflt": 1, + "min": 0, + "description": "The number each triplet should sum to, and the maximum range of each axis", + "editType": "plot" }, - "textfont": { - "color": { - "arrayOk": true, - "editType": "style", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "aaxis": { + "title": { + "valType": "string", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the title of this axis." }, - "description": "Sets the text font.", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" + }, + "color": { + "valType": "color", + "dflt": "#444", "role": "style", - "strict": true, - "valType": "string" + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", + "nticks": { + "valType": "integer", "min": 1, + "dflt": 6, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "textposition": { - "arrayOk": true, - "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.", - "dflt": "middle center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top left", - "top center", - "top right", - "middle left", - "middle center", - "middle right", - "bottom left", - "bottom center", - "bottom right" - ] - }, - "textpositionsrc": { - "description": "Sets the source reference on plot.ly for textposition .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "scatterternary", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", - "role": "style", - "valType": "color" + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, - "min": 0, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "number" + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "role": "object", "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", - "min": 0, + "valType": "number", "role": "style", - "valType": "number" - } - }, - "role": "object", - "textfont": { + "min": 1, + "editType": "plot" + }, "color": { - "description": "Sets the text font color of unselected points, applied only when a selection exists.", - "editType": "style", + "valType": "color", "role": "style", - "valType": "color" + "editType": "plot" }, - "editType": "style", + "editType": "plot", + "description": "Sets the tick font.", "role": "object" - } - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "Provides similar functionality to the *scatter* type but on a ternary phase diagram. The data is provided by at least two arrays out of `a`, `b`, `c` triplets.", - "hrName": "scatter_ternary" - } - }, - "splom": { - "attributes": { - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "diagonal": { - "editType": "calc", - "role": "object", - "visible": { - "description": "Determines whether or not subplots on the diagonal are displayed.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "dimensions": { - "items": { - "dimension": { - "editType": "calc+clearAxisTypes", - "label": { - "description": "Sets the label corresponding to this splom dimension.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "role": "object", - "values": { - "description": "Sets the dimension values to be plotted.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "valuessrc": { - "description": "Sets the source reference on plot.ly for values .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this dimension is shown on the graph. Note that even visible false dimension contribute to the default grid generate by this splom trace.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" } - } + }, + "role": "object" }, - "role": "object" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "hoverformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "showline": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "linecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the axis line color." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", + "dflt": true + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", + "min": { + "valType": "number", + "dflt": 0, + "role": "info", + "min": 0, + "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", + "editType": "plot" + }, + "editType": "plot", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "baxis": { + "title": { + "valType": "string", + "role": "info", + "editType": "plot", + "description": "Sets the title of this axis." + }, + "titlefont": { "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "role": "object", "size": { - "arrayOk": true, - "editType": "none", + "valType": "number", + "role": "style", "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "plot" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "color": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "integer" + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" - }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "marker": { - "autocolorscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", + "editType": "plot", "impliedEdits": {}, - "role": "style", - "valType": "boolean" + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "cauto": { - "description": "Has an effect only if `marker.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" + "nticks": { + "valType": "integer", + "min": 1, + "dflt": 6, + "role": "style", + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "cmax": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmin` must be set as well.", - "dflt": null, - "editType": "calc", + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", "impliedEdits": { - "cauto": false + "tickmode": "linear" }, - "role": "info", - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "cmin": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.color` array index, and if set, `marker.cmax` must be set as well.", - "dflt": null, - "editType": "calc", + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", "impliedEdits": { - "cauto": false + "tickmode": "linear" }, - "role": "info", - "valType": "number" + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "color": { - "arrayOk": true, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", - "role": "style", - "valType": "color" + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] - }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", - "min": 0, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "integer" + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "outlinecolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "color" + "min": 1, + "editType": "plot" }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "plot" }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" + } }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "role": "object" + }, + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "showline": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", + "dflt": true + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", + "role": "info", + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." + }, + "min": { + "valType": "number", + "dflt": 0, + "role": "info", + "min": 0, + "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", + "editType": "plot" + }, + "editType": "plot", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "caxis": { + "title": { + "valType": "string", + "role": "info", + "editType": "plot", + "description": "Sets the title of this axis." + }, + "titlefont": { + "family": { + "valType": "string", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "boolean" + "min": 1, + "editType": "plot" }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "plot" }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", - "dflt": "all", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "all", - "first", - "last", - "none" - ] + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" + }, + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 1, + "dflt": 6, + "role": "style", + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "enumerated", - "values": [ - "fraction", - "pixels" - ] + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, + "size": { + "valType": "number", "role": "style", - "valType": "any" + "min": 1, + "editType": "plot" }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "angle" + "editType": "plot" }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" } }, - "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "tickformatstops": { - "items": { - "tickformatstop": { - "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" - }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "editType": "calc", - "role": "object", - "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - } - } - }, - "role": "object" - }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, + "role": "object" + }, + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "showline": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", + "dflt": true + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", + "role": "info", + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." + }, + "min": { + "valType": "number", + "dflt": 0, + "role": "info", + "min": 0, + "description": "The minimum value visible on this axis. The maximum is determined by the sum minus the minimum values of the other two axes. The full view corresponds to all the minima set to zero.", + "editType": "plot" + }, + "editType": "plot", + "role": "object", + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "editType": "plot", + "_isSubplotObj": true, + "role": "object" + }, + "scene": { + "_arrayAttrRegexps": [ + {} + ], + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(0,0,0,0)", + "editType": "plot" + }, + "camera": { + "up": { + "x": { + "valType": "number", "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] - }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] - }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", - "role": "style", - "valType": "string" - }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": 0, + "editType": "camera" }, - "ticktextsrc": { - "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "y": { + "valType": "number", "role": "info", - "valType": "string" - }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": 0, + "editType": "camera" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "z": { + "valType": "number", "role": "info", - "valType": "string" - }, - "tickwidth": { - "description": "Sets the tick width (in px).", "dflt": 1, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } - }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "right", - "top", - "bottom" - ] + "editType": "camera" }, + "editType": "camera", + "description": "Sets the (x,y,z) components of the 'up' camera vector. This vector determines the up direction of this scene with respect to the page. The default is *{x: 0, y: 0, z: 1}* which means that the z axis points up.", + "role": "object" + }, + "center": { "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] - }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "valType": "number", + "role": "info", + "dflt": 0, + "editType": "camera" }, "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, - "role": "style", - "valType": "number" - }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "top", - "middle", - "bottom" - ] - }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "line": { - "autocolorscale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array and `cmin`, `cmax` are set by the user. In this case, it controls whether the range of colors in `colorscale` is mapped to the range of values in the `color` array (`cauto: true`), or the `cmin`/`cmax` values (`cauto: false`). Defaults to `false` when `cmin`, `cmax` are set by the user.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "valType": "number", "role": "info", - "valType": "boolean" + "dflt": 0, + "editType": "camera" }, - "cmax": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the upper bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmin` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "z": { + "valType": "number", "role": "info", - "valType": "number" + "dflt": 0, + "editType": "camera" }, - "cmin": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Sets the lower bound of the color domain. Value should be associated to the `marker.line.color` array index, and if set, `marker.line.cmax` must be set as well.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "cauto": false - }, + "editType": "camera", + "description": "Sets the (x,y,z) components of the 'center' camera vector This vector determines the translation (x,y,z) space about the center of this scene. By default, there is no such translation.", + "role": "object" + }, + "eye": { + "x": { + "valType": "number", "role": "info", - "valType": "number" - }, - "color": { - "arrayOk": true, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorscale": { - "description": "Sets the colorscale and only has an effect if `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Greys, YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, Rainbow, Portland, Jet, Hot, Blackbody, Earth, Electric, Viridis, Cividis", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false - }, - "role": "style", - "valType": "colorscale" + "dflt": 1.25, + "editType": "camera" }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", + "y": { + "valType": "number", "role": "info", - "valType": "string" - }, - "editType": "calc", - "reversescale": { - "description": "Has an effect only if `marker.line.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "role": "object", - "width": { - "arrayOk": true, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "dflt": 1.25, + "editType": "camera" }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", + "z": { + "valType": "number", "role": "info", - "valType": "string" - } - }, - "opacity": { - "arrayOk": true, - "description": "Sets the marker opacity.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "dflt": 1.25, + "editType": "camera" + }, + "editType": "camera", + "description": "Sets the (x,y,z) components of the 'eye' camera vector. This vector determines the view point about the origin of this scene.", + "role": "object" }, - "opacitysrc": { - "description": "Sets the source reference on plot.ly for opacity .", - "editType": "none", + "editType": "camera", + "role": "object" + }, + "domain": { + "x": { + "valType": "info_array", "role": "info", - "valType": "string" - }, - "reversescale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Reverses the color mapping if true (`cmin` will correspond to the last color in the array and `cmax` will correspond to the first color).", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this scene subplot (in plot fraction)." }, - "role": "object", - "showscale": { - "description": "Has an effect only if `marker.color` is set to a numerical array. Determines whether or not a colorbar is displayed.", - "dflt": false, - "editType": "calc", + "y": { + "valType": "info_array", "role": "info", - "valType": "boolean" + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this scene subplot (in plot fraction)." }, - "size": { - "arrayOk": true, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calc", + "editType": "plot", + "row": { + "valType": "integer", "min": 0, - "role": "style", - "valType": "number" - }, - "sizemin": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.", "dflt": 0, - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - }, - "sizemode": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.", - "dflt": "diameter", - "editType": "calc", "role": "info", - "valType": "enumerated", - "values": [ - "diameter", - "area" - ] - }, - "sizeref": { - "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.", - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" + "editType": "plot", + "description": "If there is a layout grid, use the domain for this row in the grid for this scene subplot ." }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, "role": "info", - "valType": "string" - }, - "symbol": { - "arrayOk": true, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] - }, - "symbolsrc": { - "description": "Sets the source reference on plot.ly for symbol .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "plot", + "description": "If there is a layout grid, use the domain for this column in the grid for this scene subplot ." }, "role": "object" }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "showlowerhalf": { - "description": "Determines whether or not subplots on the lower half from the diagonal are displayed.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "showupperhalf": { - "description": "Determines whether or not subplots on the upper half from the diagonal are displayed.", - "dflt": true, - "editType": "calc", + "aspectmode": { + "valType": "enumerated", "role": "info", - "valType": "boolean" + "values": [ + "auto", + "cube", + "data", + "manual" + ], + "dflt": "auto", + "editType": "plot", + "impliedEdits": {}, + "description": "If *cube*, this scene's axes are drawn as a cube, regardless of the axes' ranges. If *data*, this scene's axes are drawn in proportion with the axes' ranges. If *manual*, this scene's axes are drawn in proportion with the input of *aspectratio* (the default behavior if *aspectratio* is provided). If *auto*, this scene's axes are drawn using the results of *data* except when one axis is more than four times the size of the two others, where in that case the results of *cube* are used." }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, + "aspectratio": { + "x": { + "valType": "number", "role": "info", - "valType": "number" + "min": 0, + "editType": "plot", + "impliedEdits": { + "^aspectmode": "manual" + } }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, + "y": { + "valType": "number", "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets text elements associated with each (x,y) pair to appear on hover. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "splom", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "calc", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "calc", - "min": 0, - "role": "style", - "valType": "number" + "min": 0, + "editType": "plot", + "impliedEdits": { + "^aspectmode": "manual" } }, - "role": "object" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "xaxes": { - "description": "Sets the list of x axes corresponding to this splom trace. By default, a splom will match the first N xaxes where N is the number of input dimensions.", - "editType": "calc", - "freeLength": true, - "items": { + "z": { + "valType": "number", + "role": "info", + "min": 0, "editType": "plot", - "regex": "/^x([2-9]|[1-9][0-9]+)?$/", - "valType": "subplotid" + "impliedEdits": { + "^aspectmode": "manual" + } }, - "role": "info", - "valType": "info_array" + "editType": "plot", + "impliedEdits": { + "aspectmode": "manual", + "role": "object" + }, + "description": "Sets this scene's axis aspectratio.", + "role": "object" }, - "yaxes": { - "description": "Sets the list of y axes corresponding to this splom trace. By default, a splom will match the first N yaxes where N is the number of input dimensions.", - "editType": "calc", - "freeLength": true, - "items": { + "xaxis": { + "visible": { + "valType": "boolean", + "role": "info", "editType": "plot", - "regex": "/^y([2-9]|[1-9][0-9]+)?$/", - "valType": "subplotid" + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false" }, - "role": "info", - "valType": "info_array" - } - }, - "meta": { - "description": "Splom traces generate scatter plot matrix visualizations. Each splom `dimensions` items correspond to a generated axis. Values for each of those dimensions are set in `dimensions[i].values`. Splom traces support all `scattergl` marker style attributes. Specify `layout.grid` attributes and/or layout x-axis and y-axis attributes for more control over the axis positioning and style. " - } - }, - "surface": { - "attributes": { - "_deprecated": { - "zauto": { - "description": "Obsolete. Use `cauto` instead.", + "showspikes": { + "valType": "boolean", + "role": "info", "dflt": true, - "editType": "calc", - "impliedEdits": {}, + "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", + "editType": "plot" + }, + "spikesides": { + "valType": "boolean", "role": "info", - "valType": "boolean" + "dflt": true, + "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", + "editType": "plot" }, - "zmax": { - "description": "Obsolete. Use `cmax` instead.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, + "spikethickness": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 2, + "description": "Sets the thickness (in px) of the spikes.", + "editType": "plot" + }, + "spikecolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the spikes.", + "editType": "plot" + }, + "showbackground": { + "valType": "boolean", "role": "info", - "valType": "number" + "dflt": false, + "description": "Sets whether or not this axis' wall has a background color.", + "editType": "plot" }, - "zmin": { - "description": "Obsolete. Use `cmin` instead.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false - }, + "backgroundcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(204, 204, 204, 0.5)", + "description": "Sets the background color of this axis' wall.", + "editType": "plot" + }, + "showaxeslabels": { + "valType": "boolean", "role": "info", - "valType": "number" - } - }, - "autocolorscale": { - "description": "Determines whether or not the colorscale is picked using the sign of the input z values.", - "dflt": false, - "editType": "calc", - "impliedEdits": {}, - "role": "style", - "valType": "boolean" - }, - "cauto": { - "description": "Determines the whether or not the color domain is computed with respect to the input data.", - "dflt": true, - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "boolean" - }, - "cmax": { - "description": "Sets the upper bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false + "dflt": true, + "description": "Sets whether or not this axis is labeled", + "editType": "plot" }, - "role": "info", - "valType": "number" - }, - "cmin": { - "description": "Sets the lower bound of color domain.", - "dflt": null, - "editType": "calc", - "impliedEdits": { - "zauto": false + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "role": "info", - "valType": "number" - }, - "colorbar": { - "bgcolor": { - "description": "Sets the color of padded area.", - "dflt": "rgba(0,0,0,0)", - "editType": "calc", + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "plot", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "plot", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "title": { + "valType": "string", + "role": "info", + "editType": "plot", + "description": "Sets the title of this axis." + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "log", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "plot", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, "role": "style", - "valType": "color" + "editType": "plot", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." }, - "bordercolor": { - "description": "Sets the axis line color.", - "dflt": "#444", - "editType": "calc", + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", "role": "style", - "valType": "color" + "editType": "plot", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." }, - "borderwidth": { - "description": "Sets the width (in px) or the border enclosing this color bar.", - "dflt": 0, - "editType": "calc", + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } + }, + { + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } + } + ], + "editType": "plot", + "impliedEdits": { + "autorange": false + }, + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "dtick": { - "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*", - "editType": "calc", + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", "impliedEdits": { "tickmode": "linear" }, - "role": "style", - "valType": "any" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "editType": "calc", - "exponentformat": { - "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B.", - "dflt": "B", - "editType": "calc", + "dtick": { + "valType": "any", "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { "valType": "enumerated", "values": [ - "none", - "e", - "E", - "power", - "SI", - "B" - ] - }, - "len": { - "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.", - "dflt": 1, - "editType": "calc", - "min": 0, + "outside", + "inside", + "" + ], "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." }, - "lenmode": { - "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", - "dflt": "fraction", - "editType": "calc", - "role": "info", + "mirror": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] + true, + "ticks", + false, + "all", + "allticks" + ], + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots." }, - "nticks": { - "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.", - "dflt": 0, - "editType": "calc", + "ticklen": { + "valType": "number", "min": 0, + "dflt": 5, "role": "style", - "valType": "integer" + "editType": "plot", + "description": "Sets the tick length (in px)." }, - "outlinecolor": { - "description": "Sets the axis line color.", + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", "dflt": "#444", - "editType": "calc", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the tick color." }, - "outlinewidth": { - "description": "Sets the width (in px) of the axis line.", - "dflt": 1, - "editType": "calc", - "min": 0, + "showticklabels": { + "valType": "boolean", + "dflt": true, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." }, - "role": "object", - "separatethousands": { - "description": "If \"true\", even 4-digit integers are separated", - "dflt": false, - "editType": "calc", + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "boolean" + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "showexponent": { - "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.", - "dflt": "all", - "editType": "calc", + "tickprefix": { + "valType": "string", + "dflt": "", "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showtickprefix": { "valType": "enumerated", "values": [ "all", "first", "last", "none" - ] - }, - "showticklabels": { - "description": "Determines whether or not the tick labels are drawn.", - "dflt": true, - "editType": "calc", + ], + "dflt": "all", "role": "style", - "valType": "boolean" + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, - "showtickprefix": { - "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.", - "dflt": "all", - "editType": "calc", + "ticksuffix": { + "valType": "string", + "dflt": "", "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { "valType": "enumerated", "values": [ "all", "first", "last", "none" - ] - }, - "showticksuffix": { - "description": "Same as `showtickprefix` but for tick suffixes.", + ], "dflt": "all", - "editType": "calc", "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { "valType": "enumerated", "values": [ "all", "first", "last", "none" - ] - }, - "thickness": { - "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.", - "dflt": 30, - "editType": "calc", - "min": 0, + ], + "dflt": "all", "role": "style", - "valType": "number" + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, - "thicknessmode": { - "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.", - "dflt": "pixels", - "editType": "calc", - "role": "style", + "exponentformat": { "valType": "enumerated", "values": [ - "fraction", - "pixels" - ] - }, - "tick0": { - "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.", - "editType": "calc", - "impliedEdits": { - "tickmode": "linear" - }, - "role": "style", - "valType": "any" - }, - "tickangle": { - "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.", - "dflt": "auto", - "editType": "calc", + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", "role": "style", - "valType": "angle" + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "tickcolor": { - "description": "Sets the tick color.", - "dflt": "#444", - "editType": "calc", + "separatethousands": { + "valType": "boolean", + "dflt": false, "role": "style", - "valType": "color" - }, - "tickfont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets the color bar's tick label font", - "editType": "calc", - "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "role": "object", - "size": { - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - } + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" }, "tickformat": { - "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, "tickformatstops": { "items": { "tickformatstop": { "dtickrange": { - "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*", - "editType": "calc", + "valType": "info_array", + "role": "info", "items": [ { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "plot" }, { - "editType": "calc", - "valType": "any" + "valType": "any", + "editType": "plot" } ], - "role": "info", - "valType": "info_array" + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" }, - "editType": "calc", - "role": "object", "value": { - "description": "string - dtickformat for described zoom level, the same as *tickformat*", + "valType": "string", "dflt": "", - "editType": "calc", "role": "style", - "valType": "string" - } + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" } }, "role": "object" }, - "ticklen": { - "description": "Sets the tick length (in px).", - "dflt": 5, - "editType": "calc", + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the width (in px) of the axis line." }, - "tickmode": { - "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).", - "editType": "calc", - "impliedEdits": {}, - "role": "info", - "valType": "enumerated", - "values": [ - "auto", - "linear", - "array" - ] + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." }, - "tickprefix": { - "description": "Sets a tick label prefix.", - "dflt": "", - "editType": "calc", + "gridcolor": { + "valType": "color", + "dflt": "rgb(204, 204, 204)", "role": "style", - "valType": "string" + "editType": "plot", + "description": "Sets the color of the grid lines." }, - "ticks": { - "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.", - "dflt": "", - "editType": "calc", + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, "role": "style", - "valType": "enumerated", - "values": [ - "outside", - "inside", - "" - ] + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." }, - "ticksuffix": { - "description": "Sets a tick label suffix.", - "dflt": "", - "editType": "calc", + "zeroline": { + "valType": "boolean", "role": "style", - "valType": "string" + "editType": "plot", + "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines." }, - "ticktext": { - "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "zerolinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the line color of the zero line." + }, + "zerolinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the zero line." + }, + "editType": "plot", + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", "editType": "calc", - "role": "data", - "valType": "data_array" + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" + }, + "role": "object", + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + }, + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, "ticktextsrc": { + "valType": "string", + "role": "info", "description": "Sets the source reference on plot.ly for ticktext .", - "editType": "none", + "editType": "none" + } + }, + "yaxis": { + "visible": { + "valType": "boolean", "role": "info", - "valType": "string" + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false" }, - "tickvals": { - "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "showspikes": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", + "editType": "plot" }, - "tickvalssrc": { - "description": "Sets the source reference on plot.ly for tickvals .", - "editType": "none", + "spikesides": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", + "editType": "plot" }, - "tickwidth": { - "description": "Sets the tick width (in px).", - "dflt": 1, - "editType": "calc", + "spikethickness": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 2, + "description": "Sets the thickness (in px) of the spikes.", + "editType": "plot" + }, + "spikecolor": { + "valType": "color", "role": "style", - "valType": "number" + "dflt": "#444", + "description": "Sets the color of the spikes.", + "editType": "plot" }, - "title": { - "description": "Sets the title of the color bar.", - "editType": "calc", + "showbackground": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not this axis' wall has a background color.", + "editType": "plot" + }, + "backgroundcolor": { + "valType": "color", + "role": "style", + "dflt": "rgba(204, 204, 204, 0.5)", + "description": "Sets the background color of this axis' wall.", + "editType": "plot" + }, + "showaxeslabels": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Sets whether or not this axis is labeled", + "editType": "plot" + }, + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "plot", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "plot", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "title": { + "valType": "string", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the title of this axis." }, "titlefont": { - "color": { - "editType": "calc", - "role": "style", - "valType": "color" - }, - "description": "Sets this color bar's title font.", - "editType": "calc", "family": { - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, + "valType": "string", "role": "style", + "noBlank": true, "strict": true, - "valType": "string" + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "role": "object", "size": { - "editType": "calc", + "valType": "number", + "role": "style", "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", "role": "style", - "valType": "number" - } + "editType": "plot" + }, + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" }, - "titleside": { - "description": "Determines the location of the colorbar title with respect to the color bar.", - "dflt": "top", - "editType": "calc", - "role": "style", + "type": { "valType": "enumerated", "values": [ - "right", - "top", - "bottom" - ] + "-", + "linear", + "log", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "plot", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." }, - "x": { - "description": "Sets the x position of the color bar (in plot fraction).", - "dflt": 1.02, - "editType": "calc", - "max": 3, - "min": -2, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, "role": "style", - "valType": "number" + "editType": "plot", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." }, - "xanchor": { - "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar.", - "dflt": "left", - "editType": "calc", + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", "role": "style", + "editType": "plot", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." + }, + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } + }, + { + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } + } + ], + "editType": "plot", + "impliedEdits": { + "autorange": false + }, + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "tickmode": { "valType": "enumerated", "values": [ - "left", - "center", - "right" - ] + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "xpad": { - "description": "Sets the amount of padding (in px) along the x direction.", - "dflt": 10, - "editType": "calc", + "nticks": { + "valType": "integer", "min": 0, + "dflt": 0, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "y": { - "description": "Sets the y position of the color bar (in plot fraction).", - "dflt": 0.5, - "editType": "calc", - "max": 3, - "min": -2, + "tick0": { + "valType": "any", "role": "style", - "valType": "number" + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." }, - "yanchor": { - "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar.", - "dflt": "middle", - "editType": "calc", + "dtick": { + "valType": "any", "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { "valType": "enumerated", "values": [ - "top", - "middle", - "bottom" - ] + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." }, - "ypad": { - "description": "Sets the amount of padding (in px) along the y direction.", - "dflt": 10, - "editType": "calc", + "mirror": { + "valType": "enumerated", + "values": [ + true, + "ticks", + false, + "all", + "allticks" + ], + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots." + }, + "ticklen": { + "valType": "number", "min": 0, + "dflt": 5, "role": "style", - "valType": "number" - } - }, - "colorscale": { - "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in z space, use zmin and zmax", - "editType": "calc", - "impliedEdits": { - "autocolorscale": false + "editType": "plot", + "description": "Sets the tick length (in px)." }, - "role": "style", - "valType": "colorscale" - }, - "contours": { - "editType": "calc", - "role": "object", - "x": { - "color": { - "description": "Sets the color of the contour lines.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "highlight": { - "description": "Determines whether or not contour lines about the x dimension are highlighted on hover.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "highlightcolor": { - "description": "Sets the color of the highlighted contour lines.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "highlightwidth": { - "description": "Sets the width of the highlighted contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, - "role": "style", - "valType": "number" - }, - "project": { - "editType": "calc", - "role": "object", - "x": { - "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "y": { - "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "z": { - "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "role": "object", - "show": { - "description": "Determines whether or not contour lines about the x dimension are drawn.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "usecolormap": { - "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets the width of the contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, - "role": "style", - "valType": "number" - } + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." }, - "y": { - "color": { - "description": "Sets the color of the contour lines.", - "dflt": "#444", - "editType": "calc", + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "color" - }, - "editType": "calc", - "highlight": { - "description": "Determines whether or not contour lines about the y dimension are highlighted on hover.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "highlightcolor": { - "description": "Sets the color of the highlighted contour lines.", - "dflt": "#444", - "editType": "calc", + "size": { + "valType": "number", "role": "style", - "valType": "color" - }, - "highlightwidth": { - "description": "Sets the width of the highlighted contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, "min": 1, - "role": "style", - "valType": "number" - }, - "project": { - "editType": "calc", - "role": "object", - "x": { - "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "y": { - "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "z": { - "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "role": "object", - "show": { - "description": "Determines whether or not contour lines about the y dimension are drawn.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "usecolormap": { - "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" + "editType": "plot" }, - "width": { - "description": "Sets the width of the contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, - "role": "style", - "valType": "number" - } - }, - "z": { "color": { - "description": "Sets the color of the contour lines.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "editType": "calc", - "highlight": { - "description": "Determines whether or not contour lines about the z dimension are highlighted on hover.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "highlightcolor": { - "description": "Sets the color of the highlighted contour lines.", - "dflt": "#444", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "highlightwidth": { - "description": "Sets the width of the highlighted contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, + "valType": "color", "role": "style", - "valType": "number" - }, - "project": { - "editType": "calc", - "role": "object", - "x": { - "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "y": { - "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "z": { - "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - } - }, - "role": "object", - "show": { - "description": "Determines whether or not contour lines about the z dimension are drawn.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "usecolormap": { - "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" + "editType": "plot" }, - "width": { - "description": "Sets the width of the contour lines.", - "dflt": 2, - "editType": "calc", - "max": 16, - "min": 1, - "role": "style", - "valType": "number" - } - } - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hidesurface": { - "description": "Determines whether or not a surface is drawn. For example, set `hidesurface` to *false* `contours.x.show` to *true* and `contours.y.show` to *true* to draw a wire frame plot.", - "dflt": false, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "calc", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", - "role": "style", - "valType": "color" - }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" + } }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "hoverformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "integer" + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "lighting": { - "ambient": { - "description": "Ambient light increases overall color visibility but can wash out the image.", - "dflt": 0.8, - "editType": "calc", - "max": 1, - "min": 0, + "linecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the axis line color." }, - "diffuse": { - "description": "Represents the extent that incident rays are reflected in a range of angles.", - "dflt": 0.8, - "editType": "calc", - "max": 1, + "linewidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the width (in px) of the axis line." }, - "editType": "calc", - "fresnel": { - "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.", - "dflt": 0.2, - "editType": "calc", - "max": 5, - "min": 0, + "showgrid": { + "valType": "boolean", "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." }, - "role": "object", - "roughness": { - "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.", - "dflt": 0.5, - "editType": "calc", - "max": 1, - "min": 0, + "gridcolor": { + "valType": "color", + "dflt": "rgb(204, 204, 204)", "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the color of the grid lines." }, - "specular": { - "description": "Represents the level that incident rays are reflected in a single direction, causing shine.", - "dflt": 0.05, - "editType": "calc", - "max": 2, + "gridwidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "lightposition": { - "editType": "calc", - "role": "object", - "x": { - "description": "Numeric vector, representing the X coordinate for each vertex.", - "dflt": 10, - "editType": "calc", - "max": 100000, - "min": -100000, + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "zeroline": { + "valType": "boolean", "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines." }, - "y": { - "description": "Numeric vector, representing the Y coordinate for each vertex.", - "dflt": 10000, - "editType": "calc", - "max": 100000, - "min": -100000, + "zerolinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "number" + "editType": "plot", + "description": "Sets the line color of the zero line." }, - "z": { - "description": "Numeric vector, representing the Z coordinate for each vertex.", - "dflt": 0, - "editType": "calc", - "max": 100000, - "min": -100000, + "zerolinewidth": { + "valType": "number", + "dflt": 1, "role": "style", - "valType": "number" - } - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the surface.", - "dflt": 1, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "reversescale": { - "description": "Reverses the colorscale.", - "dflt": false, - "editType": "calc", - "role": "style", - "valType": "boolean" - }, - "scene": { - "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.", - "dflt": "scene", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "showscale": { - "description": "Determines whether or not a colorbar is displayed for this trace.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, + "editType": "plot", + "description": "Sets the width (in px) of the zero line." + }, + "editType": "plot", + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], "role": "info", - "valType": "number" + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" }, "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, + "categoryarraysrc": { + "valType": "string", "role": "info", - "strict": true, - "valType": "string" + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + }, + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" } }, - "surfacecolor": { - "description": "Sets the surface color values, used for setting a color scale independent of `z`.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "surfacecolorsrc": { - "description": "Sets the source reference on plot.ly for surfacecolor .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "text": { - "arrayOk": true, - "description": "Sets the text elements associated with each z value. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "surface", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "xcalendar": { - "description": "Sets the calendar system to use with `x` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "ycalendar": { - "description": "Sets the calendar system to use with `y` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "z": { - "description": "Sets the z coordinates.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "zcalendar": { - "description": "Sets the calendar system to use with `z` date data.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "gregorian", - "chinese", - "coptic", - "discworld", - "ethiopian", - "hebrew", - "islamic", - "julian", - "mayan", - "nanakshahi", - "nepali", - "persian", - "jalali", - "taiwan", - "thai", - "ummalqura" - ] - }, - "zsrc": { - "description": "Sets the source reference on plot.ly for z .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "meta": { - "description": "The data the describes the coordinates of the surface is set in `z`. Data in `z` should be a {2D array}. Coordinates in `x` and `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph parametric surfaces). If not provided in `x` and `y`, the x and y coordinates are assumed to be linear starting at 0 with a unit step. The color scale corresponds to the `z` values by default. For custom color scales, use `surfacecolor` which should be a {2D array}, where its bounds can be controlled using `cmin` and `cmax`." - } - }, - "table": { - "attributes": { - "cells": { - "align": { - "arrayOk": true, - "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", - "dflt": "center", - "editType": "calc", - "role": "style", - "valType": "enumerated", - "values": [ - "left", - "center", - "right" - ] + "zaxis": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false" }, - "alignsrc": { - "description": "Sets the source reference on plot.ly for align .", - "editType": "none", + "showspikes": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "description": "Sets whether or not spikes starting from data points to this axis' wall are shown on hover.", + "editType": "plot" }, - "editType": "calc", - "fill": { - "color": { - "arrayOk": true, - "description": "Sets the cell fill color. It accepts either a specific color or an array of colors.", - "dflt": "white", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object" - }, - "font": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "format": { - "description": "Sets the cell value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": [], - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "formatsrc": { - "description": "Sets the source reference on plot.ly for format .", - "editType": "none", + "spikesides": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "description": "Sets whether or not spikes extending from the projection data points to this axis' wall boundaries are shown on hover.", + "editType": "plot" }, - "height": { - "description": "The height of cells.", - "dflt": 20, - "editType": "calc", + "spikethickness": { + "valType": "number", "role": "style", - "valType": "number" + "min": 0, + "dflt": 2, + "description": "Sets the thickness (in px) of the spikes.", + "editType": "plot" }, - "line": { - "color": { - "arrayOk": true, - "dflt": "grey", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "dflt": 1, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } + "spikecolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the spikes.", + "editType": "plot" }, - "prefix": { - "arrayOk": true, - "description": "Prefix for cell values.", - "dflt": null, - "editType": "calc", + "showbackground": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not this axis' wall has a background color.", + "editType": "plot" + }, + "backgroundcolor": { + "valType": "color", "role": "style", - "valType": "string" + "dflt": "rgba(204, 204, 204, 0.5)", + "description": "Sets the background color of this axis' wall.", + "editType": "plot" }, - "prefixsrc": { - "description": "Sets the source reference on plot.ly for prefix .", - "editType": "none", + "showaxeslabels": { + "valType": "boolean", "role": "info", - "valType": "string" + "dflt": true, + "description": "Sets whether or not this axis is labeled", + "editType": "plot" }, - "role": "object", - "suffix": { - "arrayOk": true, - "description": "Suffix for cell values.", - "dflt": null, - "editType": "calc", + "color": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "string" + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." }, - "suffixsrc": { - "description": "Sets the source reference on plot.ly for suffix .", - "editType": "none", + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", "role": "info", - "valType": "string" + "editType": "plot", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." }, - "values": { - "description": "Cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.", - "dflt": [], - "editType": "calc", + "categoryarray": { + "valType": "data_array", "role": "data", - "valType": "data_array" + "editType": "plot", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." }, - "valuessrc": { - "description": "Sets the source reference on plot.ly for values .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "columnorder": { - "description": "Specifies the rendered order of the data columns; for example, a value `2` at position `0` means that column index `0` in the data will be rendered as the third column, as columns have an index base of zero.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "columnordersrc": { - "description": "Sets the source reference on plot.ly for columnorder .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "columnwidth": { - "arrayOk": true, - "description": "The width of columns expressed as a ratio. Columns fill the available width in proportion of their specified column widths.", - "dflt": null, - "editType": "calc", - "role": "style", - "valType": "number" - }, - "columnwidthsrc": { - "description": "Sets the source reference on plot.ly for columnwidth .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "domain": { - "column": { - "description": "If there is a layout grid, use the domain for this column in the grid for this table trace .", - "dflt": 0, - "editType": "calc", - "min": 0, + "title": { + "valType": "string", "role": "info", - "valType": "integer" + "editType": "plot", + "description": "Sets the title of this axis." }, - "editType": "calc", - "role": "object", - "row": { - "description": "If there is a layout grid, use the domain for this row in the grid for this table trace .", - "dflt": 0, - "editType": "calc", - "min": 0, - "role": "info", - "valType": "integer" + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" }, - "x": { - "description": "Sets the horizontal domain of this table trace (in plot fraction).", - "dflt": [ - 0, - 1 - ], - "editType": "calc", - "items": [ - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - }, - { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" - } + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "log", + "date", + "category" ], + "dflt": "-", "role": "info", - "valType": "info_array" + "editType": "plot", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." }, - "y": { - "description": "Sets the vertical domain of this table trace (in plot fraction).", - "dflt": [ - 0, - 1 + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" ], - "editType": "calc", + "dflt": true, + "role": "style", + "editType": "plot", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." + }, + "rangemode": { + "valType": "enumerated", + "values": [ + "normal", + "tozero", + "nonnegative" + ], + "dflt": "normal", + "role": "style", + "editType": "plot", + "description": "If *normal*, the range is computed in relation to the extrema of the input data. If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data." + }, + "range": { + "valType": "info_array", + "role": "info", "items": [ { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } }, { - "editType": "calc", - "max": 1, - "min": 0, - "valType": "number" + "valType": "any", + "editType": "plot", + "impliedEdits": { + "^autorange": false + } } ], - "role": "info", - "valType": "info_array" - } - }, - "editType": "calc", - "header": { - "align": { - "arrayOk": true, - "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width.", - "dflt": "center", - "editType": "calc", - "role": "style", + "editType": "plot", + "impliedEdits": { + "autorange": false + }, + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "tickmode": { "valType": "enumerated", "values": [ - "left", - "center", - "right" - ] - }, - "alignsrc": { - "description": "Sets the source reference on plot.ly for align .", - "editType": "none", + "auto", + "linear", + "array" + ], "role": "info", - "valType": "string" + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." }, - "editType": "calc", - "fill": { - "color": { - "arrayOk": true, - "description": "Sets the cell fill color. It accepts either a specific color or an array of colors.", - "dflt": "white", - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "editType": "calc", - "role": "object" + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." }, - "font": { - "color": { - "arrayOk": true, - "editType": "calc", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "", - "editType": "calc", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "calc", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "calc", - "min": 1, - "role": "style", - "valType": "number" + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" }, - "format": { - "description": "Sets the cell value formatting rule using d3 formatting mini-language which is similar to those of Python. See https://github.com/d3/d3-format/blob/master/README.md#locale_format", - "dflt": [], - "editType": "calc", - "role": "data", - "valType": "data_array" + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" }, - "formatsrc": { - "description": "Sets the source reference on plot.ly for format .", - "editType": "none", - "role": "info", - "valType": "string" + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" }, - "height": { - "description": "The height of cells.", - "dflt": 28, - "editType": "calc", + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], "role": "style", - "valType": "number" + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." }, - "line": { - "color": { - "arrayOk": true, - "dflt": "grey", - "editType": "calc", + "mirror": { + "valType": "enumerated", + "values": [ + true, + "ticks", + false, + "all", + "allticks" + ], + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines if the axis lines or/and ticks are mirrored to the opposite side of the plotting area. If *true*, the axis lines are mirrored. If *ticks*, the axis lines and ticks are mirrored. If *false*, mirroring is disable. If *all*, axis lines are mirrored on all shared-axes subplots. If *allticks*, axis lines and ticks are mirrored on all shared-axes subplots." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "tickfont": { + "family": { + "valType": "string", "role": "style", - "valType": "color" + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" }, - "editType": "calc", - "role": "object", - "width": { - "arrayOk": true, - "dflt": 1, - "editType": "calc", + "color": { + "valType": "color", "role": "style", - "valType": "number" + "editType": "plot" }, - "widthsrc": { - "description": "Sets the source reference on plot.ly for width .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" }, - "prefix": { - "arrayOk": true, - "description": "Prefix for cell values.", - "dflt": null, - "editType": "calc", + "tickangle": { + "valType": "angle", + "dflt": "auto", "role": "style", - "valType": "string" + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." }, - "prefixsrc": { - "description": "Sets the source reference on plot.ly for prefix .", - "editType": "none", - "role": "info", - "valType": "string" + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." }, - "role": "object", - "suffix": { - "arrayOk": true, - "description": "Suffix for cell values.", - "dflt": null, - "editType": "calc", + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "string" + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." }, - "suffixsrc": { - "description": "Sets the source reference on plot.ly for suffix .", - "editType": "none", - "role": "info", - "valType": "string" + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." }, - "values": { - "description": "Header cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.", - "dflt": [], - "editType": "calc", - "role": "data", - "valType": "data_array" + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." }, - "valuessrc": { - "description": "Sets the source reference on plot.ly for values .", - "editType": "none", - "role": "info", - "valType": "string" - } - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", "role": "style", - "valType": "color" + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "separatethousands": { + "valType": "boolean", + "dflt": false, "role": "style", - "valType": "color" + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" + } }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "role": "object" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, + "hoverformat": { + "valType": "string", + "dflt": "", "role": "style", - "valType": "integer" - }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "plot", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" }, - "role": "object" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", - "role": "info", - "valType": "string" - }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover.", - "editType": "style", - "role": "info", - "valType": "string" - }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" + "showline": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "type": "table", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - } - }, - "meta": { - "description": "Table view for detailed data viewing. The data are arranged in a grid of rows and columns. Most styling can be specified for columns, rows or individual cells. Table is using a column-major order, ie. the grid is represented as a vector of column vectors." - } - }, - "violin": { - "attributes": { - "bandwidth": { - "description": "Sets the bandwidth used to compute the kernel density estimate. By default, the bandwidth is determined by Silverman's rule of thumb.", - "editType": "calc", - "min": 0, - "role": "info", - "valType": "number" - }, - "box": { - "editType": "plot", - "fillcolor": { - "description": "Sets the inner box plot fill color.", - "editType": "style", + "linecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the axis line color." }, - "line": { - "color": { - "description": "Sets the inner box plot bounding line color.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "style", - "role": "object", - "width": { - "description": "Sets the inner box plot bounding line width.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." }, - "role": "object", - "visible": { - "description": "Determines if an miniature box plot is drawn inside the violins. ", - "dflt": false, + "showgrid": { + "valType": "boolean", + "role": "style", "editType": "plot", - "role": "info", - "valType": "boolean" + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark." }, - "width": { - "description": "Sets the width of the inner box plots relative to the violins' width. For example, with 1, the inner box plots are as wide as the violins.", - "dflt": 0.25, + "gridcolor": { + "valType": "color", + "dflt": "rgb(204, 204, 204)", + "role": "style", "editType": "plot", - "max": 1, + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", "min": 0, - "role": "info", - "valType": "number" - } - }, - "customdata": { - "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements", - "editType": "calc", - "role": "data", - "valType": "data_array" - }, - "customdatasrc": { - "description": "Sets the source reference on plot.ly for customdata .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "fillcolor": { - "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.", - "editType": "style", - "role": "style", - "valType": "color" - }, - "hoverinfo": { - "arrayOk": true, - "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.", - "dflt": "all", - "editType": "none", - "extras": [ - "all", - "none", - "skip" - ], - "flags": [ - "x", - "y", - "z", - "text", - "name" - ], - "role": "info", - "valType": "flaglist" - }, - "hoverinfosrc": { - "description": "Sets the source reference on plot.ly for hoverinfo .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "hoverlabel": { - "bgcolor": { - "arrayOk": true, - "description": "Sets the background color of the hover labels for this trace", - "editType": "none", + "dflt": 1, "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." }, - "bgcolorsrc": { - "description": "Sets the source reference on plot.ly for bgcolor .", - "editType": "none", - "role": "info", - "valType": "string" + "zeroline": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line is drawn at along the 0 value of this axis. If *true*, the zero line is drawn on top of the grid lines." }, - "bordercolor": { - "arrayOk": true, - "description": "Sets the border color of the hover labels for this trace.", - "editType": "none", + "zerolinecolor": { + "valType": "color", + "dflt": "#444", "role": "style", - "valType": "color" + "editType": "plot", + "description": "Sets the line color of the zero line." }, - "bordercolorsrc": { - "description": "Sets the source reference on plot.ly for bordercolor .", - "editType": "none", - "role": "info", - "valType": "string" + "zerolinewidth": { + "valType": "number", + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the zero line." }, - "editType": "calc", - "font": { - "color": { - "arrayOk": true, - "editType": "none", - "role": "style", - "valType": "color" - }, - "colorsrc": { - "description": "Sets the source reference on plot.ly for color .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "description": "Sets the font used in hover labels.", - "editType": "none", - "family": { - "arrayOk": true, - "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", - "editType": "none", - "noBlank": true, - "role": "style", - "strict": true, - "valType": "string" - }, - "familysrc": { - "description": "Sets the source reference on plot.ly for family .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "role": "object", - "size": { - "arrayOk": true, - "editType": "none", - "min": 1, - "role": "style", - "valType": "number" - }, - "sizesrc": { - "description": "Sets the source reference on plot.ly for size .", - "editType": "none", - "role": "info", - "valType": "string" - } + "editType": "plot", + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" }, - "namelength": { - "arrayOk": true, - "description": "Sets the length (in number of characters) of the trace name in the hover labels for this trace. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.", - "editType": "none", - "min": -1, - "role": "style", - "valType": "integer" + "role": "object", + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" }, - "namelengthsrc": { - "description": "Sets the source reference on plot.ly for namelength .", - "editType": "none", + "tickvalssrc": { + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" }, - "role": "object" - }, - "hoveron": { - "description": "Do the hover effects highlight individual violins or sample points or the kernel density estimate or any combination of them?", - "dflt": "violins+points+kde", - "editType": "style", - "extras": [ - "all" - ], - "flags": [ - "violins", - "points", - "kde" - ], - "role": "info", - "valType": "flaglist" - }, - "ids": { - "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.", - "editType": "calc", - "role": "data", - "valType": "data_array" + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } }, - "idssrc": { - "description": "Sets the source reference on plot.ly for ids .", - "editType": "none", + "dragmode": { + "valType": "enumerated", "role": "info", - "valType": "string" - }, - "jitter": { - "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the violins.", - "editType": "calcIfAutorange", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "values": [ + "orbit", + "turntable", + "zoom", + "pan", + false + ], + "dflt": "turntable", + "editType": "plot", + "description": "Determines the mode of drag interactions for this scene." }, - "legendgroup": { - "description": "Sets the legend group for this trace. Traces part of the same legend group hide/show at the same time when toggling legend items.", - "dflt": "", - "editType": "style", + "hovermode": { + "valType": "enumerated", "role": "info", - "valType": "string" + "values": [ + "closest", + false + ], + "dflt": "closest", + "editType": "modebar", + "description": "Determines the mode of hover interactions for this scene." }, - "line": { - "color": { - "description": "Sets the color of line bounding the violin(s).", - "editType": "style", - "role": "style", - "valType": "color" - }, - "editType": "plot", - "role": "object", - "width": { - "description": "Sets the width (in px) of line bounding the violin(s).", - "dflt": 2, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" + "editType": "plot", + "_deprecated": { + "cameraposition": { + "valType": "info_array", + "role": "info", + "editType": "camera", + "description": "Obsolete. Use `camera` instead." } }, - "marker": { - "color": { - "arrayOk": false, - "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "editType": "style", - "role": "style", - "valType": "color" + "annotations": { + "items": { + "annotation": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calc", + "description": "Determines whether or not this annotation is visible." + }, + "x": { + "valType": "any", + "role": "info", + "description": "Sets the annotation's x position.", + "editType": "calc" + }, + "y": { + "valType": "any", + "role": "info", + "description": "Sets the annotation's y position.", + "editType": "calc" + }, + "z": { + "valType": "any", + "role": "info", + "description": "Sets the annotation's z position.", + "editType": "calc" + }, + "ax": { + "valType": "number", + "role": "info", + "description": "Sets the x component of the arrow tail about the arrow head (in pixels).", + "editType": "calc" + }, + "ay": { + "valType": "number", + "role": "info", + "description": "Sets the y component of the arrow tail about the arrow head (in pixels).", + "editType": "calc" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "auto", + "role": "info", + "editType": "calc", + "description": "Sets the text box's horizontal position anchor This anchor binds the `x` position to the *left*, *center* or *right* of the annotation. For example, if `x` is set to 1, `xref` to *paper* and `xanchor` to *right* then the right-most portion of the annotation lines up with the right-most edge of the plotting area. If *auto*, the anchor is equivalent to *center* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side." + }, + "xshift": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Shifts the position of the whole annotation and arrow to the right (positive) or left (negative) by this many pixels." + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "auto", + "role": "info", + "editType": "calc", + "description": "Sets the text box's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the annotation. For example, if `y` is set to 1, `yref` to *paper* and `yanchor` to *top* then the top-most portion of the annotation lines up with the top-most edge of the plotting area. If *auto*, the anchor is equivalent to *middle* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side." + }, + "yshift": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Shifts the position of the whole annotation and arrow up (positive) or down (negative) by this many pixels." + }, + "text": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "Sets the text associated with this annotation. Plotly uses a subset of HTML tags to do things like newline (
), bold (), italics (), hyperlinks (). Tags , , are also supported." + }, + "textangle": { + "valType": "angle", + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Sets the angle at which the `text` is drawn with respect to the horizontal." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "editType": "calc", + "description": "Sets the annotation text font.", + "role": "object" + }, + "width": { + "valType": "number", + "min": 1, + "dflt": null, + "role": "style", + "editType": "calc", + "description": "Sets an explicit width for the text box. null (default) lets the text set the box width. Wider text will be clipped. There is no automatic wrapping; use
to start a new line." + }, + "height": { + "valType": "number", + "min": 1, + "dflt": null, + "role": "style", + "editType": "calc", + "description": "Sets an explicit height for the text box. null (default) lets the text set the box height. Taller text will be clipped." + }, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the opacity of the annotation (text + arrow)." + }, + "align": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "center", + "role": "style", + "editType": "calc", + "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width." + }, + "valign": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "dflt": "middle", + "role": "style", + "editType": "calc", + "description": "Sets the vertical alignment of the `text` within the box. Has an effect only if an explicit height is set to override the text height." + }, + "bgcolor": { + "valType": "color", + "dflt": "rgba(0,0,0,0)", + "role": "style", + "editType": "calc", + "description": "Sets the background color of the annotation." + }, + "bordercolor": { + "valType": "color", + "dflt": "rgba(0,0,0,0)", + "role": "style", + "editType": "calc", + "description": "Sets the color of the border enclosing the annotation `text`." + }, + "borderpad": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the padding (in px) between the `text` and the enclosing border." + }, + "borderwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of the border enclosing the annotation `text`." + }, + "showarrow": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calc", + "description": "Determines whether or not the annotation is drawn with an arrow. If *true*, `text` is placed near the arrow's tail. If *false*, `text` lines up with the `x` and `y` provided." + }, + "arrowcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the color of the annotation arrow." + }, + "arrowhead": { + "valType": "integer", + "min": 0, + "max": 8, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the end annotation arrow head style." + }, + "startarrowhead": { + "valType": "integer", + "min": 0, + "max": 8, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the start annotation arrow head style." + }, + "arrowside": { + "valType": "flaglist", + "flags": [ + "end", + "start" + ], + "extras": [ + "none" + ], + "dflt": "end", + "role": "style", + "editType": "calc", + "description": "Sets the annotation arrow head position." + }, + "arrowsize": { + "valType": "number", + "min": 0.3, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the size of the end annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line." + }, + "startarrowsize": { + "valType": "number", + "min": 0.3, + "dflt": 1, + "role": "style", + "editType": "calc", + "description": "Sets the size of the start annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line." + }, + "arrowwidth": { + "valType": "number", + "min": 0.1, + "role": "style", + "editType": "calc", + "description": "Sets the width (in px) of annotation arrow line." + }, + "standoff": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Sets a distance, in pixels, to move the end arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount." + }, + "startstandoff": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calc", + "description": "Sets a distance, in pixels, to move the start arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount." + }, + "hovertext": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "Sets text to appear when hovering over this annotation. If omitted or blank, no hover label will appear." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the background color of the hover label. By default uses the annotation's `bgcolor` made opaque, or white if it was transparent." + }, + "bordercolor": { + "valType": "color", + "role": "style", + "editType": "calc", + "description": "Sets the border color of the hover label. By default uses either dark grey or white, for maximum contrast with `hoverlabel.bgcolor`." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calc", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calc" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "calc" + }, + "editType": "calc", + "description": "Sets the hover label text font. By default uses the global hover font and size, with color from `hoverlabel.bordercolor`.", + "role": "object" + }, + "editType": "calc", + "role": "object" + }, + "captureevents": { + "valType": "boolean", + "role": "info", + "editType": "calc", + "description": "Determines whether the annotation text box captures mouse move and click events, or allows those events to pass through to data points in the plot that may be behind the annotation. By default `captureevents` is *false* unless `hovertext` is provided. If you use the event `plotly_clickannotation` without `hovertext` you must explicitly enable `captureevents`." + }, + "editType": "calc", + "role": "object" + } + }, + "role": "object" + }, + "_isSubplotObj": true, + "role": "object" + }, + "geo": { + "domain": { + "x": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this geo subplot (in plot fraction). Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", + "editType": "plot" + }, + "y": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this geo subplot (in plot fraction). Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", + "editType": "plot" + }, + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "description": "If there is a layout grid, use the domain for this row in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", + "editType": "plot" + }, + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "description": "If there is a layout grid, use the domain for this column in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.", + "editType": "plot" }, "editType": "plot", - "line": { - "color": { - "arrayOk": false, - "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `cmin` and `cmax` if set.", - "dflt": "#444", - "editType": "style", - "role": "style", - "valType": "color" + "role": "object" + }, + "resolution": { + "valType": "enumerated", + "values": [ + 110, + 50 + ], + "role": "info", + "dflt": 110, + "coerceNumber": true, + "description": "Sets the resolution of the base layers. The values have units of km/mm e.g. 110 corresponds to a scale ratio of 1:110,000,000.", + "editType": "plot" + }, + "scope": { + "valType": "enumerated", + "role": "info", + "values": [ + "world", + "usa", + "europe", + "asia", + "africa", + "north america", + "south america" + ], + "dflt": "world", + "description": "Set the scope of the map.", + "editType": "plot" + }, + "projection": { + "type": { + "valType": "enumerated", + "role": "info", + "values": [ + "equirectangular", + "mercator", + "orthographic", + "natural earth", + "kavrayskiy7", + "miller", + "robinson", + "eckert4", + "azimuthal equal area", + "azimuthal equidistant", + "conic equal area", + "conic conformal", + "conic equidistant", + "gnomonic", + "stereographic", + "mollweide", + "hammer", + "transverse mercator", + "albers usa", + "winkel tripel", + "aitoff", + "sinusoidal" + ], + "description": "Sets the projection type.", + "editType": "plot" + }, + "rotation": { + "lon": { + "valType": "number", + "role": "info", + "description": "Rotates the map along parallels (in degrees East). Defaults to the center of the `lonaxis.range` values.", + "editType": "plot" }, - "editType": "style", - "outliercolor": { - "description": "Sets the border line color of the outlier sample points. Defaults to marker.color", - "editType": "style", - "role": "style", - "valType": "color" + "lat": { + "valType": "number", + "role": "info", + "description": "Rotates the map along meridians (in degrees North).", + "editType": "plot" }, - "outlierwidth": { - "description": "Sets the border line width (in px) of the outlier sample points.", - "dflt": 1, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" + "roll": { + "valType": "number", + "role": "info", + "description": "Roll the map (in degrees) For example, a roll of *180* makes the map appear upside down.", + "editType": "plot" }, - "role": "object", - "width": { - "arrayOk": false, - "description": "Sets the width (in px) of the lines bounding the marker points.", - "dflt": 0, - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "editType": "plot", + "role": "object" }, - "opacity": { - "arrayOk": false, - "description": "Sets the marker opacity.", - "dflt": 1, - "editType": "style", - "max": 1, + "parallels": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "editType": "plot" + }, + { + "valType": "number", + "editType": "plot" + } + ], + "description": "For conic projection types only. Sets the parallels (tangent, secant) where the cone intersects the sphere.", + "editType": "plot" + }, + "scale": { + "valType": "number", + "role": "info", "min": 0, - "role": "style", - "valType": "number" + "dflt": 1, + "description": "Zooms in or out on the map view. A scale of *1* corresponds to the largest zoom level that fits the map's lon and lat ranges. ", + "editType": "plot" }, - "outliercolor": { - "description": "Sets the color of the outlier sample points.", - "dflt": "rgba(0, 0, 0, 0)", - "editType": "style", - "role": "style", - "valType": "color" + "editType": "plot", + "role": "object" + }, + "center": { + "lon": { + "valType": "number", + "role": "info", + "description": "Sets the longitude of the map's center. By default, the map's longitude center lies at the middle of the longitude range for scoped projection and above `projection.rotation.lon` otherwise.", + "editType": "plot" }, - "role": "object", - "size": { - "arrayOk": false, - "description": "Sets the marker size (in px).", - "dflt": 6, - "editType": "calcIfAutorange", - "min": 0, - "role": "style", - "valType": "number" - }, - "symbol": { - "arrayOk": false, - "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.", - "dflt": "circle", - "editType": "plot", - "role": "style", - "valType": "enumerated", - "values": [ - 0, - "circle", - 100, - "circle-open", - 200, - "circle-dot", - 300, - "circle-open-dot", - 1, - "square", - 101, - "square-open", - 201, - "square-dot", - 301, - "square-open-dot", - 2, - "diamond", - 102, - "diamond-open", - 202, - "diamond-dot", - 302, - "diamond-open-dot", - 3, - "cross", - 103, - "cross-open", - 203, - "cross-dot", - 303, - "cross-open-dot", - 4, - "x", - 104, - "x-open", - 204, - "x-dot", - 304, - "x-open-dot", - 5, - "triangle-up", - 105, - "triangle-up-open", - 205, - "triangle-up-dot", - 305, - "triangle-up-open-dot", - 6, - "triangle-down", - 106, - "triangle-down-open", - 206, - "triangle-down-dot", - 306, - "triangle-down-open-dot", - 7, - "triangle-left", - 107, - "triangle-left-open", - 207, - "triangle-left-dot", - 307, - "triangle-left-open-dot", - 8, - "triangle-right", - 108, - "triangle-right-open", - 208, - "triangle-right-dot", - 308, - "triangle-right-open-dot", - 9, - "triangle-ne", - 109, - "triangle-ne-open", - 209, - "triangle-ne-dot", - 309, - "triangle-ne-open-dot", - 10, - "triangle-se", - 110, - "triangle-se-open", - 210, - "triangle-se-dot", - 310, - "triangle-se-open-dot", - 11, - "triangle-sw", - 111, - "triangle-sw-open", - 211, - "triangle-sw-dot", - 311, - "triangle-sw-open-dot", - 12, - "triangle-nw", - 112, - "triangle-nw-open", - 212, - "triangle-nw-dot", - 312, - "triangle-nw-open-dot", - 13, - "pentagon", - 113, - "pentagon-open", - 213, - "pentagon-dot", - 313, - "pentagon-open-dot", - 14, - "hexagon", - 114, - "hexagon-open", - 214, - "hexagon-dot", - 314, - "hexagon-open-dot", - 15, - "hexagon2", - 115, - "hexagon2-open", - 215, - "hexagon2-dot", - 315, - "hexagon2-open-dot", - 16, - "octagon", - 116, - "octagon-open", - 216, - "octagon-dot", - 316, - "octagon-open-dot", - 17, - "star", - 117, - "star-open", - 217, - "star-dot", - 317, - "star-open-dot", - 18, - "hexagram", - 118, - "hexagram-open", - 218, - "hexagram-dot", - 318, - "hexagram-open-dot", - 19, - "star-triangle-up", - 119, - "star-triangle-up-open", - 219, - "star-triangle-up-dot", - 319, - "star-triangle-up-open-dot", - 20, - "star-triangle-down", - 120, - "star-triangle-down-open", - 220, - "star-triangle-down-dot", - 320, - "star-triangle-down-open-dot", - 21, - "star-square", - 121, - "star-square-open", - 221, - "star-square-dot", - 321, - "star-square-open-dot", - 22, - "star-diamond", - 122, - "star-diamond-open", - 222, - "star-diamond-dot", - 322, - "star-diamond-open-dot", - 23, - "diamond-tall", - 123, - "diamond-tall-open", - 223, - "diamond-tall-dot", - 323, - "diamond-tall-open-dot", - 24, - "diamond-wide", - 124, - "diamond-wide-open", - 224, - "diamond-wide-dot", - 324, - "diamond-wide-open-dot", - 25, - "hourglass", - 125, - "hourglass-open", - 26, - "bowtie", - 126, - "bowtie-open", - 27, - "circle-cross", - 127, - "circle-cross-open", - 28, - "circle-x", - 128, - "circle-x-open", - 29, - "square-cross", - 129, - "square-cross-open", - 30, - "square-x", - 130, - "square-x-open", - 31, - "diamond-cross", - 131, - "diamond-cross-open", - 32, - "diamond-x", - 132, - "diamond-x-open", - 33, - "cross-thin", - 133, - "cross-thin-open", - 34, - "x-thin", - 134, - "x-thin-open", - 35, - "asterisk", - 135, - "asterisk-open", - 36, - "hash", - 136, - "hash-open", - 236, - "hash-dot", - 336, - "hash-open-dot", - 37, - "y-up", - 137, - "y-up-open", - 38, - "y-down", - 138, - "y-down-open", - 39, - "y-left", - 139, - "y-left-open", - 40, - "y-right", - 140, - "y-right-open", - 41, - "line-ew", - 141, - "line-ew-open", - 42, - "line-ns", - 142, - "line-ns-open", - 43, - "line-ne", - 143, - "line-ne-open", - 44, - "line-nw", - 144, - "line-nw-open" - ] - } - }, - "meanline": { - "color": { - "description": "Sets the mean line color.", - "editType": "style", - "role": "style", - "valType": "color" + "lat": { + "valType": "number", + "role": "info", + "description": "Sets the latitude of the map's center. For all projection types, the map's latitude center lies at the middle of the latitude range by default.", + "editType": "plot" }, "editType": "plot", - "role": "object", - "visible": { - "description": "Determines if a line corresponding to the sample's mean is shown inside the violins. If `box.visible` is turned on, the mean line is drawn inside the inner box. Otherwise, the mean line is drawn from one side of the violin to other.", - "dflt": false, - "editType": "plot", - "role": "info", - "valType": "boolean" - }, - "width": { - "description": "Sets the mean line width.", - "editType": "style", - "min": 0, - "role": "style", - "valType": "number" - } + "role": "object" }, - "name": { - "description": "Sets the trace name. The trace name appear as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical", - "editType": "calc+clearAxisTypes", + "showcoastlines": { + "valType": "boolean", "role": "info", - "valType": "string" + "description": "Sets whether or not the coastlines are drawn.", + "editType": "plot" }, - "opacity": { - "description": "Sets the opacity of the trace.", - "dflt": 1, - "editType": "style", - "max": 1, + "coastlinecolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the coastline color.", + "editType": "plot" + }, + "coastlinewidth": { + "valType": "number", + "role": "style", "min": 0, + "dflt": 1, + "description": "Sets the coastline stroke width (in px).", + "editType": "plot" + }, + "showland": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not land masses are filled in color.", + "editType": "plot" + }, + "landcolor": { + "valType": "color", "role": "style", - "valType": "number" + "dflt": "#F0DC82", + "description": "Sets the land mass color.", + "editType": "plot" }, - "orientation": { - "description": "Sets the orientation of the violin(s). If *v* (*h*), the distribution is visualized along the vertical (horizontal).", - "editType": "calc+clearAxisTypes", + "showocean": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not oceans are filled in color.", + "editType": "plot" + }, + "oceancolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "v", - "h" - ] + "dflt": "#3399FF", + "description": "Sets the ocean color", + "editType": "plot" }, - "pointpos": { - "description": "Sets the position of the sample points in relation to the violins. If *0*, the sample points are places over the center of the violins. Positive (negative) values correspond to positions to the right (left) for vertical violins and above (below) for horizontal violins.", - "editType": "calcIfAutorange", - "max": 2, - "min": -2, + "showlakes": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not lakes are drawn.", + "editType": "plot" + }, + "lakecolor": { + "valType": "color", "role": "style", - "valType": "number" + "dflt": "#3399FF", + "description": "Sets the color of the lakes.", + "editType": "plot" }, - "points": { - "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the violins are shown with no sample points", - "dflt": "outliers", - "editType": "calcIfAutorange", + "showrivers": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not rivers are drawn.", + "editType": "plot" + }, + "rivercolor": { + "valType": "color", "role": "style", - "valType": "enumerated", - "values": [ - "all", - "outliers", - "suspectedoutliers", - false - ] + "dflt": "#3399FF", + "description": "Sets color of the rivers.", + "editType": "plot" }, - "scalegroup": { - "description": "If there are multiple violins that should be sized according to to some metric (see `scalemode`), link them by providing a non-empty group id here shared by every trace in the same group.", - "dflt": "", - "editType": "calc", + "riverwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets the stroke width (in px) of the rivers.", + "editType": "plot" + }, + "showcountries": { + "valType": "boolean", "role": "info", - "valType": "string" + "description": "Sets whether or not country boundaries are drawn.", + "editType": "plot" }, - "scalemode": { - "description": "Sets the metric by which the width of each violin is determined.*width* means each violin has the same (max) width*count* means the violins are scaled by the number of sample points makingup each violin.", - "dflt": "width", - "editType": "calc", + "countrycolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets line color of the country boundaries.", + "editType": "plot" + }, + "countrywidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets line width (in px) of the country boundaries.", + "editType": "plot" + }, + "showsubunits": { + "valType": "boolean", "role": "info", - "valType": "enumerated", - "values": [ - "width", - "count" - ] + "description": "Sets whether or not boundaries of subunits within countries (e.g. states, provinces) are drawn.", + "editType": "plot" }, - "selected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of selected points.", - "editType": "style", + "subunitcolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color of the subunits boundaries.", + "editType": "plot" + }, + "subunitwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets the stroke width (in px) of the subunits boundaries.", + "editType": "plot" + }, + "showframe": { + "valType": "boolean", + "role": "info", + "description": "Sets whether or not a frame is drawn around the map.", + "editType": "plot" + }, + "framecolor": { + "valType": "color", + "role": "style", + "dflt": "#444", + "description": "Sets the color the frame.", + "editType": "plot" + }, + "framewidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets the stroke width (in px) of the frame.", + "editType": "plot" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "#fff", + "description": "Set the background color of the map", + "editType": "plot" + }, + "lonaxis": { + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "editType": "plot" + }, + { + "valType": "number", + "editType": "plot" + } + ], + "description": "Sets the range of this axis (in degrees), sets the map's clipped coordinates.", + "editType": "plot" + }, + "showgrid": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not graticule are shown on the map.", + "editType": "plot" + }, + "tick0": { + "valType": "number", + "role": "info", + "description": "Sets the graticule's starting tick longitude/latitude.", + "editType": "plot" + }, + "dtick": { + "valType": "number", + "role": "info", + "description": "Sets the graticule's longitude/latitude tick step.", + "editType": "plot" + }, + "gridcolor": { + "valType": "color", + "role": "style", + "dflt": "#eee", + "description": "Sets the graticule's stroke color.", + "editType": "plot" + }, + "gridwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets the graticule's stroke width (in px).", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "lataxis": { + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "editType": "plot" + }, + { + "valType": "number", + "editType": "plot" + } + ], + "description": "Sets the range of this axis (in degrees), sets the map's clipped coordinates.", + "editType": "plot" + }, + "showgrid": { + "valType": "boolean", + "role": "info", + "dflt": false, + "description": "Sets whether or not graticule are shown on the map.", + "editType": "plot" + }, + "tick0": { + "valType": "number", + "role": "info", + "description": "Sets the graticule's starting tick longitude/latitude.", + "editType": "plot" + }, + "dtick": { + "valType": "number", + "role": "info", + "description": "Sets the graticule's longitude/latitude tick step.", + "editType": "plot" + }, + "gridcolor": { + "valType": "color", + "role": "style", + "dflt": "#eee", + "description": "Sets the graticule's stroke color.", + "editType": "plot" + }, + "gridwidth": { + "valType": "number", + "role": "style", + "min": 0, + "dflt": 1, + "description": "Sets the graticule's stroke width (in px).", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "editType": "plot", + "_isSubplotObj": true, + "role": "object" + }, + "mapbox": { + "_arrayAttrRegexps": [ + {} + ], + "domain": { + "x": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this mapbox subplot (in plot fraction).", + "editType": "plot" + }, + "y": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this mapbox subplot (in plot fraction).", + "editType": "plot" + }, + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "description": "If there is a layout grid, use the domain for this row in the grid for this mapbox subplot .", + "editType": "plot" + }, + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "description": "If there is a layout grid, use the domain for this column in the grid for this mapbox subplot .", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "accesstoken": { + "valType": "string", + "noBlank": true, + "strict": true, + "role": "info", + "description": "Sets the mapbox access token to be used for this mapbox map. Alternatively, the mapbox access token can be set in the configuration options under `mapboxAccessToken`.", + "editType": "plot" + }, + "style": { + "valType": "any", + "values": [ + "basic", + "streets", + "outdoors", + "light", + "dark", + "satellite", + "satellite-streets" + ], + "dflt": "basic", + "role": "style", + "description": "Sets the Mapbox map style. Either input one of the default Mapbox style names or the URL to a custom style or a valid Mapbox style JSON.", + "editType": "plot" + }, + "center": { + "lon": { + "valType": "number", + "dflt": 0, + "role": "info", + "description": "Sets the longitude of the center of the map (in degrees East).", + "editType": "plot" + }, + "lat": { + "valType": "number", + "dflt": 0, + "role": "info", + "description": "Sets the latitude of the center of the map (in degrees North).", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "zoom": { + "valType": "number", + "dflt": 1, + "role": "info", + "description": "Sets the zoom level of the map.", + "editType": "plot" + }, + "bearing": { + "valType": "number", + "dflt": 0, + "role": "info", + "description": "Sets the bearing angle of the map (in degrees counter-clockwise from North).", + "editType": "plot" + }, + "pitch": { + "valType": "number", + "dflt": 0, + "role": "info", + "description": "Sets the pitch angle of the map (in degrees, where *0* means perpendicular to the surface of the map).", + "editType": "plot" + }, + "layers": { + "items": { + "layer": { + "sourcetype": { + "valType": "enumerated", + "values": [ + "geojson", + "vector" + ], + "dflt": "geojson", + "role": "info", + "description": "Sets the source type for this layer. Support for *raster*, *image* and *video* source types is coming soon.", + "editType": "plot" + }, + "source": { + "valType": "any", + "role": "info", + "description": "Sets the source data for this layer. Source can be either a URL, a geojson object (with `sourcetype` set to *geojson*) or an array of tile URLS (with `sourcetype` set to *vector*).", + "editType": "plot" + }, + "sourcelayer": { + "valType": "string", + "dflt": "", + "role": "info", + "description": "Specifies the layer to use from a vector tile source. Required for *vector* source type that supports multiple layers.", + "editType": "plot" + }, + "type": { + "valType": "enumerated", + "values": [ + "circle", + "line", + "fill", + "symbol" + ], + "dflt": "circle", + "role": "info", + "description": "Sets the layer type. Support for *raster*, *background* types is coming soon. Note that *line* and *fill* are not compatible with Point GeoJSON geometries.", + "editType": "plot" + }, + "below": { + "valType": "string", + "dflt": "", + "role": "info", + "description": "Determines if the layer will be inserted before the layer with the specified ID. If omitted or set to '', the layer will be inserted above every existing layer.", + "editType": "plot" + }, + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "description": "Sets the primary layer color. If `type` is *circle*, color corresponds to the circle color If `type` is *line*, color corresponds to the line color If `type` is *fill*, color corresponds to the fill color If `type` is *symbol*, color corresponds to the icon color", + "editType": "plot" + }, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 1, + "role": "info", + "description": "Sets the opacity of the layer.", + "editType": "plot" + }, + "circle": { + "radius": { + "valType": "number", + "dflt": 15, + "role": "style", + "description": "Sets the circle radius. Has an effect only when `type` is set to *circle*.", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "line": { + "width": { + "valType": "number", + "dflt": 2, + "role": "style", + "description": "Sets the line width. Has an effect only when `type` is set to *line*.", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "fill": { + "outlinecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "description": "Sets the fill outline color. Has an effect only when `type` is set to *fill*.", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "symbol": { + "icon": { + "valType": "string", + "dflt": "marker", + "role": "style", + "description": "Sets the symbol icon image. Full list: https://www.mapbox.com/maki-icons/", + "editType": "plot" + }, + "iconsize": { + "valType": "number", + "dflt": 10, + "role": "style", + "description": "Sets the symbol icon size. Has an effect only when `type` is set to *symbol*.", + "editType": "plot" + }, + "text": { + "valType": "string", + "dflt": "", + "role": "info", + "description": "Sets the symbol text.", + "editType": "plot" + }, + "textfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "dflt": "Open Sans Regular, Arial Unicode MS Regular", + "editType": "plot" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "description": "Sets the icon text font. Has an effect only when `type` is set to *symbol*.", + "editType": "plot", + "role": "object" + }, + "textposition": { + "valType": "enumerated", + "values": [ + "top left", + "top center", + "top right", + "middle left", + "middle center", + "middle right", + "bottom left", + "bottom center", + "bottom right" + ], + "dflt": "middle center", + "arrayOk": false, + "role": "style", + "editType": "plot", + "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates." + }, + "editType": "plot", + "role": "object" + }, + "editType": "plot", + "role": "object" + } + }, + "role": "object" + }, + "editType": "plot", + "_isSubplotObj": true, + "role": "object" + }, + "polar": { + "domain": { + "x": { + "valType": "info_array", + "role": "info", + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the horizontal domain of this polar subplot (in plot fraction)." + }, + "y": { + "valType": "info_array", + "role": "info", + "editType": "plot", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "description": "Sets the vertical domain of this polar subplot (in plot fraction)." + }, + "editType": "plot", + "row": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "plot", + "description": "If there is a layout grid, use the domain for this row in the grid for this polar subplot ." + }, + "column": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "info", + "editType": "plot", + "description": "If there is a layout grid, use the domain for this column in the grid for this polar subplot ." + }, + "role": "object" + }, + "sector": { + "valType": "info_array", + "items": [ + { + "valType": "number", + "editType": "plot" + }, + { + "valType": "number", + "editType": "plot" + } + ], + "dflt": [ + 0, + 360 + ], + "role": "info", + "editType": "plot", + "description": "Sets angular span of this polar subplot with two angles (in degrees). Sector are assumed to be spanned in the counterclockwise direction with *0* corresponding to rightmost limit of the polar subplot." + }, + "bgcolor": { + "valType": "color", + "role": "style", + "editType": "plot", + "dflt": "#fff", + "description": "Set the background color of the subplot" + }, + "radialaxis": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", + "dflt": true + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "log", + "date", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "calc", + "description": "Sets the axis type. By default, plotly attempts to determined the axis type by looking into the data of the traces that referenced the axis in question." + }, + "autorange": { + "valType": "enumerated", + "values": [ + true, + false, + "reversed" + ], + "dflt": true, + "role": "style", + "editType": "calc", + "impliedEdits": {}, + "description": "Determines whether or not the range of this axis is computed in relation to the input data. See `rangemode` for more info. If `range` is provided, then `autorange` is set to *false*." + }, + "rangemode": { + "valType": "enumerated", + "values": [ + "tozero", + "nonnegative", + "normal" + ], + "dflt": "tozero", + "role": "style", + "editType": "calc", + "description": "If *tozero*`, the range extends to 0, regardless of the input data If *nonnegative*, the range is non-negative, regardless of the input data. If *normal*, the range is computed in relation to the extrema of the input data (same behavior as for cartesian axes)." + }, + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "axrange+margins", + "impliedEdits": { + "^autorange": false + } + }, + { + "valType": "any", + "editType": "axrange+margins", + "impliedEdits": { + "^autorange": false + } + } + ], + "editType": "axrange+margins", + "impliedEdits": { + "autorange": false + }, + "description": "Sets the range of this axis. If the axis `type` is *log*, then you must take the log of your desired range (e.g. to set the range from 1 to 100, set the range from 0 to 2). If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "calc", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "angle": { + "valType": "angle", + "editType": "plot", + "role": "info", + "description": "Sets the angle (in degrees) from which the radial axis is drawn. Note that by default, radial axis line on the theta=0 line corresponds to a line pointing right (like what mathematicians prefer). Defaults to the first `polar.sector` angle." + }, + "side": { + "valType": "enumerated", + "values": [ + "clockwise", + "counterclockwise" + ], + "dflt": "clockwise", + "editType": "plot", + "role": "info", + "description": "Determines on which side of radial axis line the tick and tick labels appear." + }, + "title": { + "valType": "string", + "role": "info", + "editType": "plot", + "description": "Sets the title of this axis.", + "dflt": "" + }, + "titlefont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets this axis' title font.", + "role": "object" + }, + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "editType": "plot", + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "showline": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", + "dflt": true + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" + } + }, + "role": "object" + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", + "role": "info", + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." + }, + "calendar": { + "valType": "enumerated", + "values": [ + "gregorian", + "chinese", + "coptic", + "discworld", + "ethiopian", + "hebrew", + "islamic", + "julian", + "mayan", + "nanakshahi", + "nepali", + "persian", + "jalali", + "taiwan", + "thai", + "ummalqura" + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `range` and `tick0` if this is a date axis. This does not set the calendar for interpreting data on this axis, that's specified in the trace or via the global `layout.calendar`" + }, + "role": "object", + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + }, + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "angularaxis": { + "visible": { + "valType": "boolean", + "role": "info", + "editType": "plot", + "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false", + "dflt": true + }, + "type": { + "valType": "enumerated", + "values": [ + "-", + "linear", + "category" + ], + "dflt": "-", + "role": "info", + "editType": "calc", + "description": "Sets the angular axis type. If *linear*, set `thetaunit` to determine the unit in which axis value are shown. If *category, use `period` to set the number of integer coordinates around polar axis." + }, + "categoryorder": { + "valType": "enumerated", + "values": [ + "trace", + "category ascending", + "category descending", + "array" + ], + "dflt": "trace", + "role": "info", + "editType": "calc", + "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`." + }, + "categoryarray": { + "valType": "data_array", + "role": "data", + "editType": "calc", + "description": "Sets the order in which categories on this axis appear. Only has an effect if `categoryorder` is set to *array*. Used with `categoryorder`." + }, + "thetaunit": { + "valType": "enumerated", + "values": [ + "radians", + "degrees" + ], + "dflt": "degrees", + "role": "info", + "editType": "calc", + "description": "Sets the format unit of the formatted *theta* values. Has an effect only when `angularaxis.type` is *linear*." + }, + "period": { + "valType": "number", + "editType": "calc", + "min": 0, + "role": "info", + "description": "Set the angular period. Has an effect only when `angularaxis.type` is *category*." + }, + "direction": { + "valType": "enumerated", + "values": [ + "counterclockwise", + "clockwise" + ], + "dflt": "counterclockwise", + "role": "info", + "editType": "calc", + "description": "Sets the direction corresponding to positive angles." + }, + "rotation": { + "valType": "angle", + "editType": "calc", + "role": "info", + "description": "Sets that start position (in degrees) of the angular axis By default, polar subplots with `direction` set to *counterclockwise* get a `rotation` of *0* which corresponds to due East (like what mathematicians prefer). In turn, polar with `direction` set to *clockwise* get a rotation of *90* which corresponds to due North (like on a compass)," + }, + "hoverformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "none", + "description": "Sets the hover text formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "editType": "plot", + "color": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets default for all colors associated with this axis all at once: line, font, tick, and grid colors. Grid color is lightened by blending this with the plot background Individual pieces can override this." + }, + "showline": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not a line bounding this axis is drawn." + }, + "linecolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the axis line color." + }, + "linewidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the axis line." + }, + "showgrid": { + "valType": "boolean", + "role": "style", + "editType": "plot", + "description": "Determines whether or not grid lines are drawn. If *true*, the grid lines are drawn at every tick mark.", + "dflt": true + }, + "gridcolor": { + "valType": "color", + "dflt": "#eee", + "role": "style", + "editType": "plot", + "description": "Sets the color of the grid lines." + }, + "gridwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the width (in px) of the grid lines." + }, + "tickmode": { + "valType": "enumerated", + "values": [ + "auto", + "linear", + "array" + ], + "role": "info", + "editType": "plot", + "impliedEdits": {}, + "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided)." + }, + "nticks": { + "valType": "integer", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "plot", + "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*." + }, + "tick0": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "dtick": { + "valType": "any", + "role": "style", + "editType": "plot", + "impliedEdits": { + "tickmode": "linear" + }, + "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*" + }, + "tickvals": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.", + "role": "data" + }, + "ticktext": { + "valType": "data_array", + "editType": "plot", + "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.", + "role": "data" + }, + "ticks": { + "valType": "enumerated", + "values": [ + "outside", + "inside", + "" + ], + "role": "style", + "editType": "plot", + "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines." + }, + "ticklen": { + "valType": "number", + "min": 0, + "dflt": 5, + "role": "style", + "editType": "plot", + "description": "Sets the tick length (in px)." + }, + "tickwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "plot", + "description": "Sets the tick width (in px)." + }, + "tickcolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "plot", + "description": "Sets the tick color." + }, + "showticklabels": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "plot", + "description": "Determines whether or not the tick labels are drawn." + }, + "showtickprefix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden." + }, + "tickprefix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label prefix." + }, + "showticksuffix": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "Same as `showtickprefix` but for tick suffixes." + }, + "ticksuffix": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets a tick label suffix." + }, + "showexponent": { + "valType": "enumerated", + "values": [ + "all", + "first", + "last", + "none" + ], + "dflt": "all", + "role": "style", + "editType": "plot", + "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear." + }, + "exponentformat": { + "valType": "enumerated", + "values": [ + "none", + "e", + "E", + "power", + "SI", + "B" + ], + "dflt": "B", + "role": "style", + "editType": "plot", + "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B." + }, + "separatethousands": { + "valType": "boolean", + "dflt": false, + "role": "style", + "editType": "plot", + "description": "If \"true\", even 4-digit integers are separated" + }, + "tickfont": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "plot", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "plot" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "plot" + }, + "editType": "plot", + "description": "Sets the tick font.", + "role": "object" + }, + "tickangle": { + "valType": "angle", + "dflt": "auto", + "role": "style", + "editType": "plot", + "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically." + }, + "tickformat": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/blob/master/README.md#locale_format And for dates see: https://github.com/d3/d3-time-format/blob/master/README.md#locale_format We add one item to d3's date formatter: *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*" + }, + "tickformatstops": { + "items": { + "tickformatstop": { + "dtickrange": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "any", + "editType": "plot" + }, + { + "valType": "any", + "editType": "plot" + } + ], + "editType": "plot", + "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*" + }, + "value": { + "valType": "string", + "dflt": "", + "role": "style", + "editType": "plot", + "description": "string - dtickformat for described zoom level, the same as *tickformat*" + }, + "editType": "plot", + "role": "object" + } + }, + "role": "object" + }, + "layer": { + "valType": "enumerated", + "values": [ + "above traces", + "below traces" + ], + "dflt": "above traces", + "role": "info", + "editType": "plot", + "description": "Sets the layer on which this axis is displayed. If *above traces*, this axis is displayed above all the subplot's traces If *below traces*, this axis is displayed below all the subplot's traces, but above the grid lines. Useful when used together with scatter-like traces with `cliponaxis` set to *false* to show markers and/or text nodes above this axis." + }, + "role": "object", + "categoryarraysrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for categoryarray .", + "editType": "none" + }, + "tickvalssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for tickvals .", + "editType": "none" + }, + "ticktextsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for ticktext .", + "editType": "none" + } + }, + "editType": "calc", + "_isSubplotObj": true, + "role": "object" + }, + "radialaxis": { + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "editType": "plot" + }, + { + "valType": "number", + "editType": "plot" + } + ], + "description": "Defines the start and end point of this radial axis.", + "editType": "plot" + }, + "domain": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "editType": "plot", + "description": "Polar chart subplots are not supported yet. This key has currently no effect." + }, + "orientation": { + "valType": "number", + "role": "style", + "description": "Sets the orientation (an angle with respect to the origin) of the radial axis.", + "editType": "plot" + }, + "showline": { + "valType": "boolean", + "role": "style", + "description": "Determines whether or not the line bounding this radial axis will be shown on the figure.", + "editType": "plot" + }, + "showticklabels": { + "valType": "boolean", + "role": "style", + "description": "Determines whether or not the radial axis ticks will feature tick labels.", + "editType": "plot" + }, + "tickorientation": { + "valType": "enumerated", + "values": [ + "horizontal", + "vertical" + ], + "role": "style", + "description": "Sets the orientation (from the paper perspective) of the radial axis tick labels.", + "editType": "plot" + }, + "ticklen": { + "valType": "number", + "min": 0, + "role": "style", + "description": "Sets the length of the tick lines on this radial axis.", + "editType": "plot" + }, + "tickcolor": { + "valType": "color", + "role": "style", + "description": "Sets the color of the tick lines on this radial axis.", + "editType": "plot" + }, + "ticksuffix": { + "valType": "string", + "role": "style", + "description": "Sets the length of the tick lines on this radial axis.", + "editType": "plot" + }, + "endpadding": { + "valType": "number", + "role": "style", + "editType": "plot" + }, + "visible": { + "valType": "boolean", + "role": "info", + "description": "Determines whether or not this axis will be visible.", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "angularaxis": { + "range": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "dflt": 0, + "editType": "plot" + }, + { + "valType": "number", + "dflt": 360, + "editType": "plot" + } + ], + "description": "Defines the start and end point of this angular axis.", + "editType": "plot" + }, + "domain": { + "valType": "info_array", + "role": "info", + "items": [ + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + }, + { + "valType": "number", + "min": 0, + "max": 1, + "editType": "plot" + } + ], + "dflt": [ + 0, + 1 + ], + "editType": "plot", + "description": "Polar chart subplots are not supported yet. This key has currently no effect." + }, + "showline": { + "valType": "boolean", + "role": "style", + "description": "Determines whether or not the line bounding this angular axis will be shown on the figure.", + "editType": "plot" + }, + "showticklabels": { + "valType": "boolean", + "role": "style", + "description": "Determines whether or not the angular axis ticks will feature tick labels.", + "editType": "plot" + }, + "tickorientation": { + "valType": "enumerated", + "values": [ + "horizontal", + "vertical" + ], + "role": "style", + "description": "Sets the orientation (from the paper perspective) of the angular axis tick labels.", + "editType": "plot" + }, + "ticklen": { + "valType": "number", + "min": 0, + "role": "style", + "description": "Sets the length of the tick lines on this angular axis.", + "editType": "plot" + }, + "tickcolor": { + "valType": "color", + "role": "style", + "description": "Sets the color of the tick lines on this angular axis.", + "editType": "plot" + }, + "ticksuffix": { + "valType": "string", + "role": "style", + "description": "Sets the length of the tick lines on this angular axis.", + "editType": "plot" + }, + "endpadding": { + "valType": "number", + "role": "style", + "editType": "plot" + }, + "visible": { + "valType": "boolean", + "role": "info", + "description": "Determines whether or not this axis will be visible.", + "editType": "plot" + }, + "editType": "plot", + "role": "object" + }, + "direction": { + "valType": "enumerated", + "values": [ + "clockwise", + "counterclockwise" + ], + "role": "info", + "description": "For polar plots only. Sets the direction corresponding to positive angles.", + "editType": "plot" + }, + "orientation": { + "valType": "angle", + "role": "info", + "description": "For polar plots only. Rotates the entire polar by the given angle.", + "editType": "plot" + }, + "editType": "plot", + "legend": { + "bgcolor": { + "valType": "color", + "role": "style", + "editType": "legend", + "description": "Sets the legend background color." + }, + "bordercolor": { + "valType": "color", + "dflt": "#444", + "role": "style", + "editType": "legend", + "description": "Sets the color of the border enclosing the legend." + }, + "borderwidth": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "legend", + "description": "Sets the width (in px) of the border enclosing the legend." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "legend", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "legend" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "legend" + }, + "editType": "legend", + "description": "Sets the font used to text the legend items.", + "role": "object" + }, + "orientation": { + "valType": "enumerated", + "values": [ + "v", + "h" + ], + "dflt": "v", + "role": "info", + "editType": "legend", + "description": "Sets the orientation of the legend." + }, + "traceorder": { + "valType": "flaglist", + "flags": [ + "reversed", + "grouped" + ], + "extras": [ + "normal" + ], + "role": "style", + "editType": "legend", + "description": "Determines the order at which the legend items are displayed. If *normal*, the items are displayed top-to-bottom in the same order as the input data. If *reversed*, the items are displayed in the opposite order as *normal*. If *grouped*, the items are displayed in groups (when a trace `legendgroup` is provided). if *grouped+reversed*, the items are displayed in the opposite order as *grouped*." + }, + "tracegroupgap": { + "valType": "number", + "min": 0, + "dflt": 10, + "role": "style", + "editType": "legend", + "description": "Sets the amount of vertical space (in px) between legend groups." + }, + "x": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": 1.02, + "role": "style", + "editType": "legend", + "description": "Sets the x position (in normalized coordinates) of the legend." + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "left", + "role": "info", + "editType": "legend", + "description": "Sets the legend's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the legend." + }, + "y": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": 1, + "role": "style", + "editType": "legend", + "description": "Sets the y position (in normalized coordinates) of the legend." + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "auto", + "role": "info", + "editType": "legend", + "description": "Sets the legend's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the legend." + }, + "editType": "legend", + "role": "object" + }, + "annotations": { + "items": { + "annotation": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calcIfAutorange+arraydraw", + "description": "Determines whether or not this annotation is visible." + }, + "text": { + "valType": "string", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the text associated with this annotation. Plotly uses a subset of HTML tags to do things like newline (
), bold (), italics (), hyperlinks (). Tags , , are also supported." + }, + "textangle": { + "valType": "angle", + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the angle at which the `text` is drawn with respect to the horizontal." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "calcIfAutorange+arraydraw", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "calcIfAutorange+arraydraw" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw" + }, + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the annotation text font.", + "role": "object" + }, + "width": { + "valType": "number", + "min": 1, + "dflt": null, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets an explicit width for the text box. null (default) lets the text set the box width. Wider text will be clipped. There is no automatic wrapping; use
to start a new line." + }, + "height": { + "valType": "number", + "min": 1, + "dflt": null, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets an explicit height for the text box. null (default) lets the text set the box height. Taller text will be clipped." + }, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 1, + "role": "style", + "editType": "arraydraw", + "description": "Sets the opacity of the annotation (text + arrow)." + }, + "align": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "center", + "role": "style", + "editType": "arraydraw", + "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans more two or more lines (i.e. `text` contains one or more
HTML tags) or if an explicit width is set to override the text width." + }, + "valign": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "dflt": "middle", + "role": "style", + "editType": "arraydraw", + "description": "Sets the vertical alignment of the `text` within the box. Has an effect only if an explicit height is set to override the text height." + }, + "bgcolor": { + "valType": "color", + "dflt": "rgba(0,0,0,0)", + "role": "style", + "editType": "arraydraw", + "description": "Sets the background color of the annotation." + }, + "bordercolor": { + "valType": "color", + "dflt": "rgba(0,0,0,0)", + "role": "style", + "editType": "arraydraw", + "description": "Sets the color of the border enclosing the annotation `text`." + }, + "borderpad": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the padding (in px) between the `text` and the enclosing border." + }, + "borderwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the width (in px) of the border enclosing the annotation `text`." + }, + "showarrow": { + "valType": "boolean", + "dflt": true, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Determines whether or not the annotation is drawn with an arrow. If *true*, `text` is placed near the arrow's tail. If *false*, `text` lines up with the `x` and `y` provided." + }, + "arrowcolor": { + "valType": "color", + "role": "style", + "editType": "arraydraw", + "description": "Sets the color of the annotation arrow." + }, + "arrowhead": { + "valType": "integer", + "min": 0, + "max": 8, + "dflt": 1, + "role": "style", + "editType": "arraydraw", + "description": "Sets the end annotation arrow head style." + }, + "startarrowhead": { + "valType": "integer", + "min": 0, + "max": 8, + "dflt": 1, + "role": "style", + "editType": "arraydraw", + "description": "Sets the start annotation arrow head style." + }, + "arrowside": { + "valType": "flaglist", + "flags": [ + "end", + "start" + ], + "extras": [ + "none" + ], + "dflt": "end", + "role": "style", + "editType": "arraydraw", + "description": "Sets the annotation arrow head position." + }, + "arrowsize": { + "valType": "number", + "min": 0.3, + "dflt": 1, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the size of the end annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line." + }, + "startarrowsize": { + "valType": "number", + "min": 0.3, + "dflt": 1, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the size of the start annotation arrow head, relative to `arrowwidth`. A value of 1 (default) gives a head about 3x as wide as the line." + }, + "arrowwidth": { + "valType": "number", + "min": 0.1, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the width (in px) of annotation arrow line." + }, + "standoff": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets a distance, in pixels, to move the end arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount." + }, + "startstandoff": { + "valType": "number", + "min": 0, + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets a distance, in pixels, to move the start arrowhead away from the position it is pointing at, for example to point at the edge of a marker independent of zoom. Note that this shortens the arrow from the `ax` / `ay` vector, in contrast to `xshift` / `yshift` which moves everything by this amount." + }, + "ax": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the x component of the arrow tail about the arrow head. If `axref` is `pixel`, a positive (negative) component corresponds to an arrow pointing from right to left (left to right). If `axref` is an axis, this is an absolute value on that axis, like `x`, NOT a relative value." + }, + "ay": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the y component of the arrow tail about the arrow head. If `ayref` is `pixel`, a positive (negative) component corresponds to an arrow pointing from bottom to top (top to bottom). If `ayref` is an axis, this is an absolute value on that axis, like `y`, NOT a relative value." + }, + "axref": { + "valType": "enumerated", + "dflt": "pixel", + "values": [ + "pixel", + "/^x([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Indicates in what terms the tail of the annotation (ax,ay) is specified. If `pixel`, `ax` is a relative offset in pixels from `x`. If set to an x axis id (e.g. *x* or *x2*), `ax` is specified in the same terms as that axis. This is useful for trendline annotations which should continue to indicate the correct trend when zoomed." + }, + "ayref": { + "valType": "enumerated", + "dflt": "pixel", + "values": [ + "pixel", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Indicates in what terms the tail of the annotation (ax,ay) is specified. If `pixel`, `ay` is a relative offset in pixels from `y`. If set to a y axis id (e.g. *y* or *y2*), `ay` is specified in the same terms as that axis. This is useful for trendline annotations which should continue to indicate the correct trend when zoomed." + }, + "xref": { + "valType": "enumerated", + "values": [ + "paper", + "/^x([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Sets the annotation's x coordinate axis. If set to an x axis id (e.g. *x* or *x2*), the `x` position refers to an x coordinate If set to *paper*, the `x` position refers to the distance from the left side of the plotting area in normalized coordinates where 0 (1) corresponds to the left (right) side." + }, + "x": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the annotation's x position. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "auto", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the text box's horizontal position anchor This anchor binds the `x` position to the *left*, *center* or *right* of the annotation. For example, if `x` is set to 1, `xref` to *paper* and `xanchor` to *right* then the right-most portion of the annotation lines up with the right-most edge of the plotting area. If *auto*, the anchor is equivalent to *center* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side." + }, + "xshift": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Shifts the position of the whole annotation and arrow to the right (positive) or left (negative) by this many pixels." + }, + "yref": { + "valType": "enumerated", + "values": [ + "paper", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Sets the annotation's y coordinate axis. If set to an y axis id (e.g. *y* or *y2*), the `y` position refers to an y coordinate If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where 0 (1) corresponds to the bottom (top)." + }, + "y": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the annotation's y position. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, it should be date strings, like date data, though Date objects and unix milliseconds will be accepted and converted to strings. If the axis `type` is *category*, it should be numbers, using the scale where each category is assigned a serial number from zero in the order it appears." + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "auto", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the text box's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the annotation. For example, if `y` is set to 1, `yref` to *paper* and `yanchor` to *top* then the top-most portion of the annotation lines up with the top-most edge of the plotting area. If *auto*, the anchor is equivalent to *middle* for data-referenced annotations or if there is an arrow, whereas for paper-referenced with no arrow, the anchor picked corresponds to the closest side." + }, + "yshift": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Shifts the position of the whole annotation and arrow up (positive) or down (negative) by this many pixels." + }, + "clicktoshow": { + "valType": "enumerated", + "values": [ + false, + "onoff", + "onout" + ], + "dflt": false, + "role": "style", + "editType": "arraydraw", + "description": "Makes this annotation respond to clicks on the plot. If you click a data point that exactly matches the `x` and `y` values of this annotation, and it is hidden (visible: false), it will appear. In *onoff* mode, you must click the same point again to make it disappear, so if you click multiple points, you can show multiple annotations. In *onout* mode, a click anywhere else in the plot (on another data point or not) will hide this annotation. If you need to show/hide this annotation in response to different `x` or `y` values, you can set `xclick` and/or `yclick`. This is useful for example to label the side of a bar. To label markers though, `standoff` is preferred over `xclick` and `yclick`." + }, + "xclick": { + "valType": "any", + "role": "info", + "editType": "arraydraw", + "description": "Toggle this annotation when clicking a data point whose `x` value is `xclick` rather than the annotation's `x` value." + }, + "yclick": { + "valType": "any", + "role": "info", + "editType": "arraydraw", + "description": "Toggle this annotation when clicking a data point whose `y` value is `yclick` rather than the annotation's `y` value." + }, + "hovertext": { + "valType": "string", + "role": "info", + "editType": "arraydraw", + "description": "Sets text to appear when hovering over this annotation. If omitted or blank, no hover label will appear." + }, + "hoverlabel": { + "bgcolor": { + "valType": "color", + "role": "style", + "editType": "arraydraw", + "description": "Sets the background color of the hover label. By default uses the annotation's `bgcolor` made opaque, or white if it was transparent." + }, + "bordercolor": { + "valType": "color", + "role": "style", + "editType": "arraydraw", + "description": "Sets the border color of the hover label. By default uses either dark grey or white, for maximum contrast with `hoverlabel.bgcolor`." + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "editType": "arraydraw", + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*." + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "arraydraw" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw" + }, + "editType": "arraydraw", + "description": "Sets the hover label text font. By default uses the global hover font and size, with color from `hoverlabel.bordercolor`.", + "role": "object" + }, + "editType": "arraydraw", + "role": "object" + }, + "captureevents": { + "valType": "boolean", + "role": "info", + "editType": "arraydraw", + "description": "Determines whether the annotation text box captures mouse move and click events, or allows those events to pass through to data points in the plot that may be behind the annotation. By default `captureevents` is *false* unless `hovertext` is provided. If you use the event `plotly_clickannotation` without `hovertext` you must explicitly enable `captureevents`." + }, + "editType": "calc", + "_deprecated": { + "ref": { + "valType": "string", + "role": "info", + "editType": "calc", + "description": "Obsolete. Set `xref` and `yref` separately instead." + } + }, + "role": "object" + } + }, + "role": "object" + }, + "shapes": { + "items": { + "shape": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "calcIfAutorange+arraydraw", + "description": "Determines whether or not this shape is visible." + }, + "type": { + "valType": "enumerated", + "values": [ + "circle", + "rect", + "path", + "line" + ], + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Specifies the shape type to be drawn. If *line*, a line is drawn from (`x0`,`y0`) to (`x1`,`y1`) with respect to the axes' sizing mode. If *circle*, a circle is drawn from ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 -`y0`)|) with respect to the axes' sizing mode. If *rect*, a rectangle is drawn linking (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), (`x0`,`y1`), (`x0`,`y0`) with respect to the axes' sizing mode. If *path*, draw a custom SVG path using `path`. with respect to the axes' sizing mode." + }, + "layer": { + "valType": "enumerated", + "values": [ + "below", + "above" + ], + "dflt": "above", + "role": "info", + "editType": "arraydraw", + "description": "Specifies whether shapes are drawn below or above traces." + }, + "xref": { + "valType": "enumerated", + "values": [ + "paper", + "/^x([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Sets the shape's x coordinate axis. If set to an x axis id (e.g. *x* or *x2*), the `x` position refers to an x coordinate. If set to *paper*, the `x` position refers to the distance from the left side of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right) side. If the axis `type` is *log*, then you must take the log of your desired range. If the axis `type` is *date*, then you must convert the date to unix time in milliseconds." + }, + "xsizemode": { + "valType": "enumerated", + "values": [ + "scaled", + "pixel" + ], + "dflt": "scaled", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shapes's sizing mode along the x axis. If set to *scaled*, `x0`, `x1` and x coordinates within `path` refer to data values on the x axis or a fraction of the plot area's width (`xref` set to *paper*). If set to *pixel*, `xanchor` specifies the x position in terms of data or plot fraction but `x0`, `x1` and x coordinates within `path` are pixels relative to `xanchor`. This way, the shape can have a fixed width while maintaining a position relative to data or plot fraction." + }, + "xanchor": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Only relevant in conjunction with `xsizemode` set to *pixel*. Specifies the anchor point on the x axis to which `x0`, `x1` and x coordinates within `path` are relative to. E.g. useful to attach a pixel sized shape to a certain data value. No effect when `xsizemode` not set to *pixel*." + }, + "x0": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shape's starting x position. See `type` and `xsizemode` for more info." + }, + "x1": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shape's end x position. See `type` and `xsizemode` for more info." + }, + "yref": { + "valType": "enumerated", + "values": [ + "paper", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "role": "info", + "editType": "calc", + "description": "Sets the annotation's y coordinate axis. If set to an y axis id (e.g. *y* or *y2*), the `y` position refers to an y coordinate If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top)." + }, + "ysizemode": { + "valType": "enumerated", + "values": [ + "scaled", + "pixel" + ], + "dflt": "scaled", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shapes's sizing mode along the y axis. If set to *scaled*, `y0`, `y1` and y coordinates within `path` refer to data values on the y axis or a fraction of the plot area's height (`yref` set to *paper*). If set to *pixel*, `yanchor` specifies the y position in terms of data or plot fraction but `y0`, `y1` and y coordinates within `path` are pixels relative to `yanchor`. This way, the shape can have a fixed height while maintaining a position relative to data or plot fraction." + }, + "yanchor": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Only relevant in conjunction with `ysizemode` set to *pixel*. Specifies the anchor point on the y axis to which `y0`, `y1` and y coordinates within `path` are relative to. E.g. useful to attach a pixel sized shape to a certain data value. No effect when `ysizemode` not set to *pixel*." + }, + "y0": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shape's starting y position. See `type` and `ysizemode` for more info." + }, + "y1": { + "valType": "any", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the shape's end y position. See `type` and `ysizemode` for more info." + }, + "path": { + "valType": "string", + "role": "info", + "editType": "calcIfAutorange+arraydraw", + "description": "For `type` *path* - a valid SVG path with the pixel values replaced by data values in `xsizemode`/`ysizemode` being *scaled* and taken unmodified as pixels relative to `xanchor` and `yanchor` in case of *pixel* size mode. There are a few restrictions / quirks only absolute instructions, not relative. So the allowed segments are: M, L, H, V, Q, C, T, S, and Z arcs (A) are not allowed because radius rx and ry are relative. In the future we could consider supporting relative commands, but we would have to decide on how to handle date and log axes. Note that even as is, Q and C Bezier paths that are smooth on linear axes may not be smooth on log, and vice versa. no chained \"polybezier\" commands - specify the segment type for each one. On category axes, values are numbers scaled to the serial numbers of categories because using the categories themselves there would be no way to describe fractional positions On data axes: because space and T are both normal components of path strings, we can't use either to separate date from time parts. Therefore we'll use underscore for this purpose: 2015-02-21_13:45:56.789" + }, + "opacity": { + "valType": "number", + "min": 0, + "max": 1, + "dflt": 1, + "role": "info", + "editType": "arraydraw", + "description": "Sets the opacity of the shape." + }, + "line": { + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw", + "description": "Sets the line color." + }, + "width": { + "valType": "number", + "min": 0, + "dflt": 2, + "role": "style", + "editType": "calcIfAutorange+arraydraw", + "description": "Sets the line width (in px)." + }, + "dash": { + "valType": "string", + "values": [ + "solid", + "dot", + "dash", + "longdash", + "dashdot", + "longdashdot" + ], + "dflt": "solid", + "role": "style", + "editType": "arraydraw", + "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*)." + }, + "role": "object", + "editType": "calcIfAutorange+arraydraw" + }, + "fillcolor": { + "valType": "color", + "dflt": "rgba(0,0,0,0)", + "role": "info", + "editType": "arraydraw", + "description": "Sets the color filling the shape's interior." + }, + "editType": "arraydraw", + "role": "object" + } + }, + "role": "object" + }, + "images": { + "items": { + "image": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "editType": "arraydraw", + "description": "Determines whether or not this image is visible." + }, + "source": { + "valType": "string", + "role": "info", + "editType": "arraydraw", + "description": "Specifies the URL of the image to be used. The URL must be accessible from the domain where the plot code is run, and can be either relative or absolute." + }, + "layer": { + "valType": "enumerated", + "values": [ + "below", + "above" + ], + "dflt": "above", + "role": "info", + "editType": "arraydraw", + "description": "Specifies whether images are drawn below or above traces. When `xref` and `yref` are both set to `paper`, image is drawn below the entire plot area." + }, + "sizex": { + "valType": "number", + "role": "info", + "dflt": 0, + "editType": "arraydraw", + "description": "Sets the image container size horizontally. The image will be sized based on the `position` value. When `xref` is set to `paper`, units are sized relative to the plot width." + }, + "sizey": { + "valType": "number", + "role": "info", + "dflt": 0, + "editType": "arraydraw", + "description": "Sets the image container size vertically. The image will be sized based on the `position` value. When `yref` is set to `paper`, units are sized relative to the plot height." + }, + "sizing": { + "valType": "enumerated", + "values": [ + "fill", + "contain", + "stretch" + ], + "dflt": "contain", + "role": "info", + "editType": "arraydraw", + "description": "Specifies which dimension of the image to constrain." + }, + "opacity": { + "valType": "number", + "role": "info", + "min": 0, + "max": 1, + "dflt": 1, + "editType": "arraydraw", + "description": "Sets the opacity of the image." + }, + "x": { + "valType": "any", + "role": "info", + "dflt": 0, + "editType": "arraydraw", + "description": "Sets the image's x position. When `xref` is set to `paper`, units are sized relative to the plot height. See `xref` for more info" + }, + "y": { + "valType": "any", + "role": "info", + "dflt": 0, + "editType": "arraydraw", + "description": "Sets the image's y position. When `yref` is set to `paper`, units are sized relative to the plot height. See `yref` for more info" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "info", + "editType": "arraydraw", + "description": "Sets the anchor for the x position" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "top", + "middle", + "bottom" + ], + "dflt": "top", + "role": "info", + "editType": "arraydraw", + "description": "Sets the anchor for the y position." + }, + "xref": { + "valType": "enumerated", + "values": [ + "paper", + "/^x([2-9]|[1-9][0-9]+)?$/" + ], + "dflt": "paper", + "role": "info", + "editType": "arraydraw", + "description": "Sets the images's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to an x data coordinate If set to *paper*, the `x` position refers to the distance from the left of plot in normalized coordinates where *0* (*1*) corresponds to the left (right)." + }, + "yref": { + "valType": "enumerated", + "values": [ + "paper", + "/^y([2-9]|[1-9][0-9]+)?$/" + ], + "dflt": "paper", + "role": "info", + "editType": "arraydraw", + "description": "Sets the images's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y data coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plot in normalized coordinates where *0* (*1*) corresponds to the bottom (top)." + }, + "editType": "arraydraw", + "role": "object" + } + }, + "role": "object" + }, + "updatemenus": { + "items": { + "updatemenu": { + "_arrayAttrRegexps": [ + {} + ], + "visible": { + "valType": "boolean", + "role": "info", + "description": "Determines whether or not the update menu is visible.", + "editType": "arraydraw" + }, + "type": { + "valType": "enumerated", + "values": [ + "dropdown", + "buttons" + ], + "dflt": "dropdown", + "role": "info", + "description": "Determines whether the buttons are accessible via a dropdown menu or whether the buttons are stacked horizontally or vertically", + "editType": "arraydraw" + }, + "direction": { + "valType": "enumerated", + "values": [ + "left", + "right", + "up", + "down" + ], + "dflt": "down", + "role": "info", + "description": "Determines the direction in which the buttons are laid out, whether in a dropdown menu or a row/column of buttons. For `left` and `up`, the buttons will still appear in left-to-right or top-to-bottom order respectively.", + "editType": "arraydraw" + }, + "active": { + "valType": "integer", + "role": "info", + "min": -1, + "dflt": 0, + "description": "Determines which button (by index starting from 0) is considered active.", + "editType": "arraydraw" + }, + "showactive": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Highlights active dropdown item or active button if true.", + "editType": "arraydraw" + }, + "buttons": { + "items": { + "button": { + "method": { + "valType": "enumerated", + "values": [ + "restyle", + "relayout", + "animate", + "update", + "skip" + ], + "dflt": "restyle", + "role": "info", + "description": "Sets the Plotly method to be called on click. If the `skip` method is used, the API updatemenu will function as normal but will perform no API calls and will not bind automatically to state updates. This may be used to create a component interface and attach to updatemenu events manually via JavaScript.", + "editType": "arraydraw" + }, + "args": { + "valType": "info_array", + "role": "info", + "freeLength": true, + "items": [ + { + "valType": "any", + "editType": "arraydraw" + }, + { + "valType": "any", + "editType": "arraydraw" + }, + { + "valType": "any", + "editType": "arraydraw" + } + ], + "description": "Sets the arguments values to be passed to the Plotly method set in `method` on click.", + "editType": "arraydraw" + }, + "label": { + "valType": "string", + "role": "info", + "dflt": "", + "description": "Sets the text label to appear on the button.", + "editType": "arraydraw" + }, + "execute": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "When true, the API method is executed. When false, all other behaviors are the same and command execution is skipped. This may be useful when hooking into, for example, the `plotly_buttonclicked` method and executing the API command manually without losing the benefit of the updatemenu automatically binding to the state of the plot through the specification of `method` and `args`.", + "editType": "arraydraw" + }, + "editType": "arraydraw", + "role": "object" + } + }, + "role": "object" + }, + "x": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": -0.05, + "role": "style", + "description": "Sets the x position (in normalized coordinates) of the update menu.", + "editType": "arraydraw" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "right", + "role": "info", + "description": "Sets the update menu's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector.", + "editType": "arraydraw" + }, + "y": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": 1, + "role": "style", + "description": "Sets the y position (in normalized coordinates) of the update menu.", + "editType": "arraydraw" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "top", + "role": "info", + "description": "Sets the update menu's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector.", + "editType": "arraydraw" + }, + "pad": { + "t": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) along the top of the component." + }, + "r": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) on the right side of the component." + }, + "b": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) along the bottom of the component." + }, + "l": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) on the left side of the component." + }, + "editType": "arraydraw", + "description": "Sets the padding around the buttons or dropdown menu.", + "role": "object" + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "arraydraw" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "arraydraw" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw" + }, + "description": "Sets the font of the update menu button text.", + "editType": "arraydraw", + "role": "object" + }, + "bgcolor": { + "valType": "color", + "role": "style", + "description": "Sets the background color of the update menu buttons.", + "editType": "arraydraw" + }, + "bordercolor": { + "valType": "color", + "dflt": "#BEC8D9", + "role": "style", + "description": "Sets the color of the border enclosing the update menu.", + "editType": "arraydraw" + }, + "borderwidth": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "editType": "arraydraw", + "description": "Sets the width (in px) of the border enclosing the update menu." + }, + "editType": "arraydraw", + "role": "object" + } + }, + "role": "object" + }, + "sliders": { + "items": { + "slider": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Determines whether or not the slider is visible.", + "editType": "arraydraw" + }, + "active": { + "valType": "number", + "role": "info", + "min": 0, + "dflt": 0, + "description": "Determines which button (by index starting from 0) is considered active.", + "editType": "arraydraw" + }, + "steps": { + "items": { + "step": { + "method": { + "valType": "enumerated", + "values": [ + "restyle", + "relayout", + "animate", + "update", + "skip" + ], + "dflt": "restyle", + "role": "info", + "description": "Sets the Plotly method to be called when the slider value is changed. If the `skip` method is used, the API slider will function as normal but will perform no API calls and will not bind automatically to state updates. This may be used to create a component interface and attach to slider events manually via JavaScript.", + "editType": "arraydraw" + }, + "args": { + "valType": "info_array", + "role": "info", + "freeLength": true, + "items": [ + { + "valType": "any", + "editType": "arraydraw" + }, + { + "valType": "any", + "editType": "arraydraw" + }, + { + "valType": "any", + "editType": "arraydraw" + } + ], + "description": "Sets the arguments values to be passed to the Plotly method set in `method` on slide.", + "editType": "arraydraw" + }, + "label": { + "valType": "string", + "role": "info", + "description": "Sets the text label to appear on the slider", + "editType": "arraydraw" + }, + "value": { + "valType": "string", + "role": "info", + "description": "Sets the value of the slider step, used to refer to the step programatically. Defaults to the slider label if not provided.", + "editType": "arraydraw" + }, + "execute": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "When true, the API method is executed. When false, all other behaviors are the same and command execution is skipped. This may be useful when hooking into, for example, the `plotly_sliderchange` method and executing the API command manually without losing the benefit of the slider automatically binding to the state of the plot through the specification of `method` and `args`.", + "editType": "arraydraw" + }, + "editType": "arraydraw", + "role": "object" + } + }, + "role": "object" + }, + "lenmode": { + "valType": "enumerated", + "values": [ + "fraction", + "pixels" + ], + "role": "info", + "dflt": "fraction", + "description": "Determines whether this slider length is set in units of plot *fraction* or in *pixels. Use `len` to set the value.", + "editType": "arraydraw" + }, + "len": { + "valType": "number", + "min": 0, + "dflt": 1, + "role": "style", + "description": "Sets the length of the slider This measure excludes the padding of both ends. That is, the slider's length is this length minus the padding on both ends.", + "editType": "arraydraw" + }, + "x": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": 0, + "role": "style", + "description": "Sets the x position (in normalized coordinates) of the slider.", + "editType": "arraydraw" + }, + "pad": { + "t": { + "valType": "number", + "dflt": 20, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) along the top of the component." + }, + "r": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) on the right side of the component." + }, + "b": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) along the bottom of the component." + }, + "l": { + "valType": "number", + "dflt": 0, + "role": "style", + "editType": "arraydraw", + "description": "The amount of padding (in px) on the left side of the component." + }, + "editType": "arraydraw", + "description": "Set the padding of the slider component along each side.", + "role": "object" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "auto", + "left", + "center", + "right" + ], + "dflt": "left", + "role": "info", + "description": "Sets the slider's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the range selector.", + "editType": "arraydraw" + }, + "y": { + "valType": "number", + "min": -2, + "max": 3, + "dflt": 0, + "role": "style", + "description": "Sets the y position (in normalized coordinates) of the slider.", + "editType": "arraydraw" + }, + "yanchor": { + "valType": "enumerated", + "values": [ + "auto", + "top", + "middle", + "bottom" + ], + "dflt": "top", + "role": "info", + "description": "Sets the slider's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the range selector.", + "editType": "arraydraw" + }, + "transition": { + "duration": { + "valType": "number", + "role": "info", + "min": 0, + "dflt": 150, + "description": "Sets the duration of the slider transition", + "editType": "arraydraw" + }, + "easing": { + "valType": "enumerated", + "values": [ + "linear", + "quad", + "cubic", + "sin", + "exp", + "circle", + "elastic", + "back", + "bounce", + "linear-in", + "quad-in", + "cubic-in", + "sin-in", + "exp-in", + "circle-in", + "elastic-in", + "back-in", + "bounce-in", + "linear-out", + "quad-out", + "cubic-out", + "sin-out", + "exp-out", + "circle-out", + "elastic-out", + "back-out", + "bounce-out", + "linear-in-out", + "quad-in-out", + "cubic-in-out", + "sin-in-out", + "exp-in-out", + "circle-in-out", + "elastic-in-out", + "back-in-out", + "bounce-in-out" + ], + "role": "info", + "dflt": "cubic-in-out", + "description": "Sets the easing function of the slider transition", + "editType": "arraydraw" + }, + "editType": "arraydraw", + "role": "object" + }, + "currentvalue": { + "visible": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Shows the currently-selected value above the slider.", + "editType": "arraydraw" + }, + "xanchor": { + "valType": "enumerated", + "values": [ + "left", + "center", + "right" + ], + "dflt": "left", + "role": "info", + "description": "The alignment of the value readout relative to the length of the slider.", + "editType": "arraydraw" + }, + "offset": { + "valType": "number", + "dflt": 10, + "role": "info", + "description": "The amount of space, in pixels, between the current value label and the slider.", + "editType": "arraydraw" + }, + "prefix": { + "valType": "string", + "role": "info", + "description": "When currentvalue.visible is true, this sets the prefix of the label.", + "editType": "arraydraw" + }, + "suffix": { + "valType": "string", + "role": "info", + "description": "When currentvalue.visible is true, this sets the suffix of the label.", + "editType": "arraydraw" + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "arraydraw" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "arraydraw" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw" + }, + "description": "Sets the font of the current value label text.", + "editType": "arraydraw", + "role": "object" + }, + "editType": "arraydraw", + "role": "object" + }, + "font": { + "family": { + "valType": "string", + "role": "style", + "noBlank": true, + "strict": true, + "description": "HTML font family - the typeface that will be applied by the web browser. The web browser will only be able to apply a font if it is available on the system which it operates. Provide multiple font families, separated by commas, to indicate the preference in which to apply fonts if they aren't available on the system. The plotly service (at https://plot.ly or on-premise) generates images on a server, where only a select number of fonts are installed and supported. These include *Arial*, *Balto*, *Courier New*, *Droid Sans*,, *Droid Serif*, *Droid Sans Mono*, *Gravitas One*, *Old Standard TT*, *Open Sans*, *Overpass*, *PT Sans Narrow*, *Raleway*, *Times New Roman*.", + "editType": "arraydraw" + }, + "size": { + "valType": "number", + "role": "style", + "min": 1, + "editType": "arraydraw" + }, + "color": { + "valType": "color", + "role": "style", + "editType": "arraydraw" + }, + "description": "Sets the font of the slider step labels.", + "editType": "arraydraw", + "role": "object" + }, + "activebgcolor": { + "valType": "color", "role": "style", - "valType": "color" + "dflt": "#dbdde0", + "description": "Sets the background color of the slider grip while dragging.", + "editType": "arraydraw" }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of selected points.", - "editType": "style", - "max": 1, + "bgcolor": { + "valType": "color", + "role": "style", + "dflt": "#f8fafc", + "description": "Sets the background color of the slider.", + "editType": "arraydraw" + }, + "bordercolor": { + "valType": "color", + "dflt": "#bec8d9", + "role": "style", + "description": "Sets the color of the border enclosing the slider.", + "editType": "arraydraw" + }, + "borderwidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the width (in px) of the border enclosing the slider.", + "editType": "arraydraw" }, - "role": "object", - "size": { - "description": "Sets the marker size of selected points.", - "editType": "style", + "ticklen": { + "valType": "number", "min": 0, + "dflt": 7, "role": "style", - "valType": "number" - } - }, - "role": "object" - }, - "selectedpoints": { - "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.", - "editType": "calc", - "role": "info", - "valType": "any" - }, - "showlegend": { - "description": "Determines whether or not an item corresponding to this trace is shown in the legend.", - "dflt": true, - "editType": "style", - "role": "info", - "valType": "boolean" - }, - "side": { - "description": "Determines on which side of the position value the density function making up one half of a violin is plotted. Useful when comparing two violin traces under *overlay* mode, where one trace has `side` set to *positive* and the other to *negative*.", - "dflt": "both", - "editType": "plot", - "role": "info", - "valType": "enumerated", - "values": [ - "both", - "positive", - "negative" - ] - }, - "span": { - "description": "Sets the span in data space for which the density function will be computed. Has an effect only when `spanmode` is set to *manual*.", - "editType": "calc", - "items": [ - { - "editType": "calc", - "valType": "any" + "description": "Sets the length in pixels of step tick marks", + "editType": "arraydraw" }, - { - "editType": "calc", - "valType": "any" - } - ], - "role": "info", - "valType": "info_array" - }, - "spanmode": { - "description": "Sets the method by which the span in data space where the density function will be computed. *soft* means the span goes from the sample's minimum value minus two bandwidths to the sample's maximum value plus two bandwidths. *hard* means the span goes from the sample's minimum to its maximum value. For custom span settings, use mode *manual* and fill in the `span` attribute.", - "dflt": "soft", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "soft", - "hard", - "manual" - ] - }, - "stream": { - "editType": "calc", - "maxpoints": { - "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.", - "dflt": 500, - "editType": "calc", - "max": 10000, - "min": 0, - "role": "info", - "valType": "number" - }, - "role": "object", - "token": { - "description": "The stream id number links a data trace on a plot with a stream. See https://plot.ly/settings for more details.", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - } - }, - "text": { - "arrayOk": true, - "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.", - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "textsrc": { - "description": "Sets the source reference on plot.ly for text .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "type": "violin", - "uid": { - "dflt": "", - "editType": "calc", - "role": "info", - "valType": "string" - }, - "unselected": { - "editType": "style", - "marker": { - "color": { - "description": "Sets the marker color of unselected points, applied only when a selection exists.", - "editType": "style", + "tickcolor": { + "valType": "color", + "dflt": "#333", "role": "style", - "valType": "color" + "description": "Sets the color of the border enclosing the slider.", + "editType": "arraydraw" }, - "editType": "style", - "opacity": { - "description": "Sets the marker opacity of unselected points, applied only when a selection exists.", - "editType": "style", - "max": 1, + "tickwidth": { + "valType": "number", "min": 0, + "dflt": 1, "role": "style", - "valType": "number" + "description": "Sets the tick width (in px).", + "editType": "arraydraw" }, - "role": "object", - "size": { - "description": "Sets the marker size of unselected points, applied only when a selection exists.", - "editType": "style", + "minorticklen": { + "valType": "number", "min": 0, + "dflt": 4, "role": "style", - "valType": "number" - } - }, - "role": "object" + "description": "Sets the length in pixels of minor step tick marks", + "editType": "arraydraw" + }, + "editType": "arraydraw", + "role": "object" + } }, - "visible": { - "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).", + "role": "object" + } + } + }, + "transforms": { + "aggregate": { + "attributes": { + "enabled": { + "valType": "boolean", "dflt": true, - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - true, - false, - "legendonly" - ] - }, - "x": { - "description": "Sets the x sample data or coordinates. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "x0": { - "description": "Sets the x coordinate of the box. See overview for more info.", - "editType": "calc+clearAxisTypes", "role": "info", - "valType": "any" + "editType": "calc", + "description": "Determines whether this aggregate transform is enabled or disabled." }, - "xaxis": { - "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.", + "groups": { + "valType": "string", + "strict": true, + "noBlank": true, + "arrayOk": true, "dflt": "x", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "xsrc": { - "description": "Sets the source reference on plot.ly for x .", - "editType": "none", - "role": "info", - "valType": "string" - }, - "y": { - "description": "Sets the y sample data or coordinates. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "data", - "valType": "data_array" - }, - "y0": { - "description": "Sets the y coordinate of the box. See overview for more info.", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "any" - }, - "yaxis": { - "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.", - "dflt": "y", - "editType": "calc+clearAxisTypes", - "role": "info", - "valType": "subplotid" - }, - "ysrc": { - "description": "Sets the source reference on plot.ly for y .", - "editType": "none", "role": "info", - "valType": "string" - } - }, - "layoutAttributes": { - "violingap": { - "description": "Sets the gap (in plot fraction) between violins of adjacent location coordinates.", - "dflt": 0.3, - "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" - }, - "violingroupgap": { - "description": "Sets the gap (in plot fraction) between violins of the same location coordinate.", - "dflt": 0.3, "editType": "calc", - "max": 1, - "min": 0, - "role": "style", - "valType": "number" + "description": "Sets the grouping target to which the aggregation is applied. Data points with matching group values will be coalesced into one point, using the supplied aggregation functions to reduce data in other data arrays. If a string, `groups` is assumed to be a reference to a data array in the parent trace object. To aggregate by nested variables, use *.* to access them. For example, set `groups` to *marker.color* to aggregate about the marker color array. If an array, `groups` is itself the data array by which we aggregate." }, - "violinmode": { - "description": "Determines how violins at the same location coordinate are displayed on the graph. If *group*, the violins are plotted next to one another centered around the shared location. If *overlay*, the violins are plotted over one another, you might need to set *opacity* to see them multiple violins.", - "dflt": "overlay", - "editType": "calc", - "role": "info", - "valType": "enumerated", - "values": [ - "group", - "overlay" - ] - } - }, - "meta": { - "description": "In vertical (horizontal) violin plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one violin per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single violin is drawn. That violin position is then positioned with with `name` or with `x0` (`y0`) if provided." - } - } - }, - "transforms": { - "aggregate": { - "attributes": { "aggregations": { "items": { "aggregation": { - "editType": "calc", - "enabled": { - "description": "Determines whether this aggregation function is enabled or disabled.", - "dflt": true, - "editType": "calc", + "target": { + "valType": "string", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "A reference to the data array in the parent trace to aggregate. To aggregate by nested variables, use *.* to access them. For example, set `groups` to *marker.color* to aggregate over the marker color array. The referenced array must already exist, unless `func` is *count*, and each array may only be referenced once." }, "func": { - "description": "Sets the aggregation function. All values from the linked `target`, corresponding to the same value in the `groups` array, are collected and reduced by this function. *count* is simply the number of values in the `groups` array, so does not even require the linked array to exist. *first* (*last*) is just the first (last) linked value. Invalid values are ignored, so for example in *avg* they do not contribute to either the numerator or the denominator. Any data type (numeric, date, category) may be aggregated with any function, even though in certain cases it is unlikely to make sense, for example a sum of dates or average of categories. *median* will return the average of the two central values if there is an even count. *mode* will return the first value to reach the maximum count, in case of a tie.", - "dflt": "first", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "count", @@ -44516,71 +45654,65 @@ "max", "first", "last" - ] + ], + "dflt": "first", + "role": "info", + "editType": "calc", + "description": "Sets the aggregation function. All values from the linked `target`, corresponding to the same value in the `groups` array, are collected and reduced by this function. *count* is simply the number of values in the `groups` array, so does not even require the linked array to exist. *first* (*last*) is just the first (last) linked value. Invalid values are ignored, so for example in *avg* they do not contribute to either the numerator or the denominator. Any data type (numeric, date, category) may be aggregated with any function, even though in certain cases it is unlikely to make sense, for example a sum of dates or average of categories. *median* will return the average of the two central values if there is an even count. *mode* will return the first value to reach the maximum count, in case of a tie." }, "funcmode": { - "description": "*stddev* supports two formula variants: *sample* (normalize by N-1) and *population* (normalize by N).", - "dflt": "sample", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "sample", "population" - ] - }, - "role": "object", - "target": { - "description": "A reference to the data array in the parent trace to aggregate. To aggregate by nested variables, use *.* to access them. For example, set `groups` to *marker.color* to aggregate over the marker color array. The referenced array must already exist, unless `func` is *count*, and each array may only be referenced once.", + ], + "dflt": "sample", + "role": "info", "editType": "calc", + "description": "*stddev* supports two formula variants: *sample* (normalize by N-1) and *population* (normalize by N)." + }, + "enabled": { + "valType": "boolean", + "dflt": true, "role": "info", - "valType": "string" - } + "editType": "calc", + "description": "Determines whether this aggregation function is enabled or disabled." + }, + "editType": "calc", + "role": "object" } }, "role": "object" }, "editType": "calc", - "enabled": { - "description": "Determines whether this aggregate transform is enabled or disabled.", - "dflt": true, - "editType": "calc", - "role": "info", - "valType": "boolean" - }, - "groups": { - "arrayOk": true, - "description": "Sets the grouping target to which the aggregation is applied. Data points with matching group values will be coalesced into one point, using the supplied aggregation functions to reduce data in other data arrays. If a string, `groups` is assumed to be a reference to a data array in the parent trace object. To aggregate by nested variables, use *.* to access them. For example, set `groups` to *marker.color* to aggregate about the marker color array. If an array, `groups` is itself the data array by which we aggregate.", - "dflt": "x", - "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" - }, "groupssrc": { - "description": "Sets the source reference on plot.ly for groups .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for groups .", + "editType": "none" } } }, "filter": { "attributes": { - "editType": "calc", "enabled": { - "description": "Determines whether this filter transform is enabled or disabled.", + "valType": "boolean", "dflt": true, + "role": "info", "editType": "calc", + "description": "Determines whether this filter transform is enabled or disabled." + }, + "target": { + "valType": "string", + "strict": true, + "noBlank": true, + "arrayOk": true, + "dflt": "x", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "Sets the filter target by which the filter is applied. If a string, `target` is assumed to be a reference to a data array in the parent trace object. To filter about nested variables, use *.* to access them. For example, set `target` to *marker.color* to filter about the marker color array. If an array, `target` is then the data array by which the filter is applied." }, "operation": { - "description": "Sets the filter operation. *=* keeps items equal to `value` *!=* keeps items not equal to `value` *<* keeps items less than `value` *<=* keeps items less than or equal to `value` *>* keeps items greater than `value` *>=* keeps items greater than or equal to `value` *[]* keeps items inside `value[0]` to `value[1]` including both bounds *()* keeps items inside `value[0]` to `value[1]` excluding both bounds *[)* keeps items inside `value[0]` to `value[1]` including `value[0]` but excluding `value[1] *(]* keeps items inside `value[0]` to `value[1]` excluding `value[0]` but including `value[1] *][* keeps items outside `value[0]` to `value[1]` and equal to both bounds *)(* keeps items outside `value[0]` to `value[1]` *](* keeps items outside `value[0]` to `value[1]` and equal to `value[0]` *)[* keeps items outside `value[0]` to `value[1]` and equal to `value[1]` *{}* keeps items present in a set of values *}{* keeps items not present in a set of values", - "dflt": "=", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "=", @@ -44599,30 +45731,28 @@ ")[", "{}", "}{" - ] + ], + "dflt": "=", + "role": "info", + "editType": "calc", + "description": "Sets the filter operation. *=* keeps items equal to `value` *!=* keeps items not equal to `value` *<* keeps items less than `value` *<=* keeps items less than or equal to `value` *>* keeps items greater than `value` *>=* keeps items greater than or equal to `value` *[]* keeps items inside `value[0]` to `value[1]` including both bounds *()* keeps items inside `value[0]` to `value[1]` excluding both bounds *[)* keeps items inside `value[0]` to `value[1]` including `value[0]` but excluding `value[1] *(]* keeps items inside `value[0]` to `value[1]` excluding `value[0]` but including `value[1] *][* keeps items outside `value[0]` to `value[1]` and equal to both bounds *)(* keeps items outside `value[0]` to `value[1]` *](* keeps items outside `value[0]` to `value[1]` and equal to `value[0]` *)[* keeps items outside `value[0]` to `value[1]` and equal to `value[1]` *{}* keeps items present in a set of values *}{* keeps items not present in a set of values" + }, + "value": { + "valType": "any", + "dflt": 0, + "role": "info", + "editType": "calc", + "description": "Sets the value or values by which to filter. Values are expected to be in the same type as the data linked to `target`. When `operation` is set to one of the comparison values (=,!=,<,>=,>,<=) `value` is expected to be a number or a string. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) `value` is expected to be 2-item array where the first item is the lower bound and the second item is the upper bound. When `operation`, is set to one of the set values ({},}{) `value` is expected to be an array with as many items as the desired set elements." }, "preservegaps": { - "description": "Determines whether or not gaps in data arrays produced by the filter operation are preserved. Setting this to *true* might be useful when plotting a line chart with `connectgaps` set to *false*.", + "valType": "boolean", "dflt": false, - "editType": "calc", "role": "info", - "valType": "boolean" - }, - "target": { - "arrayOk": true, - "description": "Sets the filter target by which the filter is applied. If a string, `target` is assumed to be a reference to a data array in the parent trace object. To filter about nested variables, use *.* to access them. For example, set `target` to *marker.color* to filter about the marker color array. If an array, `target` is then the data array by which the filter is applied.", - "dflt": "x", "editType": "calc", - "noBlank": true, - "role": "info", - "strict": true, - "valType": "string" + "description": "Determines whether or not gaps in data arrays produced by the filter operation are preserved. Setting this to *true* might be useful when plotting a line chart with `connectgaps` set to *false*." }, - "targetcalendar": { - "description": "Sets the calendar system to use for `target`, if it is an array of dates. If `target` is a string (eg *x*) we use the corresponding trace attribute (eg `xcalendar`) if it exists, even if `targetcalendar` is provided.", - "dflt": "gregorian", - "editType": "calc", - "role": "info", + "editType": "calc", + "valuecalendar": { "valType": "enumerated", "values": [ "gregorian", @@ -44641,26 +45771,13 @@ "taiwan", "thai", "ummalqura" - ] - }, - "targetsrc": { - "description": "Sets the source reference on plot.ly for target .", - "editType": "none", + ], "role": "info", - "valType": "string" - }, - "value": { - "description": "Sets the value or values by which to filter. Values are expected to be in the same type as the data linked to `target`. When `operation` is set to one of the comparison values (=,!=,<,>=,>,<=) `value` is expected to be a number or a string. When `operation` is set to one of the interval values ([],(),[),(],][,)(,](,)[) `value` is expected to be 2-item array where the first item is the lower bound and the second item is the upper bound. When `operation`, is set to one of the set values ({},}{) `value` is expected to be an array with as many items as the desired set elements.", - "dflt": 0, "editType": "calc", - "role": "info", - "valType": "any" - }, - "valuecalendar": { - "description": "Sets the calendar system to use for `value`, if it is a date.", "dflt": "gregorian", - "editType": "calc", - "role": "info", + "description": "Sets the calendar system to use for `value`, if it is a date." + }, + "targetcalendar": { "valType": "enumerated", "values": [ "gregorian", @@ -44679,101 +45796,249 @@ "taiwan", "thai", "ummalqura" - ] + ], + "role": "info", + "editType": "calc", + "dflt": "gregorian", + "description": "Sets the calendar system to use for `target`, if it is an array of dates. If `target` is a string (eg *x*) we use the corresponding trace attribute (eg `xcalendar`) if it exists, even if `targetcalendar` is provided." + }, + "targetsrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for target .", + "editType": "none" } } }, "groupby": { "attributes": { - "editType": "calc", "enabled": { - "description": "Determines whether this group-by transform is enabled or disabled.", + "valType": "boolean", "dflt": true, - "editType": "calc", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "Determines whether this group-by transform is enabled or disabled." }, "groups": { - "description": "Sets the groups in which the trace data will be split. For example, with `x` set to *[1, 2, 3, 4]* and `groups` set to *['a', 'b', 'a', 'b']*, the groupby transform with split in one trace with `x` [1, 3] and one trace with `x` [2, 4].", + "valType": "data_array", "dflt": [], - "editType": "calc", "role": "data", - "valType": "data_array" - }, - "groupssrc": { - "description": "Sets the source reference on plot.ly for groups .", - "editType": "none", - "role": "info", - "valType": "string" + "editType": "calc", + "description": "Sets the groups in which the trace data will be split. For example, with `x` set to *[1, 2, 3, 4]* and `groups` set to *['a', 'b', 'a', 'b']*, the groupby transform with split in one trace with `x` [1, 3] and one trace with `x` [2, 4]." }, "nameformat": { - "description": "Pattern by which grouped traces are named. If only one trace is present, defaults to the group name (`\"%{group}\"`), otherwise defaults to the group name with trace name (`\"%{group} (%{trace})\"`). Available escape sequences are `%{group}`, which inserts the group name, and `%{trace}`, which inserts the trace name. If grouping GDP data by country when more than one trace is present, for example, the default \"%{group} (%{trace})\" would return \"Monaco (GDP per capita)\".", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "string" + "editType": "calc", + "description": "Pattern by which grouped traces are named. If only one trace is present, defaults to the group name (`\"%{group}\"`), otherwise defaults to the group name with trace name (`\"%{group} (%{trace})\"`). Available escape sequences are `%{group}`, which inserts the group name, and `%{trace}`, which inserts the trace name. If grouping GDP data by country when more than one trace is present, for example, the default \"%{group} (%{trace})\" would return \"Monaco (GDP per capita)\"." }, "styles": { "items": { "style": { - "editType": "calc", - "role": "object", "target": { - "description": "The group value which receives these styles.", - "editType": "calc", + "valType": "string", "role": "info", - "valType": "string" + "editType": "calc", + "description": "The group value which receives these styles." }, "value": { - "description": "Sets each group styles. For example, with `groups` set to *['a', 'b', 'a', 'b']* and `styles` set to *[{target: 'a', value: { marker: { color: 'red' } }}] marker points in group *'a'* will be drawn in red.", + "valType": "any", + "role": "info", "dflt": {}, "editType": "calc", - "role": "info", - "valType": "any" - } + "description": "Sets each group styles. For example, with `groups` set to *['a', 'b', 'a', 'b']* and `styles` set to *[{target: 'a', value: { marker: { color: 'red' } }}] marker points in group *'a'* will be drawn in red.", + "_compareAsJSON": true + }, + "editType": "calc", + "role": "object" } }, "role": "object" + }, + "editType": "calc", + "groupssrc": { + "valType": "string", + "role": "info", + "description": "Sets the source reference on plot.ly for groups .", + "editType": "none" } } }, "sort": { "attributes": { - "editType": "calc", "enabled": { - "description": "Determines whether this sort transform is enabled or disabled.", + "valType": "boolean", "dflt": true, + "role": "info", "editType": "calc", + "description": "Determines whether this sort transform is enabled or disabled." + }, + "target": { + "valType": "string", + "strict": true, + "noBlank": true, + "arrayOk": true, + "dflt": "x", "role": "info", - "valType": "boolean" + "editType": "calc", + "description": "Sets the target by which the sort transform is applied. If a string, *target* is assumed to be a reference to a data array in the parent trace object. To sort about nested variables, use *.* to access them. For example, set `target` to *marker.size* to sort about the marker size array. If an array, *target* is then the data array by which the sort transform is applied." }, "order": { - "description": "Sets the sort transform order.", - "dflt": "ascending", - "editType": "calc", - "role": "info", "valType": "enumerated", "values": [ "ascending", "descending" - ] - }, - "target": { - "arrayOk": true, - "description": "Sets the target by which the sort transform is applied. If a string, *target* is assumed to be a reference to a data array in the parent trace object. To sort about nested variables, use *.* to access them. For example, set `target` to *marker.size* to sort about the marker size array. If an array, *target* is then the data array by which the sort transform is applied.", - "dflt": "x", - "editType": "calc", - "noBlank": true, + ], + "dflt": "ascending", "role": "info", - "strict": true, - "valType": "string" + "editType": "calc", + "description": "Sets the sort transform order." }, + "editType": "calc", "targetsrc": { - "description": "Sets the source reference on plot.ly for target .", - "editType": "none", + "valType": "string", "role": "info", - "valType": "string" + "description": "Sets the source reference on plot.ly for target .", + "editType": "none" } } } + }, + "frames": { + "items": { + "frames_entry": { + "group": { + "valType": "string", + "role": "info", + "description": "An identifier that specifies the group to which the frame belongs, used by animate to select a subset of frames." + }, + "name": { + "valType": "string", + "role": "info", + "description": "A label by which to identify the frame" + }, + "traces": { + "valType": "any", + "role": "info", + "description": "A list of trace indices that identify the respective traces in the data attribute" + }, + "baseframe": { + "valType": "string", + "role": "info", + "description": "The name of the frame into which this frame's properties are merged before applying. This is used to unify properties and avoid needing to specify the same values for the same properties in multiple frames." + }, + "data": { + "valType": "any", + "role": "object", + "description": "A list of traces this frame modifies. The format is identical to the normal trace definition." + }, + "layout": { + "valType": "any", + "role": "object", + "description": "Layout properties which this frame modifies. The format is identical to the normal layout definition." + }, + "role": "object" + } + }, + "role": "object" + }, + "animation": { + "mode": { + "valType": "enumerated", + "dflt": "afterall", + "role": "info", + "values": [ + "immediate", + "next", + "afterall" + ], + "description": "Describes how a new animate call interacts with currently-running animations. If `immediate`, current animations are interrupted and the new animation is started. If `next`, the current frame is allowed to complete, after which the new animation is started. If `afterall` all existing frames are animated to completion before the new animation is started." + }, + "direction": { + "valType": "enumerated", + "role": "info", + "values": [ + "forward", + "reverse" + ], + "dflt": "forward", + "description": "The direction in which to play the frames triggered by the animation call" + }, + "fromcurrent": { + "valType": "boolean", + "dflt": false, + "role": "info", + "description": "Play frames starting at the current frame instead of the beginning." + }, + "frame": { + "duration": { + "valType": "number", + "role": "info", + "min": 0, + "dflt": 500, + "description": "The duration in milliseconds of each frame. If greater than the frame duration, it will be limited to the frame duration." + }, + "redraw": { + "valType": "boolean", + "role": "info", + "dflt": true, + "description": "Redraw the plot at completion of the transition. This is desirable for transitions that include properties that cannot be transitioned, but may significantly slow down updates that do not require a full redraw of the plot" + }, + "role": "object" + }, + "transition": { + "duration": { + "valType": "number", + "role": "info", + "min": 0, + "dflt": 500, + "description": "The duration of the transition, in milliseconds. If equal to zero, updates are synchronous." + }, + "easing": { + "valType": "enumerated", + "dflt": "cubic-in-out", + "values": [ + "linear", + "quad", + "cubic", + "sin", + "exp", + "circle", + "elastic", + "back", + "bounce", + "linear-in", + "quad-in", + "cubic-in", + "sin-in", + "exp-in", + "circle-in", + "elastic-in", + "back-in", + "bounce-in", + "linear-out", + "quad-out", + "cubic-out", + "sin-out", + "exp-out", + "circle-out", + "elastic-out", + "back-out", + "bounce-out", + "linear-in-out", + "quad-in-out", + "cubic-in-out", + "sin-in-out", + "exp-in-out", + "circle-in-out", + "elastic-in-out", + "back-in-out", + "bounce-in-out" + ], + "role": "info", + "description": "The easing function used for the transition" + }, + "role": "object" + } } } \ No newline at end of file diff --git a/plotly/package_data/plotly.min.js b/plotly/package_data/plotly.min.js index a1070e4580..18a5516c2e 100644 --- a/plotly/package_data/plotly.min.js +++ b/plotly/package_data/plotly.min.js @@ -1,7 +1,7 @@ /** -* plotly.js v1.38.0 +* plotly.js v1.38.3 * Copyright 2012-2018, Plotly, Inc. * All rights reserved. * Licensed under the MIT license */ -!function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).Plotly=t()}}(function(){return function(){return function t(e,r,n){function i(o,s){if(!r[o]){if(!e[o]){var l="function"==typeof require&&require;if(!s&&l)return l(o,!0);if(a)return a(o,!0);var c=new Error("Cannot find module '"+o+"'");throw c.code="MODULE_NOT_FOUND",c}var u=r[o]={exports:{}};e[o][0].call(u.exports,function(t){var r=e[o][1][t];return i(r||t)},u,u.exports,t,e,r,n)}return r[o].exports}for(var a="function"==typeof require&&require,o=0;oMath.abs(e))c.rotate(o,0,0,-t*i*Math.PI*d.rotateSpeed/window.innerWidth);else{var s=d.zoomSpeed*a*e/window.innerHeight*(o-c.lastT())/100;c.pan(o,0,0,f*(Math.exp(s)-1))}},!0),d};var n=t("right-now"),i=t("3d-view"),a=t("mouse-change"),o=t("mouse-wheel"),s=t("mouse-event-offset"),l=t("has-passive-events")},{"3d-view":42,"has-passive-events":355,"mouse-change":378,"mouse-event-offset":379,"mouse-wheel":381,"right-now":440}],42:[function(t,e,r){"use strict";e.exports=function(t){var e=(t=t||{}).eye||[0,0,1],r=t.center||[0,0,0],s=t.up||[0,1,0],l=t.distanceLimits||[0,1/0],c=t.mode||"turntable",u=n(),f=i(),h=a();return u.setDistanceLimits(l[0],l[1]),u.lookAt(0,e,r,s),f.setDistanceLimits(l[0],l[1]),f.lookAt(0,e,r,s),h.setDistanceLimits(l[0],l[1]),h.lookAt(0,e,r,s),new o({turntable:u,orbit:f,matrix:h},c)};var n=t("turntable-camera-controller"),i=t("orbit-camera-controller"),a=t("matrix-camera-controller");function o(t,e){this._controllerNames=Object.keys(t),this._controllerList=this._controllerNames.map(function(e){return t[e]}),this._mode=e,this._active=t[e],this._active||(this._mode="turntable",this._active=t.turntable),this.modes=this._controllerNames,this.computedMatrix=this._active.computedMatrix,this.computedEye=this._active.computedEye,this.computedUp=this._active.computedUp,this.computedCenter=this._active.computedCenter,this.computedRadius=this._active.computedRadius}var s=o.prototype;[["flush",1],["idle",1],["lookAt",4],["rotate",4],["pan",4],["translate",4],["setMatrix",2],["setDistanceLimits",2],["setDistance",2]].forEach(function(t){for(var e=t[0],r=[],n=0;n0;--t)p(c*=.99),d(),h(c),d();function h(t){function r(t){return u(t.source)*t.value}i.forEach(function(n){n.forEach(function(n){if(n.targetLinks.length){var i=e.sum(n.targetLinks,r)/e.sum(n.targetLinks,f);n.y+=(i-u(n))*t}})})}function p(t){function r(t){return u(t.target)*t.value}i.slice().reverse().forEach(function(n){n.forEach(function(n){if(n.sourceLinks.length){var i=e.sum(n.sourceLinks,r)/e.sum(n.sourceLinks,f);n.y+=(i-u(n))*t}})})}function d(){i.forEach(function(t){var e,r,n,i=0,s=t.length;for(t.sort(g),n=0;n0&&(e.y+=r),i=e.y+e.dy+a;if((r=i-a-o[1])>0)for(i=e.y-=r,n=s-2;n>=0;--n)e=t[n],(r=e.y+e.dy+a-i)>0&&(e.y-=r),i=e.y})}function g(t,e){return t.y-e.y}}(n),c(),t},t.relayout=function(){return c(),t},t.link=function(){var t=.5;function e(e){var r=e.source.x+e.source.dx,i=e.target.x,a=n.interpolateNumber(r,i),o=a(t),s=a(1-t),l=e.source.y+e.sy,c=l+e.dy,u=e.target.y+e.ty,f=u+e.dy;return"M"+r+","+l+"C"+o+","+l+" "+s+","+u+" "+i+","+u+"L"+i+","+f+"C"+s+","+f+" "+o+","+c+" "+r+","+c+"Z"}return e.curvature=function(r){return arguments.length?(t=+r,e):t},e},t},Object.defineProperty(t,"__esModule",{value:!0})},"object"==typeof r&&void 0!==e?i(r,t("d3-array"),t("d3-collection"),t("d3-interpolate")):i(n.d3=n.d3||{},n.d3,n.d3,n.d3)},{"d3-array":123,"d3-collection":124,"d3-interpolate":128}],44:[function(t,e,r){"use strict";var n="undefined"==typeof WeakMap?t("weak-map"):WeakMap,i=t("gl-buffer"),a=t("gl-vao"),o=new n;e.exports=function(t){var e=o.get(t),r=e&&(e._triangleBuffer.handle||e._triangleBuffer.buffer);if(!r||!t.isBuffer(r)){var n=i(t,new Float32Array([-1,-1,-1,4,4,-1]));(e=a(t,[{buffer:n,type:t.FLOAT,size:2}]))._triangleBuffer=n,o.set(t,e)}e.bind(),t.drawArrays(t.TRIANGLES,0,3),e.unbind()}},{"gl-buffer":211,"gl-vao":284,"weak-map":490}],45:[function(t,e,r){e.exports=function(t){var e=0,r=0,n=0,i=0;return t.map(function(t){var a=(t=t.slice())[0],o=a.toUpperCase();if(a!=o)switch(t[0]=o,a){case"a":t[6]+=n,t[7]+=i;break;case"v":t[1]+=i;break;case"h":t[1]+=n;break;default:for(var s=1;si&&(i=t[o]),t[o]=0;c--)if(u[c]!==f[c])return!1;for(c=u.length-1;c>=0;c--)if(l=u[c],!y(t[l],e[l],r,n))return!1;return!0}(t,e,r,o))}return r?t===e:t==e}function x(t){return"[object Arguments]"==Object.prototype.toString.call(t)}function b(t,e){if(!t||!e)return!1;if("[object RegExp]"==Object.prototype.toString.call(e))return e.test(t);try{if(t instanceof e)return!0}catch(t){}return!Error.isPrototypeOf(e)&&!0===e.call({},t)}function _(t,e,r,n){var i;if("function"!=typeof e)throw new TypeError('"block" argument must be a function');"string"==typeof r&&(n=r,r=null),i=function(t){var e;try{t()}catch(t){e=t}return e}(e),n=(r&&r.name?" ("+r.name+").":".")+(n?" "+n:"."),t&&!i&&m(i,r,"Missing expected exception"+n);var o="string"==typeof n,s=!t&&a.isError(i),l=!t&&i&&!r;if((s&&o&&b(i,r)||l)&&m(i,r,"Got unwanted exception"+n),t&&i&&r&&!b(i,r)||!t&&i)throw i}f.AssertionError=function(t){var e;this.name="AssertionError",this.actual=t.actual,this.expected=t.expected,this.operator=t.operator,t.message?(this.message=t.message,this.generatedMessage=!1):(this.message=d(g((e=this).actual),128)+" "+e.operator+" "+d(g(e.expected),128),this.generatedMessage=!0);var r=t.stackStartFunction||m;if(Error.captureStackTrace)Error.captureStackTrace(this,r);else{var n=new Error;if(n.stack){var i=n.stack,a=p(r),o=i.indexOf("\n"+a);if(o>=0){var s=i.indexOf("\n",o+1);i=i.substring(s+1)}this.stack=i}}},a.inherits(f.AssertionError,Error),f.fail=m,f.ok=v,f.equal=function(t,e,r){t!=e&&m(t,e,r,"==",f.equal)},f.notEqual=function(t,e,r){t==e&&m(t,e,r,"!=",f.notEqual)},f.deepEqual=function(t,e,r){y(t,e,!1)||m(t,e,r,"deepEqual",f.deepEqual)},f.deepStrictEqual=function(t,e,r){y(t,e,!0)||m(t,e,r,"deepStrictEqual",f.deepStrictEqual)},f.notDeepEqual=function(t,e,r){y(t,e,!1)&&m(t,e,r,"notDeepEqual",f.notDeepEqual)},f.notDeepStrictEqual=function t(e,r,n){y(e,r,!0)&&m(e,r,n,"notDeepStrictEqual",t)},f.strictEqual=function(t,e,r){t!==e&&m(t,e,r,"===",f.strictEqual)},f.notStrictEqual=function(t,e,r){t===e&&m(t,e,r,"!==",f.notStrictEqual)},f.throws=function(t,e,r){_(!0,t,e,r)},f.doesNotThrow=function(t,e,r){_(!1,t,e,r)},f.ifError=function(t){if(t)throw t};var w=Object.keys||function(t){var e=[];for(var r in t)o.call(t,r)&&e.push(r);return e}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"util/":487}],54:[function(t,e,r){e.exports=function(t){return atob(t)}},{}],55:[function(t,e,r){"use strict";e.exports=function(t,e){for(var r=e.length,a=new Array(r+1),o=0;o0?l-4:l;var u=0;for(e=0;e>16&255,s[u++]=n>>8&255,s[u++]=255&n;2===o?(n=i[t.charCodeAt(e)]<<2|i[t.charCodeAt(e+1)]>>4,s[u++]=255&n):1===o&&(n=i[t.charCodeAt(e)]<<10|i[t.charCodeAt(e+1)]<<4|i[t.charCodeAt(e+2)]>>2,s[u++]=n>>8&255,s[u++]=255&n);return s},r.fromByteArray=function(t){for(var e,r=t.length,i=r%3,a="",o=[],s=0,l=r-i;sl?l:s+16383));1===i?(e=t[r-1],a+=n[e>>2],a+=n[e<<4&63],a+="=="):2===i&&(e=(t[r-2]<<8)+t[r-1],a+=n[e>>10],a+=n[e>>4&63],a+=n[e<<2&63],a+="=");return o.push(a),o.join("")};for(var n=[],i=[],a="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=0,l=o.length;s0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===t[e-2]?2:"="===t[e-1]?1:0}function u(t,e,r){for(var i,a,o=[],s=e;s>18&63]+n[a>>12&63]+n[a>>6&63]+n[63&a]);return o.join("")}i["-".charCodeAt(0)]=62,i["_".charCodeAt(0)]=63},{}],57:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]).add(e[0].mul(t[1])),t[1].mul(e[1]))}},{"./lib/rationalize":67}],58:[function(t,e,r){"use strict";e.exports=function(t,e){return t[0].mul(e[1]).cmp(e[0].mul(t[1]))}},{}],59:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]),t[1].mul(e[0]))}},{"./lib/rationalize":67}],60:[function(t,e,r){"use strict";var n=t("./is-rat"),i=t("./lib/is-bn"),a=t("./lib/num-to-bn"),o=t("./lib/str-to-bn"),s=t("./lib/rationalize"),l=t("./div");e.exports=function t(e,r){if(n(e))return r?l(e,t(r)):[e[0].clone(),e[1].clone()];var c=0;var u,f;if(i(e))u=e.clone();else if("string"==typeof e)u=o(e);else{if(0===e)return[a(0),a(1)];if(e===Math.floor(e))u=a(e);else{for(;e!==Math.floor(e);)e*=Math.pow(2,256),c-=256;u=a(e)}}if(n(r))u.mul(r[1]),f=r[0].clone();else if(i(r))f=r.clone();else if("string"==typeof r)f=o(r);else if(r)if(r===Math.floor(r))f=a(r);else{for(;r!==Math.floor(r);)r*=Math.pow(2,256),c+=256;f=a(r)}else f=a(1);c>0?u=u.ushln(c):c<0&&(f=f.ushln(-c));return s(u,f)}},{"./div":59,"./is-rat":61,"./lib/is-bn":65,"./lib/num-to-bn":66,"./lib/rationalize":67,"./lib/str-to-bn":68}],61:[function(t,e,r){"use strict";var n=t("./lib/is-bn");e.exports=function(t){return Array.isArray(t)&&2===t.length&&n(t[0])&&n(t[1])}},{"./lib/is-bn":65}],62:[function(t,e,r){"use strict";var n=t("bn.js");e.exports=function(t){return t.cmp(new n(0))}},{"bn.js":76}],63:[function(t,e,r){"use strict";var n=t("./bn-sign");e.exports=function(t){var e=t.length,r=t.words,i=0;if(1===e)i=r[0];else if(2===e)i=r[0]+67108864*r[1];else for(var a=0;a20)return 52;return r+32}},{"bit-twiddle":74,"double-bits":134}],65:[function(t,e,r){"use strict";t("bn.js");e.exports=function(t){return t&&"object"==typeof t&&Boolean(t.words)}},{"bn.js":76}],66:[function(t,e,r){"use strict";var n=t("bn.js"),i=t("double-bits");e.exports=function(t){var e=i.exponent(t);return e<52?new n(t):new n(t*Math.pow(2,52-e)).ushln(e-52)}},{"bn.js":76,"double-bits":134}],67:[function(t,e,r){"use strict";var n=t("./num-to-bn"),i=t("./bn-sign");e.exports=function(t,e){var r=i(t),a=i(e);if(0===r)return[n(0),n(1)];if(0===a)return[n(0),n(0)];a<0&&(t=t.neg(),e=e.neg());var o=t.gcd(e);if(o.cmpn(1))return[t.div(o),e.div(o)];return[t,e]}},{"./bn-sign":62,"./num-to-bn":66}],68:[function(t,e,r){"use strict";var n=t("bn.js");e.exports=function(t){return new n(t)}},{"bn.js":76}],69:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[0]),t[1].mul(e[1]))}},{"./lib/rationalize":67}],70:[function(t,e,r){"use strict";var n=t("./lib/bn-sign");e.exports=function(t){return n(t[0])*n(t[1])}},{"./lib/bn-sign":62}],71:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]).sub(t[1].mul(e[0])),t[1].mul(e[1]))}},{"./lib/rationalize":67}],72:[function(t,e,r){"use strict";var n=t("./lib/bn-to-num"),i=t("./lib/ctz");e.exports=function(t){var e=t[0],r=t[1];if(0===e.cmpn(0))return 0;var a=e.abs().divmod(r.abs()),o=a.div,s=n(o),l=a.mod,c=e.negative!==r.negative?-1:1;if(0===l.cmpn(0))return c*s;if(s){var u=i(s)+4,f=n(l.ushln(u).divRound(r));return c*(s+f*Math.pow(2,-u))}var h=r.bitLength()-l.bitLength()+53,f=n(l.ushln(h).divRound(r));return h<1023?c*f*Math.pow(2,-h):(f*=Math.pow(2,-1023),c*f*Math.pow(2,1023-h))}},{"./lib/bn-to-num":63,"./lib/ctz":64}],73:[function(t,e,r){"use strict";function n(t,e,r,n,i,a){var o=["function ",t,"(a,l,h,",n.join(","),"){",a?"":"var i=",r?"l-1":"h+1",";while(l<=h){var m=(l+h)>>>1,x=a",i?".get(m)":"[m]"];return a?e.indexOf("c")<0?o.push(";if(x===y){return m}else if(x<=y){"):o.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){"):o.push(";if(",e,"){i=m;"),r?o.push("l=m+1}else{h=m-1}"):o.push("h=m-1}else{l=m+1}"),o.push("}"),a?o.push("return -1};"):o.push("return i};"),o.join("")}function i(t,e,r,i){return new Function([n("A","x"+t+"y",e,["y"],!1,i),n("B","x"+t+"y",e,["y"],!0,i),n("P","c(x,y)"+t+"0",e,["y","c"],!1,i),n("Q","c(x,y)"+t+"0",e,["y","c"],!0,i),"function dispatchBsearch",r,"(a,y,c,l,h){if(a.shape){if(typeof(c)==='function'){return Q(a,(l===undefined)?0:l|0,(h===undefined)?a.shape[0]-1:h|0,y,c)}else{return B(a,(c===undefined)?0:c|0,(l===undefined)?a.shape[0]-1:l|0,y)}}else{if(typeof(c)==='function'){return P(a,(l===undefined)?0:l|0,(h===undefined)?a.length-1:h|0,y,c)}else{return A(a,(c===undefined)?0:c|0,(l===undefined)?a.length-1:l|0,y)}}}return dispatchBsearch",r].join(""))()}e.exports={ge:i(">=",!1,"GE"),gt:i(">",!1,"GT"),lt:i("<",!0,"LT"),le:i("<=",!0,"LE"),eq:i("-",!0,"EQ",!0)}},{}],74:[function(t,e,r){"use strict";"use restrict";function n(t){var e=32;return(t&=-t)&&e--,65535&t&&(e-=16),16711935&t&&(e-=8),252645135&t&&(e-=4),858993459&t&&(e-=2),1431655765&t&&(e-=1),e}r.INT_BITS=32,r.INT_MAX=2147483647,r.INT_MIN=-1<<31,r.sign=function(t){return(t>0)-(t<0)},r.abs=function(t){var e=t>>31;return(t^e)-e},r.min=function(t,e){return e^(t^e)&-(t65535)<<4,e|=r=((t>>>=e)>255)<<3,e|=r=((t>>>=r)>15)<<2,(e|=r=((t>>>=r)>3)<<1)|(t>>>=r)>>1},r.log10=function(t){return t>=1e9?9:t>=1e8?8:t>=1e7?7:t>=1e6?6:t>=1e5?5:t>=1e4?4:t>=1e3?3:t>=100?2:t>=10?1:0},r.popCount=function(t){return 16843009*((t=(858993459&(t-=t>>>1&1431655765))+(t>>>2&858993459))+(t>>>4)&252645135)>>>24},r.countTrailingZeros=n,r.nextPow2=function(t){return t+=0===t,--t,t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)+1},r.prevPow2=function(t){return t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)-(t>>>1)},r.parity=function(t){return t^=t>>>16,t^=t>>>8,t^=t>>>4,27030>>>(t&=15)&1};var i=new Array(256);!function(t){for(var e=0;e<256;++e){var r=e,n=e,i=7;for(r>>>=1;r;r>>>=1)n<<=1,n|=1&r,--i;t[e]=n<>>8&255]<<16|i[t>>>16&255]<<8|i[t>>>24&255]},r.interleave2=function(t,e){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t&=65535)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e&=65535)|e<<8))|e<<4))|e<<2))|e<<1))<<1},r.deinterleave2=function(t,e){return(t=65535&((t=16711935&((t=252645135&((t=858993459&((t=t>>>e&1431655765)|t>>>1))|t>>>2))|t>>>4))|t>>>16))<<16>>16},r.interleave3=function(t,e,r){return t=1227133513&((t=3272356035&((t=251719695&((t=4278190335&((t&=1023)|t<<16))|t<<8))|t<<4))|t<<2),(t|=(e=1227133513&((e=3272356035&((e=251719695&((e=4278190335&((e&=1023)|e<<16))|e<<8))|e<<4))|e<<2))<<1)|(r=1227133513&((r=3272356035&((r=251719695&((r=4278190335&((r&=1023)|r<<16))|r<<8))|r<<4))|r<<2))<<2},r.deinterleave3=function(t,e){return(t=1023&((t=4278190335&((t=251719695&((t=3272356035&((t=t>>>e&1227133513)|t>>>2))|t>>>4))|t>>>8))|t>>>16))<<22>>22},r.nextCombination=function(t){var e=t|t-1;return e+1|(~e&-~e)-1>>>n(t)+1}},{}],75:[function(t,e,r){"use strict";var n=t("clamp");e.exports=function(t,e){e||(e={});var r,o,s,l,c,u,f,h,p,d,g,m=null==e.cutoff?.25:e.cutoff,v=null==e.radius?8:e.radius,y=e.channel||0;if(ArrayBuffer.isView(t)||Array.isArray(t)){if(!e.width||!e.height)throw Error("For raw data width and height should be provided by options");r=e.width,o=e.height,l=t,u=e.stride?e.stride:Math.floor(t.length/r/o)}else window.HTMLCanvasElement&&t instanceof window.HTMLCanvasElement?(f=(h=t).getContext("2d"),r=h.width,o=h.height,p=f.getImageData(0,0,r,o),l=p.data,u=4):window.CanvasRenderingContext2D&&t instanceof window.CanvasRenderingContext2D?(h=t.canvas,f=t,r=h.width,o=h.height,p=f.getImageData(0,0,r,o),l=p.data,u=4):window.ImageData&&t instanceof window.ImageData&&(p=t,r=t.width,o=t.height,l=p.data,u=4);if(s=Math.max(r,o),window.Uint8ClampedArray&&l instanceof window.Uint8ClampedArray||window.Uint8Array&&l instanceof window.Uint8Array)for(c=l,l=Array(r*o),d=0,g=c.length;d=49&&o<=54?o-49+10:o>=17&&o<=22?o-17+10:15&o}return n}function l(t,e,r,n){for(var i=0,a=Math.min(t.length,r),o=e;o=49?s-49+10:s>=17?s-17+10:s}return i}a.isBN=function(t){return t instanceof a||null!==t&&"object"==typeof t&&t.constructor.wordSize===a.wordSize&&Array.isArray(t.words)},a.max=function(t,e){return t.cmp(e)>0?t:e},a.min=function(t,e){return t.cmp(e)<0?t:e},a.prototype._init=function(t,e,r){if("number"==typeof t)return this._initNumber(t,e,r);if("object"==typeof t)return this._initArray(t,e,r);"hex"===e&&(e=16),n(e===(0|e)&&e>=2&&e<=36);var i=0;"-"===(t=t.toString().replace(/\s+/g,""))[0]&&i++,16===e?this._parseHex(t,i):this._parseBase(t,e,i),"-"===t[0]&&(this.negative=1),this.strip(),"le"===r&&this._initArray(this.toArray(),e,r)},a.prototype._initNumber=function(t,e,r){t<0&&(this.negative=1,t=-t),t<67108864?(this.words=[67108863&t],this.length=1):t<4503599627370496?(this.words=[67108863&t,t/67108864&67108863],this.length=2):(n(t<9007199254740992),this.words=[67108863&t,t/67108864&67108863,1],this.length=3),"le"===r&&this._initArray(this.toArray(),e,r)},a.prototype._initArray=function(t,e,r){if(n("number"==typeof t.length),t.length<=0)return this.words=[0],this.length=1,this;this.length=Math.ceil(t.length/3),this.words=new Array(this.length);for(var i=0;i=0;i-=3)o=t[i]|t[i-1]<<8|t[i-2]<<16,this.words[a]|=o<>>26-s&67108863,(s+=24)>=26&&(s-=26,a++);else if("le"===r)for(i=0,a=0;i>>26-s&67108863,(s+=24)>=26&&(s-=26,a++);return this.strip()},a.prototype._parseHex=function(t,e){this.length=Math.ceil((t.length-e)/6),this.words=new Array(this.length);for(var r=0;r=e;r-=6)i=s(t,r,r+6),this.words[n]|=i<>>26-a&4194303,(a+=24)>=26&&(a-=26,n++);r+6!==e&&(i=s(t,e,r+6),this.words[n]|=i<>>26-a&4194303),this.strip()},a.prototype._parseBase=function(t,e,r){this.words=[0],this.length=1;for(var n=0,i=1;i<=67108863;i*=e)n++;n--,i=i/e|0;for(var a=t.length-r,o=a%n,s=Math.min(a,a-o)+r,c=0,u=r;u1&&0===this.words[this.length-1];)this.length--;return this._normSign()},a.prototype._normSign=function(){return 1===this.length&&0===this.words[0]&&(this.negative=0),this},a.prototype.inspect=function(){return(this.red?""};var c=["","0","00","000","0000","00000","000000","0000000","00000000","000000000","0000000000","00000000000","000000000000","0000000000000","00000000000000","000000000000000","0000000000000000","00000000000000000","000000000000000000","0000000000000000000","00000000000000000000","000000000000000000000","0000000000000000000000","00000000000000000000000","000000000000000000000000","0000000000000000000000000"],u=[0,0,25,16,12,11,10,9,8,8,7,7,7,7,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],f=[0,0,33554432,43046721,16777216,48828125,60466176,40353607,16777216,43046721,1e7,19487171,35831808,62748517,7529536,11390625,16777216,24137569,34012224,47045881,64e6,4084101,5153632,6436343,7962624,9765625,11881376,14348907,17210368,20511149,243e5,28629151,33554432,39135393,45435424,52521875,60466176];function h(t,e,r){r.negative=e.negative^t.negative;var n=t.length+e.length|0;r.length=n,n=n-1|0;var i=0|t.words[0],a=0|e.words[0],o=i*a,s=67108863&o,l=o/67108864|0;r.words[0]=s;for(var c=1;c>>26,f=67108863&l,h=Math.min(c,e.length-1),p=Math.max(0,c-t.length+1);p<=h;p++){var d=c-p|0;u+=(o=(i=0|t.words[d])*(a=0|e.words[p])+f)/67108864|0,f=67108863&o}r.words[c]=0|f,l=0|u}return 0!==l?r.words[c]=0|l:r.length--,r.strip()}a.prototype.toString=function(t,e){var r;if(t=t||10,e=0|e||1,16===t||"hex"===t){r="";for(var i=0,a=0,o=0;o>>24-i&16777215)||o!==this.length-1?c[6-l.length]+l+r:l+r,(i+=2)>=26&&(i-=26,o--)}for(0!==a&&(r=a.toString(16)+r);r.length%e!=0;)r="0"+r;return 0!==this.negative&&(r="-"+r),r}if(t===(0|t)&&t>=2&&t<=36){var h=u[t],p=f[t];r="";var d=this.clone();for(d.negative=0;!d.isZero();){var g=d.modn(p).toString(t);r=(d=d.idivn(p)).isZero()?g+r:c[h-g.length]+g+r}for(this.isZero()&&(r="0"+r);r.length%e!=0;)r="0"+r;return 0!==this.negative&&(r="-"+r),r}n(!1,"Base should be between 2 and 36")},a.prototype.toNumber=function(){var t=this.words[0];return 2===this.length?t+=67108864*this.words[1]:3===this.length&&1===this.words[2]?t+=4503599627370496+67108864*this.words[1]:this.length>2&&n(!1,"Number can only safely store up to 53 bits"),0!==this.negative?-t:t},a.prototype.toJSON=function(){return this.toString(16)},a.prototype.toBuffer=function(t,e){return n(void 0!==o),this.toArrayLike(o,t,e)},a.prototype.toArray=function(t,e){return this.toArrayLike(Array,t,e)},a.prototype.toArrayLike=function(t,e,r){var i=this.byteLength(),a=r||Math.max(1,i);n(i<=a,"byte array longer than desired length"),n(a>0,"Requested array length <= 0"),this.strip();var o,s,l="le"===e,c=new t(a),u=this.clone();if(l){for(s=0;!u.isZero();s++)o=u.andln(255),u.iushrn(8),c[s]=o;for(;s=4096&&(r+=13,e>>>=13),e>=64&&(r+=7,e>>>=7),e>=8&&(r+=4,e>>>=4),e>=2&&(r+=2,e>>>=2),r+e},a.prototype._zeroBits=function(t){if(0===t)return 26;var e=t,r=0;return 0==(8191&e)&&(r+=13,e>>>=13),0==(127&e)&&(r+=7,e>>>=7),0==(15&e)&&(r+=4,e>>>=4),0==(3&e)&&(r+=2,e>>>=2),0==(1&e)&&r++,r},a.prototype.bitLength=function(){var t=this.words[this.length-1],e=this._countBits(t);return 26*(this.length-1)+e},a.prototype.zeroBits=function(){if(this.isZero())return 0;for(var t=0,e=0;et.length?this.clone().ior(t):t.clone().ior(this)},a.prototype.uor=function(t){return this.length>t.length?this.clone().iuor(t):t.clone().iuor(this)},a.prototype.iuand=function(t){var e;e=this.length>t.length?t:this;for(var r=0;rt.length?this.clone().iand(t):t.clone().iand(this)},a.prototype.uand=function(t){return this.length>t.length?this.clone().iuand(t):t.clone().iuand(this)},a.prototype.iuxor=function(t){var e,r;this.length>t.length?(e=this,r=t):(e=t,r=this);for(var n=0;nt.length?this.clone().ixor(t):t.clone().ixor(this)},a.prototype.uxor=function(t){return this.length>t.length?this.clone().iuxor(t):t.clone().iuxor(this)},a.prototype.inotn=function(t){n("number"==typeof t&&t>=0);var e=0|Math.ceil(t/26),r=t%26;this._expand(e),r>0&&e--;for(var i=0;i0&&(this.words[i]=~this.words[i]&67108863>>26-r),this.strip()},a.prototype.notn=function(t){return this.clone().inotn(t)},a.prototype.setn=function(t,e){n("number"==typeof t&&t>=0);var r=t/26|0,i=t%26;return this._expand(r+1),this.words[r]=e?this.words[r]|1<t.length?(r=this,n=t):(r=t,n=this);for(var i=0,a=0;a>>26;for(;0!==i&&a>>26;if(this.length=r.length,0!==i)this.words[this.length]=i,this.length++;else if(r!==this)for(;at.length?this.clone().iadd(t):t.clone().iadd(this)},a.prototype.isub=function(t){if(0!==t.negative){t.negative=0;var e=this.iadd(t);return t.negative=1,e._normSign()}if(0!==this.negative)return this.negative=0,this.iadd(t),this.negative=1,this._normSign();var r,n,i=this.cmp(t);if(0===i)return this.negative=0,this.length=1,this.words[0]=0,this;i>0?(r=this,n=t):(r=t,n=this);for(var a=0,o=0;o>26,this.words[o]=67108863&e;for(;0!==a&&o>26,this.words[o]=67108863&e;if(0===a&&o>>13,p=0|o[1],d=8191&p,g=p>>>13,m=0|o[2],v=8191&m,y=m>>>13,x=0|o[3],b=8191&x,_=x>>>13,w=0|o[4],k=8191&w,M=w>>>13,A=0|o[5],T=8191&A,S=A>>>13,C=0|o[6],E=8191&C,L=C>>>13,z=0|o[7],P=8191&z,D=z>>>13,O=0|o[8],I=8191&O,R=O>>>13,B=0|o[9],F=8191&B,N=B>>>13,j=0|s[0],V=8191&j,U=j>>>13,q=0|s[1],H=8191&q,G=q>>>13,W=0|s[2],Y=8191&W,X=W>>>13,Z=0|s[3],J=8191&Z,K=Z>>>13,Q=0|s[4],$=8191&Q,tt=Q>>>13,et=0|s[5],rt=8191&et,nt=et>>>13,it=0|s[6],at=8191&it,ot=it>>>13,st=0|s[7],lt=8191&st,ct=st>>>13,ut=0|s[8],ft=8191&ut,ht=ut>>>13,pt=0|s[9],dt=8191&pt,gt=pt>>>13;r.negative=t.negative^e.negative,r.length=19;var mt=(c+(n=Math.imul(f,V))|0)+((8191&(i=(i=Math.imul(f,U))+Math.imul(h,V)|0))<<13)|0;c=((a=Math.imul(h,U))+(i>>>13)|0)+(mt>>>26)|0,mt&=67108863,n=Math.imul(d,V),i=(i=Math.imul(d,U))+Math.imul(g,V)|0,a=Math.imul(g,U);var vt=(c+(n=n+Math.imul(f,H)|0)|0)+((8191&(i=(i=i+Math.imul(f,G)|0)+Math.imul(h,H)|0))<<13)|0;c=((a=a+Math.imul(h,G)|0)+(i>>>13)|0)+(vt>>>26)|0,vt&=67108863,n=Math.imul(v,V),i=(i=Math.imul(v,U))+Math.imul(y,V)|0,a=Math.imul(y,U),n=n+Math.imul(d,H)|0,i=(i=i+Math.imul(d,G)|0)+Math.imul(g,H)|0,a=a+Math.imul(g,G)|0;var yt=(c+(n=n+Math.imul(f,Y)|0)|0)+((8191&(i=(i=i+Math.imul(f,X)|0)+Math.imul(h,Y)|0))<<13)|0;c=((a=a+Math.imul(h,X)|0)+(i>>>13)|0)+(yt>>>26)|0,yt&=67108863,n=Math.imul(b,V),i=(i=Math.imul(b,U))+Math.imul(_,V)|0,a=Math.imul(_,U),n=n+Math.imul(v,H)|0,i=(i=i+Math.imul(v,G)|0)+Math.imul(y,H)|0,a=a+Math.imul(y,G)|0,n=n+Math.imul(d,Y)|0,i=(i=i+Math.imul(d,X)|0)+Math.imul(g,Y)|0,a=a+Math.imul(g,X)|0;var xt=(c+(n=n+Math.imul(f,J)|0)|0)+((8191&(i=(i=i+Math.imul(f,K)|0)+Math.imul(h,J)|0))<<13)|0;c=((a=a+Math.imul(h,K)|0)+(i>>>13)|0)+(xt>>>26)|0,xt&=67108863,n=Math.imul(k,V),i=(i=Math.imul(k,U))+Math.imul(M,V)|0,a=Math.imul(M,U),n=n+Math.imul(b,H)|0,i=(i=i+Math.imul(b,G)|0)+Math.imul(_,H)|0,a=a+Math.imul(_,G)|0,n=n+Math.imul(v,Y)|0,i=(i=i+Math.imul(v,X)|0)+Math.imul(y,Y)|0,a=a+Math.imul(y,X)|0,n=n+Math.imul(d,J)|0,i=(i=i+Math.imul(d,K)|0)+Math.imul(g,J)|0,a=a+Math.imul(g,K)|0;var bt=(c+(n=n+Math.imul(f,$)|0)|0)+((8191&(i=(i=i+Math.imul(f,tt)|0)+Math.imul(h,$)|0))<<13)|0;c=((a=a+Math.imul(h,tt)|0)+(i>>>13)|0)+(bt>>>26)|0,bt&=67108863,n=Math.imul(T,V),i=(i=Math.imul(T,U))+Math.imul(S,V)|0,a=Math.imul(S,U),n=n+Math.imul(k,H)|0,i=(i=i+Math.imul(k,G)|0)+Math.imul(M,H)|0,a=a+Math.imul(M,G)|0,n=n+Math.imul(b,Y)|0,i=(i=i+Math.imul(b,X)|0)+Math.imul(_,Y)|0,a=a+Math.imul(_,X)|0,n=n+Math.imul(v,J)|0,i=(i=i+Math.imul(v,K)|0)+Math.imul(y,J)|0,a=a+Math.imul(y,K)|0,n=n+Math.imul(d,$)|0,i=(i=i+Math.imul(d,tt)|0)+Math.imul(g,$)|0,a=a+Math.imul(g,tt)|0;var _t=(c+(n=n+Math.imul(f,rt)|0)|0)+((8191&(i=(i=i+Math.imul(f,nt)|0)+Math.imul(h,rt)|0))<<13)|0;c=((a=a+Math.imul(h,nt)|0)+(i>>>13)|0)+(_t>>>26)|0,_t&=67108863,n=Math.imul(E,V),i=(i=Math.imul(E,U))+Math.imul(L,V)|0,a=Math.imul(L,U),n=n+Math.imul(T,H)|0,i=(i=i+Math.imul(T,G)|0)+Math.imul(S,H)|0,a=a+Math.imul(S,G)|0,n=n+Math.imul(k,Y)|0,i=(i=i+Math.imul(k,X)|0)+Math.imul(M,Y)|0,a=a+Math.imul(M,X)|0,n=n+Math.imul(b,J)|0,i=(i=i+Math.imul(b,K)|0)+Math.imul(_,J)|0,a=a+Math.imul(_,K)|0,n=n+Math.imul(v,$)|0,i=(i=i+Math.imul(v,tt)|0)+Math.imul(y,$)|0,a=a+Math.imul(y,tt)|0,n=n+Math.imul(d,rt)|0,i=(i=i+Math.imul(d,nt)|0)+Math.imul(g,rt)|0,a=a+Math.imul(g,nt)|0;var wt=(c+(n=n+Math.imul(f,at)|0)|0)+((8191&(i=(i=i+Math.imul(f,ot)|0)+Math.imul(h,at)|0))<<13)|0;c=((a=a+Math.imul(h,ot)|0)+(i>>>13)|0)+(wt>>>26)|0,wt&=67108863,n=Math.imul(P,V),i=(i=Math.imul(P,U))+Math.imul(D,V)|0,a=Math.imul(D,U),n=n+Math.imul(E,H)|0,i=(i=i+Math.imul(E,G)|0)+Math.imul(L,H)|0,a=a+Math.imul(L,G)|0,n=n+Math.imul(T,Y)|0,i=(i=i+Math.imul(T,X)|0)+Math.imul(S,Y)|0,a=a+Math.imul(S,X)|0,n=n+Math.imul(k,J)|0,i=(i=i+Math.imul(k,K)|0)+Math.imul(M,J)|0,a=a+Math.imul(M,K)|0,n=n+Math.imul(b,$)|0,i=(i=i+Math.imul(b,tt)|0)+Math.imul(_,$)|0,a=a+Math.imul(_,tt)|0,n=n+Math.imul(v,rt)|0,i=(i=i+Math.imul(v,nt)|0)+Math.imul(y,rt)|0,a=a+Math.imul(y,nt)|0,n=n+Math.imul(d,at)|0,i=(i=i+Math.imul(d,ot)|0)+Math.imul(g,at)|0,a=a+Math.imul(g,ot)|0;var kt=(c+(n=n+Math.imul(f,lt)|0)|0)+((8191&(i=(i=i+Math.imul(f,ct)|0)+Math.imul(h,lt)|0))<<13)|0;c=((a=a+Math.imul(h,ct)|0)+(i>>>13)|0)+(kt>>>26)|0,kt&=67108863,n=Math.imul(I,V),i=(i=Math.imul(I,U))+Math.imul(R,V)|0,a=Math.imul(R,U),n=n+Math.imul(P,H)|0,i=(i=i+Math.imul(P,G)|0)+Math.imul(D,H)|0,a=a+Math.imul(D,G)|0,n=n+Math.imul(E,Y)|0,i=(i=i+Math.imul(E,X)|0)+Math.imul(L,Y)|0,a=a+Math.imul(L,X)|0,n=n+Math.imul(T,J)|0,i=(i=i+Math.imul(T,K)|0)+Math.imul(S,J)|0,a=a+Math.imul(S,K)|0,n=n+Math.imul(k,$)|0,i=(i=i+Math.imul(k,tt)|0)+Math.imul(M,$)|0,a=a+Math.imul(M,tt)|0,n=n+Math.imul(b,rt)|0,i=(i=i+Math.imul(b,nt)|0)+Math.imul(_,rt)|0,a=a+Math.imul(_,nt)|0,n=n+Math.imul(v,at)|0,i=(i=i+Math.imul(v,ot)|0)+Math.imul(y,at)|0,a=a+Math.imul(y,ot)|0,n=n+Math.imul(d,lt)|0,i=(i=i+Math.imul(d,ct)|0)+Math.imul(g,lt)|0,a=a+Math.imul(g,ct)|0;var Mt=(c+(n=n+Math.imul(f,ft)|0)|0)+((8191&(i=(i=i+Math.imul(f,ht)|0)+Math.imul(h,ft)|0))<<13)|0;c=((a=a+Math.imul(h,ht)|0)+(i>>>13)|0)+(Mt>>>26)|0,Mt&=67108863,n=Math.imul(F,V),i=(i=Math.imul(F,U))+Math.imul(N,V)|0,a=Math.imul(N,U),n=n+Math.imul(I,H)|0,i=(i=i+Math.imul(I,G)|0)+Math.imul(R,H)|0,a=a+Math.imul(R,G)|0,n=n+Math.imul(P,Y)|0,i=(i=i+Math.imul(P,X)|0)+Math.imul(D,Y)|0,a=a+Math.imul(D,X)|0,n=n+Math.imul(E,J)|0,i=(i=i+Math.imul(E,K)|0)+Math.imul(L,J)|0,a=a+Math.imul(L,K)|0,n=n+Math.imul(T,$)|0,i=(i=i+Math.imul(T,tt)|0)+Math.imul(S,$)|0,a=a+Math.imul(S,tt)|0,n=n+Math.imul(k,rt)|0,i=(i=i+Math.imul(k,nt)|0)+Math.imul(M,rt)|0,a=a+Math.imul(M,nt)|0,n=n+Math.imul(b,at)|0,i=(i=i+Math.imul(b,ot)|0)+Math.imul(_,at)|0,a=a+Math.imul(_,ot)|0,n=n+Math.imul(v,lt)|0,i=(i=i+Math.imul(v,ct)|0)+Math.imul(y,lt)|0,a=a+Math.imul(y,ct)|0,n=n+Math.imul(d,ft)|0,i=(i=i+Math.imul(d,ht)|0)+Math.imul(g,ft)|0,a=a+Math.imul(g,ht)|0;var At=(c+(n=n+Math.imul(f,dt)|0)|0)+((8191&(i=(i=i+Math.imul(f,gt)|0)+Math.imul(h,dt)|0))<<13)|0;c=((a=a+Math.imul(h,gt)|0)+(i>>>13)|0)+(At>>>26)|0,At&=67108863,n=Math.imul(F,H),i=(i=Math.imul(F,G))+Math.imul(N,H)|0,a=Math.imul(N,G),n=n+Math.imul(I,Y)|0,i=(i=i+Math.imul(I,X)|0)+Math.imul(R,Y)|0,a=a+Math.imul(R,X)|0,n=n+Math.imul(P,J)|0,i=(i=i+Math.imul(P,K)|0)+Math.imul(D,J)|0,a=a+Math.imul(D,K)|0,n=n+Math.imul(E,$)|0,i=(i=i+Math.imul(E,tt)|0)+Math.imul(L,$)|0,a=a+Math.imul(L,tt)|0,n=n+Math.imul(T,rt)|0,i=(i=i+Math.imul(T,nt)|0)+Math.imul(S,rt)|0,a=a+Math.imul(S,nt)|0,n=n+Math.imul(k,at)|0,i=(i=i+Math.imul(k,ot)|0)+Math.imul(M,at)|0,a=a+Math.imul(M,ot)|0,n=n+Math.imul(b,lt)|0,i=(i=i+Math.imul(b,ct)|0)+Math.imul(_,lt)|0,a=a+Math.imul(_,ct)|0,n=n+Math.imul(v,ft)|0,i=(i=i+Math.imul(v,ht)|0)+Math.imul(y,ft)|0,a=a+Math.imul(y,ht)|0;var Tt=(c+(n=n+Math.imul(d,dt)|0)|0)+((8191&(i=(i=i+Math.imul(d,gt)|0)+Math.imul(g,dt)|0))<<13)|0;c=((a=a+Math.imul(g,gt)|0)+(i>>>13)|0)+(Tt>>>26)|0,Tt&=67108863,n=Math.imul(F,Y),i=(i=Math.imul(F,X))+Math.imul(N,Y)|0,a=Math.imul(N,X),n=n+Math.imul(I,J)|0,i=(i=i+Math.imul(I,K)|0)+Math.imul(R,J)|0,a=a+Math.imul(R,K)|0,n=n+Math.imul(P,$)|0,i=(i=i+Math.imul(P,tt)|0)+Math.imul(D,$)|0,a=a+Math.imul(D,tt)|0,n=n+Math.imul(E,rt)|0,i=(i=i+Math.imul(E,nt)|0)+Math.imul(L,rt)|0,a=a+Math.imul(L,nt)|0,n=n+Math.imul(T,at)|0,i=(i=i+Math.imul(T,ot)|0)+Math.imul(S,at)|0,a=a+Math.imul(S,ot)|0,n=n+Math.imul(k,lt)|0,i=(i=i+Math.imul(k,ct)|0)+Math.imul(M,lt)|0,a=a+Math.imul(M,ct)|0,n=n+Math.imul(b,ft)|0,i=(i=i+Math.imul(b,ht)|0)+Math.imul(_,ft)|0,a=a+Math.imul(_,ht)|0;var St=(c+(n=n+Math.imul(v,dt)|0)|0)+((8191&(i=(i=i+Math.imul(v,gt)|0)+Math.imul(y,dt)|0))<<13)|0;c=((a=a+Math.imul(y,gt)|0)+(i>>>13)|0)+(St>>>26)|0,St&=67108863,n=Math.imul(F,J),i=(i=Math.imul(F,K))+Math.imul(N,J)|0,a=Math.imul(N,K),n=n+Math.imul(I,$)|0,i=(i=i+Math.imul(I,tt)|0)+Math.imul(R,$)|0,a=a+Math.imul(R,tt)|0,n=n+Math.imul(P,rt)|0,i=(i=i+Math.imul(P,nt)|0)+Math.imul(D,rt)|0,a=a+Math.imul(D,nt)|0,n=n+Math.imul(E,at)|0,i=(i=i+Math.imul(E,ot)|0)+Math.imul(L,at)|0,a=a+Math.imul(L,ot)|0,n=n+Math.imul(T,lt)|0,i=(i=i+Math.imul(T,ct)|0)+Math.imul(S,lt)|0,a=a+Math.imul(S,ct)|0,n=n+Math.imul(k,ft)|0,i=(i=i+Math.imul(k,ht)|0)+Math.imul(M,ft)|0,a=a+Math.imul(M,ht)|0;var Ct=(c+(n=n+Math.imul(b,dt)|0)|0)+((8191&(i=(i=i+Math.imul(b,gt)|0)+Math.imul(_,dt)|0))<<13)|0;c=((a=a+Math.imul(_,gt)|0)+(i>>>13)|0)+(Ct>>>26)|0,Ct&=67108863,n=Math.imul(F,$),i=(i=Math.imul(F,tt))+Math.imul(N,$)|0,a=Math.imul(N,tt),n=n+Math.imul(I,rt)|0,i=(i=i+Math.imul(I,nt)|0)+Math.imul(R,rt)|0,a=a+Math.imul(R,nt)|0,n=n+Math.imul(P,at)|0,i=(i=i+Math.imul(P,ot)|0)+Math.imul(D,at)|0,a=a+Math.imul(D,ot)|0,n=n+Math.imul(E,lt)|0,i=(i=i+Math.imul(E,ct)|0)+Math.imul(L,lt)|0,a=a+Math.imul(L,ct)|0,n=n+Math.imul(T,ft)|0,i=(i=i+Math.imul(T,ht)|0)+Math.imul(S,ft)|0,a=a+Math.imul(S,ht)|0;var Et=(c+(n=n+Math.imul(k,dt)|0)|0)+((8191&(i=(i=i+Math.imul(k,gt)|0)+Math.imul(M,dt)|0))<<13)|0;c=((a=a+Math.imul(M,gt)|0)+(i>>>13)|0)+(Et>>>26)|0,Et&=67108863,n=Math.imul(F,rt),i=(i=Math.imul(F,nt))+Math.imul(N,rt)|0,a=Math.imul(N,nt),n=n+Math.imul(I,at)|0,i=(i=i+Math.imul(I,ot)|0)+Math.imul(R,at)|0,a=a+Math.imul(R,ot)|0,n=n+Math.imul(P,lt)|0,i=(i=i+Math.imul(P,ct)|0)+Math.imul(D,lt)|0,a=a+Math.imul(D,ct)|0,n=n+Math.imul(E,ft)|0,i=(i=i+Math.imul(E,ht)|0)+Math.imul(L,ft)|0,a=a+Math.imul(L,ht)|0;var Lt=(c+(n=n+Math.imul(T,dt)|0)|0)+((8191&(i=(i=i+Math.imul(T,gt)|0)+Math.imul(S,dt)|0))<<13)|0;c=((a=a+Math.imul(S,gt)|0)+(i>>>13)|0)+(Lt>>>26)|0,Lt&=67108863,n=Math.imul(F,at),i=(i=Math.imul(F,ot))+Math.imul(N,at)|0,a=Math.imul(N,ot),n=n+Math.imul(I,lt)|0,i=(i=i+Math.imul(I,ct)|0)+Math.imul(R,lt)|0,a=a+Math.imul(R,ct)|0,n=n+Math.imul(P,ft)|0,i=(i=i+Math.imul(P,ht)|0)+Math.imul(D,ft)|0,a=a+Math.imul(D,ht)|0;var zt=(c+(n=n+Math.imul(E,dt)|0)|0)+((8191&(i=(i=i+Math.imul(E,gt)|0)+Math.imul(L,dt)|0))<<13)|0;c=((a=a+Math.imul(L,gt)|0)+(i>>>13)|0)+(zt>>>26)|0,zt&=67108863,n=Math.imul(F,lt),i=(i=Math.imul(F,ct))+Math.imul(N,lt)|0,a=Math.imul(N,ct),n=n+Math.imul(I,ft)|0,i=(i=i+Math.imul(I,ht)|0)+Math.imul(R,ft)|0,a=a+Math.imul(R,ht)|0;var Pt=(c+(n=n+Math.imul(P,dt)|0)|0)+((8191&(i=(i=i+Math.imul(P,gt)|0)+Math.imul(D,dt)|0))<<13)|0;c=((a=a+Math.imul(D,gt)|0)+(i>>>13)|0)+(Pt>>>26)|0,Pt&=67108863,n=Math.imul(F,ft),i=(i=Math.imul(F,ht))+Math.imul(N,ft)|0,a=Math.imul(N,ht);var Dt=(c+(n=n+Math.imul(I,dt)|0)|0)+((8191&(i=(i=i+Math.imul(I,gt)|0)+Math.imul(R,dt)|0))<<13)|0;c=((a=a+Math.imul(R,gt)|0)+(i>>>13)|0)+(Dt>>>26)|0,Dt&=67108863;var Ot=(c+(n=Math.imul(F,dt))|0)+((8191&(i=(i=Math.imul(F,gt))+Math.imul(N,dt)|0))<<13)|0;return c=((a=Math.imul(N,gt))+(i>>>13)|0)+(Ot>>>26)|0,Ot&=67108863,l[0]=mt,l[1]=vt,l[2]=yt,l[3]=xt,l[4]=bt,l[5]=_t,l[6]=wt,l[7]=kt,l[8]=Mt,l[9]=At,l[10]=Tt,l[11]=St,l[12]=Ct,l[13]=Et,l[14]=Lt,l[15]=zt,l[16]=Pt,l[17]=Dt,l[18]=Ot,0!==c&&(l[19]=c,r.length++),r};function d(t,e,r){return(new g).mulp(t,e,r)}function g(t,e){this.x=t,this.y=e}Math.imul||(p=h),a.prototype.mulTo=function(t,e){var r=this.length+t.length;return 10===this.length&&10===t.length?p(this,t,e):r<63?h(this,t,e):r<1024?function(t,e,r){r.negative=e.negative^t.negative,r.length=t.length+e.length;for(var n=0,i=0,a=0;a>>26)|0)>>>26,o&=67108863}r.words[a]=s,n=o,o=i}return 0!==n?r.words[a]=n:r.length--,r.strip()}(this,t,e):d(this,t,e)},g.prototype.makeRBT=function(t){for(var e=new Array(t),r=a.prototype._countBits(t)-1,n=0;n>=1;return n},g.prototype.permute=function(t,e,r,n,i,a){for(var o=0;o>>=1)i++;return 1<>>=13,r[2*o+1]=8191&a,a>>>=13;for(o=2*e;o>=26,e+=i/67108864|0,e+=a>>>26,this.words[r]=67108863&a}return 0!==e&&(this.words[r]=e,this.length++),this},a.prototype.muln=function(t){return this.clone().imuln(t)},a.prototype.sqr=function(){return this.mul(this)},a.prototype.isqr=function(){return this.imul(this.clone())},a.prototype.pow=function(t){var e=function(t){for(var e=new Array(t.bitLength()),r=0;r>>i}return e}(t);if(0===e.length)return new a(1);for(var r=this,n=0;n=0);var e,r=t%26,i=(t-r)/26,a=67108863>>>26-r<<26-r;if(0!==r){var o=0;for(e=0;e>>26-r}o&&(this.words[e]=o,this.length++)}if(0!==i){for(e=this.length-1;e>=0;e--)this.words[e+i]=this.words[e];for(e=0;e=0),i=e?(e-e%26)/26:0;var a=t%26,o=Math.min((t-a)/26,this.length),s=67108863^67108863>>>a<o)for(this.length-=o,c=0;c=0&&(0!==u||c>=i);c--){var f=0|this.words[c];this.words[c]=u<<26-a|f>>>a,u=f&s}return l&&0!==u&&(l.words[l.length++]=u),0===this.length&&(this.words[0]=0,this.length=1),this.strip()},a.prototype.ishrn=function(t,e,r){return n(0===this.negative),this.iushrn(t,e,r)},a.prototype.shln=function(t){return this.clone().ishln(t)},a.prototype.ushln=function(t){return this.clone().iushln(t)},a.prototype.shrn=function(t){return this.clone().ishrn(t)},a.prototype.ushrn=function(t){return this.clone().iushrn(t)},a.prototype.testn=function(t){n("number"==typeof t&&t>=0);var e=t%26,r=(t-e)/26,i=1<=0);var e=t%26,r=(t-e)/26;if(n(0===this.negative,"imaskn works only with positive numbers"),this.length<=r)return this;if(0!==e&&r++,this.length=Math.min(r,this.length),0!==e){var i=67108863^67108863>>>e<=67108864;e++)this.words[e]-=67108864,e===this.length-1?this.words[e+1]=1:this.words[e+1]++;return this.length=Math.max(this.length,e+1),this},a.prototype.isubn=function(t){if(n("number"==typeof t),n(t<67108864),t<0)return this.iaddn(-t);if(0!==this.negative)return this.negative=0,this.iaddn(t),this.negative=1,this;if(this.words[0]-=t,1===this.length&&this.words[0]<0)this.words[0]=-this.words[0],this.negative=1;else for(var e=0;e>26)-(l/67108864|0),this.words[i+r]=67108863&a}for(;i>26,this.words[i+r]=67108863&a;if(0===s)return this.strip();for(n(-1===s),s=0,i=0;i>26,this.words[i]=67108863&a;return this.negative=1,this.strip()},a.prototype._wordDiv=function(t,e){var r=(this.length,t.length),n=this.clone(),i=t,o=0|i.words[i.length-1];0!==(r=26-this._countBits(o))&&(i=i.ushln(r),n.iushln(r),o=0|i.words[i.length-1]);var s,l=n.length-i.length;if("mod"!==e){(s=new a(null)).length=l+1,s.words=new Array(s.length);for(var c=0;c=0;f--){var h=67108864*(0|n.words[i.length+f])+(0|n.words[i.length+f-1]);for(h=Math.min(h/o|0,67108863),n._ishlnsubmul(i,h,f);0!==n.negative;)h--,n.negative=0,n._ishlnsubmul(i,1,f),n.isZero()||(n.negative^=1);s&&(s.words[f]=h)}return s&&s.strip(),n.strip(),"div"!==e&&0!==r&&n.iushrn(r),{div:s||null,mod:n}},a.prototype.divmod=function(t,e,r){return n(!t.isZero()),this.isZero()?{div:new a(0),mod:new a(0)}:0!==this.negative&&0===t.negative?(s=this.neg().divmod(t,e),"mod"!==e&&(i=s.div.neg()),"div"!==e&&(o=s.mod.neg(),r&&0!==o.negative&&o.iadd(t)),{div:i,mod:o}):0===this.negative&&0!==t.negative?(s=this.divmod(t.neg(),e),"mod"!==e&&(i=s.div.neg()),{div:i,mod:s.mod}):0!=(this.negative&t.negative)?(s=this.neg().divmod(t.neg(),e),"div"!==e&&(o=s.mod.neg(),r&&0!==o.negative&&o.isub(t)),{div:s.div,mod:o}):t.length>this.length||this.cmp(t)<0?{div:new a(0),mod:this}:1===t.length?"div"===e?{div:this.divn(t.words[0]),mod:null}:"mod"===e?{div:null,mod:new a(this.modn(t.words[0]))}:{div:this.divn(t.words[0]),mod:new a(this.modn(t.words[0]))}:this._wordDiv(t,e);var i,o,s},a.prototype.div=function(t){return this.divmod(t,"div",!1).div},a.prototype.mod=function(t){return this.divmod(t,"mod",!1).mod},a.prototype.umod=function(t){return this.divmod(t,"mod",!0).mod},a.prototype.divRound=function(t){var e=this.divmod(t);if(e.mod.isZero())return e.div;var r=0!==e.div.negative?e.mod.isub(t):e.mod,n=t.ushrn(1),i=t.andln(1),a=r.cmp(n);return a<0||1===i&&0===a?e.div:0!==e.div.negative?e.div.isubn(1):e.div.iaddn(1)},a.prototype.modn=function(t){n(t<=67108863);for(var e=(1<<26)%t,r=0,i=this.length-1;i>=0;i--)r=(e*r+(0|this.words[i]))%t;return r},a.prototype.idivn=function(t){n(t<=67108863);for(var e=0,r=this.length-1;r>=0;r--){var i=(0|this.words[r])+67108864*e;this.words[r]=i/t|0,e=i%t}return this.strip()},a.prototype.divn=function(t){return this.clone().idivn(t)},a.prototype.egcd=function(t){n(0===t.negative),n(!t.isZero());var e=this,r=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var i=new a(1),o=new a(0),s=new a(0),l=new a(1),c=0;e.isEven()&&r.isEven();)e.iushrn(1),r.iushrn(1),++c;for(var u=r.clone(),f=e.clone();!e.isZero();){for(var h=0,p=1;0==(e.words[0]&p)&&h<26;++h,p<<=1);if(h>0)for(e.iushrn(h);h-- >0;)(i.isOdd()||o.isOdd())&&(i.iadd(u),o.isub(f)),i.iushrn(1),o.iushrn(1);for(var d=0,g=1;0==(r.words[0]&g)&&d<26;++d,g<<=1);if(d>0)for(r.iushrn(d);d-- >0;)(s.isOdd()||l.isOdd())&&(s.iadd(u),l.isub(f)),s.iushrn(1),l.iushrn(1);e.cmp(r)>=0?(e.isub(r),i.isub(s),o.isub(l)):(r.isub(e),s.isub(i),l.isub(o))}return{a:s,b:l,gcd:r.iushln(c)}},a.prototype._invmp=function(t){n(0===t.negative),n(!t.isZero());var e=this,r=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var i,o=new a(1),s=new a(0),l=r.clone();e.cmpn(1)>0&&r.cmpn(1)>0;){for(var c=0,u=1;0==(e.words[0]&u)&&c<26;++c,u<<=1);if(c>0)for(e.iushrn(c);c-- >0;)o.isOdd()&&o.iadd(l),o.iushrn(1);for(var f=0,h=1;0==(r.words[0]&h)&&f<26;++f,h<<=1);if(f>0)for(r.iushrn(f);f-- >0;)s.isOdd()&&s.iadd(l),s.iushrn(1);e.cmp(r)>=0?(e.isub(r),o.isub(s)):(r.isub(e),s.isub(o))}return(i=0===e.cmpn(1)?o:s).cmpn(0)<0&&i.iadd(t),i},a.prototype.gcd=function(t){if(this.isZero())return t.abs();if(t.isZero())return this.abs();var e=this.clone(),r=t.clone();e.negative=0,r.negative=0;for(var n=0;e.isEven()&&r.isEven();n++)e.iushrn(1),r.iushrn(1);for(;;){for(;e.isEven();)e.iushrn(1);for(;r.isEven();)r.iushrn(1);var i=e.cmp(r);if(i<0){var a=e;e=r,r=a}else if(0===i||0===r.cmpn(1))break;e.isub(r)}return r.iushln(n)},a.prototype.invm=function(t){return this.egcd(t).a.umod(t)},a.prototype.isEven=function(){return 0==(1&this.words[0])},a.prototype.isOdd=function(){return 1==(1&this.words[0])},a.prototype.andln=function(t){return this.words[0]&t},a.prototype.bincn=function(t){n("number"==typeof t);var e=t%26,r=(t-e)/26,i=1<>>26,s&=67108863,this.words[o]=s}return 0!==a&&(this.words[o]=a,this.length++),this},a.prototype.isZero=function(){return 1===this.length&&0===this.words[0]},a.prototype.cmpn=function(t){var e,r=t<0;if(0!==this.negative&&!r)return-1;if(0===this.negative&&r)return 1;if(this.strip(),this.length>1)e=1;else{r&&(t=-t),n(t<=67108863,"Number is too big");var i=0|this.words[0];e=i===t?0:it.length)return 1;if(this.length=0;r--){var n=0|this.words[r],i=0|t.words[r];if(n!==i){ni&&(e=1);break}}return e},a.prototype.gtn=function(t){return 1===this.cmpn(t)},a.prototype.gt=function(t){return 1===this.cmp(t)},a.prototype.gten=function(t){return this.cmpn(t)>=0},a.prototype.gte=function(t){return this.cmp(t)>=0},a.prototype.ltn=function(t){return-1===this.cmpn(t)},a.prototype.lt=function(t){return-1===this.cmp(t)},a.prototype.lten=function(t){return this.cmpn(t)<=0},a.prototype.lte=function(t){return this.cmp(t)<=0},a.prototype.eqn=function(t){return 0===this.cmpn(t)},a.prototype.eq=function(t){return 0===this.cmp(t)},a.red=function(t){return new w(t)},a.prototype.toRed=function(t){return n(!this.red,"Already a number in reduction context"),n(0===this.negative,"red works only with positives"),t.convertTo(this)._forceRed(t)},a.prototype.fromRed=function(){return n(this.red,"fromRed works only with numbers in reduction context"),this.red.convertFrom(this)},a.prototype._forceRed=function(t){return this.red=t,this},a.prototype.forceRed=function(t){return n(!this.red,"Already a number in reduction context"),this._forceRed(t)},a.prototype.redAdd=function(t){return n(this.red,"redAdd works only with red numbers"),this.red.add(this,t)},a.prototype.redIAdd=function(t){return n(this.red,"redIAdd works only with red numbers"),this.red.iadd(this,t)},a.prototype.redSub=function(t){return n(this.red,"redSub works only with red numbers"),this.red.sub(this,t)},a.prototype.redISub=function(t){return n(this.red,"redISub works only with red numbers"),this.red.isub(this,t)},a.prototype.redShl=function(t){return n(this.red,"redShl works only with red numbers"),this.red.shl(this,t)},a.prototype.redMul=function(t){return n(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.mul(this,t)},a.prototype.redIMul=function(t){return n(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.imul(this,t)},a.prototype.redSqr=function(){return n(this.red,"redSqr works only with red numbers"),this.red._verify1(this),this.red.sqr(this)},a.prototype.redISqr=function(){return n(this.red,"redISqr works only with red numbers"),this.red._verify1(this),this.red.isqr(this)},a.prototype.redSqrt=function(){return n(this.red,"redSqrt works only with red numbers"),this.red._verify1(this),this.red.sqrt(this)},a.prototype.redInvm=function(){return n(this.red,"redInvm works only with red numbers"),this.red._verify1(this),this.red.invm(this)},a.prototype.redNeg=function(){return n(this.red,"redNeg works only with red numbers"),this.red._verify1(this),this.red.neg(this)},a.prototype.redPow=function(t){return n(this.red&&!t.red,"redPow(normalNum)"),this.red._verify1(this),this.red.pow(this,t)};var m={k256:null,p224:null,p192:null,p25519:null};function v(t,e){this.name=t,this.p=new a(e,16),this.n=this.p.bitLength(),this.k=new a(1).iushln(this.n).isub(this.p),this.tmp=this._tmp()}function y(){v.call(this,"k256","ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f")}function x(){v.call(this,"p224","ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001")}function b(){v.call(this,"p192","ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff")}function _(){v.call(this,"25519","7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed")}function w(t){if("string"==typeof t){var e=a._prime(t);this.m=e.p,this.prime=e}else n(t.gtn(1),"modulus must be greater than 1"),this.m=t,this.prime=null}function k(t){w.call(this,t),this.shift=this.m.bitLength(),this.shift%26!=0&&(this.shift+=26-this.shift%26),this.r=new a(1).iushln(this.shift),this.r2=this.imod(this.r.sqr()),this.rinv=this.r._invmp(this.m),this.minv=this.rinv.mul(this.r).isubn(1).div(this.m),this.minv=this.minv.umod(this.r),this.minv=this.r.sub(this.minv)}v.prototype._tmp=function(){var t=new a(null);return t.words=new Array(Math.ceil(this.n/13)),t},v.prototype.ireduce=function(t){var e,r=t;do{this.split(r,this.tmp),e=(r=(r=this.imulK(r)).iadd(this.tmp)).bitLength()}while(e>this.n);var n=e0?r.isub(this.p):r.strip(),r},v.prototype.split=function(t,e){t.iushrn(this.n,0,e)},v.prototype.imulK=function(t){return t.imul(this.k)},i(y,v),y.prototype.split=function(t,e){for(var r=Math.min(t.length,9),n=0;n>>22,i=a}i>>>=22,t.words[n-10]=i,0===i&&t.length>10?t.length-=10:t.length-=9},y.prototype.imulK=function(t){t.words[t.length]=0,t.words[t.length+1]=0,t.length+=2;for(var e=0,r=0;r>>=26,t.words[r]=i,e=n}return 0!==e&&(t.words[t.length++]=e),t},a._prime=function(t){if(m[t])return m[t];var e;if("k256"===t)e=new y;else if("p224"===t)e=new x;else if("p192"===t)e=new b;else{if("p25519"!==t)throw new Error("Unknown prime "+t);e=new _}return m[t]=e,e},w.prototype._verify1=function(t){n(0===t.negative,"red works only with positives"),n(t.red,"red works only with red numbers")},w.prototype._verify2=function(t,e){n(0==(t.negative|e.negative),"red works only with positives"),n(t.red&&t.red===e.red,"red works only with red numbers")},w.prototype.imod=function(t){return this.prime?this.prime.ireduce(t)._forceRed(this):t.umod(this.m)._forceRed(this)},w.prototype.neg=function(t){return t.isZero()?t.clone():this.m.sub(t)._forceRed(this)},w.prototype.add=function(t,e){this._verify2(t,e);var r=t.add(e);return r.cmp(this.m)>=0&&r.isub(this.m),r._forceRed(this)},w.prototype.iadd=function(t,e){this._verify2(t,e);var r=t.iadd(e);return r.cmp(this.m)>=0&&r.isub(this.m),r},w.prototype.sub=function(t,e){this._verify2(t,e);var r=t.sub(e);return r.cmpn(0)<0&&r.iadd(this.m),r._forceRed(this)},w.prototype.isub=function(t,e){this._verify2(t,e);var r=t.isub(e);return r.cmpn(0)<0&&r.iadd(this.m),r},w.prototype.shl=function(t,e){return this._verify1(t),this.imod(t.ushln(e))},w.prototype.imul=function(t,e){return this._verify2(t,e),this.imod(t.imul(e))},w.prototype.mul=function(t,e){return this._verify2(t,e),this.imod(t.mul(e))},w.prototype.isqr=function(t){return this.imul(t,t.clone())},w.prototype.sqr=function(t){return this.mul(t,t)},w.prototype.sqrt=function(t){if(t.isZero())return t.clone();var e=this.m.andln(3);if(n(e%2==1),3===e){var r=this.m.add(new a(1)).iushrn(2);return this.pow(t,r)}for(var i=this.m.subn(1),o=0;!i.isZero()&&0===i.andln(1);)o++,i.iushrn(1);n(!i.isZero());var s=new a(1).toRed(this),l=s.redNeg(),c=this.m.subn(1).iushrn(1),u=this.m.bitLength();for(u=new a(2*u*u).toRed(this);0!==this.pow(u,c).cmp(l);)u.redIAdd(l);for(var f=this.pow(u,i),h=this.pow(t,i.addn(1).iushrn(1)),p=this.pow(t,i),d=o;0!==p.cmp(s);){for(var g=p,m=0;0!==g.cmp(s);m++)g=g.redSqr();n(m=0;n--){for(var c=e.words[n],u=l-1;u>=0;u--){var f=c>>u&1;i!==r[0]&&(i=this.sqr(i)),0!==f||0!==o?(o<<=1,o|=f,(4===++s||0===n&&0===u)&&(i=this.mul(i,r[o]),s=0,o=0)):s=0}l=26}return i},w.prototype.convertTo=function(t){var e=t.umod(this.m);return e===t?e.clone():e},w.prototype.convertFrom=function(t){var e=t.clone();return e.red=null,e},a.mont=function(t){return new k(t)},i(k,w),k.prototype.convertTo=function(t){return this.imod(t.ushln(this.shift))},k.prototype.convertFrom=function(t){var e=this.imod(t.mul(this.rinv));return e.red=null,e},k.prototype.imul=function(t,e){if(t.isZero()||e.isZero())return t.words[0]=0,t.length=1,t;var r=t.imul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=r.isub(n).iushrn(this.shift),a=i;return i.cmp(this.m)>=0?a=i.isub(this.m):i.cmpn(0)<0&&(a=i.iadd(this.m)),a._forceRed(this)},k.prototype.mul=function(t,e){if(t.isZero()||e.isZero())return new a(0)._forceRed(this);var r=t.mul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=r.isub(n).iushrn(this.shift),o=i;return i.cmp(this.m)>=0?o=i.isub(this.m):i.cmpn(0)<0&&(o=i.iadd(this.m)),o._forceRed(this)},k.prototype.invm=function(t){return this.imod(t._invmp(this.m).mul(this.r2))._forceRed(this)}}(void 0===e||e,this)},{buffer:85}],77:[function(t,e,r){"use strict";e.exports=function(t){var e,r,n,i=t.length,a=0;for(e=0;e>>1;if(!(u<=0)){var f,h=i.mallocDouble(2*u*s),p=i.mallocInt32(s);if((s=l(t,u,h,p))>0){if(1===u&&n)a.init(s),f=a.sweepComplete(u,r,0,s,h,p,0,s,h,p);else{var d=i.mallocDouble(2*u*c),g=i.mallocInt32(c);(c=l(e,u,d,g))>0&&(a.init(s+c),f=1===u?a.sweepBipartite(u,r,0,s,h,p,0,c,d,g):o(u,r,n,s,h,p,c,d,g),i.free(d),i.free(g))}i.free(h),i.free(p)}return f}}}function u(t,e){n.push([t,e])}},{"./lib/intersect":80,"./lib/sweep":84,"typedarray-pool":481}],79:[function(t,e,r){"use strict";var n="d",i="ax",a="vv",o="fp",s="es",l="rs",c="re",u="rb",f="ri",h="rp",p="bs",d="be",g="bb",m="bi",v="bp",y="rv",x="Q",b=[n,i,a,l,c,u,f,p,d,g,m];function _(t){var e="bruteForce"+(t?"Full":"Partial"),r=[],_=b.slice();t||_.splice(3,0,o);var w=["function "+e+"("+_.join()+"){"];function k(e,o){var _=function(t,e,r){var o="bruteForce"+(t?"Red":"Blue")+(e?"Flip":"")+(r?"Full":""),_=["function ",o,"(",b.join(),"){","var ",s,"=2*",n,";"],w="for(var i="+l+","+h+"="+s+"*"+l+";i<"+c+";++i,"+h+"+="+s+"){var x0="+u+"["+i+"+"+h+"],x1="+u+"["+i+"+"+h+"+"+n+"],xi="+f+"[i];",k="for(var j="+p+","+v+"="+s+"*"+p+";j<"+d+";++j,"+v+"+="+s+"){var y0="+g+"["+i+"+"+v+"],"+(r?"y1="+g+"["+i+"+"+v+"+"+n+"],":"")+"yi="+m+"[j];";return t?_.push(w,x,":",k):_.push(k,x,":",w),r?_.push("if(y1"+d+"-"+p+"){"),t?(k(!0,!1),w.push("}else{"),k(!1,!1)):(w.push("if("+o+"){"),k(!0,!0),w.push("}else{"),k(!0,!1),w.push("}}else{if("+o+"){"),k(!1,!0),w.push("}else{"),k(!1,!1),w.push("}")),w.push("}}return "+e);var M=r.join("")+w.join("");return new Function(M)()}r.partial=_(!1),r.full=_(!0)},{}],80:[function(t,e,r){"use strict";e.exports=function(t,e,r,a,u,S,C,E,L){!function(t,e){var r=8*i.log2(e+1)*(t+1)|0,a=i.nextPow2(b*r);w.length0;){var O=(P-=1)*b,I=w[O],R=w[O+1],B=w[O+2],F=w[O+3],N=w[O+4],j=w[O+5],V=P*_,U=k[V],q=k[V+1],H=1&j,G=!!(16&j),W=u,Y=S,X=E,Z=L;if(H&&(W=E,Y=L,X=u,Z=S),!(2&j&&(B=m(t,I,R,B,W,Y,q),R>=B)||4&j&&(R=v(t,I,R,B,W,Y,U))>=B)){var J=B-R,K=N-F;if(G){if(t*J*(J+K)=p0)&&!(p1>=hi)",["p0","p1"]),g=u("lo===p0",["p0"]),m=u("lo>>1,h=2*t,p=f,d=s[h*f+e];for(;c=x?(p=y,d=x):v>=_?(p=m,d=v):(p=b,d=_):x>=_?(p=y,d=x):_>=v?(p=m,d=v):(p=b,d=_);for(var w=h*(u-1),k=h*p,M=0;Mr&&i[f+e]>c;--u,f-=o){for(var h=f,p=f+o,d=0;d=0&&i.push("lo=e[k+n]");t.indexOf("hi")>=0&&i.push("hi=e[k+o]");return r.push(n.replace("_",i.join()).replace("$",t)),Function.apply(void 0,r)};var n="for(var j=2*a,k=j*c,l=k,m=c,n=b,o=a+b,p=c;d>p;++p,k+=j){var _;if($)if(m===p)m+=1,l+=j;else{for(var s=0;j>s;++s){var t=e[k+s];e[k+s]=e[l],e[l++]=t}var u=f[p];f[p]=f[m],f[m++]=u}}return m"},{}],83:[function(t,e,r){"use strict";e.exports=function(t,e){e<=4*n?i(0,e-1,t):function t(e,r,f){var h=(r-e+1)/6|0,p=e+h,d=r-h,g=e+r>>1,m=g-h,v=g+h,y=p,x=m,b=g,_=v,w=d,k=e+1,M=r-1,A=0;c(y,x,f)&&(A=y,y=x,x=A);c(_,w,f)&&(A=_,_=w,w=A);c(y,b,f)&&(A=y,y=b,b=A);c(x,b,f)&&(A=x,x=b,b=A);c(y,_,f)&&(A=y,y=_,_=A);c(b,_,f)&&(A=b,b=_,_=A);c(x,w,f)&&(A=x,x=w,w=A);c(x,b,f)&&(A=x,x=b,b=A);c(_,w,f)&&(A=_,_=w,w=A);var T=f[2*x];var S=f[2*x+1];var C=f[2*_];var E=f[2*_+1];var L=2*y;var z=2*b;var P=2*w;var D=2*p;var O=2*g;var I=2*d;for(var R=0;R<2;++R){var B=f[L+R],F=f[z+R],N=f[P+R];f[D+R]=B,f[O+R]=F,f[I+R]=N}o(m,e,f);o(v,r,f);for(var j=k;j<=M;++j)if(u(j,T,S,f))j!==k&&a(j,k,f),++k;else if(!u(j,C,E,f))for(;;){if(u(M,C,E,f)){u(M,T,S,f)?(s(j,k,M,f),++k,--M):(a(j,M,f),--M);break}if(--Mt;){var c=r[l-2],u=r[l-1];if(cr[e+1])}function u(t,e,r,n){var i=n[t*=2];return i>>1;a(p,S);for(var C=0,E=0,k=0;k=o)d(c,u,E--,L=L-o|0);else if(L>=0)d(s,l,C--,L);else if(L<=-o){L=-L-o|0;for(var z=0;z>>1;a(p,C);for(var E=0,L=0,z=0,M=0;M>1==p[2*M+3]>>1&&(D=2,M+=1),P<0){for(var O=-(P>>1)-1,I=0;I>1)-1;0===D?d(s,l,E--,O):1===D?d(c,u,L--,O):2===D&&d(f,h,z--,O)}}},scanBipartite:function(t,e,r,n,i,c,u,f,h,m,v,y){var x=0,b=2*t,_=e,w=e+t,k=1,M=1;n?M=o:k=o;for(var A=i;A>>1;a(p,E);for(var L=0,A=0;A=o?(P=!n,T-=o):(P=!!n,T-=1),P)g(s,l,L++,T);else{var D=y[T],O=b*T,I=v[O+e+1],R=v[O+e+1+t];t:for(var B=0;B>>1;a(p,k);for(var M=0,x=0;x=o)s[M++]=b-o;else{var T=d[b-=1],S=m*b,C=h[S+e+1],E=h[S+e+1+t];t:for(var L=0;L=0;--L)if(s[L]===b){for(var O=L+1;Oa)throw new RangeError("Invalid typed array length");var e=new Uint8Array(t);return e.__proto__=s.prototype,e}function s(t,e,r){if("number"==typeof t){if("string"==typeof e)throw new Error("If encoding is specified then the first argument must be a string");return u(t)}return l(t,e,r)}function l(t,e,r){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return j(t)||t&&j(t.buffer)?function(t,e,r){if(e<0||t.byteLength=a)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a.toString(16)+" bytes");return 0|t}function p(t,e){if(s.isBuffer(t))return t.length;if(ArrayBuffer.isView(t)||j(t))return t.byteLength;"string"!=typeof t&&(t=""+t);var r=t.length;if(0===r)return 0;for(var n=!1;;)switch(e){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return B(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return F(t).length;default:if(n)return B(t).length;e=(""+e).toLowerCase(),n=!0}}function d(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function g(t,e,r,n,i){if(0===t.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),V(r=+r)&&(r=i?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(i)return-1;r=t.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof e&&(e=s.from(e,n)),s.isBuffer(e))return 0===e.length?-1:m(t,e,r,n,i);if("number"==typeof e)return e&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):m(t,[e],r,n,i);throw new TypeError("val must be string, number or Buffer")}function m(t,e,r,n,i){var a,o=1,s=t.length,l=e.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(t.length<2||e.length<2)return-1;o=2,s/=2,l/=2,r/=2}function c(t,e){return 1===o?t[e]:t.readUInt16BE(e*o)}if(i){var u=-1;for(a=r;as&&(r=s-l),a=r;a>=0;a--){for(var f=!0,h=0;hi&&(n=i):n=i;var a=e.length;n>a/2&&(n=a/2);for(var o=0;o>8,i=r%256,a.push(i),a.push(n);return a}(e,t.length-r),t,r,n)}function k(t,e,r){return 0===e&&r===t.length?n.fromByteArray(t):n.fromByteArray(t.slice(e,r))}function M(t,e,r){r=Math.min(t.length,r);for(var n=[],i=e;i239?4:c>223?3:c>191?2:1;if(i+f<=r)switch(f){case 1:c<128&&(u=c);break;case 2:128==(192&(a=t[i+1]))&&(l=(31&c)<<6|63&a)>127&&(u=l);break;case 3:a=t[i+1],o=t[i+2],128==(192&a)&&128==(192&o)&&(l=(15&c)<<12|(63&a)<<6|63&o)>2047&&(l<55296||l>57343)&&(u=l);break;case 4:a=t[i+1],o=t[i+2],s=t[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&(l=(15&c)<<18|(63&a)<<12|(63&o)<<6|63&s)>65535&&l<1114112&&(u=l)}null===u?(u=65533,f=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|1023&u),n.push(u),i+=f}return function(t){var e=t.length;if(e<=A)return String.fromCharCode.apply(String,t);var r="",n=0;for(;nthis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(e>>>=0))return"";for(t||(t="utf8");;)switch(t){case"hex":return C(this,e,r);case"utf8":case"utf-8":return M(this,e,r);case"ascii":return T(this,e,r);case"latin1":case"binary":return S(this,e,r);case"base64":return k(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return E(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}.apply(this,arguments)},s.prototype.toLocaleString=s.prototype.toString,s.prototype.equals=function(t){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");return this===t||0===s.compare(this,t)},s.prototype.inspect=function(){var t="",e=r.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString("hex",0,e).match(/.{2}/g).join(" "),this.length>e&&(t+=" ... ")),""},s.prototype.compare=function(t,e,r,n,i){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");if(void 0===e&&(e=0),void 0===r&&(r=t?t.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),e<0||r>t.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&e>=r)return 0;if(n>=i)return-1;if(e>=r)return 1;if(e>>>=0,r>>>=0,n>>>=0,i>>>=0,this===t)return 0;for(var a=i-n,o=r-e,l=Math.min(a,o),c=this.slice(n,i),u=t.slice(e,r),f=0;f>>=0,isFinite(r)?(r>>>=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var i=this.length-e;if((void 0===r||r>i)&&(r=i),t.length>0&&(r<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var a=!1;;)switch(n){case"hex":return v(this,t,e,r);case"utf8":case"utf-8":return y(this,t,e,r);case"ascii":return x(this,t,e,r);case"latin1":case"binary":return b(this,t,e,r);case"base64":return _(this,t,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return w(this,t,e,r);default:if(a)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),a=!0}},s.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var A=4096;function T(t,e,r){var n="";r=Math.min(t.length,r);for(var i=e;in)&&(r=n);for(var i="",a=e;ar)throw new RangeError("Trying to access beyond buffer length")}function z(t,e,r,n,i,a){if(!s.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>i||et.length)throw new RangeError("Index out of range")}function P(t,e,r,n,i,a){if(r+n>t.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function D(t,e,r,n,a){return e=+e,r>>>=0,a||P(t,0,r,4),i.write(t,e,r,n,23,4),r+4}function O(t,e,r,n,a){return e=+e,r>>>=0,a||P(t,0,r,8),i.write(t,e,r,n,52,8),r+8}s.prototype.slice=function(t,e){var r=this.length;t=~~t,e=void 0===e?r:~~e,t<0?(t+=r)<0&&(t=0):t>r&&(t=r),e<0?(e+=r)<0&&(e=0):e>r&&(e=r),e>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t],i=1,a=0;++a>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t+--e],i=1;e>0&&(i*=256);)n+=this[t+--e]*i;return n},s.prototype.readUInt8=function(t,e){return t>>>=0,e||L(t,1,this.length),this[t]},s.prototype.readUInt16LE=function(t,e){return t>>>=0,e||L(t,2,this.length),this[t]|this[t+1]<<8},s.prototype.readUInt16BE=function(t,e){return t>>>=0,e||L(t,2,this.length),this[t]<<8|this[t+1]},s.prototype.readUInt32LE=function(t,e){return t>>>=0,e||L(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},s.prototype.readUInt32BE=function(t,e){return t>>>=0,e||L(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},s.prototype.readIntLE=function(t,e,r){t>>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t],i=1,a=0;++a=(i*=128)&&(n-=Math.pow(2,8*e)),n},s.prototype.readIntBE=function(t,e,r){t>>>=0,e>>>=0,r||L(t,e,this.length);for(var n=e,i=1,a=this[t+--n];n>0&&(i*=256);)a+=this[t+--n]*i;return a>=(i*=128)&&(a-=Math.pow(2,8*e)),a},s.prototype.readInt8=function(t,e){return t>>>=0,e||L(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},s.prototype.readInt16LE=function(t,e){t>>>=0,e||L(t,2,this.length);var r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt16BE=function(t,e){t>>>=0,e||L(t,2,this.length);var r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt32LE=function(t,e){return t>>>=0,e||L(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},s.prototype.readInt32BE=function(t,e){return t>>>=0,e||L(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},s.prototype.readFloatLE=function(t,e){return t>>>=0,e||L(t,4,this.length),i.read(this,t,!0,23,4)},s.prototype.readFloatBE=function(t,e){return t>>>=0,e||L(t,4,this.length),i.read(this,t,!1,23,4)},s.prototype.readDoubleLE=function(t,e){return t>>>=0,e||L(t,8,this.length),i.read(this,t,!0,52,8)},s.prototype.readDoubleBE=function(t,e){return t>>>=0,e||L(t,8,this.length),i.read(this,t,!1,52,8)},s.prototype.writeUIntLE=function(t,e,r,n){(t=+t,e>>>=0,r>>>=0,n)||z(this,t,e,r,Math.pow(2,8*r)-1,0);var i=1,a=0;for(this[e]=255&t;++a>>=0,r>>>=0,n)||z(this,t,e,r,Math.pow(2,8*r)-1,0);var i=r-1,a=1;for(this[e+i]=255&t;--i>=0&&(a*=256);)this[e+i]=t/a&255;return e+r},s.prototype.writeUInt8=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,1,255,0),this[e]=255&t,e+1},s.prototype.writeUInt16LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,65535,0),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeUInt16BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,65535,0),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeUInt32LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,4294967295,0),this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t,e+4},s.prototype.writeUInt32BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,4294967295,0),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e>>>=0,!n){var i=Math.pow(2,8*r-1);z(this,t,e,r,i-1,-i)}var a=0,o=1,s=0;for(this[e]=255&t;++a>0)-s&255;return e+r},s.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e>>>=0,!n){var i=Math.pow(2,8*r-1);z(this,t,e,r,i-1,-i)}var a=r-1,o=1,s=0;for(this[e+a]=255&t;--a>=0&&(o*=256);)t<0&&0===s&&0!==this[e+a+1]&&(s=1),this[e+a]=(t/o>>0)-s&255;return e+r},s.prototype.writeInt8=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,1,127,-128),t<0&&(t=255+t+1),this[e]=255&t,e+1},s.prototype.writeInt16LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,32767,-32768),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeInt16BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,32767,-32768),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeInt32LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,2147483647,-2147483648),this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24,e+4},s.prototype.writeInt32BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeFloatLE=function(t,e,r){return D(this,t,e,!0,r)},s.prototype.writeFloatBE=function(t,e,r){return D(this,t,e,!1,r)},s.prototype.writeDoubleLE=function(t,e,r){return O(this,t,e,!0,r)},s.prototype.writeDoubleBE=function(t,e,r){return O(this,t,e,!1,r)},s.prototype.copy=function(t,e,r,n){if(!s.isBuffer(t))throw new TypeError("argument should be a Buffer");if(r||(r=0),n||0===n||(n=this.length),e>=t.length&&(e=t.length),e||(e=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),t.length-e=0;--a)t[a+e]=this[a+r];else Uint8Array.prototype.set.call(t,this.subarray(r,n),e);return i},s.prototype.fill=function(t,e,r,n){if("string"==typeof t){if("string"==typeof e?(n=e,e=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!s.isEncoding(n))throw new TypeError("Unknown encoding: "+n);if(1===t.length){var i=t.charCodeAt(0);("utf8"===n&&i<128||"latin1"===n)&&(t=i)}}else"number"==typeof t&&(t&=255);if(e<0||this.length>>=0,r=void 0===r?this.length:r>>>0,t||(t=0),"number"==typeof t)for(a=e;a55295&&r<57344){if(!i){if(r>56319){(e-=3)>-1&&a.push(239,191,189);continue}if(o+1===n){(e-=3)>-1&&a.push(239,191,189);continue}i=r;continue}if(r<56320){(e-=3)>-1&&a.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(e-=3)>-1&&a.push(239,191,189);if(i=null,r<128){if((e-=1)<0)break;a.push(r)}else if(r<2048){if((e-=2)<0)break;a.push(r>>6|192,63&r|128)}else if(r<65536){if((e-=3)<0)break;a.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;a.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return a}function F(t){return n.toByteArray(function(t){if((t=(t=t.split("=")[0]).trim().replace(I,"")).length<2)return"";for(;t.length%4!=0;)t+="=";return t}(t))}function N(t,e,r,n){for(var i=0;i=e.length||i>=t.length);++i)e[i+r]=t[i];return i}function j(t){return t instanceof ArrayBuffer||null!=t&&null!=t.constructor&&"ArrayBuffer"===t.constructor.name&&"number"==typeof t.byteLength}function V(t){return t!=t}},{"base64-js":56,ieee754:356}],87:[function(t,e,r){"use strict";var n=t("./lib/monotone"),i=t("./lib/triangulation"),a=t("./lib/delaunay"),o=t("./lib/filter");function s(t){return[Math.min(t[0],t[1]),Math.max(t[0],t[1])]}function l(t,e){return t[0]-e[0]||t[1]-e[1]}function c(t,e,r){return e in t?t[e]:r}e.exports=function(t,e,r){Array.isArray(e)?(r=r||{},e=e||[]):(r=e||{},e=[]);var u=!!c(r,"delaunay",!0),f=!!c(r,"interior",!0),h=!!c(r,"exterior",!0),p=!!c(r,"infinity",!1);if(!f&&!h||0===t.length)return[];var d=n(t,e);if(u||f!==h||p){for(var g=i(t.length,function(t){return t.map(s).sort(l)}(e)),m=0;m0;){for(var u=r.pop(),s=r.pop(),f=-1,h=-1,l=o[s],d=1;d=0||(e.flip(s,u),i(t,e,r,f,s,h),i(t,e,r,s,h,f),i(t,e,r,h,u,f),i(t,e,r,u,f,h)))}}},{"binary-search-bounds":92,"robust-in-sphere":444}],89:[function(t,e,r){"use strict";var n,i=t("binary-search-bounds");function a(t,e,r,n,i,a,o){this.cells=t,this.neighbor=e,this.flags=n,this.constraint=r,this.active=i,this.next=a,this.boundary=o}function o(t,e){return t[0]-e[0]||t[1]-e[1]||t[2]-e[2]}e.exports=function(t,e,r){var n=function(t,e){for(var r=t.cells(),n=r.length,i=0;i0||l.length>0;){for(;s.length>0;){var p=s.pop();if(c[p]!==-i){c[p]=i;u[p];for(var d=0;d<3;++d){var g=h[3*p+d];g>=0&&0===c[g]&&(f[3*p+d]?l.push(g):(s.push(g),c[g]=i))}}}var m=l;l=s,s=m,l.length=0,i=-i}var v=function(t,e,r){for(var n=0,i=0;i1&&i(r[h[p-2]],r[h[p-1]],a)>0;)t.push([h[p-1],h[p-2],o]),p-=1;h.length=p,h.push(o);var d=u.upperIds;for(p=d.length;p>1&&i(r[d[p-2]],r[d[p-1]],a)<0;)t.push([d[p-2],d[p-1],o]),p-=1;d.length=p,d.push(o)}}function p(t,e){var r;return(r=t.a[0]v[0]&&i.push(new c(v,m,s,f),new c(m,v,o,f))}i.sort(u);for(var y=i[0].a[0]-(1+Math.abs(i[0].a[0]))*Math.pow(2,-52),x=[new l([y,1],[y,0],-1,[],[],[],[])],b=[],f=0,_=i.length;f<_;++f){var w=i[f],k=w.type;k===a?h(b,x,t,w.a,w.idx):k===s?d(x,t,w):g(x,t,w)}return b}},{"binary-search-bounds":92,"robust-orientation":446}],91:[function(t,e,r){"use strict";var n=t("binary-search-bounds");function i(t,e){this.stars=t,this.edges=e}e.exports=function(t,e){for(var r=new Array(t),n=0;n=0}}(),a.removeTriangle=function(t,e,r){var n=this.stars;o(n[t],e,r),o(n[e],r,t),o(n[r],t,e)},a.addTriangle=function(t,e,r){var n=this.stars;n[t].push(e,r),n[e].push(r,t),n[r].push(t,e)},a.opposite=function(t,e){for(var r=this.stars[e],n=1,i=r.length;n>>1,x=a[m]"];return i?e.indexOf("c")<0?a.push(";if(x===y){return m}else if(x<=y){"):a.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){"):a.push(";if(",e,"){i=m;"),r?a.push("l=m+1}else{h=m-1}"):a.push("h=m-1}else{l=m+1}"),a.push("}"),i?a.push("return -1};"):a.push("return i};"),a.join("")}function i(t,e,r,i){return new Function([n("A","x"+t+"y",e,["y"],i),n("P","c(x,y)"+t+"0",e,["y","c"],i),"function dispatchBsearch",r,"(a,y,c,l,h){if(typeof(c)==='function'){return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)}else{return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)}}return dispatchBsearch",r].join(""))()}e.exports={ge:i(">=",!1,"GE"),gt:i(">",!1,"GT"),lt:i("<",!0,"LT"),le:i("<=",!0,"LE"),eq:i("-",!0,"EQ",!0)}},{}],93:[function(t,e,r){"use strict";e.exports=function(t){for(var e=1,r=1;rr?r:t:te?e:t}},{}],97:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n;if(r){n=e;for(var i=new Array(e.length),a=0;ae[2]?1:0)}function v(t,e,r){if(0!==t.length){if(e)for(var n=0;n=0;--a){var x=e[u=(S=n[a])[0]],b=x[0],_=x[1],w=t[b],k=t[_];if((w[0]-k[0]||w[1]-k[1])<0){var M=b;b=_,_=M}x[0]=b;var A,T=x[1]=S[1];for(i&&(A=x[2]);a>0&&n[a-1][0]===u;){var S,C=(S=n[--a])[1];i?e.push([T,C,A]):e.push([T,C]),T=C}i?e.push([T,_,A]):e.push([T,_])}return h}(t,e,h,m,r));return v(e,y,r),!!y||(h.length>0||m.length>0)}},{"./lib/rat-seg-intersect":98,"big-rat":60,"big-rat/cmp":58,"big-rat/to-float":72,"box-intersect":78,nextafter:394,"rat-vec":428,"robust-segment-intersect":449,"union-find":482}],98:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var a=s(e,t),f=s(n,r),h=u(a,f);if(0===o(h))return null;var p=s(t,r),d=u(f,p),g=i(d,h),m=c(a,g);return l(t,m)};var n=t("big-rat/mul"),i=t("big-rat/div"),a=t("big-rat/sub"),o=t("big-rat/sign"),s=t("rat-vec/sub"),l=t("rat-vec/add"),c=t("rat-vec/muls");function u(t,e){return a(n(t[0],e[1]),n(t[1],e[0]))}},{"big-rat/div":59,"big-rat/mul":69,"big-rat/sign":70,"big-rat/sub":71,"rat-vec/add":427,"rat-vec/muls":429,"rat-vec/sub":430}],99:[function(t,e,r){"use strict";var n=t("clamp");function i(t,e){null==e&&(e=!0);var r=t[0],i=t[1],a=t[2],o=t[3];return null==o&&(o=e?1:255),e&&(r*=255,i*=255,a*=255,o*=255),16777216*(r=255&n(r,0,255))+((i=255&n(i,0,255))<<16)+((a=255&n(a,0,255))<<8)+(o=255&n(o,0,255))}e.exports=i,e.exports.to=i,e.exports.from=function(t,e){var r=(t=+t)>>>24,n=(16711680&t)>>>16,i=(65280&t)>>>8,a=255&t;return!1===e?[r,n,i,a]:[r/255,n/255,i/255,a/255]}},{clamp:96}],100:[function(t,e,r){"use strict";e.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}},{}],101:[function(t,e,r){"use strict";var n=t("color-rgba"),i=t("clamp"),a=t("dtype");e.exports=function(t,e){"float"!==e&&e||(e="array"),"uint"===e&&(e="uint8"),"uint_clamped"===e&&(e="uint8_clamped");var r=a(e),o=new r(4);if(t instanceof r)return Array.isArray(t)?t.slice():(o.set(t),o);var s="uint8"!==e&&"uint8_clamped"!==e;return t instanceof Uint8Array||t instanceof Uint8ClampedArray?(o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=null!=t[3]?t[3]:255,s&&(o[0]/=255,o[1]/=255,o[2]/=255,o[3]/=255),o):(t.length&&"string"!=typeof t||((t=n(t))[0]/=255,t[1]/=255,t[2]/=255),s?(o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=null!=t[3]?t[3]:1):(o[0]=i(Math.round(255*t[0]),0,255),o[1]=i(Math.round(255*t[1]),0,255),o[2]=i(Math.round(255*t[2]),0,255),o[3]=null==t[3]?255:i(Math.floor(255*t[3]),0,255)),o)}},{clamp:96,"color-rgba":103,dtype:136}],102:[function(t,e,r){(function(r){"use strict";var n=t("color-name"),i=t("is-plain-obj"),a=t("defined");e.exports=function(t){var e,s,l=[],c=1;if("string"==typeof t)if(n[t])l=n[t].slice(),s="rgb";else if("transparent"===t)c=0,s="rgb",l=[0,0,0];else if(/^#[A-Fa-f0-9]+$/.test(t)){var u=t.slice(1),f=u.length,h=f<=4;c=1,h?(l=[parseInt(u[0]+u[0],16),parseInt(u[1]+u[1],16),parseInt(u[2]+u[2],16)],4===f&&(c=parseInt(u[3]+u[3],16)/255)):(l=[parseInt(u[0]+u[1],16),parseInt(u[2]+u[3],16),parseInt(u[4]+u[5],16)],8===f&&(c=parseInt(u[6]+u[7],16)/255)),l[0]||(l[0]=0),l[1]||(l[1]=0),l[2]||(l[2]=0),s="rgb"}else if(e=/^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(t)){var p=e[1],u=p.replace(/a$/,"");s=u;var f="cmyk"===u?4:"gray"===u?1:3;l=e[2].trim().split(/\s*,\s*/).map(function(t,e){if(/%$/.test(t))return e===f?parseFloat(t)/100:"rgb"===u?255*parseFloat(t)/100:parseFloat(t);if("h"===u[e]){if(/deg$/.test(t))return parseFloat(t);if(void 0!==o[t])return o[t]}return parseFloat(t)}),p===u&&l.push(1),c=void 0===l[f]?1:l[f],l=l.slice(0,f)}else t.length>10&&/[0-9](?:\s|\/)/.test(t)&&(l=t.match(/([0-9]+)/g).map(function(t){return parseFloat(t)}),s=t.match(/([a-z])/gi).join("").toLowerCase());else if("number"==typeof t)s="rgb",l=[t>>>16,(65280&t)>>>8,255&t];else if(i(t)){var d=a(t.r,t.red,t.R,null);null!==d?(s="rgb",l=[d,a(t.g,t.green,t.G),a(t.b,t.blue,t.B)]):(s="hsl",l=[a(t.h,t.hue,t.H),a(t.s,t.saturation,t.S),a(t.l,t.lightness,t.L,t.b,t.brightness)]),c=a(t.a,t.alpha,t.opacity,1),null!=t.opacity&&(c/=100)}else(Array.isArray(t)||r.ArrayBuffer&&ArrayBuffer.isView&&ArrayBuffer.isView(t))&&(l=[t[0],t[1],t[2]],s="rgb",c=4===t.length?t[3]:1);return{space:s,values:l,alpha:c}};var o={red:0,orange:60,yellow:120,green:180,blue:240,purple:300}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"color-name":100,defined:132,"is-plain-obj":366}],103:[function(t,e,r){"use strict";var n=t("color-parse"),i=t("color-space/hsl"),a=t("clamp");e.exports=function(t){var e;if("string"!=typeof t)throw Error("Argument should be a string");var r=n(t);return r.space?((e=Array(3))[0]=a(r.values[0],0,255),e[1]=a(r.values[1],0,255),e[2]=a(r.values[2],0,255),"h"===r.space[0]&&(e=i.rgb(e)),e.push(a(r.alpha,0,1)),e):[]}},{clamp:96,"color-parse":102,"color-space/hsl":104}],104:[function(t,e,r){"use strict";var n=t("./rgb");e.exports={name:"hsl",min:[0,0,0],max:[360,100,100],channel:["hue","saturation","lightness"],alias:["HSL"],rgb:function(t){var e,r,n,i,a,o=t[0]/360,s=t[1]/100,l=t[2]/100;if(0===s)return[a=255*l,a,a];e=2*l-(r=l<.5?l*(1+s):l+s-l*s),i=[0,0,0];for(var c=0;c<3;c++)(n=o+1/3*-(c-1))<0?n++:n>1&&n--,a=6*n<1?e+6*(r-e)*n:2*n<1?r:3*n<2?e+(r-e)*(2/3-n)*6:e,i[c]=255*a;return i}},n.hsl=function(t){var e,r,n=t[0]/255,i=t[1]/255,a=t[2]/255,o=Math.min(n,i,a),s=Math.max(n,i,a),l=s-o;return s===o?e=0:n===s?e=(i-a)/l:i===s?e=2+(a-n)/l:a===s&&(e=4+(n-i)/l),(e=Math.min(60*e,360))<0&&(e+=360),r=(o+s)/2,[e,100*(s===o?0:r<=.5?l/(s+o):l/(2-s-o)),100*r]}},{"./rgb":105}],105:[function(t,e,r){"use strict";e.exports={name:"rgb",min:[0,0,0],max:[255,255,255],channel:["red","green","blue"],alias:["RGB"]}},{}],106:[function(t,e,r){e.exports={jet:[{index:0,rgb:[0,0,131]},{index:.125,rgb:[0,60,170]},{index:.375,rgb:[5,255,255]},{index:.625,rgb:[255,255,0]},{index:.875,rgb:[250,0,0]},{index:1,rgb:[128,0,0]}],hsv:[{index:0,rgb:[255,0,0]},{index:.169,rgb:[253,255,2]},{index:.173,rgb:[247,255,2]},{index:.337,rgb:[0,252,4]},{index:.341,rgb:[0,252,10]},{index:.506,rgb:[1,249,255]},{index:.671,rgb:[2,0,253]},{index:.675,rgb:[8,0,253]},{index:.839,rgb:[255,0,251]},{index:.843,rgb:[255,0,245]},{index:1,rgb:[255,0,6]}],hot:[{index:0,rgb:[0,0,0]},{index:.3,rgb:[230,0,0]},{index:.6,rgb:[255,210,0]},{index:1,rgb:[255,255,255]}],cool:[{index:0,rgb:[0,255,255]},{index:1,rgb:[255,0,255]}],spring:[{index:0,rgb:[255,0,255]},{index:1,rgb:[255,255,0]}],summer:[{index:0,rgb:[0,128,102]},{index:1,rgb:[255,255,102]}],autumn:[{index:0,rgb:[255,0,0]},{index:1,rgb:[255,255,0]}],winter:[{index:0,rgb:[0,0,255]},{index:1,rgb:[0,255,128]}],bone:[{index:0,rgb:[0,0,0]},{index:.376,rgb:[84,84,116]},{index:.753,rgb:[169,200,200]},{index:1,rgb:[255,255,255]}],copper:[{index:0,rgb:[0,0,0]},{index:.804,rgb:[255,160,102]},{index:1,rgb:[255,199,127]}],greys:[{index:0,rgb:[0,0,0]},{index:1,rgb:[255,255,255]}],yignbu:[{index:0,rgb:[8,29,88]},{index:.125,rgb:[37,52,148]},{index:.25,rgb:[34,94,168]},{index:.375,rgb:[29,145,192]},{index:.5,rgb:[65,182,196]},{index:.625,rgb:[127,205,187]},{index:.75,rgb:[199,233,180]},{index:.875,rgb:[237,248,217]},{index:1,rgb:[255,255,217]}],greens:[{index:0,rgb:[0,68,27]},{index:.125,rgb:[0,109,44]},{index:.25,rgb:[35,139,69]},{index:.375,rgb:[65,171,93]},{index:.5,rgb:[116,196,118]},{index:.625,rgb:[161,217,155]},{index:.75,rgb:[199,233,192]},{index:.875,rgb:[229,245,224]},{index:1,rgb:[247,252,245]}],yiorrd:[{index:0,rgb:[128,0,38]},{index:.125,rgb:[189,0,38]},{index:.25,rgb:[227,26,28]},{index:.375,rgb:[252,78,42]},{index:.5,rgb:[253,141,60]},{index:.625,rgb:[254,178,76]},{index:.75,rgb:[254,217,118]},{index:.875,rgb:[255,237,160]},{index:1,rgb:[255,255,204]}],bluered:[{index:0,rgb:[0,0,255]},{index:1,rgb:[255,0,0]}],rdbu:[{index:0,rgb:[5,10,172]},{index:.35,rgb:[106,137,247]},{index:.5,rgb:[190,190,190]},{index:.6,rgb:[220,170,132]},{index:.7,rgb:[230,145,90]},{index:1,rgb:[178,10,28]}],picnic:[{index:0,rgb:[0,0,255]},{index:.1,rgb:[51,153,255]},{index:.2,rgb:[102,204,255]},{index:.3,rgb:[153,204,255]},{index:.4,rgb:[204,204,255]},{index:.5,rgb:[255,255,255]},{index:.6,rgb:[255,204,255]},{index:.7,rgb:[255,153,255]},{index:.8,rgb:[255,102,204]},{index:.9,rgb:[255,102,102]},{index:1,rgb:[255,0,0]}],rainbow:[{index:0,rgb:[150,0,90]},{index:.125,rgb:[0,0,200]},{index:.25,rgb:[0,25,255]},{index:.375,rgb:[0,152,255]},{index:.5,rgb:[44,255,150]},{index:.625,rgb:[151,255,0]},{index:.75,rgb:[255,234,0]},{index:.875,rgb:[255,111,0]},{index:1,rgb:[255,0,0]}],portland:[{index:0,rgb:[12,51,131]},{index:.25,rgb:[10,136,186]},{index:.5,rgb:[242,211,56]},{index:.75,rgb:[242,143,56]},{index:1,rgb:[217,30,30]}],blackbody:[{index:0,rgb:[0,0,0]},{index:.2,rgb:[230,0,0]},{index:.4,rgb:[230,210,0]},{index:.7,rgb:[255,255,255]},{index:1,rgb:[160,200,255]}],earth:[{index:0,rgb:[0,0,130]},{index:.1,rgb:[0,180,180]},{index:.2,rgb:[40,210,40]},{index:.4,rgb:[230,230,50]},{index:.6,rgb:[120,70,20]},{index:1,rgb:[255,255,255]}],electric:[{index:0,rgb:[0,0,0]},{index:.15,rgb:[30,0,100]},{index:.4,rgb:[120,0,100]},{index:.6,rgb:[160,90,0]},{index:.8,rgb:[230,200,0]},{index:1,rgb:[255,250,220]}],alpha:[{index:0,rgb:[255,255,255,0]},{index:1,rgb:[255,255,255,1]}],viridis:[{index:0,rgb:[68,1,84]},{index:.13,rgb:[71,44,122]},{index:.25,rgb:[59,81,139]},{index:.38,rgb:[44,113,142]},{index:.5,rgb:[33,144,141]},{index:.63,rgb:[39,173,129]},{index:.75,rgb:[92,200,99]},{index:.88,rgb:[170,220,50]},{index:1,rgb:[253,231,37]}],inferno:[{index:0,rgb:[0,0,4]},{index:.13,rgb:[31,12,72]},{index:.25,rgb:[85,15,109]},{index:.38,rgb:[136,34,106]},{index:.5,rgb:[186,54,85]},{index:.63,rgb:[227,89,51]},{index:.75,rgb:[249,140,10]},{index:.88,rgb:[249,201,50]},{index:1,rgb:[252,255,164]}],magma:[{index:0,rgb:[0,0,4]},{index:.13,rgb:[28,16,68]},{index:.25,rgb:[79,18,123]},{index:.38,rgb:[129,37,129]},{index:.5,rgb:[181,54,122]},{index:.63,rgb:[229,80,100]},{index:.75,rgb:[251,135,97]},{index:.88,rgb:[254,194,135]},{index:1,rgb:[252,253,191]}],plasma:[{index:0,rgb:[13,8,135]},{index:.13,rgb:[75,3,161]},{index:.25,rgb:[125,3,168]},{index:.38,rgb:[168,34,150]},{index:.5,rgb:[203,70,121]},{index:.63,rgb:[229,107,93]},{index:.75,rgb:[248,148,65]},{index:.88,rgb:[253,195,40]},{index:1,rgb:[240,249,33]}],warm:[{index:0,rgb:[125,0,179]},{index:.13,rgb:[172,0,187]},{index:.25,rgb:[219,0,170]},{index:.38,rgb:[255,0,130]},{index:.5,rgb:[255,63,74]},{index:.63,rgb:[255,123,0]},{index:.75,rgb:[234,176,0]},{index:.88,rgb:[190,228,0]},{index:1,rgb:[147,255,0]}],cool:[{index:0,rgb:[125,0,179]},{index:.13,rgb:[116,0,218]},{index:.25,rgb:[98,74,237]},{index:.38,rgb:[68,146,231]},{index:.5,rgb:[0,204,197]},{index:.63,rgb:[0,247,146]},{index:.75,rgb:[0,255,88]},{index:.88,rgb:[40,255,8]},{index:1,rgb:[147,255,0]}],"rainbow-soft":[{index:0,rgb:[125,0,179]},{index:.1,rgb:[199,0,180]},{index:.2,rgb:[255,0,121]},{index:.3,rgb:[255,108,0]},{index:.4,rgb:[222,194,0]},{index:.5,rgb:[150,255,0]},{index:.6,rgb:[0,255,55]},{index:.7,rgb:[0,246,150]},{index:.8,rgb:[50,167,222]},{index:.9,rgb:[103,51,235]},{index:1,rgb:[124,0,186]}],bathymetry:[{index:0,rgb:[40,26,44]},{index:.13,rgb:[59,49,90]},{index:.25,rgb:[64,76,139]},{index:.38,rgb:[63,110,151]},{index:.5,rgb:[72,142,158]},{index:.63,rgb:[85,174,163]},{index:.75,rgb:[120,206,163]},{index:.88,rgb:[187,230,172]},{index:1,rgb:[253,254,204]}],cdom:[{index:0,rgb:[47,15,62]},{index:.13,rgb:[87,23,86]},{index:.25,rgb:[130,28,99]},{index:.38,rgb:[171,41,96]},{index:.5,rgb:[206,67,86]},{index:.63,rgb:[230,106,84]},{index:.75,rgb:[242,149,103]},{index:.88,rgb:[249,193,135]},{index:1,rgb:[254,237,176]}],chlorophyll:[{index:0,rgb:[18,36,20]},{index:.13,rgb:[25,63,41]},{index:.25,rgb:[24,91,59]},{index:.38,rgb:[13,119,72]},{index:.5,rgb:[18,148,80]},{index:.63,rgb:[80,173,89]},{index:.75,rgb:[132,196,122]},{index:.88,rgb:[175,221,162]},{index:1,rgb:[215,249,208]}],density:[{index:0,rgb:[54,14,36]},{index:.13,rgb:[89,23,80]},{index:.25,rgb:[110,45,132]},{index:.38,rgb:[120,77,178]},{index:.5,rgb:[120,113,213]},{index:.63,rgb:[115,151,228]},{index:.75,rgb:[134,185,227]},{index:.88,rgb:[177,214,227]},{index:1,rgb:[230,241,241]}],"freesurface-blue":[{index:0,rgb:[30,4,110]},{index:.13,rgb:[47,14,176]},{index:.25,rgb:[41,45,236]},{index:.38,rgb:[25,99,212]},{index:.5,rgb:[68,131,200]},{index:.63,rgb:[114,156,197]},{index:.75,rgb:[157,181,203]},{index:.88,rgb:[200,208,216]},{index:1,rgb:[241,237,236]}],"freesurface-red":[{index:0,rgb:[60,9,18]},{index:.13,rgb:[100,17,27]},{index:.25,rgb:[142,20,29]},{index:.38,rgb:[177,43,27]},{index:.5,rgb:[192,87,63]},{index:.63,rgb:[205,125,105]},{index:.75,rgb:[216,162,148]},{index:.88,rgb:[227,199,193]},{index:1,rgb:[241,237,236]}],oxygen:[{index:0,rgb:[64,5,5]},{index:.13,rgb:[106,6,15]},{index:.25,rgb:[144,26,7]},{index:.38,rgb:[168,64,3]},{index:.5,rgb:[188,100,4]},{index:.63,rgb:[206,136,11]},{index:.75,rgb:[220,174,25]},{index:.88,rgb:[231,215,44]},{index:1,rgb:[248,254,105]}],par:[{index:0,rgb:[51,20,24]},{index:.13,rgb:[90,32,35]},{index:.25,rgb:[129,44,34]},{index:.38,rgb:[159,68,25]},{index:.5,rgb:[182,99,19]},{index:.63,rgb:[199,134,22]},{index:.75,rgb:[212,171,35]},{index:.88,rgb:[221,210,54]},{index:1,rgb:[225,253,75]}],phase:[{index:0,rgb:[145,105,18]},{index:.13,rgb:[184,71,38]},{index:.25,rgb:[186,58,115]},{index:.38,rgb:[160,71,185]},{index:.5,rgb:[110,97,218]},{index:.63,rgb:[50,123,164]},{index:.75,rgb:[31,131,110]},{index:.88,rgb:[77,129,34]},{index:1,rgb:[145,105,18]}],salinity:[{index:0,rgb:[42,24,108]},{index:.13,rgb:[33,50,162]},{index:.25,rgb:[15,90,145]},{index:.38,rgb:[40,118,137]},{index:.5,rgb:[59,146,135]},{index:.63,rgb:[79,175,126]},{index:.75,rgb:[120,203,104]},{index:.88,rgb:[193,221,100]},{index:1,rgb:[253,239,154]}],temperature:[{index:0,rgb:[4,35,51]},{index:.13,rgb:[23,51,122]},{index:.25,rgb:[85,59,157]},{index:.38,rgb:[129,79,143]},{index:.5,rgb:[175,95,130]},{index:.63,rgb:[222,112,101]},{index:.75,rgb:[249,146,66]},{index:.88,rgb:[249,196,65]},{index:1,rgb:[232,250,91]}],turbidity:[{index:0,rgb:[34,31,27]},{index:.13,rgb:[65,50,41]},{index:.25,rgb:[98,69,52]},{index:.38,rgb:[131,89,57]},{index:.5,rgb:[161,112,59]},{index:.63,rgb:[185,140,66]},{index:.75,rgb:[202,174,88]},{index:.88,rgb:[216,209,126]},{index:1,rgb:[233,246,171]}],"velocity-blue":[{index:0,rgb:[17,32,64]},{index:.13,rgb:[35,52,116]},{index:.25,rgb:[29,81,156]},{index:.38,rgb:[31,113,162]},{index:.5,rgb:[50,144,169]},{index:.63,rgb:[87,173,176]},{index:.75,rgb:[149,196,189]},{index:.88,rgb:[203,221,211]},{index:1,rgb:[254,251,230]}],"velocity-green":[{index:0,rgb:[23,35,19]},{index:.13,rgb:[24,64,38]},{index:.25,rgb:[11,95,45]},{index:.38,rgb:[39,123,35]},{index:.5,rgb:[95,146,12]},{index:.63,rgb:[152,165,18]},{index:.75,rgb:[201,186,69]},{index:.88,rgb:[233,216,137]},{index:1,rgb:[255,253,205]}],cubehelix:[{index:0,rgb:[0,0,0]},{index:.07,rgb:[22,5,59]},{index:.13,rgb:[60,4,105]},{index:.2,rgb:[109,1,135]},{index:.27,rgb:[161,0,147]},{index:.33,rgb:[210,2,142]},{index:.4,rgb:[251,11,123]},{index:.47,rgb:[255,29,97]},{index:.53,rgb:[255,54,69]},{index:.6,rgb:[255,85,46]},{index:.67,rgb:[255,120,34]},{index:.73,rgb:[255,157,37]},{index:.8,rgb:[241,191,57]},{index:.87,rgb:[224,220,93]},{index:.93,rgb:[218,241,142]},{index:1,rgb:[227,253,198]}]}},{}],107:[function(t,e,r){"use strict";var n=t("./colorScale"),i=t("lerp");function a(t){return[t[0]/255,t[1]/255,t[2]/255,t[3]]}function o(t){for(var e,r="#",n=0;n<3;++n)r+=("00"+(e=(e=t[n]).toString(16))).substr(e.length);return r}function s(t){return"rgba("+t.join(",")+")"}e.exports=function(t){var e,r,l,c,u,f,h,p,d,g;t||(t={});p=(t.nshades||72)-1,h=t.format||"hex",(f=t.colormap)||(f="jet");if("string"==typeof f){if(f=f.toLowerCase(),!n[f])throw Error(f+" not a supported colorscale");u=n[f]}else{if(!Array.isArray(f))throw Error("unsupported colormap option",f);u=f.slice()}if(u.length>p)throw new Error(f+" map requires nshades to be at least size "+u.length);d=Array.isArray(t.alpha)?2!==t.alpha.length?[1,1]:t.alpha.slice():"number"==typeof t.alpha?[t.alpha,t.alpha]:[1,1];e=u.map(function(t){return Math.round(t.index*p)}),d[0]=Math.min(Math.max(d[0],0),1),d[1]=Math.min(Math.max(d[1],0),1);var m=u.map(function(t,e){var r=u[e].index,n=u[e].rgb.slice();return 4===n.length&&n[3]>=0&&n[3]<=1?n:(n[3]=d[0]+(d[1]-d[0])*r,n)}),v=[];for(g=0;g0?-1:l(t,e,a)?-1:1:0===s?c>0?1:l(t,e,r)?1:-1:i(c-s)}var h=n(t,e,r);if(h>0)return o>0&&n(t,e,a)>0?1:-1;if(h<0)return o>0||n(t,e,a)>0?1:-1;var p=n(t,e,a);return p>0?1:l(t,e,r)?1:-1};var n=t("robust-orientation"),i=t("signum"),a=t("two-sum"),o=t("robust-product"),s=t("robust-sum");function l(t,e,r){var n=a(t[0],-e[0]),i=a(t[1],-e[1]),l=a(r[0],-e[0]),c=a(r[1],-e[1]),u=s(o(n,l),o(i,c));return u[u.length-1]>=0}},{"robust-orientation":446,"robust-product":447,"robust-sum":451,signum:452,"two-sum":480}],109:[function(t,e,r){e.exports=function(t,e){var r=t.length,a=t.length-e.length;if(a)return a;switch(r){case 0:return 0;case 1:return t[0]-e[0];case 2:return t[0]+t[1]-e[0]-e[1]||n(t[0],t[1])-n(e[0],e[1]);case 3:var o=t[0]+t[1],s=e[0]+e[1];if(a=o+t[2]-(s+e[2]))return a;var l=n(t[0],t[1]),c=n(e[0],e[1]);return n(l,t[2])-n(c,e[2])||n(l+t[2],o)-n(c+e[2],s);case 4:var u=t[0],f=t[1],h=t[2],p=t[3],d=e[0],g=e[1],m=e[2],v=e[3];return u+f+h+p-(d+g+m+v)||n(u,f,h,p)-n(d,g,m,v,d)||n(u+f,u+h,u+p,f+h,f+p,h+p)-n(d+g,d+m,d+v,g+m,g+v,m+v)||n(u+f+h,u+f+p,u+h+p,f+h+p)-n(d+g+m,d+g+v,d+m+v,g+m+v);default:for(var y=t.slice().sort(i),x=e.slice().sort(i),b=0;bt[r][0]&&(r=n);return er?[[r],[e]]:[[e]]}},{}],113:[function(t,e,r){"use strict";e.exports=function(t){var e=n(t),r=e.length;if(r<=2)return[];for(var i=new Array(r),a=e[r-1],o=0;o=e[l]&&(s+=1);a[o]=s}}return t}(o,r)}};var n=t("incremental-convex-hull"),i=t("affine-hull")},{"affine-hull":47,"incremental-convex-hull":357}],115:[function(t,e,r){e.exports={AFG:"afghan",ALA:"\\b\\wland",ALB:"albania",DZA:"algeria",ASM:"^(?=.*americ).*samoa",AND:"andorra",AGO:"angola",AIA:"anguill?a",ATA:"antarctica",ATG:"antigua",ARG:"argentin",ARM:"armenia",ABW:"^(?!.*bonaire).*\\baruba",AUS:"australia",AUT:"^(?!.*hungary).*austria|\\baustri.*\\bemp",AZE:"azerbaijan",BHS:"bahamas",BHR:"bahrain",BGD:"bangladesh|^(?=.*east).*paki?stan",BRB:"barbados",BLR:"belarus|byelo",BEL:"^(?!.*luxem).*belgium",BLZ:"belize|^(?=.*british).*honduras",BEN:"benin|dahome",BMU:"bermuda",BTN:"bhutan",BOL:"bolivia",BES:"^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\bbes.?islands",BIH:"herzegovina|bosnia",BWA:"botswana|bechuana",BVT:"bouvet",BRA:"brazil",IOT:"british.?indian.?ocean",BRN:"brunei",BGR:"bulgaria",BFA:"burkina|\\bfaso|upper.?volta",BDI:"burundi",CPV:"verde",KHM:"cambodia|kampuchea|khmer",CMR:"cameroon",CAN:"canada",CYM:"cayman",CAF:"\\bcentral.african.republic",TCD:"\\bchad",CHL:"\\bchile",CHN:"^(?!.*\\bmac)(?!.*\\bhong)(?!.*\\btai)(?!.*\\brep).*china|^(?=.*peo)(?=.*rep).*china",CXR:"christmas",CCK:"\\bcocos|keeling",COL:"colombia",COM:"comoro",COG:"^(?!.*\\bdem)(?!.*\\bd[\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\bcongo",COK:"\\bcook",CRI:"costa.?rica",CIV:"ivoire|ivory",HRV:"croatia",CUB:"\\bcuba",CUW:"^(?!.*bonaire).*\\bcura(c|\xe7)ao",CYP:"cyprus",CSK:"czechoslovakia",CZE:"^(?=.*rep).*czech|czechia|bohemia",COD:"\\bdem.*congo|congo.*\\bdem|congo.*\\bd[\\.]?r|\\bd[\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc",DNK:"denmark",DJI:"djibouti",DMA:"dominica(?!n)",DOM:"dominican.rep",ECU:"ecuador",EGY:"egypt",SLV:"el.?salvador",GNQ:"guine.*eq|eq.*guine|^(?=.*span).*guinea",ERI:"eritrea",EST:"estonia",ETH:"ethiopia|abyssinia",FLK:"falkland|malvinas",FRO:"faroe|faeroe",FJI:"fiji",FIN:"finland",FRA:"^(?!.*\\bdep)(?!.*martinique).*france|french.?republic|\\bgaul",GUF:"^(?=.*french).*guiana",PYF:"french.?polynesia|tahiti",ATF:"french.?southern",GAB:"gabon",GMB:"gambia",GEO:"^(?!.*south).*georgia",DDR:"german.?democratic.?republic|democratic.?republic.*germany|east.germany",DEU:"^(?!.*east).*germany|^(?=.*\\bfed.*\\brep).*german",GHA:"ghana|gold.?coast",GIB:"gibraltar",GRC:"greece|hellenic|hellas",GRL:"greenland",GRD:"grenada",GLP:"guadeloupe",GUM:"\\bguam",GTM:"guatemala",GGY:"guernsey",GIN:"^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea",GNB:"bissau|^(?=.*portu).*guinea",GUY:"guyana|british.?guiana",HTI:"haiti",HMD:"heard.*mcdonald",VAT:"holy.?see|vatican|papal.?st",HND:"^(?!.*brit).*honduras",HKG:"hong.?kong",HUN:"^(?!.*austr).*hungary",ISL:"iceland",IND:"india(?!.*ocea)",IDN:"indonesia",IRN:"\\biran|persia",IRQ:"\\biraq|mesopotamia",IRL:"(^ireland)|(^republic.*ireland)",IMN:"^(?=.*isle).*\\bman",ISR:"israel",ITA:"italy",JAM:"jamaica",JPN:"japan",JEY:"jersey",JOR:"jordan",KAZ:"kazak",KEN:"kenya|british.?east.?africa|east.?africa.?prot",KIR:"kiribati",PRK:"^(?=.*democrat|people|north|d.*p.*.r).*\\bkorea|dprk|korea.*(d.*p.*r)",KWT:"kuwait",KGZ:"kyrgyz|kirghiz",LAO:"\\blaos?\\b",LVA:"latvia",LBN:"lebanon",LSO:"lesotho|basuto",LBR:"liberia",LBY:"libya",LIE:"liechtenstein",LTU:"lithuania",LUX:"^(?!.*belg).*luxem",MAC:"maca(o|u)",MDG:"madagascar|malagasy",MWI:"malawi|nyasa",MYS:"malaysia",MDV:"maldive",MLI:"\\bmali\\b",MLT:"\\bmalta",MHL:"marshall",MTQ:"martinique",MRT:"mauritania",MUS:"mauritius",MYT:"\\bmayotte",MEX:"\\bmexic",FSM:"fed.*micronesia|micronesia.*fed",MCO:"monaco",MNG:"mongolia",MNE:"^(?!.*serbia).*montenegro",MSR:"montserrat",MAR:"morocco|\\bmaroc",MOZ:"mozambique",MMR:"myanmar|burma",NAM:"namibia",NRU:"nauru",NPL:"nepal",NLD:"^(?!.*\\bant)(?!.*\\bcarib).*netherlands",ANT:"^(?=.*\\bant).*(nether|dutch)",NCL:"new.?caledonia",NZL:"new.?zealand",NIC:"nicaragua",NER:"\\bniger(?!ia)",NGA:"nigeria",NIU:"niue",NFK:"norfolk",MNP:"mariana",NOR:"norway",OMN:"\\boman|trucial",PAK:"^(?!.*east).*paki?stan",PLW:"palau",PSE:"palestin|\\bgaza|west.?bank",PAN:"panama",PNG:"papua|new.?guinea",PRY:"paraguay",PER:"peru",PHL:"philippines",PCN:"pitcairn",POL:"poland",PRT:"portugal",PRI:"puerto.?rico",QAT:"qatar",KOR:"^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\bkorea(?!.*d.*p.*r)",MDA:"moldov|b(a|e)ssarabia",REU:"r(e|\xe9)union",ROU:"r(o|u|ou)mania",RUS:"\\brussia|soviet.?union|u\\.?s\\.?s\\.?r|socialist.?republics",RWA:"rwanda",BLM:"barth(e|\xe9)lemy",SHN:"helena",KNA:"kitts|\\bnevis",LCA:"\\blucia",MAF:"^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)",SPM:"miquelon",VCT:"vincent",WSM:"^(?!.*amer).*samoa",SMR:"san.?marino",STP:"\\bs(a|\xe3)o.?tom(e|\xe9)",SAU:"\\bsa\\w*.?arabia",SEN:"senegal",SRB:"^(?!.*monte).*serbia",SYC:"seychell",SLE:"sierra",SGP:"singapore",SXM:"^(?!.*martin)(?!.*saba).*maarten",SVK:"^(?!.*cze).*slovak",SVN:"slovenia",SLB:"solomon",SOM:"somali",ZAF:"south.africa|s\\\\..?africa",SGS:"south.?georgia|sandwich",SSD:"\\bs\\w*.?sudan",ESP:"spain",LKA:"sri.?lanka|ceylon",SDN:"^(?!.*\\bs(?!u)).*sudan",SUR:"surinam|dutch.?guiana",SJM:"svalbard",SWZ:"swaziland",SWE:"sweden",CHE:"switz|swiss",SYR:"syria",TWN:"taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china",TJK:"tajik",THA:"thailand|\\bsiam",MKD:"macedonia|fyrom",TLS:"^(?=.*leste).*timor|^(?=.*east).*timor",TGO:"togo",TKL:"tokelau",TON:"tonga",TTO:"trinidad|tobago",TUN:"tunisia",TUR:"turkey",TKM:"turkmen",TCA:"turks",TUV:"tuvalu",UGA:"uganda",UKR:"ukrain",ARE:"emirates|^u\\.?a\\.?e\\.?$|united.?arab.?em",GBR:"united.?kingdom|britain|^u\\.?k\\.?$",TZA:"tanzania",USA:"united.?states\\b(?!.*islands)|\\bu\\.?s\\.?a\\.?\\b|^\\s*u\\.?s\\.?\\b(?!.*islands)",UMI:"minor.?outlying.?is",URY:"uruguay",UZB:"uzbek",VUT:"vanuatu|new.?hebrides",VEN:"venezuela",VNM:"^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam",VGB:"^(?=.*\\bu\\.?\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin",VIR:"^(?=.*\\bu\\.?\\s?s).*virgin|^(?=.*states).*virgin",WLF:"futuna|wallis",ESH:"western.sahara",YEM:"^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\bp\\.?d\\.?r).*yemen",YMD:"^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\bp\\.?d\\.?r).*yemen",YUG:"yugoslavia",ZMB:"zambia|northern.?rhodesia",EAZ:"zanzibar",ZWE:"zimbabwe|^(?!.*northern).*rhodesia"}},{}],116:[function(t,e,r){"use strict";e.exports=function(t,e,r,n,i,a){var o=i-1,s=i*i,l=o*o,c=(1+2*i)*l,u=i*l,f=s*(3-2*i),h=s*o;if(t.length){a||(a=new Array(t.length));for(var p=t.length-1;p>=0;--p)a[p]=c*t[p]+u*e[p]+f*r[p]+h*n[p];return a}return c*t+u*e+f*r+h*n},e.exports.derivative=function(t,e,r,n,i,a){var o=6*i*i-6*i,s=3*i*i-4*i+1,l=-6*i*i+6*i,c=3*i*i-2*i;if(t.length){a||(a=new Array(t.length));for(var u=t.length-1;u>=0;--u)a[u]=o*t[u]+s*e[u]+l*r[u]+c*n[u];return a}return o*t+s*e+l*r[u]+c*n}},{}],117:[function(t,e,r){"use strict";var n=t("./lib/thunk.js");e.exports=function(t){var e=new function(){this.argTypes=[],this.shimArgs=[],this.arrayArgs=[],this.arrayBlockIndices=[],this.scalarArgs=[],this.offsetArgs=[],this.offsetArgIndex=[],this.indexArgs=[],this.shapeArgs=[],this.funcName="",this.pre=null,this.body=null,this.post=null,this.debug=!1};e.pre=t.pre,e.body=t.body,e.post=t.post;var r=t.args.slice(0);e.argTypes=r;for(var i=0;i0)throw new Error("cwise: pre() block may not reference array args");if(i0)throw new Error("cwise: post() block may not reference array args")}else if("scalar"===a)e.scalarArgs.push(i),e.shimArgs.push("scalar"+i);else if("index"===a){if(e.indexArgs.push(i),i0)throw new Error("cwise: pre() block may not reference array index");if(i0)throw new Error("cwise: post() block may not reference array index")}else if("shape"===a){if(e.shapeArgs.push(i),ir.length)throw new Error("cwise: Too many arguments in pre() block");if(e.body.args.length>r.length)throw new Error("cwise: Too many arguments in body() block");if(e.post.args.length>r.length)throw new Error("cwise: Too many arguments in post() block");return e.debug=!!t.printCode||!!t.debug,e.funcName=t.funcName||"cwise",e.blockSize=t.blockSize||64,n(e)}},{"./lib/thunk.js":119}],118:[function(t,e,r){"use strict";var n=t("uniq");function i(t,e,r){var n,i,a=t.length,o=e.arrayArgs.length,s=e.indexArgs.length>0,l=[],c=[],u=0,f=0;for(n=0;n0&&l.push("var "+c.join(",")),n=a-1;n>=0;--n)u=t[n],l.push(["for(i",n,"=0;i",n,"0&&l.push(["index[",f,"]-=s",f].join("")),l.push(["++index[",u,"]"].join(""))),l.push("}")}return l.join("\n")}function a(t,e,r){for(var n=t.body,i=[],a=[],o=0;o0&&y.push("shape=SS.slice(0)"),t.indexArgs.length>0){var x=new Array(r);for(l=0;l0&&v.push("var "+y.join(",")),l=0;l3&&v.push(a(t.pre,t,s));var k=a(t.body,t,s),M=function(t){for(var e=0,r=t[0].length;e0,c=[],u=0;u0;){"].join("")),c.push(["if(j",u,"<",s,"){"].join("")),c.push(["s",e[u],"=j",u].join("")),c.push(["j",u,"=0"].join("")),c.push(["}else{s",e[u],"=",s].join("")),c.push(["j",u,"-=",s,"}"].join("")),l&&c.push(["index[",e[u],"]=j",u].join(""));for(u=0;u3&&v.push(a(t.post,t,s)),t.debug&&console.log("-----Generated cwise routine for ",e,":\n"+v.join("\n")+"\n----------");var A=[t.funcName||"unnamed","_cwise_loop_",o[0].join("s"),"m",M,function(t){for(var e=new Array(t.length),r=!0,n=0;n0&&(r=r&&e[n]===e[n-1])}return r?e[0]:e.join("")}(s)].join("");return new Function(["function ",A,"(",m.join(","),"){",v.join("\n"),"} return ",A].join(""))()}},{uniq:483}],119:[function(t,e,r){"use strict";var n=t("./compile.js");e.exports=function(t){var e=["'use strict'","var CACHED={}"],r=[],i=t.funcName+"_cwise_thunk";e.push(["return function ",i,"(",t.shimArgs.join(","),"){"].join(""));for(var a=[],o=[],s=[["array",t.arrayArgs[0],".shape.slice(",Math.max(0,t.arrayBlockIndices[0]),t.arrayBlockIndices[0]<0?","+t.arrayBlockIndices[0]+")":")"].join("")],l=[],c=[],u=0;u0&&(l.push("array"+t.arrayArgs[0]+".shape.length===array"+f+".shape.length+"+(Math.abs(t.arrayBlockIndices[0])-Math.abs(t.arrayBlockIndices[u]))),c.push("array"+t.arrayArgs[0]+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[0])+"]===array"+f+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[u])+"]"))}for(t.arrayArgs.length>1&&(e.push("if (!("+l.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same dimensionality!')"),e.push("for(var shapeIndex=array"+t.arrayArgs[0]+".shape.length-"+Math.abs(t.arrayBlockIndices[0])+"; shapeIndex--\x3e0;) {"),e.push("if (!("+c.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same shape!')"),e.push("}")),u=0;ue?1:t>=e?0:NaN},r=function(t){var r;return 1===t.length&&(r=t,t=function(t,n){return e(r(t),n)}),{left:function(e,r,n,i){for(null==n&&(n=0),null==i&&(i=e.length);n>>1;t(e[a],r)<0?n=a+1:i=a}return n},right:function(e,r,n,i){for(null==n&&(n=0),null==i&&(i=e.length);n>>1;t(e[a],r)>0?i=a:n=a+1}return n}}};var n=r(e),i=n.right,a=n.left;function o(t,e){return[t,e]}var s=function(t){return null===t?NaN:+t},l=function(t,e){var r,n,i=t.length,a=0,o=-1,l=0,c=0;if(null==e)for(;++o1)return c/(a-1)},c=function(t,e){var r=l(t,e);return r?Math.sqrt(r):r},u=function(t,e){var r,n,i,a=t.length,o=-1;if(null==e){for(;++o=r)for(n=i=r;++or&&(n=r),i=r)for(n=i=r;++or&&(n=r),i=0?(a>=v?10:a>=y?5:a>=x?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(a>=v?10:a>=y?5:a>=x?2:1)}function _(t,e,r){var n=Math.abs(e-t)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),a=n/i;return a>=v?i*=10:a>=y?i*=5:a>=x&&(i*=2),e=1)return+r(t[n-1],n-1,t);var n,i=(n-1)*e,a=Math.floor(i),o=+r(t[a],a,t);return o+(+r(t[a+1],a+1,t)-o)*(i-a)}},M=function(t,e){var r,n,i=t.length,a=-1;if(null==e){for(;++a=r)for(n=r;++ar&&(n=r)}else for(;++a=r)for(n=r;++ar&&(n=r);return n},A=function(t){if(!(i=t.length))return[];for(var e=-1,r=M(t,T),n=new Array(r);++et?1:e>=t?0:NaN},t.deviation=c,t.extent=u,t.histogram=function(){var t=g,e=u,r=w;function n(n){var a,o,s=n.length,l=new Array(s);for(a=0;af;)h.pop(),--p;var d,g=new Array(p+1);for(a=0;a<=p;++a)(d=g[a]=[]).x0=a>0?h[a-1]:u,d.x1=a=r)for(n=r;++an&&(n=r)}else for(;++a=r)for(n=r;++an&&(n=r);return n},t.mean=function(t,e){var r,n=t.length,i=n,a=-1,o=0;if(null==e)for(;++a=0;)for(e=(n=t[i]).length;--e>=0;)r[--o]=n[e];return r},t.min=M,t.pairs=function(t,e){null==e&&(e=o);for(var r=0,n=t.length-1,i=t[0],a=new Array(n<0?0:n);r0)return[t];if((n=e0)for(t=Math.ceil(t/o),e=Math.floor(e/o),a=new Array(i=Math.ceil(e-t+1));++s=l.length)return null!=t&&n.sort(t),null!=e?e(n):n;for(var s,c,f,h=-1,p=n.length,d=l[i++],g=r(),m=a();++hl.length)return r;var i,a=c[n-1];return null!=e&&n>=l.length?i=r.entries():(i=[],r.each(function(e,r){i.push({key:r,values:t(e,n)})})),null!=a?i.sort(function(t,e){return a(t.key,e.key)}):i}(u(t,0,a,o),0)},key:function(t){return l.push(t),s},sortKeys:function(t){return c[l.length-1]=t,s},sortValues:function(e){return t=e,s},rollup:function(t){return e=t,s}}},t.set=c,t.map=r,t.keys=function(t){var e=[];for(var r in t)e.push(r);return e},t.values=function(t){var e=[];for(var r in t)e.push(t[r]);return e},t.entries=function(t){var e=[];for(var r in t)e.push({key:r,value:t[r]});return e},Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],125:[function(t,e,r){var n;n=this,function(t){"use strict";var e=function(t,e,r){t.prototype=e.prototype=r,r.constructor=t};function r(t,e){var r=Object.create(t.prototype);for(var n in e)r[n]=e[n];return r}function n(){}var i="\\s*([+-]?\\d+)\\s*",a="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",o="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",s=/^#([0-9a-f]{3})$/,l=/^#([0-9a-f]{6})$/,c=new RegExp("^rgb\\("+[i,i,i]+"\\)$"),u=new RegExp("^rgb\\("+[o,o,o]+"\\)$"),f=new RegExp("^rgba\\("+[i,i,i,a]+"\\)$"),h=new RegExp("^rgba\\("+[o,o,o,a]+"\\)$"),p=new RegExp("^hsl\\("+[a,o,o]+"\\)$"),d=new RegExp("^hsla\\("+[a,o,o,a]+"\\)$"),g={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function m(t){var e;return t=(t+"").trim().toLowerCase(),(e=s.exec(t))?new _((e=parseInt(e[1],16))>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):(e=l.exec(t))?v(parseInt(e[1],16)):(e=c.exec(t))?new _(e[1],e[2],e[3],1):(e=u.exec(t))?new _(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=f.exec(t))?y(e[1],e[2],e[3],e[4]):(e=h.exec(t))?y(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=p.exec(t))?w(e[1],e[2]/100,e[3]/100,1):(e=d.exec(t))?w(e[1],e[2]/100,e[3]/100,e[4]):g.hasOwnProperty(t)?v(g[t]):"transparent"===t?new _(NaN,NaN,NaN,0):null}function v(t){return new _(t>>16&255,t>>8&255,255&t,1)}function y(t,e,r,n){return n<=0&&(t=e=r=NaN),new _(t,e,r,n)}function x(t){return t instanceof n||(t=m(t)),t?new _((t=t.rgb()).r,t.g,t.b,t.opacity):new _}function b(t,e,r,n){return 1===arguments.length?x(t):new _(t,e,r,null==n?1:n)}function _(t,e,r,n){this.r=+t,this.g=+e,this.b=+r,this.opacity=+n}function w(t,e,r,n){return n<=0?t=e=r=NaN:r<=0||r>=1?t=e=NaN:e<=0&&(t=NaN),new M(t,e,r,n)}function k(t,e,r,i){return 1===arguments.length?function(t){if(t instanceof M)return new M(t.h,t.s,t.l,t.opacity);if(t instanceof n||(t=m(t)),!t)return new M;if(t instanceof M)return t;var e=(t=t.rgb()).r/255,r=t.g/255,i=t.b/255,a=Math.min(e,r,i),o=Math.max(e,r,i),s=NaN,l=o-a,c=(o+a)/2;return l?(s=e===o?(r-i)/l+6*(r0&&c<1?0:s,new M(s,l,c,t.opacity)}(t):new M(t,e,r,null==i?1:i)}function M(t,e,r,n){this.h=+t,this.s=+e,this.l=+r,this.opacity=+n}function A(t,e,r){return 255*(t<60?e+(r-e)*t/60:t<180?r:t<240?e+(r-e)*(240-t)/60:e)}e(n,m,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}}),e(_,b,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new _(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new _(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}})),e(M,k,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new M(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new M(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*e,i=2*r-n;return new _(A(t>=240?t-240:t+120,i,n),A(t,i,n),A(t<120?t+240:t-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}));var T=Math.PI/180,S=180/Math.PI,C=.95047,E=1,L=1.08883,z=4/29,P=6/29,D=3*P*P,O=P*P*P;function I(t){if(t instanceof B)return new B(t.l,t.a,t.b,t.opacity);if(t instanceof q){var e=t.h*T;return new B(t.l,Math.cos(e)*t.c,Math.sin(e)*t.c,t.opacity)}t instanceof _||(t=x(t));var r=V(t.r),n=V(t.g),i=V(t.b),a=F((.4124564*r+.3575761*n+.1804375*i)/C),o=F((.2126729*r+.7151522*n+.072175*i)/E);return new B(116*o-16,500*(a-o),200*(o-F((.0193339*r+.119192*n+.9503041*i)/L)),t.opacity)}function R(t,e,r,n){return 1===arguments.length?I(t):new B(t,e,r,null==n?1:n)}function B(t,e,r,n){this.l=+t,this.a=+e,this.b=+r,this.opacity=+n}function F(t){return t>O?Math.pow(t,1/3):t/D+z}function N(t){return t>P?t*t*t:D*(t-z)}function j(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function V(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function U(t,e,r,n){return 1===arguments.length?function(t){if(t instanceof q)return new q(t.h,t.c,t.l,t.opacity);t instanceof B||(t=I(t));var e=Math.atan2(t.b,t.a)*S;return new q(e<0?e+360:e,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}(t):new q(t,e,r,null==n?1:n)}function q(t,e,r,n){this.h=+t,this.c=+e,this.l=+r,this.opacity=+n}e(B,R,r(n,{brighter:function(t){return new B(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new B(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,r=isNaN(this.b)?t:t-this.b/200;return t=E*N(t),new _(j(3.2404542*(e=C*N(e))-1.5371385*t-.4985314*(r=L*N(r))),j(-.969266*e+1.8760108*t+.041556*r),j(.0556434*e-.2040259*t+1.0572252*r),this.opacity)}})),e(q,U,r(n,{brighter:function(t){return new q(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new q(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return I(this).rgb()}}));var H=-.14861,G=1.78277,W=-.29227,Y=-.90649,X=1.97294,Z=X*Y,J=X*G,K=G*W-Y*H;function Q(t,e,r,n){return 1===arguments.length?function(t){if(t instanceof $)return new $(t.h,t.s,t.l,t.opacity);t instanceof _||(t=x(t));var e=t.r/255,r=t.g/255,n=t.b/255,i=(K*n+Z*e-J*r)/(K+Z-J),a=n-i,o=(X*(r-i)-W*a)/Y,s=Math.sqrt(o*o+a*a)/(X*i*(1-i)),l=s?Math.atan2(o,a)*S-120:NaN;return new $(l<0?l+360:l,s,i,t.opacity)}(t):new $(t,e,r,null==n?1:n)}function $(t,e,r,n){this.h=+t,this.s=+e,this.l=+r,this.opacity=+n}e($,Q,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new $(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new $(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*T,e=+this.l,r=isNaN(this.s)?0:this.s*e*(1-e),n=Math.cos(t),i=Math.sin(t);return new _(255*(e+r*(H*n+G*i)),255*(e+r*(W*n+Y*i)),255*(e+r*(X*n)),this.opacity)}})),t.color=m,t.rgb=b,t.hsl=k,t.lab=R,t.hcl=U,t.cubehelix=Q,Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],126:[function(t,e,r){var n;n=this,function(t){"use strict";var e={value:function(){}};function r(){for(var t,e=0,r=arguments.length,i={};e=0&&(e=t.slice(r+1),t=t.slice(0,r)),t&&!n.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:e}})),l=-1,c=s.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++l0)for(var r,n,i=new Array(r),a=0;ah+c||np+c||au.index){var f=h-s.x-s.vx,m=p-s.y-s.vy,v=f*f+m*m;vt.r&&(t.r=t[e].r)}function h(){if(r){var e,i,a=r.length;for(n=new Array(a),e=0;e=c)){(t.data!==r||t.next)&&(0===f&&(d+=(f=o())*f),0===h&&(d+=(h=o())*h),d1?(null==r?u.remove(t):u.set(t,y(r)),e):u.get(t)},find:function(e,r,n){var i,a,o,s,l,c=0,u=t.length;for(null==n?n=1/0:n*=n,c=0;c1?(h.on(t,r),e):h.on(t)}}},t.forceX=function(t){var e,r,n,i=a(.1);function o(t){for(var i,a=0,o=e.length;a=1?(n=1,e-1):Math.floor(n*e),a=t[i],o=t[i+1],s=i>0?t[i-1]:2*a-o,l=i180||r<-180?r-360*Math.round(r/360):r):a(isNaN(t)?e:t)}function l(t){return 1==(t=+t)?c:function(e,r){return r-e?function(t,e,r){return t=Math.pow(t,r),e=Math.pow(e,r)-t,r=1/r,function(n){return Math.pow(t+n*e,r)}}(e,r,t):a(isNaN(e)?r:e)}}function c(t,e){var r=e-t;return r?o(t,r):a(isNaN(t)?e:t)}var u=function t(r){var n=l(r);function i(t,r){var i=n((t=e.rgb(t)).r,(r=e.rgb(r)).r),a=n(t.g,r.g),o=n(t.b,r.b),s=c(t.opacity,r.opacity);return function(e){return t.r=i(e),t.g=a(e),t.b=o(e),t.opacity=s(e),t+""}}return i.gamma=t,i}(1);function f(t){return function(r){var n,i,a=r.length,o=new Array(a),s=new Array(a),l=new Array(a);for(n=0;na&&(i=e.slice(a,i),s[o]?s[o]+=i:s[++o]=i),(r=r[0])===(n=n[0])?s[o]?s[o]+=n:s[++o]=n:(s[++o]=null,l.push({i:o,x:m(r,n)})),a=x.lastIndex;return a180?e+=360:e-t>180&&(t+=360),a.push({i:r.push(i(r)+"rotate(",null,n)-2,x:m(t,e)})):e&&r.push(i(r)+"rotate("+e+n)}(a.rotate,o.rotate,s,l),function(t,e,r,a){t!==e?a.push({i:r.push(i(r)+"skewX(",null,n)-2,x:m(t,e)}):e&&r.push(i(r)+"skewX("+e+n)}(a.skewX,o.skewX,s,l),function(t,e,r,n,a,o){if(t!==r||e!==n){var s=a.push(i(a)+"scale(",null,",",null,")");o.push({i:s-4,x:m(t,r)},{i:s-2,x:m(e,n)})}else 1===r&&1===n||a.push(i(a)+"scale("+r+","+n+")")}(a.scaleX,a.scaleY,o.scaleX,o.scaleY,s,l),a=o=null,function(t){for(var e,r=-1,n=l.length;++r=(a=(g+v)/2))?g=a:v=a,(u=r>=(o=(m+y)/2))?m=o:y=o,i=p,!(p=p[f=u<<1|c]))return i[f]=d,t;if(s=+t._x.call(null,p.data),l=+t._y.call(null,p.data),e===s&&r===l)return d.next=p,i?i[f]=d:t._root=d,t;do{i=i?i[f]=new Array(4):t._root=new Array(4),(c=e>=(a=(g+v)/2))?g=a:v=a,(u=r>=(o=(m+y)/2))?m=o:y=o}while((f=u<<1|c)==(h=(l>=o)<<1|s>=a));return i[h]=p,i[f]=d,t}var r=function(t,e,r,n,i){this.node=t,this.x0=e,this.y0=r,this.x1=n,this.y1=i};function n(t){return t[0]}function i(t){return t[1]}function a(t,e,r){var a=new o(null==e?n:e,null==r?i:r,NaN,NaN,NaN,NaN);return null==t?a:a.addAll(t)}function o(t,e,r,n,i,a){this._x=t,this._y=e,this._x0=r,this._y0=n,this._x1=i,this._y1=a,this._root=void 0}function s(t){for(var e={data:t.data},r=e;t=t.next;)r=r.next={data:t.data};return e}var l=a.prototype=o.prototype;l.copy=function(){var t,e,r=new o(this._x,this._y,this._x0,this._y0,this._x1,this._y1),n=this._root;if(!n)return r;if(!n.length)return r._root=s(n),r;for(t=[{source:n,target:r._root=new Array(4)}];n=t.pop();)for(var i=0;i<4;++i)(e=n.source[i])&&(e.length?t.push({source:e,target:n.target[i]=new Array(4)}):n.target[i]=s(e));return r},l.add=function(t){var r=+this._x.call(null,t),n=+this._y.call(null,t);return e(this.cover(r,n),r,n,t)},l.addAll=function(t){var r,n,i,a,o=t.length,s=new Array(o),l=new Array(o),c=1/0,u=1/0,f=-1/0,h=-1/0;for(n=0;nf&&(f=i),ah&&(h=a));for(ft||t>i||n>e||e>a))return this;var o,s,l=i-r,c=this._root;switch(s=(e<(n+a)/2)<<1|t<(r+i)/2){case 0:do{(o=new Array(4))[s]=c,c=o}while(a=n+(l*=2),t>(i=r+l)||e>a);break;case 1:do{(o=new Array(4))[s]=c,c=o}while(a=n+(l*=2),(r=i-l)>t||e>a);break;case 2:do{(o=new Array(4))[s]=c,c=o}while(n=a-(l*=2),t>(i=r+l)||n>e);break;case 3:do{(o=new Array(4))[s]=c,c=o}while(n=a-(l*=2),(r=i-l)>t||n>e)}this._root&&this._root.length&&(this._root=c)}return this._x0=r,this._y0=n,this._x1=i,this._y1=a,this},l.data=function(){var t=[];return this.visit(function(e){if(!e.length)do{t.push(e.data)}while(e=e.next)}),t},l.extent=function(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},l.find=function(t,e,n){var i,a,o,s,l,c,u,f=this._x0,h=this._y0,p=this._x1,d=this._y1,g=[],m=this._root;for(m&&g.push(new r(m,f,h,p,d)),null==n?n=1/0:(f=t-n,h=e-n,p=t+n,d=e+n,n*=n);c=g.pop();)if(!(!(m=c.node)||(a=c.x0)>p||(o=c.y0)>d||(s=c.x1)=y)<<1|t>=v)&&(c=g[g.length-1],g[g.length-1]=g[g.length-1-u],g[g.length-1-u]=c)}else{var x=t-+this._x.call(null,m.data),b=e-+this._y.call(null,m.data),_=x*x+b*b;if(_=(s=(d+m)/2))?d=s:m=s,(u=o>=(l=(g+v)/2))?g=l:v=l,e=p,!(p=p[f=u<<1|c]))return this;if(!p.length)break;(e[f+1&3]||e[f+2&3]||e[f+3&3])&&(r=e,h=f)}for(;p.data!==t;)if(n=p,!(p=p.next))return this;return(i=p.next)&&delete p.next,n?(i?n.next=i:delete n.next,this):e?(i?e[f]=i:delete e[f],(p=e[0]||e[1]||e[2]||e[3])&&p===(e[3]||e[2]||e[1]||e[0])&&!p.length&&(r?r[h]=p:this._root=p),this):(this._root=i,this)},l.removeAll=function(t){for(var e=0,r=t.length;e=0&&r._call.call(null,t),r=r._next;--n}function v(){l=(s=u.now())+c,n=i=0;try{m()}finally{n=0,function(){var t,n,i=e,a=1/0;for(;i;)i._call?(a>i._time&&(a=i._time),t=i,i=i._next):(n=i._next,i._next=null,i=t?t._next=n:e=n);r=t,x(a)}(),l=0}}function y(){var t=u.now(),e=t-s;e>o&&(c-=e,s=t)}function x(t){n||(i&&(i=clearTimeout(i)),t-l>24?(t<1/0&&(i=setTimeout(v,t-u.now()-c)),a&&(a=clearInterval(a))):(a||(s=u.now(),a=setInterval(y,o)),n=1,f(v)))}d.prototype=g.prototype={constructor:d,restart:function(t,n,i){if("function"!=typeof t)throw new TypeError("callback is not a function");i=(null==i?h():+i)+(null==n?0:+n),this._next||r===this||(r?r._next=this:e=this,r=this),this._call=t,this._time=i,x()},stop:function(){this._call&&(this._call=null,this._time=1/0,x())}};t.now=h,t.timer=g,t.timerFlush=m,t.timeout=function(t,e,r){var n=new d;return e=null==e?0:+e,n.restart(function(r){n.stop(),t(r+e)},e,r),n},t.interval=function(t,e,r){var n=new d,i=e;return null==e?(n.restart(t,e,r),n):(e=+e,r=null==r?h():+r,n.restart(function a(o){o+=i,n.restart(a,i+=e,r),t(o)},e,r),n)},Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],131:[function(t,e,r){!function(){var t={version:"3.5.17"},r=[].slice,n=function(t){return r.call(t)},i=this.document;function a(t){return t&&(t.ownerDocument||t.document||t).documentElement}function o(t){return t&&(t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView)}if(i)try{n(i.documentElement.childNodes)[0].nodeType}catch(t){n=function(t){for(var e=t.length,r=new Array(e);e--;)r[e]=t[e];return r}}if(Date.now||(Date.now=function(){return+new Date}),i)try{i.createElement("DIV").style.setProperty("opacity",0,"")}catch(t){var s=this.Element.prototype,l=s.setAttribute,c=s.setAttributeNS,u=this.CSSStyleDeclaration.prototype,f=u.setProperty;s.setAttribute=function(t,e){l.call(this,t,e+"")},s.setAttributeNS=function(t,e,r){c.call(this,t,e,r+"")},u.setProperty=function(t,e,r){f.call(this,t,e+"",r)}}function h(t,e){return te?1:t>=e?0:NaN}function p(t){return null===t?NaN:+t}function d(t){return!isNaN(t)}function g(t){return{left:function(e,r,n,i){for(arguments.length<3&&(n=0),arguments.length<4&&(i=e.length);n>>1;t(e[a],r)<0?n=a+1:i=a}return n},right:function(e,r,n,i){for(arguments.length<3&&(n=0),arguments.length<4&&(i=e.length);n>>1;t(e[a],r)>0?i=a:n=a+1}return n}}}t.ascending=h,t.descending=function(t,e){return et?1:e>=t?0:NaN},t.min=function(t,e){var r,n,i=-1,a=t.length;if(1===arguments.length){for(;++i=n){r=n;break}for(;++in&&(r=n)}else{for(;++i=n){r=n;break}for(;++in&&(r=n)}return r},t.max=function(t,e){var r,n,i=-1,a=t.length;if(1===arguments.length){for(;++i=n){r=n;break}for(;++ir&&(r=n)}else{for(;++i=n){r=n;break}for(;++ir&&(r=n)}return r},t.extent=function(t,e){var r,n,i,a=-1,o=t.length;if(1===arguments.length){for(;++a=n){r=i=n;break}for(;++an&&(r=n),i=n){r=i=n;break}for(;++an&&(r=n),i1)return o/(l-1)},t.deviation=function(){var e=t.variance.apply(this,arguments);return e?Math.sqrt(e):e};var m=g(h);function v(t){return t.length}t.bisectLeft=m.left,t.bisect=t.bisectRight=m.right,t.bisector=function(t){return g(1===t.length?function(e,r){return h(t(e),r)}:t)},t.shuffle=function(t,e,r){(a=arguments.length)<3&&(r=t.length,a<2&&(e=0));for(var n,i,a=r-e;a;)i=Math.random()*a--|0,n=t[a+e],t[a+e]=t[i+e],t[i+e]=n;return t},t.permute=function(t,e){for(var r=e.length,n=new Array(r);r--;)n[r]=t[e[r]];return n},t.pairs=function(t){for(var e=0,r=t.length-1,n=t[0],i=new Array(r<0?0:r);e=0;)for(e=(n=t[i]).length;--e>=0;)r[--o]=n[e];return r};var y=Math.abs;function x(t,e){for(var r in e)Object.defineProperty(t.prototype,r,{value:e[r],enumerable:!1})}function b(){this._=Object.create(null)}t.range=function(t,e,r){if(arguments.length<3&&(r=1,arguments.length<2&&(e=t,t=0)),(e-t)/r==1/0)throw new Error("infinite range");var n,i=[],a=function(t){var e=1;for(;t*e%1;)e*=10;return e}(y(r)),o=-1;if(t*=a,e*=a,(r*=a)<0)for(;(n=t+r*++o)>e;)i.push(n/a);else for(;(n=t+r*++o)=i.length)return r?r.call(n,a):e?a.sort(e):a;for(var l,c,u,f,h=-1,p=a.length,d=i[s++],g=new b;++h=i.length)return e;var n=[],o=a[r++];return e.forEach(function(e,i){n.push({key:e,values:t(i,r)})}),o?n.sort(function(t,e){return o(t.key,e.key)}):n}(o(t.map,e,0),0)},n.key=function(t){return i.push(t),n},n.sortKeys=function(t){return a[i.length-1]=t,n},n.sortValues=function(t){return e=t,n},n.rollup=function(t){return r=t,n},n},t.set=function(t){var e=new L;if(t)for(var r=0,n=t.length;r=0&&(n=t.slice(r+1),t=t.slice(0,r)),t)return arguments.length<2?this[t].on(n):this[t].on(n,e);if(2===arguments.length){if(null==e)for(t in this)this.hasOwnProperty(t)&&this[t].on(n,null);return this}},t.event=null,t.requote=function(t){return t.replace(V,"\\$&")};var V=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g,U={}.__proto__?function(t,e){t.__proto__=e}:function(t,e){for(var r in e)t[r]=e[r]};function q(t){return U(t,Y),t}var H=function(t,e){return e.querySelector(t)},G=function(t,e){return e.querySelectorAll(t)},W=function(t,e){var r=t.matches||t[D(t,"matchesSelector")];return(W=function(t,e){return r.call(t,e)})(t,e)};"function"==typeof Sizzle&&(H=function(t,e){return Sizzle(t,e)[0]||null},G=Sizzle,W=Sizzle.matchesSelector),t.selection=function(){return t.select(i.documentElement)};var Y=t.selection.prototype=[];function X(t){return"function"==typeof t?t:function(){return H(t,this)}}function Z(t){return"function"==typeof t?t:function(){return G(t,this)}}Y.select=function(t){var e,r,n,i,a=[];t=X(t);for(var o=-1,s=this.length;++o=0&&"xmlns"!==(r=t.slice(0,e))&&(t=t.slice(e+1)),K.hasOwnProperty(r)?{space:K[r],local:t}:t}},Y.attr=function(e,r){if(arguments.length<2){if("string"==typeof e){var n=this.node();return(e=t.ns.qualify(e)).local?n.getAttributeNS(e.space,e.local):n.getAttribute(e)}for(r in e)this.each(Q(r,e[r]));return this}return this.each(Q(e,r))},Y.classed=function(t,e){if(arguments.length<2){if("string"==typeof t){var r=this.node(),n=(t=et(t)).length,i=-1;if(e=r.classList){for(;++i=0;)(r=n[i])&&(a&&a!==r.nextSibling&&a.parentNode.insertBefore(r,a),a=r);return this},Y.sort=function(t){t=function(t){arguments.length||(t=h);return function(e,r){return e&&r?t(e.__data__,r.__data__):!e-!r}}.apply(this,arguments);for(var e=-1,r=this.length;++e0&&(e=e.slice(0,o));var l=dt.get(e);function c(){var t=this[a];t&&(this.removeEventListener(e,t,t.$),delete this[a])}return l&&(e=l,s=mt),o?r?function(){var t=s(r,n(arguments));c.call(this),this.addEventListener(e,this[a]=t,t.$=i),t._=r}:c:r?I:function(){var r,n=new RegExp("^__on([^.]+)"+t.requote(e)+"$");for(var i in this)if(r=i.match(n)){var a=this[i];this.removeEventListener(r[1],a,a.$),delete this[i]}}}t.selection.enter=ft,t.selection.enter.prototype=ht,ht.append=Y.append,ht.empty=Y.empty,ht.node=Y.node,ht.call=Y.call,ht.size=Y.size,ht.select=function(t){for(var e,r,n,i,a,o=[],s=-1,l=this.length;++s=n&&(n=e+1);!(o=s[n])&&++n0?1:t<0?-1:0}function Pt(t,e,r){return(e[0]-t[0])*(r[1]-t[1])-(e[1]-t[1])*(r[0]-t[0])}function Dt(t){return t>1?0:t<-1?At:Math.acos(t)}function Ot(t){return t>1?Ct:t<-1?-Ct:Math.asin(t)}function It(t){return((t=Math.exp(t))+1/t)/2}function Rt(t){return(t=Math.sin(t/2))*t}var Bt=Math.SQRT2;t.interpolateZoom=function(t,e){var r,n,i=t[0],a=t[1],o=t[2],s=e[0],l=e[1],c=e[2],u=s-i,f=l-a,h=u*u+f*f;if(h0&&(e=e.transition().duration(g)),e.call(w.event)}function S(){c&&c.domain(l.range().map(function(t){return(t-h.x)/h.k}).map(l.invert)),f&&f.domain(u.range().map(function(t){return(t-h.y)/h.k}).map(u.invert))}function C(t){m++||t({type:"zoomstart"})}function E(t){S(),t({type:"zoom",scale:h.k,translate:[h.x,h.y]})}function L(t){--m||(t({type:"zoomend"}),r=null)}function z(){var e=this,r=_.of(e,arguments),n=0,i=t.select(o(e)).on(y,function(){n=1,A(t.mouse(e),a),E(r)}).on(x,function(){i.on(y,null).on(x,null),s(n),L(r)}),a=k(t.mouse(e)),s=xt(e);ss.call(e),C(r)}function P(){var e,r=this,n=_.of(r,arguments),i={},a=0,o=".zoom-"+t.event.changedTouches[0].identifier,l="touchmove"+o,c="touchend"+o,u=[],f=t.select(r),p=xt(r);function d(){var n=t.touches(r);return e=h.k,n.forEach(function(t){t.identifier in i&&(i[t.identifier]=k(t))}),n}function g(){var e=t.event.target;t.select(e).on(l,m).on(c,y),u.push(e);for(var n=t.event.changedTouches,o=0,f=n.length;o1){v=p[0];var x=p[1],b=v[0]-x[0],_=v[1]-x[1];a=b*b+_*_}}function m(){var o,l,c,u,f=t.touches(r);ss.call(r);for(var h=0,p=f.length;h360?t-=360:t<0&&(t+=360),t<60?n+(i-n)*t/60:t<180?i:t<240?n+(i-n)*(240-t)/60:n}(t))}return t=isNaN(t)?0:(t%=360)<0?t+360:t,e=isNaN(e)?0:e<0?0:e>1?1:e,n=2*(r=r<0?0:r>1?1:r)-(i=r<=.5?r*(1+e):r+e-r*e),new ae(a(t+120),a(t),a(t-120))}function Gt(e,r,n){return this instanceof Gt?(this.h=+e,this.c=+r,void(this.l=+n)):arguments.length<2?e instanceof Gt?new Gt(e.h,e.c,e.l):ee(e instanceof Xt?e.l:(e=he((e=t.rgb(e)).r,e.g,e.b)).l,e.a,e.b):new Gt(e,r,n)}qt.brighter=function(t){return t=Math.pow(.7,arguments.length?t:1),new Ut(this.h,this.s,this.l/t)},qt.darker=function(t){return t=Math.pow(.7,arguments.length?t:1),new Ut(this.h,this.s,t*this.l)},qt.rgb=function(){return Ht(this.h,this.s,this.l)},t.hcl=Gt;var Wt=Gt.prototype=new Vt;function Yt(t,e,r){return isNaN(t)&&(t=0),isNaN(e)&&(e=0),new Xt(r,Math.cos(t*=Et)*e,Math.sin(t)*e)}function Xt(t,e,r){return this instanceof Xt?(this.l=+t,this.a=+e,void(this.b=+r)):arguments.length<2?t instanceof Xt?new Xt(t.l,t.a,t.b):t instanceof Gt?Yt(t.h,t.c,t.l):he((t=ae(t)).r,t.g,t.b):new Xt(t,e,r)}Wt.brighter=function(t){return new Gt(this.h,this.c,Math.min(100,this.l+Zt*(arguments.length?t:1)))},Wt.darker=function(t){return new Gt(this.h,this.c,Math.max(0,this.l-Zt*(arguments.length?t:1)))},Wt.rgb=function(){return Yt(this.h,this.c,this.l).rgb()},t.lab=Xt;var Zt=18,Jt=.95047,Kt=1,Qt=1.08883,$t=Xt.prototype=new Vt;function te(t,e,r){var n=(t+16)/116,i=n+e/500,a=n-r/200;return new ae(ie(3.2404542*(i=re(i)*Jt)-1.5371385*(n=re(n)*Kt)-.4985314*(a=re(a)*Qt)),ie(-.969266*i+1.8760108*n+.041556*a),ie(.0556434*i-.2040259*n+1.0572252*a))}function ee(t,e,r){return t>0?new Gt(Math.atan2(r,e)*Lt,Math.sqrt(e*e+r*r),t):new Gt(NaN,NaN,t)}function re(t){return t>.206893034?t*t*t:(t-4/29)/7.787037}function ne(t){return t>.008856?Math.pow(t,1/3):7.787037*t+4/29}function ie(t){return Math.round(255*(t<=.00304?12.92*t:1.055*Math.pow(t,1/2.4)-.055))}function ae(t,e,r){return this instanceof ae?(this.r=~~t,this.g=~~e,void(this.b=~~r)):arguments.length<2?t instanceof ae?new ae(t.r,t.g,t.b):ue(""+t,ae,Ht):new ae(t,e,r)}function oe(t){return new ae(t>>16,t>>8&255,255&t)}function se(t){return oe(t)+""}$t.brighter=function(t){return new Xt(Math.min(100,this.l+Zt*(arguments.length?t:1)),this.a,this.b)},$t.darker=function(t){return new Xt(Math.max(0,this.l-Zt*(arguments.length?t:1)),this.a,this.b)},$t.rgb=function(){return te(this.l,this.a,this.b)},t.rgb=ae;var le=ae.prototype=new Vt;function ce(t){return t<16?"0"+Math.max(0,t).toString(16):Math.min(255,t).toString(16)}function ue(t,e,r){var n,i,a,o=0,s=0,l=0;if(n=/([a-z]+)\((.*)\)/.exec(t=t.toLowerCase()))switch(i=n[2].split(","),n[1]){case"hsl":return r(parseFloat(i[0]),parseFloat(i[1])/100,parseFloat(i[2])/100);case"rgb":return e(de(i[0]),de(i[1]),de(i[2]))}return(a=ge.get(t))?e(a.r,a.g,a.b):(null==t||"#"!==t.charAt(0)||isNaN(a=parseInt(t.slice(1),16))||(4===t.length?(o=(3840&a)>>4,o|=o>>4,s=240&a,s|=s>>4,l=15&a,l|=l<<4):7===t.length&&(o=(16711680&a)>>16,s=(65280&a)>>8,l=255&a)),e(o,s,l))}function fe(t,e,r){var n,i,a=Math.min(t/=255,e/=255,r/=255),o=Math.max(t,e,r),s=o-a,l=(o+a)/2;return s?(i=l<.5?s/(o+a):s/(2-o-a),n=t==o?(e-r)/s+(e0&&l<1?0:n),new Ut(n,i,l)}function he(t,e,r){var n=ne((.4124564*(t=pe(t))+.3575761*(e=pe(e))+.1804375*(r=pe(r)))/Jt),i=ne((.2126729*t+.7151522*e+.072175*r)/Kt);return Xt(116*i-16,500*(n-i),200*(i-ne((.0193339*t+.119192*e+.9503041*r)/Qt)))}function pe(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function de(t){var e=parseFloat(t);return"%"===t.charAt(t.length-1)?Math.round(2.55*e):e}le.brighter=function(t){t=Math.pow(.7,arguments.length?t:1);var e=this.r,r=this.g,n=this.b,i=30;return e||r||n?(e&&e=200&&e<300||304===e){try{t=i.call(o,c)}catch(t){return void s.error.call(o,t)}s.load.call(o,t)}else s.error.call(o,c)}return!this.XDomainRequest||"withCredentials"in c||!/^(http(s)?:)?\/\//.test(e)||(c=new XDomainRequest),"onload"in c?c.onload=c.onerror=f:c.onreadystatechange=function(){c.readyState>3&&f()},c.onprogress=function(e){var r=t.event;t.event=e;try{s.progress.call(o,c)}finally{t.event=r}},o.header=function(t,e){return t=(t+"").toLowerCase(),arguments.length<2?l[t]:(null==e?delete l[t]:l[t]=e+"",o)},o.mimeType=function(t){return arguments.length?(r=null==t?null:t+"",o):r},o.responseType=function(t){return arguments.length?(u=t,o):u},o.response=function(t){return i=t,o},["get","post"].forEach(function(t){o[t]=function(){return o.send.apply(o,[t].concat(n(arguments)))}}),o.send=function(t,n,i){if(2===arguments.length&&"function"==typeof n&&(i=n,n=null),c.open(t,e,!0),null==r||"accept"in l||(l.accept=r+",*/*"),c.setRequestHeader)for(var a in l)c.setRequestHeader(a,l[a]);return null!=r&&c.overrideMimeType&&c.overrideMimeType(r),null!=u&&(c.responseType=u),null!=i&&o.on("error",i).on("load",function(t){i(null,t)}),s.beforesend.call(o,c),c.send(null==n?null:n),o},o.abort=function(){return c.abort(),o},t.rebind(o,s,"on"),null==a?o:o.get(function(t){return 1===t.length?function(e,r){t(null==e?r:null)}:t}(a))}ge.forEach(function(t,e){ge.set(t,oe(e))}),t.functor=me,t.xhr=ve(z),t.dsv=function(t,e){var r=new RegExp('["'+t+"\n]"),n=t.charCodeAt(0);function i(t,r,n){arguments.length<3&&(n=r,r=null);var i=ye(t,e,null==r?a:o(r),n);return i.row=function(t){return arguments.length?i.response(null==(r=t)?a:o(t)):r},i}function a(t){return i.parse(t.responseText)}function o(t){return function(e){return i.parse(e.responseText,t)}}function s(e){return e.map(l).join(t)}function l(t){return r.test(t)?'"'+t.replace(/\"/g,'""')+'"':t}return i.parse=function(t,e){var r;return i.parseRows(t,function(t,n){if(r)return r(t,n-1);var i=new Function("d","return {"+t.map(function(t,e){return JSON.stringify(t)+": d["+e+"]"}).join(",")+"}");r=e?function(t,r){return e(i(t),r)}:i})},i.parseRows=function(t,e){var r,i,a={},o={},s=[],l=t.length,c=0,u=0;function f(){if(c>=l)return o;if(i)return i=!1,a;var e=c;if(34===t.charCodeAt(e)){for(var r=e;r++24?(isFinite(e)&&(clearTimeout(we),we=setTimeout(Ae,e)),_e=0):(_e=1,ke(Ae))}function Te(){for(var t=Date.now(),e=xe;e;)t>=e.t&&e.c(t-e.t)&&(e.c=null),e=e.n;return t}function Se(){for(var t,e=xe,r=1/0;e;)e.c?(e.t8?function(t){return t/r}:function(t){return t*r},symbol:t}});t.formatPrefix=function(e,r){var n=0;return(e=+e)&&(e<0&&(e*=-1),r&&(e=t.round(e,Ce(e,r))),n=1+Math.floor(1e-12+Math.log(e)/Math.LN10),n=Math.max(-24,Math.min(24,3*Math.floor((n-1)/3)))),Ee[8+n/3]};var Le=/(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i,ze=t.map({b:function(t){return t.toString(2)},c:function(t){return String.fromCharCode(t)},o:function(t){return t.toString(8)},x:function(t){return t.toString(16)},X:function(t){return t.toString(16).toUpperCase()},g:function(t,e){return t.toPrecision(e)},e:function(t,e){return t.toExponential(e)},f:function(t,e){return t.toFixed(e)},r:function(e,r){return(e=t.round(e,Ce(e,r))).toFixed(Math.max(0,Math.min(20,Ce(e*(1+1e-15),r))))}});function Pe(t){return t+""}var De=t.time={},Oe=Date;function Ie(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arguments):arguments[0])}Ie.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTime:function(){return this._.getTime()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.valueOf()},setDate:function(){Re.setUTCDate.apply(this._,arguments)},setDay:function(){Re.setUTCDay.apply(this._,arguments)},setFullYear:function(){Re.setUTCFullYear.apply(this._,arguments)},setHours:function(){Re.setUTCHours.apply(this._,arguments)},setMilliseconds:function(){Re.setUTCMilliseconds.apply(this._,arguments)},setMinutes:function(){Re.setUTCMinutes.apply(this._,arguments)},setMonth:function(){Re.setUTCMonth.apply(this._,arguments)},setSeconds:function(){Re.setUTCSeconds.apply(this._,arguments)},setTime:function(){Re.setTime.apply(this._,arguments)}};var Re=Date.prototype;function Be(t,e,r){function n(e){var r=t(e),n=a(r,1);return e-r1)for(;o68?1900:2e3),r+i[0].length):-1}function Je(t,e,r){return/^[+-]\d{4}$/.test(e=e.slice(r,r+5))?(t.Z=-e,r+5):-1}function Ke(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.m=n[0]-1,r+n[0].length):-1}function Qe(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.d=+n[0],r+n[0].length):-1}function $e(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+3));return n?(t.j=+n[0],r+n[0].length):-1}function tr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.H=+n[0],r+n[0].length):-1}function er(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.M=+n[0],r+n[0].length):-1}function rr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.S=+n[0],r+n[0].length):-1}function nr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+3));return n?(t.L=+n[0],r+n[0].length):-1}function ir(t){var e=t.getTimezoneOffset(),r=e>0?"-":"+",n=y(e)/60|0,i=y(e)%60;return r+Ue(n,"0",2)+Ue(i,"0",2)}function ar(t,e,r){Ve.lastIndex=0;var n=Ve.exec(e.slice(r,r+1));return n?r+n[0].length:-1}function or(t){for(var e=t.length,r=-1;++r0&&s>0&&(l+s+1>e&&(s=Math.max(1,e-l)),a.push(t.substring(r-=s,r+s)),!((l+=s+1)>e));)s=i[o=(o+1)%i.length];return a.reverse().join(n)}:z;return function(e){var n=Le.exec(e),i=n[1]||" ",s=n[2]||">",l=n[3]||"-",c=n[4]||"",u=n[5],f=+n[6],h=n[7],p=n[8],d=n[9],g=1,m="",v="",y=!1,x=!0;switch(p&&(p=+p.substring(1)),(u||"0"===i&&"="===s)&&(u=i="0",s="="),d){case"n":h=!0,d="g";break;case"%":g=100,v="%",d="f";break;case"p":g=100,v="%",d="r";break;case"b":case"o":case"x":case"X":"#"===c&&(m="0"+d.toLowerCase());case"c":x=!1;case"d":y=!0,p=0;break;case"s":g=-1,d="r"}"$"===c&&(m=a[0],v=a[1]),"r"!=d||p||(d="g"),null!=p&&("g"==d?p=Math.max(1,Math.min(21,p)):"e"!=d&&"f"!=d||(p=Math.max(0,Math.min(20,p)))),d=ze.get(d)||Pe;var b=u&&h;return function(e){var n=v;if(y&&e%1)return"";var a=e<0||0===e&&1/e<0?(e=-e,"-"):"-"===l?"":l;if(g<0){var c=t.formatPrefix(e,p);e=c.scale(e),n=c.symbol+v}else e*=g;var _,w,k=(e=d(e,p)).lastIndexOf(".");if(k<0){var M=x?e.lastIndexOf("e"):-1;M<0?(_=e,w=""):(_=e.substring(0,M),w=e.substring(M))}else _=e.substring(0,k),w=r+e.substring(k+1);!u&&h&&(_=o(_,1/0));var A=m.length+_.length+w.length+(b?0:a.length),T=A"===s?T+a+e:"^"===s?T.substring(0,A>>=1)+a+e+T.substring(A):a+(b?e:T+e))+n}}}(e),timeFormat:function(e){var r=e.dateTime,n=e.date,i=e.time,a=e.periods,o=e.days,s=e.shortDays,l=e.months,c=e.shortMonths;function u(t){var e=t.length;function r(r){for(var n,i,a,o=[],s=-1,l=0;++s=c)return-1;if(37===(i=e.charCodeAt(s++))){if(o=e.charAt(s++),!(a=w[o in Ne?e.charAt(s++):o])||(n=a(t,r,n))<0)return-1}else if(i!=r.charCodeAt(n++))return-1}return n}u.utc=function(t){var e=u(t);function r(t){try{var r=new(Oe=Ie);return r._=t,e(r)}finally{Oe=Date}}return r.parse=function(t){try{Oe=Ie;var r=e.parse(t);return r&&r._}finally{Oe=Date}},r.toString=e.toString,r},u.multi=u.utc.multi=or;var h=t.map(),p=qe(o),d=He(o),g=qe(s),m=He(s),v=qe(l),y=He(l),x=qe(c),b=He(c);a.forEach(function(t,e){h.set(t.toLowerCase(),e)});var _={a:function(t){return s[t.getDay()]},A:function(t){return o[t.getDay()]},b:function(t){return c[t.getMonth()]},B:function(t){return l[t.getMonth()]},c:u(r),d:function(t,e){return Ue(t.getDate(),e,2)},e:function(t,e){return Ue(t.getDate(),e,2)},H:function(t,e){return Ue(t.getHours(),e,2)},I:function(t,e){return Ue(t.getHours()%12||12,e,2)},j:function(t,e){return Ue(1+De.dayOfYear(t),e,3)},L:function(t,e){return Ue(t.getMilliseconds(),e,3)},m:function(t,e){return Ue(t.getMonth()+1,e,2)},M:function(t,e){return Ue(t.getMinutes(),e,2)},p:function(t){return a[+(t.getHours()>=12)]},S:function(t,e){return Ue(t.getSeconds(),e,2)},U:function(t,e){return Ue(De.sundayOfYear(t),e,2)},w:function(t){return t.getDay()},W:function(t,e){return Ue(De.mondayOfYear(t),e,2)},x:u(n),X:u(i),y:function(t,e){return Ue(t.getFullYear()%100,e,2)},Y:function(t,e){return Ue(t.getFullYear()%1e4,e,4)},Z:ir,"%":function(){return"%"}},w={a:function(t,e,r){g.lastIndex=0;var n=g.exec(e.slice(r));return n?(t.w=m.get(n[0].toLowerCase()),r+n[0].length):-1},A:function(t,e,r){p.lastIndex=0;var n=p.exec(e.slice(r));return n?(t.w=d.get(n[0].toLowerCase()),r+n[0].length):-1},b:function(t,e,r){x.lastIndex=0;var n=x.exec(e.slice(r));return n?(t.m=b.get(n[0].toLowerCase()),r+n[0].length):-1},B:function(t,e,r){v.lastIndex=0;var n=v.exec(e.slice(r));return n?(t.m=y.get(n[0].toLowerCase()),r+n[0].length):-1},c:function(t,e,r){return f(t,_.c.toString(),e,r)},d:Qe,e:Qe,H:tr,I:tr,j:$e,L:nr,m:Ke,M:er,p:function(t,e,r){var n=h.get(e.slice(r,r+=2).toLowerCase());return null==n?-1:(t.p=n,r)},S:rr,U:We,w:Ge,W:Ye,x:function(t,e,r){return f(t,_.x.toString(),e,r)},X:function(t,e,r){return f(t,_.X.toString(),e,r)},y:Ze,Y:Xe,Z:Je,"%":ar};return u}(e)}};var sr=t.locale({decimal:".",thousands:",",grouping:[3],currency:["$",""],dateTime:"%a %b %e %X %Y",date:"%m/%d/%Y",time:"%H:%M:%S",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function lr(){}t.format=sr.numberFormat,t.geo={},lr.prototype={s:0,t:0,add:function(t){ur(t,this.t,cr),ur(cr.s,this.s,this),this.s?this.t+=cr.t:this.s=cr.t},reset:function(){this.s=this.t=0},valueOf:function(){return this.s}};var cr=new lr;function ur(t,e,r){var n=r.s=t+e,i=n-t,a=n-i;r.t=t-a+(e-i)}function fr(t,e){t&&pr.hasOwnProperty(t.type)&&pr[t.type](t,e)}t.geo.stream=function(t,e){t&&hr.hasOwnProperty(t.type)?hr[t.type](t,e):fr(t,e)};var hr={Feature:function(t,e){fr(t.geometry,e)},FeatureCollection:function(t,e){for(var r=t.features,n=-1,i=r.length;++n=0?1:-1,s=o*a,l=Math.cos(e),c=Math.sin(e),u=i*c,f=n*l+u*Math.cos(s),h=u*o*Math.sin(s);Cr.add(Math.atan2(h,f)),r=t,n=l,i=c}Er.point=function(o,s){Er.point=a,r=(t=o)*Et,n=Math.cos(s=(e=s)*Et/2+At/4),i=Math.sin(s)},Er.lineEnd=function(){a(t,e)}}function zr(t){var e=t[0],r=t[1],n=Math.cos(r);return[n*Math.cos(e),n*Math.sin(e),Math.sin(r)]}function Pr(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function Dr(t,e){return[t[1]*e[2]-t[2]*e[1],t[2]*e[0]-t[0]*e[2],t[0]*e[1]-t[1]*e[0]]}function Or(t,e){t[0]+=e[0],t[1]+=e[1],t[2]+=e[2]}function Ir(t,e){return[t[0]*e,t[1]*e,t[2]*e]}function Rr(t){var e=Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=e,t[1]/=e,t[2]/=e}function Br(t){return[Math.atan2(t[1],t[0]),Ot(t[2])]}function Fr(t,e){return y(t[0]-e[0])kt?i=90:c<-kt&&(r=-90),f[0]=e,f[1]=n}};function p(t,a){u.push(f=[e=t,n=t]),ai&&(i=a)}function d(t,o){var s=zr([t*Et,o*Et]);if(l){var c=Dr(l,s),u=Dr([c[1],-c[0],0],c);Rr(u),u=Br(u);var f=t-a,h=f>0?1:-1,d=u[0]*Lt*h,g=y(f)>180;if(g^(h*ai&&(i=m);else if(g^(h*a<(d=(d+360)%360-180)&&di&&(i=o);g?t_(e,n)&&(n=t):_(t,n)>_(e,n)&&(e=t):n>=e?(tn&&(n=t)):t>a?_(e,t)>_(e,n)&&(n=t):_(t,n)>_(e,n)&&(e=t)}else p(t,o);l=s,a=t}function g(){h.point=d}function m(){f[0]=e,f[1]=n,h.point=p,l=null}function v(t,e){if(l){var r=t-a;c+=y(r)>180?r+(r>0?360:-360):r}else o=t,s=e;Er.point(t,e),d(t,e)}function x(){Er.lineStart()}function b(){v(o,s),Er.lineEnd(),y(c)>kt&&(e=-(n=180)),f[0]=e,f[1]=n,l=null}function _(t,e){return(e-=t)<0?e+360:e}function w(t,e){return t[0]-e[0]}function k(t,e){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t_(g[0],g[1])&&(g[1]=p[1]),_(p[0],g[1])>_(g[0],g[1])&&(g[0]=p[0])):s.push(g=p);for(var l,c,p,d=-1/0,g=(o=0,s[c=s.length-1]);o<=c;g=p,++o)p=s[o],(l=_(g[1],p[0]))>d&&(d=l,e=p[0],n=g[1])}return u=f=null,e===1/0||r===1/0?[[NaN,NaN],[NaN,NaN]]:[[e,r],[n,i]]}}(),t.geo.centroid=function(e){vr=yr=xr=br=_r=wr=kr=Mr=Ar=Tr=Sr=0,t.geo.stream(e,Nr);var r=Ar,n=Tr,i=Sr,a=r*r+n*n+i*i;return a=0;--s)i.point((f=u[s])[0],f[1]);else n(p.x,p.p.x,-1,i);p=p.p}u=(p=p.o).z,d=!d}while(!p.v);i.lineEnd()}}}function Xr(t){if(e=t.length){for(var e,r,n=0,i=t[0];++n=0?1:-1,k=w*_,M=k>At,A=d*x;if(Cr.add(Math.atan2(A*w*Math.sin(k),g*b+A*Math.cos(k))),a+=M?_+w*Tt:_,M^h>=r^v>=r){var T=Dr(zr(f),zr(t));Rr(T);var S=Dr(i,T);Rr(S);var C=(M^_>=0?-1:1)*Ot(S[2]);(n>C||n===C&&(T[0]||T[1]))&&(o+=M^_>=0?1:-1)}if(!m++)break;h=v,d=x,g=b,f=t}}return(a<-kt||a0){for(x||(o.polygonStart(),x=!0),o.lineStart();++a1&&2&e&&r.push(r.pop().concat(r.shift())),s.push(r.filter(Kr))}return u}}function Kr(t){return t.length>1}function Qr(){var t,e=[];return{lineStart:function(){e.push(t=[])},point:function(e,r){t.push([e,r])},lineEnd:I,buffer:function(){var r=e;return e=[],t=null,r},rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))}}}function $r(t,e){return((t=t.x)[0]<0?t[1]-Ct-kt:Ct-t[1])-((e=e.x)[0]<0?e[1]-Ct-kt:Ct-e[1])}var tn=Jr(Wr,function(t){var e,r=NaN,n=NaN,i=NaN;return{lineStart:function(){t.lineStart(),e=1},point:function(a,o){var s=a>0?At:-At,l=y(a-r);y(l-At)0?Ct:-Ct),t.point(i,n),t.lineEnd(),t.lineStart(),t.point(s,n),t.point(a,n),e=0):i!==s&&l>=At&&(y(r-i)kt?Math.atan((Math.sin(e)*(a=Math.cos(n))*Math.sin(r)-Math.sin(n)*(i=Math.cos(e))*Math.sin(t))/(i*a*o)):(e+n)/2}(r,n,a,o),t.point(i,n),t.lineEnd(),t.lineStart(),t.point(s,n),e=0),t.point(r=a,n=o),i=s},lineEnd:function(){t.lineEnd(),r=n=NaN},clean:function(){return 2-e}}},function(t,e,r,n){var i;if(null==t)i=r*Ct,n.point(-At,i),n.point(0,i),n.point(At,i),n.point(At,0),n.point(At,-i),n.point(0,-i),n.point(-At,-i),n.point(-At,0),n.point(-At,i);else if(y(t[0]-e[0])>kt){var a=t[0]0)){if(a/=h,h<0){if(a0){if(a>f)return;a>u&&(u=a)}if(a=r-l,h||!(a<0)){if(a/=h,h<0){if(a>f)return;a>u&&(u=a)}else if(h>0){if(a0)){if(a/=p,p<0){if(a0){if(a>f)return;a>u&&(u=a)}if(a=n-c,p||!(a<0)){if(a/=p,p<0){if(a>f)return;a>u&&(u=a)}else if(p>0){if(a0&&(i.a={x:l+u*h,y:c+u*p}),f<1&&(i.b={x:l+f*h,y:c+f*p}),i}}}}}}var rn=1e9;function nn(e,r,n,i){return function(l){var c,u,f,h,p,d,g,m,v,y,x,b=l,_=Qr(),w=en(e,r,n,i),k={point:T,lineStart:function(){k.point=S,u&&u.push(f=[]);y=!0,v=!1,g=m=NaN},lineEnd:function(){c&&(S(h,p),d&&v&&_.rejoin(),c.push(_.buffer()));k.point=T,v&&l.lineEnd()},polygonStart:function(){l=_,c=[],u=[],x=!0},polygonEnd:function(){l=b,c=t.merge(c);var r=function(t){for(var e=0,r=u.length,n=t[1],i=0;in&&Pt(c,a,t)>0&&++e:a[1]<=n&&Pt(c,a,t)<0&&--e,c=a;return 0!==e}([e,i]),n=x&&r,a=c.length;(n||a)&&(l.polygonStart(),n&&(l.lineStart(),M(null,null,1,l),l.lineEnd()),a&&Yr(c,o,r,M,l),l.polygonEnd()),c=u=f=null}};function M(t,o,l,c){var u=0,f=0;if(null==t||(u=a(t,l))!==(f=a(o,l))||s(t,o)<0^l>0)do{c.point(0===u||3===u?e:n,u>1?i:r)}while((u=(u+l+4)%4)!==f);else c.point(o[0],o[1])}function A(t,a){return e<=t&&t<=n&&r<=a&&a<=i}function T(t,e){A(t,e)&&l.point(t,e)}function S(t,e){var r=A(t=Math.max(-rn,Math.min(rn,t)),e=Math.max(-rn,Math.min(rn,e)));if(u&&f.push([t,e]),y)h=t,p=e,d=r,y=!1,r&&(l.lineStart(),l.point(t,e));else if(r&&v)l.point(t,e);else{var n={a:{x:g,y:m},b:{x:t,y:e}};w(n)?(v||(l.lineStart(),l.point(n.a.x,n.a.y)),l.point(n.b.x,n.b.y),r||l.lineEnd(),x=!1):r&&(l.lineStart(),l.point(t,e),x=!1)}g=t,m=e,v=r}return k};function a(t,i){return y(t[0]-e)0?0:3:y(t[0]-n)0?2:1:y(t[1]-r)0?1:0:i>0?3:2}function o(t,e){return s(t.x,e.x)}function s(t,e){var r=a(t,1),n=a(e,1);return r!==n?r-n:0===r?e[1]-t[1]:1===r?t[0]-e[0]:2===r?t[1]-e[1]:e[0]-t[0]}}function an(t){var e=0,r=At/3,n=Sn(t),i=n(e,r);return i.parallels=function(t){return arguments.length?n(e=t[0]*At/180,r=t[1]*At/180):[e/At*180,r/At*180]},i}function on(t,e){var r=Math.sin(t),n=(r+Math.sin(e))/2,i=1+r*(2*n-r),a=Math.sqrt(i)/n;function o(t,e){var r=Math.sqrt(i-2*n*Math.sin(e))/n;return[r*Math.sin(t*=n),a-r*Math.cos(t)]}return o.invert=function(t,e){var r=a-e;return[Math.atan2(t,r)/n,Ot((i-(t*t+r*r)*n*n)/(2*n))]},o}t.geo.clipExtent=function(){var t,e,r,n,i,a,o={stream:function(t){return i&&(i.valid=!1),(i=a(t)).valid=!0,i},extent:function(s){return arguments.length?(a=nn(t=+s[0][0],e=+s[0][1],r=+s[1][0],n=+s[1][1]),i&&(i.valid=!1,i=null),o):[[t,e],[r,n]]}};return o.extent([[0,0],[960,500]])},(t.geo.conicEqualArea=function(){return an(on)}).raw=on,t.geo.albers=function(){return t.geo.conicEqualArea().rotate([96,0]).center([-.6,38.7]).parallels([29.5,45.5]).scale(1070)},t.geo.albersUsa=function(){var e,r,n,i,a=t.geo.albers(),o=t.geo.conicEqualArea().rotate([154,0]).center([-2,58.5]).parallels([55,65]),s=t.geo.conicEqualArea().rotate([157,0]).center([-3,19.9]).parallels([8,18]),l={point:function(t,r){e=[t,r]}};function c(t){var a=t[0],o=t[1];return e=null,r(a,o),e||(n(a,o),e)||i(a,o),e}return c.invert=function(t){var e=a.scale(),r=a.translate(),n=(t[0]-r[0])/e,i=(t[1]-r[1])/e;return(i>=.12&&i<.234&&n>=-.425&&n<-.214?o:i>=.166&&i<.234&&n>=-.214&&n<-.115?s:a).invert(t)},c.stream=function(t){var e=a.stream(t),r=o.stream(t),n=s.stream(t);return{point:function(t,i){e.point(t,i),r.point(t,i),n.point(t,i)},sphere:function(){e.sphere(),r.sphere(),n.sphere()},lineStart:function(){e.lineStart(),r.lineStart(),n.lineStart()},lineEnd:function(){e.lineEnd(),r.lineEnd(),n.lineEnd()},polygonStart:function(){e.polygonStart(),r.polygonStart(),n.polygonStart()},polygonEnd:function(){e.polygonEnd(),r.polygonEnd(),n.polygonEnd()}}},c.precision=function(t){return arguments.length?(a.precision(t),o.precision(t),s.precision(t),c):a.precision()},c.scale=function(t){return arguments.length?(a.scale(t),o.scale(.35*t),s.scale(t),c.translate(a.translate())):a.scale()},c.translate=function(t){if(!arguments.length)return a.translate();var e=a.scale(),u=+t[0],f=+t[1];return r=a.translate(t).clipExtent([[u-.455*e,f-.238*e],[u+.455*e,f+.238*e]]).stream(l).point,n=o.translate([u-.307*e,f+.201*e]).clipExtent([[u-.425*e+kt,f+.12*e+kt],[u-.214*e-kt,f+.234*e-kt]]).stream(l).point,i=s.translate([u-.205*e,f+.212*e]).clipExtent([[u-.214*e+kt,f+.166*e+kt],[u-.115*e-kt,f+.234*e-kt]]).stream(l).point,c},c.scale(1070)};var sn,ln,cn,un,fn,hn,pn={point:I,lineStart:I,lineEnd:I,polygonStart:function(){ln=0,pn.lineStart=dn},polygonEnd:function(){pn.lineStart=pn.lineEnd=pn.point=I,sn+=y(ln/2)}};function dn(){var t,e,r,n;function i(t,e){ln+=n*t-r*e,r=t,n=e}pn.point=function(a,o){pn.point=i,t=r=a,e=n=o},pn.lineEnd=function(){i(t,e)}}var gn={point:function(t,e){tfn&&(fn=t);ehn&&(hn=e)},lineStart:I,lineEnd:I,polygonStart:I,polygonEnd:I};function mn(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}var vn,yn={point:xn,lineStart:bn,lineEnd:_n,polygonStart:function(){yn.lineStart=wn},polygonEnd:function(){yn.point=xn,yn.lineStart=bn,yn.lineEnd=_n}};function xn(t,e){xr+=t,br+=e,++_r}function bn(){var t,e;function r(r,n){var i=r-t,a=n-e,o=Math.sqrt(i*i+a*a);wr+=o*(t+r)/2,kr+=o*(e+n)/2,Mr+=o,xn(t=r,e=n)}yn.point=function(n,i){yn.point=r,xn(t=n,e=i)}}function _n(){yn.point=xn}function wn(){var t,e,r,n;function i(t,e){var i=t-r,a=e-n,o=Math.sqrt(i*i+a*a);wr+=o*(r+t)/2,kr+=o*(n+e)/2,Mr+=o,Ar+=(o=n*t-r*e)*(r+t),Tr+=o*(n+e),Sr+=3*o,xn(r=t,n=e)}yn.point=function(a,o){yn.point=i,xn(t=r=a,e=n=o)},yn.lineEnd=function(){i(t,e)}}function kn(t){var e=.5,r=Math.cos(30*Et),n=16;function i(e){return(n?function(e){var r,i,o,s,l,c,u,f,h,p,d,g,m={point:v,lineStart:y,lineEnd:b,polygonStart:function(){e.polygonStart(),m.lineStart=_},polygonEnd:function(){e.polygonEnd(),m.lineStart=y}};function v(r,n){r=t(r,n),e.point(r[0],r[1])}function y(){f=NaN,m.point=x,e.lineStart()}function x(r,i){var o=zr([r,i]),s=t(r,i);a(f,h,u,p,d,g,f=s[0],h=s[1],u=r,p=o[0],d=o[1],g=o[2],n,e),e.point(f,h)}function b(){m.point=v,e.lineEnd()}function _(){y(),m.point=w,m.lineEnd=k}function w(t,e){x(r=t,e),i=f,o=h,s=p,l=d,c=g,m.point=x}function k(){a(f,h,u,p,d,g,i,o,r,s,l,c,n,e),m.lineEnd=b,b()}return m}:function(e){return An(e,function(r,n){r=t(r,n),e.point(r[0],r[1])})})(e)}function a(n,i,o,s,l,c,u,f,h,p,d,g,m,v){var x=u-n,b=f-i,_=x*x+b*b;if(_>4*e&&m--){var w=s+p,k=l+d,M=c+g,A=Math.sqrt(w*w+k*k+M*M),T=Math.asin(M/=A),S=y(y(M)-1)e||y((x*z+b*P)/_-.5)>.3||s*p+l*d+c*g0&&16,i):Math.sqrt(e)},i}function Mn(t){this.stream=t}function An(t,e){return{point:e,sphere:function(){t.sphere()},lineStart:function(){t.lineStart()},lineEnd:function(){t.lineEnd()},polygonStart:function(){t.polygonStart()},polygonEnd:function(){t.polygonEnd()}}}function Tn(t){return Sn(function(){return t})()}function Sn(e){var r,n,i,a,o,s,l=kn(function(t,e){return[(t=r(t,e))[0]*c+a,o-t[1]*c]}),c=150,u=480,f=250,h=0,p=0,d=0,g=0,m=0,v=tn,x=z,b=null,_=null;function w(t){return[(t=i(t[0]*Et,t[1]*Et))[0]*c+a,o-t[1]*c]}function k(t){return(t=i.invert((t[0]-a)/c,(o-t[1])/c))&&[t[0]*Lt,t[1]*Lt]}function M(){i=Gr(n=zn(d,g,m),r);var t=r(h,p);return a=u-t[0]*c,o=f+t[1]*c,A()}function A(){return s&&(s.valid=!1,s=null),w}return w.stream=function(t){return s&&(s.valid=!1),(s=Cn(v(n,l(x(t))))).valid=!0,s},w.clipAngle=function(t){return arguments.length?(v=null==t?(b=t,tn):function(t){var e=Math.cos(t),r=e>0,n=y(e)>kt;return Jr(i,function(t){var e,s,l,c,u;return{lineStart:function(){c=l=!1,u=1},point:function(f,h){var p,d=[f,h],g=i(f,h),m=r?g?0:o(f,h):g?o(f+(f<0?At:-At),h):0;if(!e&&(c=l=g)&&t.lineStart(),g!==l&&(p=a(e,d),(Fr(e,p)||Fr(d,p))&&(d[0]+=kt,d[1]+=kt,g=i(d[0],d[1]))),g!==l)u=0,g?(t.lineStart(),p=a(d,e),t.point(p[0],p[1])):(p=a(e,d),t.point(p[0],p[1]),t.lineEnd()),e=p;else if(n&&e&&r^g){var v;m&s||!(v=a(d,e,!0))||(u=0,r?(t.lineStart(),t.point(v[0][0],v[0][1]),t.point(v[1][0],v[1][1]),t.lineEnd()):(t.point(v[1][0],v[1][1]),t.lineEnd(),t.lineStart(),t.point(v[0][0],v[0][1])))}!g||e&&Fr(e,d)||t.point(d[0],d[1]),e=d,l=g,s=m},lineEnd:function(){l&&t.lineEnd(),e=null},clean:function(){return u|(c&&l)<<1}}},In(t,6*Et),r?[0,-t]:[-At,t-At]);function i(t,r){return Math.cos(t)*Math.cos(r)>e}function a(t,r,n){var i=[1,0,0],a=Dr(zr(t),zr(r)),o=Pr(a,a),s=a[0],l=o-s*s;if(!l)return!n&&t;var c=e*o/l,u=-e*s/l,f=Dr(i,a),h=Ir(i,c);Or(h,Ir(a,u));var p=f,d=Pr(h,p),g=Pr(p,p),m=d*d-g*(Pr(h,h)-1);if(!(m<0)){var v=Math.sqrt(m),x=Ir(p,(-d-v)/g);if(Or(x,h),x=Br(x),!n)return x;var b,_=t[0],w=r[0],k=t[1],M=r[1];w<_&&(b=_,_=w,w=b);var A=w-_,T=y(A-At)0^x[1]<(y(x[0]-_)At^(_<=x[0]&&x[0]<=w)){var S=Ir(p,(-d+v)/g);return Or(S,h),[x,Br(S)]}}}function o(e,n){var i=r?t:At-t,a=0;return e<-i?a|=1:e>i&&(a|=2),n<-i?a|=4:n>i&&(a|=8),a}}((b=+t)*Et),A()):b},w.clipExtent=function(t){return arguments.length?(_=t,x=t?nn(t[0][0],t[0][1],t[1][0],t[1][1]):z,A()):_},w.scale=function(t){return arguments.length?(c=+t,M()):c},w.translate=function(t){return arguments.length?(u=+t[0],f=+t[1],M()):[u,f]},w.center=function(t){return arguments.length?(h=t[0]%360*Et,p=t[1]%360*Et,M()):[h*Lt,p*Lt]},w.rotate=function(t){return arguments.length?(d=t[0]%360*Et,g=t[1]%360*Et,m=t.length>2?t[2]%360*Et:0,M()):[d*Lt,g*Lt,m*Lt]},t.rebind(w,l,"precision"),function(){return r=e.apply(this,arguments),w.invert=r.invert&&k,M()}}function Cn(t){return An(t,function(e,r){t.point(e*Et,r*Et)})}function En(t,e){return[t,e]}function Ln(t,e){return[t>At?t-Tt:t<-At?t+Tt:t,e]}function zn(t,e,r){return t?e||r?Gr(Dn(t),On(e,r)):Dn(t):e||r?On(e,r):Ln}function Pn(t){return function(e,r){return[(e+=t)>At?e-Tt:e<-At?e+Tt:e,r]}}function Dn(t){var e=Pn(t);return e.invert=Pn(-t),e}function On(t,e){var r=Math.cos(t),n=Math.sin(t),i=Math.cos(e),a=Math.sin(e);function o(t,e){var o=Math.cos(e),s=Math.cos(t)*o,l=Math.sin(t)*o,c=Math.sin(e),u=c*r+s*n;return[Math.atan2(l*i-u*a,s*r-c*n),Ot(u*i+l*a)]}return o.invert=function(t,e){var o=Math.cos(e),s=Math.cos(t)*o,l=Math.sin(t)*o,c=Math.sin(e),u=c*i-l*a;return[Math.atan2(l*i+c*a,s*r+u*n),Ot(u*r-s*n)]},o}function In(t,e){var r=Math.cos(t),n=Math.sin(t);return function(i,a,o,s){var l=o*e;null!=i?(i=Rn(r,i),a=Rn(r,a),(o>0?ia)&&(i+=o*Tt)):(i=t+o*Tt,a=t-.5*l);for(var c,u=i;o>0?u>a:u2?t[2]*Et:0),e.invert=function(e){return(e=t.invert(e[0]*Et,e[1]*Et))[0]*=Lt,e[1]*=Lt,e},e},Ln.invert=En,t.geo.circle=function(){var t,e,r=[0,0],n=6;function i(){var t="function"==typeof r?r.apply(this,arguments):r,n=zn(-t[0]*Et,-t[1]*Et,0).invert,i=[];return e(null,null,1,{point:function(t,e){i.push(t=n(t,e)),t[0]*=Lt,t[1]*=Lt}}),{type:"Polygon",coordinates:[i]}}return i.origin=function(t){return arguments.length?(r=t,i):r},i.angle=function(r){return arguments.length?(e=In((t=+r)*Et,n*Et),i):t},i.precision=function(r){return arguments.length?(e=In(t*Et,(n=+r)*Et),i):n},i.angle(90)},t.geo.distance=function(t,e){var r,n=(e[0]-t[0])*Et,i=t[1]*Et,a=e[1]*Et,o=Math.sin(n),s=Math.cos(n),l=Math.sin(i),c=Math.cos(i),u=Math.sin(a),f=Math.cos(a);return Math.atan2(Math.sqrt((r=f*o)*r+(r=c*u-l*f*s)*r),l*u+c*f*s)},t.geo.graticule=function(){var e,r,n,i,a,o,s,l,c,u,f,h,p=10,d=p,g=90,m=360,v=2.5;function x(){return{type:"MultiLineString",coordinates:b()}}function b(){return t.range(Math.ceil(i/g)*g,n,g).map(f).concat(t.range(Math.ceil(l/m)*m,s,m).map(h)).concat(t.range(Math.ceil(r/p)*p,e,p).filter(function(t){return y(t%g)>kt}).map(c)).concat(t.range(Math.ceil(o/d)*d,a,d).filter(function(t){return y(t%m)>kt}).map(u))}return x.lines=function(){return b().map(function(t){return{type:"LineString",coordinates:t}})},x.outline=function(){return{type:"Polygon",coordinates:[f(i).concat(h(s).slice(1),f(n).reverse().slice(1),h(l).reverse().slice(1))]}},x.extent=function(t){return arguments.length?x.majorExtent(t).minorExtent(t):x.minorExtent()},x.majorExtent=function(t){return arguments.length?(i=+t[0][0],n=+t[1][0],l=+t[0][1],s=+t[1][1],i>n&&(t=i,i=n,n=t),l>s&&(t=l,l=s,s=t),x.precision(v)):[[i,l],[n,s]]},x.minorExtent=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],o=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),o>a&&(t=o,o=a,a=t),x.precision(v)):[[r,o],[e,a]]},x.step=function(t){return arguments.length?x.majorStep(t).minorStep(t):x.minorStep()},x.majorStep=function(t){return arguments.length?(g=+t[0],m=+t[1],x):[g,m]},x.minorStep=function(t){return arguments.length?(p=+t[0],d=+t[1],x):[p,d]},x.precision=function(t){return arguments.length?(v=+t,c=Bn(o,a,90),u=Fn(r,e,v),f=Bn(l,s,90),h=Fn(i,n,v),x):v},x.majorExtent([[-180,-90+kt],[180,90-kt]]).minorExtent([[-180,-80-kt],[180,80+kt]])},t.geo.greatArc=function(){var e,r,n=Nn,i=jn;function a(){return{type:"LineString",coordinates:[e||n.apply(this,arguments),r||i.apply(this,arguments)]}}return a.distance=function(){return t.geo.distance(e||n.apply(this,arguments),r||i.apply(this,arguments))},a.source=function(t){return arguments.length?(n=t,e="function"==typeof t?null:t,a):n},a.target=function(t){return arguments.length?(i=t,r="function"==typeof t?null:t,a):i},a.precision=function(){return arguments.length?a:0},a},t.geo.interpolate=function(t,e){return r=t[0]*Et,n=t[1]*Et,i=e[0]*Et,a=e[1]*Et,o=Math.cos(n),s=Math.sin(n),l=Math.cos(a),c=Math.sin(a),u=o*Math.cos(r),f=o*Math.sin(r),h=l*Math.cos(i),p=l*Math.sin(i),d=2*Math.asin(Math.sqrt(Rt(a-n)+o*l*Rt(i-r))),g=1/Math.sin(d),(m=d?function(t){var e=Math.sin(t*=d)*g,r=Math.sin(d-t)*g,n=r*u+e*h,i=r*f+e*p,a=r*s+e*c;return[Math.atan2(i,n)*Lt,Math.atan2(a,Math.sqrt(n*n+i*i))*Lt]}:function(){return[r*Lt,n*Lt]}).distance=d,m;var r,n,i,a,o,s,l,c,u,f,h,p,d,g,m},t.geo.length=function(e){return vn=0,t.geo.stream(e,Vn),vn};var Vn={sphere:I,point:I,lineStart:function(){var t,e,r;function n(n,i){var a=Math.sin(i*=Et),o=Math.cos(i),s=y((n*=Et)-t),l=Math.cos(s);vn+=Math.atan2(Math.sqrt((s=o*Math.sin(s))*s+(s=r*a-e*o*l)*s),e*a+r*o*l),t=n,e=a,r=o}Vn.point=function(i,a){t=i*Et,e=Math.sin(a*=Et),r=Math.cos(a),Vn.point=n},Vn.lineEnd=function(){Vn.point=Vn.lineEnd=I}},lineEnd:I,polygonStart:I,polygonEnd:I};function Un(t,e){function r(e,r){var n=Math.cos(e),i=Math.cos(r),a=t(n*i);return[a*i*Math.sin(e),a*Math.sin(r)]}return r.invert=function(t,r){var n=Math.sqrt(t*t+r*r),i=e(n),a=Math.sin(i),o=Math.cos(i);return[Math.atan2(t*a,n*o),Math.asin(n&&r*a/n)]},r}var qn=Un(function(t){return Math.sqrt(2/(1+t))},function(t){return 2*Math.asin(t/2)});(t.geo.azimuthalEqualArea=function(){return Tn(qn)}).raw=qn;var Hn=Un(function(t){var e=Math.acos(t);return e&&e/Math.sin(e)},z);function Gn(t,e){var r=Math.cos(t),n=function(t){return Math.tan(At/4+t/2)},i=t===e?Math.sin(t):Math.log(r/Math.cos(e))/Math.log(n(e)/n(t)),a=r*Math.pow(n(t),i)/i;if(!i)return Xn;function o(t,e){a>0?e<-Ct+kt&&(e=-Ct+kt):e>Ct-kt&&(e=Ct-kt);var r=a/Math.pow(n(e),i);return[r*Math.sin(i*t),a-r*Math.cos(i*t)]}return o.invert=function(t,e){var r=a-e,n=zt(i)*Math.sqrt(t*t+r*r);return[Math.atan2(t,r)/i,2*Math.atan(Math.pow(a/n,1/i))-Ct]},o}function Wn(t,e){var r=Math.cos(t),n=t===e?Math.sin(t):(r-Math.cos(e))/(e-t),i=r/n+t;if(y(n)1&&Pt(t[r[n-2]],t[r[n-1]],t[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function ri(t,e){return t[0]-e[0]||t[1]-e[1]}(t.geo.stereographic=function(){return Tn(Kn)}).raw=Kn,Qn.invert=function(t,e){return[-e,2*Math.atan(Math.exp(t))-Ct]},(t.geo.transverseMercator=function(){var t=Zn(Qn),e=t.center,r=t.rotate;return t.center=function(t){return t?e([-t[1],t[0]]):[(t=e())[1],-t[0]]},t.rotate=function(t){return t?r([t[0],t[1],t.length>2?t[2]+90:90]):[(t=r())[0],t[1],t[2]-90]},r([0,0,90])}).raw=Qn,t.geom={},t.geom.hull=function(t){var e=$n,r=ti;if(arguments.length)return n(t);function n(t){if(t.length<3)return[];var n,i=me(e),a=me(r),o=t.length,s=[],l=[];for(n=0;n=0;--n)p.push(t[s[c[n]][2]]);for(n=+f;nkt)s=s.L;else{if(!((i=a-xi(s,o))>kt)){n>-kt?(e=s.P,r=s):i>-kt?(e=s,r=s.N):e=r=s;break}if(!s.R){e=s;break}s=s.R}var l=di(t);if(ci.insert(e,l),e||r){if(e===r)return ki(e),r=di(e.site),ci.insert(l,r),l.edge=r.edge=Ti(e.site,l.site),wi(e),void wi(r);if(r){ki(e),ki(r);var c=e.site,u=c.x,f=c.y,h=t.x-u,p=t.y-f,d=r.site,g=d.x-u,m=d.y-f,v=2*(h*m-p*g),y=h*h+p*p,x=g*g+m*m,b={x:(m*y-p*x)/v+u,y:(h*x-g*y)/v+f};Si(r.edge,c,d,b),l.edge=Ti(c,t,null,b),r.edge=Ti(t,d,null,b),wi(e),wi(r)}else l.edge=Ti(e.site,l.site)}}function yi(t,e){var r=t.site,n=r.x,i=r.y,a=i-e;if(!a)return n;var o=t.P;if(!o)return-1/0;var s=(r=o.site).x,l=r.y,c=l-e;if(!c)return s;var u=s-n,f=1/a-1/c,h=u/c;return f?(-h+Math.sqrt(h*h-2*f*(u*u/(-2*c)-l+c/2+i-a/2)))/f+n:(n+s)/2}function xi(t,e){var r=t.N;if(r)return yi(r,e);var n=t.site;return n.y===e?n.x:1/0}function bi(t){this.site=t,this.edges=[]}function _i(t,e){return e.angle-t.angle}function wi(t){var e=t.P,r=t.N;if(e&&r){var n=e.site,i=t.site,a=r.site;if(n!==a){var o=i.x,s=i.y,l=n.x-o,c=n.y-s,u=a.x-o,f=2*(l*(m=a.y-s)-c*u);if(!(f>=-Mt)){var h=l*l+c*c,p=u*u+m*m,d=(m*h-c*p)/f,g=(l*p-u*h)/f,m=g+s,v=pi.pop()||new function(){Li(this),this.x=this.y=this.arc=this.site=this.cy=null};v.arc=t,v.site=i,v.x=d+o,v.y=m+Math.sqrt(d*d+g*g),v.cy=m,t.circle=v;for(var y=null,x=fi._;x;)if(v.y=s)return;if(h>d){if(a){if(a.y>=c)return}else a={x:m,y:l};r={x:m,y:c}}else{if(a){if(a.y1)if(h>d){if(a){if(a.y>=c)return}else a={x:(l-i)/n,y:l};r={x:(c-i)/n,y:c}}else{if(a){if(a.y=s)return}else a={x:o,y:n*o+i};r={x:s,y:n*s+i}}else{if(a){if(a.xkt||y(i-r)>kt)&&(s.splice(o,0,new Ci((v=a.site,x=u,b=y(n-f)kt?{x:f,y:y(e-f)kt?{x:y(r-d)kt?{x:h,y:y(e-h)kt?{x:y(r-p)=r&&c.x<=i&&c.y>=n&&c.y<=o?[[r,o],[i,o],[i,n],[r,n]]:[]).point=t[s]}),e}function s(t){return t.map(function(t,e){return{x:Math.round(n(t,e)/kt)*kt,y:Math.round(i(t,e)/kt)*kt,i:e}})}return o.links=function(t){return Oi(s(t)).edges.filter(function(t){return t.l&&t.r}).map(function(e){return{source:t[e.l.i],target:t[e.r.i]}})},o.triangles=function(t){var e=[];return Oi(s(t)).cells.forEach(function(r,n){for(var i,a,o,s,l=r.site,c=r.edges.sort(_i),u=-1,f=c.length,h=c[f-1].edge,p=h.l===l?h.r:h.l;++ua&&(i=e.slice(a,i),s[o]?s[o]+=i:s[++o]=i),(r=r[0])===(n=n[0])?s[o]?s[o]+=n:s[++o]=n:(s[++o]=null,l.push({i:o,x:Vi(r,n)})),a=Hi.lastIndex;return ag&&(g=l.x),l.y>m&&(m=l.y),c.push(l.x),u.push(l.y);else for(f=0;fg&&(g=b),_>m&&(m=_),c.push(b),u.push(_)}var w=g-p,k=m-d;function M(t,e,r,n,i,a,o,s){if(!isNaN(r)&&!isNaN(n))if(t.leaf){var l=t.x,c=t.y;if(null!=l)if(y(l-r)+y(c-n)<.01)A(t,e,r,n,i,a,o,s);else{var u=t.point;t.x=t.y=t.point=null,A(t,u,l,c,i,a,o,s),A(t,e,r,n,i,a,o,s)}else t.x=r,t.y=n,t.point=e}else A(t,e,r,n,i,a,o,s)}function A(t,e,r,n,i,a,o,s){var l=.5*(i+o),c=.5*(a+s),u=r>=l,f=n>=c,h=f<<1|u;t.leaf=!1,t=t.nodes[h]||(t.nodes[h]={leaf:!0,nodes:[],point:null,x:null,y:null,add:function(t){M(T,t,+v(t,++f),+x(t,f),p,d,g,m)}}),u?i=l:o=l,f?a=c:s=c,M(t,e,r,n,i,a,o,s)}w>k?m=d+w:g=p+k;var T={leaf:!0,nodes:[],point:null,x:null,y:null,add:function(t){M(T,t,+v(t,++f),+x(t,f),p,d,g,m)}};if(T.visit=function(t){!function t(e,r,n,i,a,o){if(!e(r,n,i,a,o)){var s=.5*(n+a),l=.5*(i+o),c=r.nodes;c[0]&&t(e,c[0],n,i,s,l),c[1]&&t(e,c[1],s,i,a,l),c[2]&&t(e,c[2],n,l,s,o),c[3]&&t(e,c[3],s,l,a,o)}}(t,T,p,d,g,m)},T.find=function(t){return function(t,e,r,n,i,a,o){var s,l=1/0;return function t(c,u,f,h,p){if(!(u>a||f>o||h=_)<<1|e>=b,k=w+4;w=0&&!(n=t.interpolators[i](e,r)););return n}function Wi(t,e){var r,n=[],i=[],a=t.length,o=e.length,s=Math.min(t.length,e.length);for(r=0;r=1)return 1;var e=t*t,r=e*t;return 4*(t<.5?r:3*(t-e)+r-.75)}function ea(t){return 1-Math.cos(t*Ct)}function ra(t){return Math.pow(2,10*(t-1))}function na(t){return 1-Math.sqrt(1-t*t)}function ia(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375}function aa(t,e){return e-=t,function(r){return Math.round(t+e*r)}}function oa(t){var e,r,n,i=[t.a,t.b],a=[t.c,t.d],o=la(i),s=sa(i,a),l=la(((e=a)[0]+=(n=-s)*(r=i)[0],e[1]+=n*r[1],e))||0;i[0]*a[1]=0?t.slice(0,n):t,a=n>=0?t.slice(n+1):"in";return i=Xi.get(i)||Yi,a=Zi.get(a)||z,e=a(i.apply(null,r.call(arguments,1))),function(t){return t<=0?0:t>=1?1:e(t)}},t.interpolateHcl=function(e,r){e=t.hcl(e),r=t.hcl(r);var n=e.h,i=e.c,a=e.l,o=r.h-n,s=r.c-i,l=r.l-a;isNaN(s)&&(s=0,i=isNaN(i)?r.c:i);isNaN(o)?(o=0,n=isNaN(n)?r.h:n):o>180?o-=360:o<-180&&(o+=360);return function(t){return Yt(n+o*t,i+s*t,a+l*t)+""}},t.interpolateHsl=function(e,r){e=t.hsl(e),r=t.hsl(r);var n=e.h,i=e.s,a=e.l,o=r.h-n,s=r.s-i,l=r.l-a;isNaN(s)&&(s=0,i=isNaN(i)?r.s:i);isNaN(o)?(o=0,n=isNaN(n)?r.h:n):o>180?o-=360:o<-180&&(o+=360);return function(t){return Ht(n+o*t,i+s*t,a+l*t)+""}},t.interpolateLab=function(e,r){e=t.lab(e),r=t.lab(r);var n=e.l,i=e.a,a=e.b,o=r.l-n,s=r.a-i,l=r.b-a;return function(t){return te(n+o*t,i+s*t,a+l*t)+""}},t.interpolateRound=aa,t.transform=function(e){var r=i.createElementNS(t.ns.prefix.svg,"g");return(t.transform=function(t){if(null!=t){r.setAttribute("transform",t);var e=r.transform.baseVal.consolidate()}return new oa(e?e.matrix:ca)})(e)},oa.prototype.toString=function(){return"translate("+this.translate+")rotate("+this.rotate+")skewX("+this.skew+")scale("+this.scale+")"};var ca={a:1,b:0,c:0,d:1,e:0,f:0};function ua(t){return t.length?t.pop()+",":""}function fa(e,r){var n=[],i=[];return e=t.transform(e),r=t.transform(r),function(t,e,r,n){if(t[0]!==e[0]||t[1]!==e[1]){var i=r.push("translate(",null,",",null,")");n.push({i:i-4,x:Vi(t[0],e[0])},{i:i-2,x:Vi(t[1],e[1])})}else(e[0]||e[1])&&r.push("translate("+e+")")}(e.translate,r.translate,n,i),function(t,e,r,n){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),n.push({i:r.push(ua(r)+"rotate(",null,")")-2,x:Vi(t,e)})):e&&r.push(ua(r)+"rotate("+e+")")}(e.rotate,r.rotate,n,i),function(t,e,r,n){t!==e?n.push({i:r.push(ua(r)+"skewX(",null,")")-2,x:Vi(t,e)}):e&&r.push(ua(r)+"skewX("+e+")")}(e.skew,r.skew,n,i),function(t,e,r,n){if(t[0]!==e[0]||t[1]!==e[1]){var i=r.push(ua(r)+"scale(",null,",",null,")");n.push({i:i-4,x:Vi(t[0],e[0])},{i:i-2,x:Vi(t[1],e[1])})}else 1===e[0]&&1===e[1]||r.push(ua(r)+"scale("+e+")")}(e.scale,r.scale,n,i),e=r=null,function(t){for(var e,r=-1,a=i.length;++r0?n=t:(e.c=null,e.t=NaN,e=null,l.end({type:"end",alpha:n=0})):t>0&&(l.start({type:"start",alpha:n=t}),e=Me(s.tick)),s):n},s.start=function(){var t,e,r,n=v.length,l=y.length,u=c[0],d=c[1];for(t=0;t=0;)r.push(i[n])}function Aa(t,e){for(var r=[t],n=[];null!=(t=r.pop());)if(n.push(t),(a=t.children)&&(i=a.length))for(var i,a,o=-1;++o=0;)o.push(u=c[l]),u.parent=a,u.depth=a.depth+1;r&&(a.value=0),a.children=c}else r&&(a.value=+r.call(n,a,a.depth)||0),delete a.children;return Aa(i,function(e){var n,i;t&&(n=e.children)&&n.sort(t),r&&(i=e.parent)&&(i.value+=e.value)}),s}return n.sort=function(e){return arguments.length?(t=e,n):t},n.children=function(t){return arguments.length?(e=t,n):e},n.value=function(t){return arguments.length?(r=t,n):r},n.revalue=function(t){return r&&(Ma(t,function(t){t.children&&(t.value=0)}),Aa(t,function(t){var e;t.children||(t.value=+r.call(n,t,t.depth)||0),(e=t.parent)&&(e.value+=t.value)})),t},n},t.layout.partition=function(){var e=t.layout.hierarchy(),r=[1,1];function n(t,n){var i=e.call(this,t,n);return function t(e,r,n,i){var a=e.children;if(e.x=r,e.y=e.depth*i,e.dx=n,e.dy=i,a&&(o=a.length)){var o,s,l,c=-1;for(n=e.value?n/e.value:0;++cs&&(s=n),o.push(n)}for(r=0;ri&&(n=r,i=e);return n}function Na(t){return t.reduce(ja,0)}function ja(t,e){return t+e[1]}function Va(t,e){return Ua(t,Math.ceil(Math.log(e.length)/Math.LN2+1))}function Ua(t,e){for(var r=-1,n=+t[0],i=(t[1]-n)/e,a=[];++r<=e;)a[r]=i*r+n;return a}function qa(e){return[t.min(e),t.max(e)]}function Ha(t,e){return t.value-e.value}function Ga(t,e){var r=t._pack_next;t._pack_next=e,e._pack_prev=t,e._pack_next=r,r._pack_prev=e}function Wa(t,e){t._pack_next=e,e._pack_prev=t}function Ya(t,e){var r=e.x-t.x,n=e.y-t.y,i=t.r+e.r;return.999*i*i>r*r+n*n}function Xa(t){if((e=t.children)&&(l=e.length)){var e,r,n,i,a,o,s,l,c=1/0,u=-1/0,f=1/0,h=-1/0;if(e.forEach(Za),(r=e[0]).x=-r.r,r.y=0,x(r),l>1&&((n=e[1]).x=n.r,n.y=0,x(n),l>2))for(Ka(r,n,i=e[2]),x(i),Ga(r,i),r._pack_prev=i,Ga(i,n),n=r._pack_next,a=3;a0)for(o=-1;++o=f[0]&&l<=f[1]&&((s=c[t.bisect(h,l,1,d)-1]).y+=g,s.push(a[o]));return c}return a.value=function(t){return arguments.length?(r=t,a):r},a.range=function(t){return arguments.length?(n=me(t),a):n},a.bins=function(t){return arguments.length?(i="number"==typeof t?function(e){return Ua(e,t)}:me(t),a):i},a.frequency=function(t){return arguments.length?(e=!!t,a):e},a},t.layout.pack=function(){var e,r=t.layout.hierarchy().sort(Ha),n=0,i=[1,1];function a(t,a){var o=r.call(this,t,a),s=o[0],l=i[0],c=i[1],u=null==e?Math.sqrt:"function"==typeof e?e:function(){return e};if(s.x=s.y=0,Aa(s,function(t){t.r=+u(t.value)}),Aa(s,Xa),n){var f=n*(e?1:Math.max(2*s.r/l,2*s.r/c))/2;Aa(s,function(t){t.r+=f}),Aa(s,Xa),Aa(s,function(t){t.r-=f})}return function t(e,r,n,i){var a=e.children;e.x=r+=i*e.x;e.y=n+=i*e.y;e.r*=i;if(a)for(var o=-1,s=a.length;++op.x&&(p=t),t.depth>d.depth&&(d=t)});var g=r(h,p)/2-h.x,m=n[0]/(p.x+r(p,h)/2+g),v=n[1]/(d.depth||1);Ma(u,function(t){t.x=(t.x+g)*m,t.y=t.depth*v})}return c}function o(t){var e=t.children,n=t.parent.children,i=t.i?n[t.i-1]:null;if(e.length){!function(t){var e,r=0,n=0,i=t.children,a=i.length;for(;--a>=0;)(e=i[a]).z+=r,e.m+=r,r+=e.s+(n+=e.c)}(t);var a=(e[0].z+e[e.length-1].z)/2;i?(t.z=i.z+r(t._,i._),t.m=t.z-a):t.z=a}else i&&(t.z=i.z+r(t._,i._));t.parent.A=function(t,e,n){if(e){for(var i,a=t,o=t,s=e,l=a.parent.children[0],c=a.m,u=o.m,f=s.m,h=l.m;s=to(s),a=$a(a),s&&a;)l=$a(l),(o=to(o)).a=t,(i=s.z+f-a.z-c+r(s._,a._))>0&&(eo(ro(s,t,n),t,i),c+=i,u+=i),f+=s.m,c+=a.m,h+=l.m,u+=o.m;s&&!to(o)&&(o.t=s,o.m+=f-u),a&&!$a(l)&&(l.t=a,l.m+=c-h,n=t)}return n}(t,i,t.parent.A||n[0])}function s(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function l(t){t.x*=n[0],t.y=t.depth*n[1]}return a.separation=function(t){return arguments.length?(r=t,a):r},a.size=function(t){return arguments.length?(i=null==(n=t)?l:null,a):i?null:n},a.nodeSize=function(t){return arguments.length?(i=null==(n=t)?null:l,a):i?n:null},ka(a,e)},t.layout.cluster=function(){var e=t.layout.hierarchy().sort(null).value(null),r=Qa,n=[1,1],i=!1;function a(a,o){var s,l=e.call(this,a,o),c=l[0],u=0;Aa(c,function(e){var n=e.children;n&&n.length?(e.x=function(t){return t.reduce(function(t,e){return t+e.x},0)/t.length}(n),e.y=function(e){return 1+t.max(e,function(t){return t.y})}(n)):(e.x=s?u+=r(e,s):0,e.y=0,s=e)});var f=function t(e){var r=e.children;return r&&r.length?t(r[0]):e}(c),h=function t(e){var r,n=e.children;return n&&(r=n.length)?t(n[r-1]):e}(c),p=f.x-r(f,h)/2,d=h.x+r(h,f)/2;return Aa(c,i?function(t){t.x=(t.x-c.x)*n[0],t.y=(c.y-t.y)*n[1]}:function(t){t.x=(t.x-p)/(d-p)*n[0],t.y=(1-(c.y?t.y/c.y:1))*n[1]}),l}return a.separation=function(t){return arguments.length?(r=t,a):r},a.size=function(t){return arguments.length?(i=null==(n=t),a):i?null:n},a.nodeSize=function(t){return arguments.length?(i=null!=(n=t),a):i?n:null},ka(a,e)},t.layout.treemap=function(){var e,r=t.layout.hierarchy(),n=Math.round,i=[1,1],a=null,o=no,s=!1,l="squarify",c=.5*(1+Math.sqrt(5));function u(t,e){for(var r,n,i=-1,a=t.length;++i0;)s.push(r=c[i-1]),s.area+=r.area,"squarify"!==l||(n=p(s,g))<=h?(c.pop(),h=n):(s.area-=s.pop().area,d(s,g,a,!1),g=Math.min(a.dx,a.dy),s.length=s.area=0,h=1/0);s.length&&(d(s,g,a,!0),s.length=s.area=0),e.forEach(f)}}function h(t){var e=t.children;if(e&&e.length){var r,n=o(t),i=e.slice(),a=[];for(u(i,n.dx*n.dy/t.value),a.area=0;r=i.pop();)a.push(r),a.area+=r.area,null!=r.z&&(d(a,r.z?n.dx:n.dy,n,!i.length),a.length=a.area=0);e.forEach(h)}}function p(t,e){for(var r,n=t.area,i=0,a=1/0,o=-1,s=t.length;++oi&&(i=r));return e*=e,(n*=n)?Math.max(e*i*c/n,n/(e*a*c)):1/0}function d(t,e,r,i){var a,o=-1,s=t.length,l=r.x,c=r.y,u=e?n(t.area/e):0;if(e==r.dx){for((i||u>r.dy)&&(u=r.dy);++or.dx)&&(u=r.dx);++o1);return t+e*r*Math.sqrt(-2*Math.log(i)/i)}},logNormal:function(){var e=t.random.normal.apply(t,arguments);return function(){return Math.exp(e())}},bates:function(e){var r=t.random.irwinHall(e);return function(){return r()/e}},irwinHall:function(t){return function(){for(var e=0,r=0;r2?fo:so,s=i?pa:ha;return a=t(e,r,s,n),o=t(r,e,s,Gi),l}function l(t){return a(t)}l.invert=function(t){return o(t)};l.domain=function(t){return arguments.length?(e=t.map(Number),s()):e};l.range=function(t){return arguments.length?(r=t,s()):r};l.rangeRound=function(t){return l.range(t).interpolate(aa)};l.clamp=function(t){return arguments.length?(i=t,s()):i};l.interpolate=function(t){return arguments.length?(n=t,s()):n};l.ticks=function(t){return mo(e,t)};l.tickFormat=function(t,r){return vo(e,t,r)};l.nice=function(t){return po(e,t),s()};l.copy=function(){return t(e,r,n,i)};return s()}([0,1],[0,1],Gi,!1)};var yo={s:1,g:1,p:1,r:1,e:1};function xo(t){return-Math.floor(Math.log(t)/Math.LN10+.01)}t.scale.log=function(){return function e(r,n,i,a){function o(t){return(i?Math.log(t<0?0:t):-Math.log(t>0?0:-t))/Math.log(n)}function s(t){return i?Math.pow(n,t):-Math.pow(n,-t)}function l(t){return r(o(t))}l.invert=function(t){return s(r.invert(t))};l.domain=function(t){return arguments.length?(i=t[0]>=0,r.domain((a=t.map(Number)).map(o)),l):a};l.base=function(t){return arguments.length?(n=+t,r.domain(a.map(o)),l):n};l.nice=function(){var t=lo(a.map(o),i?Math:_o);return r.domain(t),a=t.map(s),l};l.ticks=function(){var t=ao(a),e=[],r=t[0],l=t[1],c=Math.floor(o(r)),u=Math.ceil(o(l)),f=n%1?2:n;if(isFinite(u-c)){if(i){for(;c0;h--)e.push(s(c)*h);for(c=0;e[c]l;u--);e=e.slice(c,u)}return e};l.tickFormat=function(e,r){if(!arguments.length)return bo;arguments.length<2?r=bo:"function"!=typeof r&&(r=t.format(r));var i=Math.max(1,n*e/l.ticks().length);return function(t){var e=t/s(Math.round(o(t)));return e*n0?i[t-1]:r[0],tf?0:1;if(c=St)return l(c,p)+(s?l(s,1-p):"")+"Z";var d,g,m,v,y,x,b,_,w,k,M,A,T=0,S=0,C=[];if((v=(+o.apply(this,arguments)||0)/2)&&(m=n===Co?Math.sqrt(s*s+c*c):+n.apply(this,arguments),p||(S*=-1),c&&(S=Ot(m/c*Math.sin(v))),s&&(T=Ot(m/s*Math.sin(v)))),c){y=c*Math.cos(u+S),x=c*Math.sin(u+S),b=c*Math.cos(f-S),_=c*Math.sin(f-S);var E=Math.abs(f-u-2*S)<=At?0:1;if(S&&Oo(y,x,b,_)===p^E){var L=(u+f)/2;y=c*Math.cos(L),x=c*Math.sin(L),b=_=null}}else y=x=0;if(s){w=s*Math.cos(f-T),k=s*Math.sin(f-T),M=s*Math.cos(u+T),A=s*Math.sin(u+T);var z=Math.abs(u-f+2*T)<=At?0:1;if(T&&Oo(w,k,M,A)===1-p^z){var P=(u+f)/2;w=s*Math.cos(P),k=s*Math.sin(P),M=A=null}}else w=k=0;if(h>kt&&(d=Math.min(Math.abs(c-s)/2,+r.apply(this,arguments)))>.001){g=s0?0:1}function Io(t,e,r,n,i){var a=t[0]-e[0],o=t[1]-e[1],s=(i?n:-n)/Math.sqrt(a*a+o*o),l=s*o,c=-s*a,u=t[0]+l,f=t[1]+c,h=e[0]+l,p=e[1]+c,d=(u+h)/2,g=(f+p)/2,m=h-u,v=p-f,y=m*m+v*v,x=r-n,b=u*p-h*f,_=(v<0?-1:1)*Math.sqrt(Math.max(0,x*x*y-b*b)),w=(b*v-m*_)/y,k=(-b*m-v*_)/y,M=(b*v+m*_)/y,A=(-b*m+v*_)/y,T=w-d,S=k-g,C=M-d,E=A-g;return T*T+S*S>C*C+E*E&&(w=M,k=A),[[w-l,k-c],[w*r/x,k*r/x]]}function Ro(t){var e=$n,r=ti,n=Wr,i=Fo,a=i.key,o=.7;function s(a){var s,l=[],c=[],u=-1,f=a.length,h=me(e),p=me(r);function d(){l.push("M",i(t(c),o))}for(;++u1&&i.push("H",n[0]);return i.join("")},"step-before":jo,"step-after":Vo,basis:Ho,"basis-open":function(t){if(t.length<4)return Fo(t);var e,r=[],n=-1,i=t.length,a=[0],o=[0];for(;++n<3;)e=t[n],a.push(e[0]),o.push(e[1]);r.push(Go(Xo,a)+","+Go(Xo,o)),--n;for(;++n9&&(i=3*e/Math.sqrt(i),o[s]=i*r,o[s+1]=i*n));s=-1;for(;++s<=l;)i=(t[Math.min(l,s+1)][0]-t[Math.max(0,s-1)][0])/(6*(1+o[s]*o[s])),a.push([i||0,o[s]*i||0]);return a}(t))}});function Fo(t){return t.length>1?t.join("L"):t+"Z"}function No(t){return t.join("L")+"Z"}function jo(t){for(var e=0,r=t.length,n=t[0],i=[n[0],",",n[1]];++e1){s=e[1],a=t[l],l++,n+="C"+(i[0]+o[0])+","+(i[1]+o[1])+","+(a[0]-s[0])+","+(a[1]-s[1])+","+a[0]+","+a[1];for(var c=2;cAt)+",1 "+e}function l(t,e,r,n){return"Q 0,0 "+n}return a.radius=function(t){return arguments.length?(r=me(t),a):r},a.source=function(e){return arguments.length?(t=me(e),a):t},a.target=function(t){return arguments.length?(e=me(t),a):e},a.startAngle=function(t){return arguments.length?(n=me(t),a):n},a.endAngle=function(t){return arguments.length?(i=me(t),a):i},a},t.svg.diagonal=function(){var t=Nn,e=jn,r=ts;function n(n,i){var a=t.call(this,n,i),o=e.call(this,n,i),s=(a.y+o.y)/2,l=[a,{x:a.x,y:s},{x:o.x,y:s},o];return"M"+(l=l.map(r))[0]+"C"+l[1]+" "+l[2]+" "+l[3]}return n.source=function(e){return arguments.length?(t=me(e),n):t},n.target=function(t){return arguments.length?(e=me(t),n):e},n.projection=function(t){return arguments.length?(r=t,n):r},n},t.svg.diagonal.radial=function(){var e=t.svg.diagonal(),r=ts,n=e.projection;return e.projection=function(t){return arguments.length?n(function(t){return function(){var e=t.apply(this,arguments),r=e[0],n=e[1]-Ct;return[r*Math.cos(n),r*Math.sin(n)]}}(r=t)):r},e},t.svg.symbol=function(){var t=rs,e=es;function r(r,n){return(is.get(t.call(this,r,n))||ns)(e.call(this,r,n))}return r.type=function(e){return arguments.length?(t=me(e),r):t},r.size=function(t){return arguments.length?(e=me(t),r):e},r};var is=t.map({circle:ns,cross:function(t){var e=Math.sqrt(t/5)/2;return"M"+-3*e+","+-e+"H"+-e+"V"+-3*e+"H"+e+"V"+-e+"H"+3*e+"V"+e+"H"+e+"V"+3*e+"H"+-e+"V"+e+"H"+-3*e+"Z"},diamond:function(t){var e=Math.sqrt(t/(2*os)),r=e*os;return"M0,"+-e+"L"+r+",0 0,"+e+" "+-r+",0Z"},square:function(t){var e=Math.sqrt(t)/2;return"M"+-e+","+-e+"L"+e+","+-e+" "+e+","+e+" "+-e+","+e+"Z"},"triangle-down":function(t){var e=Math.sqrt(t/as),r=e*as/2;return"M0,"+r+"L"+e+","+-r+" "+-e+","+-r+"Z"},"triangle-up":function(t){var e=Math.sqrt(t/as),r=e*as/2;return"M0,"+-r+"L"+e+","+r+" "+-e+","+r+"Z"}});t.svg.symbolTypes=is.keys();var as=Math.sqrt(3),os=Math.tan(30*Et);Y.transition=function(t){for(var e,r,n=us||++ps,i=ms(t),a=[],o=fs||{time:Date.now(),ease:ta,delay:0,duration:250},s=-1,l=this.length;++s0;)c[--h].call(t,o);if(a>=1)return f.event&&f.event.end.call(t,t.__data__,e),--u.count?delete u[n]:delete t[r],1}f||(a=i.time,o=Me(function(t){var e=f.delay;if(o.t=e+a,e<=t)return h(t-e);o.c=h},0,a),f=u[n]={tween:new b,time:a,timer:o,delay:i.delay,duration:i.duration,ease:i.ease,index:e},i=null,++u.count)}hs.call=Y.call,hs.empty=Y.empty,hs.node=Y.node,hs.size=Y.size,t.transition=function(e,r){return e&&e.transition?us?e.transition(r):e:t.selection().transition(e)},t.transition.prototype=hs,hs.select=function(t){var e,r,n,i=this.id,a=this.namespace,o=[];t=X(t);for(var s=-1,l=this.length;++srect,.s>rect").attr("width",s[1]-s[0])}function g(t){t.select(".extent").attr("y",l[0]),t.selectAll(".extent,.e>rect,.w>rect").attr("height",l[1]-l[0])}function m(){var f,m,v=this,y=t.select(t.event.target),x=n.of(v,arguments),b=t.select(v),_=y.datum(),w=!/^(n|s)$/.test(_)&&i,k=!/^(e|w)$/.test(_)&&a,M=y.classed("extent"),A=xt(v),T=t.mouse(v),S=t.select(o(v)).on("keydown.brush",function(){32==t.event.keyCode&&(M||(f=null,T[0]-=s[1],T[1]-=l[1],M=2),F())}).on("keyup.brush",function(){32==t.event.keyCode&&2==M&&(T[0]+=s[1],T[1]+=l[1],M=0,F())});if(t.event.changedTouches?S.on("touchmove.brush",L).on("touchend.brush",P):S.on("mousemove.brush",L).on("mouseup.brush",P),b.interrupt().selectAll("*").interrupt(),M)T[0]=s[0]-T[0],T[1]=l[0]-T[1];else if(_){var C=+/w$/.test(_),E=+/^n/.test(_);m=[s[1-C]-T[0],l[1-E]-T[1]],T[0]=s[C],T[1]=l[E]}else t.event.altKey&&(f=T.slice());function L(){var e=t.mouse(v),r=!1;m&&(e[0]+=m[0],e[1]+=m[1]),M||(t.event.altKey?(f||(f=[(s[0]+s[1])/2,(l[0]+l[1])/2]),T[0]=s[+(e[0]1?{floor:function(e){for(;s(e=t.floor(e));)e=Es(e-1);return e},ceil:function(e){for(;s(e=t.ceil(e));)e=Es(+e+1);return e}}:t))},i.ticks=function(t,e){var r=ao(i.domain()),n=null==t?a(r,10):"number"==typeof t?a(r,t):!t.range&&[{range:t},e];return n&&(t=n[0],e=n[1]),t.range(r[0],Es(+r[1]+1),e<1?1:e)},i.tickFormat=function(){return n},i.copy=function(){return Cs(e.copy(),r,n)},ho(i,e)}function Es(t){return new Date(t)}Ms.iso=Date.prototype.toISOString&&+new Date("2000-01-01T00:00:00.000Z")?Ss:Ts,Ss.parse=function(t){var e=new Date(t);return isNaN(e)?null:e},Ss.toString=Ts.toString,De.second=Be(function(t){return new Oe(1e3*Math.floor(t/1e3))},function(t,e){t.setTime(t.getTime()+1e3*Math.floor(e))},function(t){return t.getSeconds()}),De.seconds=De.second.range,De.seconds.utc=De.second.utc.range,De.minute=Be(function(t){return new Oe(6e4*Math.floor(t/6e4))},function(t,e){t.setTime(t.getTime()+6e4*Math.floor(e))},function(t){return t.getMinutes()}),De.minutes=De.minute.range,De.minutes.utc=De.minute.utc.range,De.hour=Be(function(t){var e=t.getTimezoneOffset()/60;return new Oe(36e5*(Math.floor(t/36e5-e)+e))},function(t,e){t.setTime(t.getTime()+36e5*Math.floor(e))},function(t){return t.getHours()}),De.hours=De.hour.range,De.hours.utc=De.hour.utc.range,De.month=Be(function(t){return(t=De.day(t)).setDate(1),t},function(t,e){t.setMonth(t.getMonth()+e)},function(t){return t.getMonth()}),De.months=De.month.range,De.months.utc=De.month.utc.range;var Ls=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,2592e6,7776e6,31536e6],zs=[[De.second,1],[De.second,5],[De.second,15],[De.second,30],[De.minute,1],[De.minute,5],[De.minute,15],[De.minute,30],[De.hour,1],[De.hour,3],[De.hour,6],[De.hour,12],[De.day,1],[De.day,2],[De.week,1],[De.month,1],[De.month,3],[De.year,1]],Ps=Ms.multi([[".%L",function(t){return t.getMilliseconds()}],[":%S",function(t){return t.getSeconds()}],["%I:%M",function(t){return t.getMinutes()}],["%I %p",function(t){return t.getHours()}],["%a %d",function(t){return t.getDay()&&1!=t.getDate()}],["%b %d",function(t){return 1!=t.getDate()}],["%B",function(t){return t.getMonth()}],["%Y",Wr]]),Ds={range:function(e,r,n){return t.range(Math.ceil(e/n)*n,+r,n).map(Es)},floor:z,ceil:z};zs.year=De.year,De.scale=function(){return Cs(t.scale.linear(),zs,Ps)};var Os=zs.map(function(t){return[t[0].utc,t[1]]}),Is=As.multi([[".%L",function(t){return t.getUTCMilliseconds()}],[":%S",function(t){return t.getUTCSeconds()}],["%I:%M",function(t){return t.getUTCMinutes()}],["%I %p",function(t){return t.getUTCHours()}],["%a %d",function(t){return t.getUTCDay()&&1!=t.getUTCDate()}],["%b %d",function(t){return 1!=t.getUTCDate()}],["%B",function(t){return t.getUTCMonth()}],["%Y",Wr]]);function Rs(t){return JSON.parse(t.responseText)}function Bs(t){var e=i.createRange();return e.selectNode(i.body),e.createContextualFragment(t.responseText)}Os.year=De.year.utc,De.scale.utc=function(){return Cs(t.scale.linear(),Os,Is)},t.text=ve(function(t){return t.responseText}),t.json=function(t,e){return ye(t,"application/json",Rs,e)},t.html=function(t,e){return ye(t,"text/html",Bs,e)},t.xml=ve(function(t){return t.responseXML}),"object"==typeof e&&e.exports?e.exports=t:this.d3=t}()},{}],132:[function(t,e,r){e.exports=function(){for(var t=0;t=2)return!1;t[r]=n}return!0}):_.filter(function(t){for(var e=0;e<=s;++e){var r=v[t[e]];if(r<0)return!1;t[e]=r}return!0});if(1&s)for(var u=0;u<_.length;++u){var b=_[u],h=b[0];b[0]=b[1],b[1]=h}return _}},{"incremental-convex-hull":357,uniq:483}],134:[function(t,e,r){(function(t){var r=!1;if("undefined"!=typeof Float64Array){var n=new Float64Array(1),i=new Uint32Array(n.buffer);if(n[0]=1,r=!0,1072693248===i[1]){e.exports=function(t){return n[0]=t,[i[0],i[1]]},e.exports.pack=function(t,e){return i[0]=t,i[1]=e,n[0]},e.exports.lo=function(t){return n[0]=t,i[0]},e.exports.hi=function(t){return n[0]=t,i[1]}}else if(1072693248===i[0]){e.exports=function(t){return n[0]=t,[i[1],i[0]]},e.exports.pack=function(t,e){return i[1]=t,i[0]=e,n[0]},e.exports.lo=function(t){return n[0]=t,i[1]},e.exports.hi=function(t){return n[0]=t,i[0]}}else r=!1}if(!r){var a=new t(8);e.exports=function(t){return a.writeDoubleLE(t,0,!0),[a.readUInt32LE(0,!0),a.readUInt32LE(4,!0)]},e.exports.pack=function(t,e){return a.writeUInt32LE(t,0,!0),a.writeUInt32LE(e,4,!0),a.readDoubleLE(0,!0)},e.exports.lo=function(t){return a.writeDoubleLE(t,0,!0),a.readUInt32LE(0,!0)},e.exports.hi=function(t){return a.writeDoubleLE(t,0,!0),a.readUInt32LE(4,!0)}}e.exports.sign=function(t){return e.exports.hi(t)>>>31},e.exports.exponent=function(t){return(e.exports.hi(t)<<1>>>21)-1023},e.exports.fraction=function(t){var r=e.exports.lo(t),n=e.exports.hi(t),i=1048575&n;return 2146435072&n&&(i+=1<<20),[r,i]},e.exports.denormalized=function(t){return!(2146435072&e.exports.hi(t))}}).call(this,t("buffer").Buffer)},{buffer:86}],135:[function(t,e,r){var n=t("abs-svg-path"),i=t("normalize-svg-path"),a={M:"moveTo",C:"bezierCurveTo"};e.exports=function(t,e){t.beginPath(),i(n(e)).forEach(function(e){var r=e[0],n=e.slice(1);t[a[r]].apply(t,n)}),t.closePath()}},{"abs-svg-path":45,"normalize-svg-path":395}],136:[function(t,e,r){e.exports=function(t){switch(t){case"int8":return Int8Array;case"int16":return Int16Array;case"int32":return Int32Array;case"uint8":return Uint8Array;case"uint16":return Uint16Array;case"uint32":return Uint32Array;case"float32":return Float32Array;case"float64":return Float64Array;case"array":return Array;case"uint8_clamped":return Uint8ClampedArray}}},{}],137:[function(t,e,r){"use strict";e.exports=function(t,e){switch(void 0===e&&(e=0),typeof t){case"number":if(t>0)return function(t,e){var r,n;for(r=new Array(t),n=0;n80*r){n=l=t[0],s=c=t[1];for(var b=r;bl&&(l=u),p>c&&(c=p);g=0!==(g=Math.max(l-n,c-s))?1/g:0}return o(y,x,r,n,s,g),x}function i(t,e,r,n,i){var a,o;if(i===A(t,e,r,n)>0)for(a=e;a=e;a-=n)o=w(a,t[a],t[a+1],o);return o&&y(o,o.next)&&(k(o),o=o.next),o}function a(t,e){if(!t)return t;e||(e=t);var r,n=t;do{if(r=!1,n.steiner||!y(n,n.next)&&0!==v(n.prev,n,n.next))n=n.next;else{if(k(n),(n=e=n.prev)===n.next)break;r=!0}}while(r||n!==e);return e}function o(t,e,r,n,i,f,h){if(t){!h&&f&&function(t,e,r,n){var i=t;do{null===i.z&&(i.z=p(i.x,i.y,e,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next}while(i!==t);i.prevZ.nextZ=null,i.prevZ=null,function(t){var e,r,n,i,a,o,s,l,c=1;do{for(r=t,t=null,a=null,o=0;r;){for(o++,n=r,s=0,e=0;e0||l>0&&n;)0!==s&&(0===l||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),a?a.nextZ=i:t=i,i.prevZ=a,a=i;r=n}a.nextZ=null,c*=2}while(o>1)}(i)}(t,n,i,f);for(var d,g,m=t;t.prev!==t.next;)if(d=t.prev,g=t.next,f?l(t,n,i,f):s(t))e.push(d.i/r),e.push(t.i/r),e.push(g.i/r),k(t),t=g.next,m=g.next;else if((t=g)===m){h?1===h?o(t=c(t,e,r),e,r,n,i,f,2):2===h&&u(t,e,r,n,i,f):o(a(t),e,r,n,i,f,1);break}}}function s(t){var e=t.prev,r=t,n=t.next;if(v(e,r,n)>=0)return!1;for(var i=t.next.next;i!==t.prev;){if(g(e.x,e.y,r.x,r.y,n.x,n.y,i.x,i.y)&&v(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function l(t,e,r,n){var i=t.prev,a=t,o=t.next;if(v(i,a,o)>=0)return!1;for(var s=i.xa.x?i.x>o.x?i.x:o.x:a.x>o.x?a.x:o.x,u=i.y>a.y?i.y>o.y?i.y:o.y:a.y>o.y?a.y:o.y,f=p(s,l,e,r,n),h=p(c,u,e,r,n),d=t.prevZ,m=t.nextZ;d&&d.z>=f&&m&&m.z<=h;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;if(d=d.prevZ,m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}for(;d&&d.z>=f;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;m&&m.z<=h;){if(m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function c(t,e,r){var n=t;do{var i=n.prev,a=n.next.next;!y(i,a)&&x(i,n,n.next,a)&&b(i,a)&&b(a,i)&&(e.push(i.i/r),e.push(n.i/r),e.push(a.i/r),k(n),k(n.next),n=t=a),n=n.next}while(n!==t);return n}function u(t,e,r,n,i,s){var l=t;do{for(var c=l.next.next;c!==l.prev;){if(l.i!==c.i&&m(l,c)){var u=_(l,c);return l=a(l,l.next),u=a(u,u.next),o(l,e,r,n,i,s),void o(u,e,r,n,i,s)}c=c.next}l=l.next}while(l!==t)}function f(t,e){return t.x-e.x}function h(t,e){if(e=function(t,e){var r,n=e,i=t.x,a=t.y,o=-1/0;do{if(a<=n.y&&a>=n.next.y&&n.next.y!==n.y){var s=n.x+(a-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(s<=i&&s>o){if(o=s,s===i){if(a===n.y)return n;if(a===n.next.y)return n.next}r=n.x=n.x&&n.x>=u&&i!==n.x&&g(ar.x)&&b(n,t)&&(r=n,h=l),n=n.next;return r}(t,e)){var r=_(e,t);a(r,r.next)}}function p(t,e,r,n,i){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-r)*i)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-n)*i)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function d(t){var e=t,r=t;do{e.x=0&&(t-o)*(n-s)-(r-o)*(e-s)>=0&&(r-o)*(a-s)-(i-o)*(n-s)>=0}function m(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){var r=t;do{if(r.i!==t.i&&r.next.i!==t.i&&r.i!==e.i&&r.next.i!==e.i&&x(r,r.next,t,e))return!0;r=r.next}while(r!==t);return!1}(t,e)&&b(t,e)&&b(e,t)&&function(t,e){var r=t,n=!1,i=(t.x+e.x)/2,a=(t.y+e.y)/2;do{r.y>a!=r.next.y>a&&r.next.y!==r.y&&i<(r.next.x-r.x)*(a-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next}while(r!==t);return n}(t,e)}function v(t,e,r){return(e.y-t.y)*(r.x-e.x)-(e.x-t.x)*(r.y-e.y)}function y(t,e){return t.x===e.x&&t.y===e.y}function x(t,e,r,n){return!!(y(t,e)&&y(r,n)||y(t,n)&&y(r,e))||v(t,e,r)>0!=v(t,e,n)>0&&v(r,n,t)>0!=v(r,n,e)>0}function b(t,e){return v(t.prev,t,t.next)<0?v(t,e,t.next)>=0&&v(t,t.prev,e)>=0:v(t,e,t.prev)<0||v(t,t.next,e)<0}function _(t,e){var r=new M(t.i,t.x,t.y),n=new M(e.i,e.x,e.y),i=t.next,a=e.prev;return t.next=e,e.prev=t,r.next=i,i.prev=r,n.next=r,r.prev=n,a.next=n,n.prev=a,n}function w(t,e,r,n){var i=new M(t,e,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function k(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function M(t,e,r){this.i=t,this.x=e,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function A(t,e,r,n){for(var i=0,a=e,o=r-n;a0&&(n+=t[i-1].length,r.holes.push(n))}return r}},{}],139:[function(t,e,r){"use strict";e.exports=function(t,e){var r=t.length;if("number"!=typeof e){e=0;for(var i=0;i=55296&&y<=56319&&(w+=t[++r]),w=k?h.call(k,M,w,g):w,e?(p.value=w,d(m,g,p)):m[g]=w,++g;v=g}if(void 0===v)for(v=o(t.length),e&&(m=new e(v)),r=0;r0?1:-1}},{}],150:[function(t,e,r){"use strict";var n=t("../math/sign"),i=Math.abs,a=Math.floor;e.exports=function(t){return isNaN(t)?0:0!==(t=Number(t))&&isFinite(t)?n(t)*a(i(t)):t}},{"../math/sign":147}],151:[function(t,e,r){"use strict";var n=t("./to-integer"),i=Math.max;e.exports=function(t){return i(0,n(t))}},{"./to-integer":150}],152:[function(t,e,r){"use strict";var n=t("./valid-callable"),i=t("./valid-value"),a=Function.prototype.bind,o=Function.prototype.call,s=Object.keys,l=Object.prototype.propertyIsEnumerable;e.exports=function(t,e){return function(r,c){var u,f=arguments[2],h=arguments[3];return r=Object(i(r)),n(c),u=s(r),h&&u.sort("function"==typeof h?a.call(h,r):void 0),"function"!=typeof t&&(t=u[t]),o.call(t,u,function(t,n){return l.call(r,t)?o.call(c,f,r[t],t,r,n):e})}}},{"./valid-callable":170,"./valid-value":172}],153:[function(t,e,r){"use strict";e.exports=t("./is-implemented")()?Object.assign:t("./shim")},{"./is-implemented":154,"./shim":155}],154:[function(t,e,r){"use strict";e.exports=function(){var t,e=Object.assign;return"function"==typeof e&&(e(t={foo:"raz"},{bar:"dwa"},{trzy:"trzy"}),t.foo+t.bar+t.trzy==="razdwatrzy")}},{}],155:[function(t,e,r){"use strict";var n=t("../keys"),i=t("../valid-value"),a=Math.max;e.exports=function(t,e){var r,o,s,l=a(arguments.length,2);for(t=Object(i(t)),s=function(n){try{t[n]=e[n]}catch(t){r||(r=t)}},o=1;o-1}},{}],176:[function(t,e,r){"use strict";var n=Object.prototype.toString,i=n.call("");e.exports=function(t){return"string"==typeof t||t&&"object"==typeof t&&(t instanceof String||n.call(t)===i)||!1}},{}],177:[function(t,e,r){"use strict";var n=Object.create(null),i=Math.random;e.exports=function(){var t;do{t=i().toString(36).slice(2)}while(n[t]);return t}},{}],178:[function(t,e,r){"use strict";var n,i=t("es5-ext/object/set-prototype-of"),a=t("es5-ext/string/#/contains"),o=t("d"),s=t("es6-symbol"),l=t("./"),c=Object.defineProperty;n=e.exports=function(t,e){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");l.call(this,t),e=e?a.call(e,"key+value")?"key+value":a.call(e,"key")?"key":"value":"value",c(this,"__kind__",o("",e))},i&&i(n,l),delete n.prototype.constructor,n.prototype=Object.create(l.prototype,{_resolve:o(function(t){return"value"===this.__kind__?this.__list__[t]:"key+value"===this.__kind__?[t,this.__list__[t]]:t})}),c(n.prototype,s.toStringTag,o("c","Array Iterator"))},{"./":181,d:122,"es5-ext/object/set-prototype-of":167,"es5-ext/string/#/contains":173,"es6-symbol":186}],179:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/object/valid-callable"),a=t("es5-ext/string/is-string"),o=t("./get"),s=Array.isArray,l=Function.prototype.call,c=Array.prototype.some;e.exports=function(t,e){var r,u,f,h,p,d,g,m,v=arguments[2];if(s(t)||n(t)?r="array":a(t)?r="string":t=o(t),i(e),f=function(){h=!0},"array"!==r)if("string"!==r)for(u=t.next();!u.done;){if(l.call(e,v,u.value,f),h)return;u=t.next()}else for(d=t.length,p=0;p=55296&&m<=56319&&(g+=t[++p]),l.call(e,v,g,f),!h);++p);else c.call(t,function(t){return l.call(e,v,t,f),h})}},{"./get":180,"es5-ext/function/is-arguments":144,"es5-ext/object/valid-callable":170,"es5-ext/string/is-string":176}],180:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/string/is-string"),a=t("./array"),o=t("./string"),s=t("./valid-iterable"),l=t("es6-symbol").iterator;e.exports=function(t){return"function"==typeof s(t)[l]?t[l]():n(t)?new a(t):i(t)?new o(t):new a(t)}},{"./array":178,"./string":183,"./valid-iterable":184,"es5-ext/function/is-arguments":144,"es5-ext/string/is-string":176,"es6-symbol":186}],181:[function(t,e,r){"use strict";var n,i=t("es5-ext/array/#/clear"),a=t("es5-ext/object/assign"),o=t("es5-ext/object/valid-callable"),s=t("es5-ext/object/valid-value"),l=t("d"),c=t("d/auto-bind"),u=t("es6-symbol"),f=Object.defineProperty,h=Object.defineProperties;e.exports=n=function(t,e){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");h(this,{__list__:l("w",s(t)),__context__:l("w",e),__nextIndex__:l("w",0)}),e&&(o(e.on),e.on("_add",this._onAdd),e.on("_delete",this._onDelete),e.on("_clear",this._onClear))},delete n.prototype.constructor,h(n.prototype,a({_next:l(function(){var t;if(this.__list__)return this.__redo__&&void 0!==(t=this.__redo__.shift())?t:this.__nextIndex__=this.__nextIndex__||(++this.__nextIndex__,this.__redo__?(this.__redo__.forEach(function(e,r){e>=t&&(this.__redo__[r]=++e)},this),this.__redo__.push(t)):f(this,"__redo__",l("c",[t])))}),_onDelete:l(function(t){var e;t>=this.__nextIndex__||(--this.__nextIndex__,this.__redo__&&(-1!==(e=this.__redo__.indexOf(t))&&this.__redo__.splice(e,1),this.__redo__.forEach(function(e,r){e>t&&(this.__redo__[r]=--e)},this)))}),_onClear:l(function(){this.__redo__&&i.call(this.__redo__),this.__nextIndex__=0})}))),f(n.prototype,u.iterator,l(function(){return this}))},{d:122,"d/auto-bind":121,"es5-ext/array/#/clear":140,"es5-ext/object/assign":153,"es5-ext/object/valid-callable":170,"es5-ext/object/valid-value":172,"es6-symbol":186}],182:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/object/is-value"),a=t("es5-ext/string/is-string"),o=t("es6-symbol").iterator,s=Array.isArray;e.exports=function(t){return!!i(t)&&(!!s(t)||(!!a(t)||(!!n(t)||"function"==typeof t[o])))}},{"es5-ext/function/is-arguments":144,"es5-ext/object/is-value":161,"es5-ext/string/is-string":176,"es6-symbol":186}],183:[function(t,e,r){"use strict";var n,i=t("es5-ext/object/set-prototype-of"),a=t("d"),o=t("es6-symbol"),s=t("./"),l=Object.defineProperty;n=e.exports=function(t){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");t=String(t),s.call(this,t),l(this,"__length__",a("",t.length))},i&&i(n,s),delete n.prototype.constructor,n.prototype=Object.create(s.prototype,{_next:a(function(){if(this.__list__)return this.__nextIndex__=55296&&e<=56319?r+this.__list__[this.__nextIndex__++]:r})}),l(n.prototype,o.toStringTag,a("c","String Iterator"))},{"./":181,d:122,"es5-ext/object/set-prototype-of":167,"es6-symbol":186}],184:[function(t,e,r){"use strict";var n=t("./is-iterable");e.exports=function(t){if(!n(t))throw new TypeError(t+" is not iterable");return t}},{"./is-iterable":182}],185:[function(t,e,r){(function(n,i){!function(t,n){"object"==typeof r&&void 0!==e?e.exports=n():t.ES6Promise=n()}(this,function(){"use strict";function e(t){return"function"==typeof t}var r=Array.isArray?Array.isArray:function(t){return"[object Array]"===Object.prototype.toString.call(t)},a=0,o=void 0,s=void 0,l=function(t,e){g[a]=t,g[a+1]=e,2===(a+=2)&&(s?s(m):_())};var c="undefined"!=typeof window?window:void 0,u=c||{},f=u.MutationObserver||u.WebKitMutationObserver,h="undefined"==typeof self&&void 0!==n&&"[object process]"==={}.toString.call(n),p="undefined"!=typeof Uint8ClampedArray&&"undefined"!=typeof importScripts&&"undefined"!=typeof MessageChannel;function d(){var t=setTimeout;return function(){return t(m,1)}}var g=new Array(1e3);function m(){for(var t=0;t0&&this._events[t].length>r&&(this._events[t].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[t].length),"function"==typeof console.trace&&console.trace()),this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(t,e){if(!i(e))throw TypeError("listener must be a function");var r=!1;function n(){this.removeListener(t,n),r||(r=!0,e.apply(this,arguments))}return n.listener=e,this.on(t,n),this},n.prototype.removeListener=function(t,e){var r,n,o,s;if(!i(e))throw TypeError("listener must be a function");if(!this._events||!this._events[t])return this;if(o=(r=this._events[t]).length,n=-1,r===e||i(r.listener)&&r.listener===e)delete this._events[t],this._events.removeListener&&this.emit("removeListener",t,e);else if(a(r)){for(s=o;s-- >0;)if(r[s]===e||r[s].listener&&r[s].listener===e){n=s;break}if(n<0)return this;1===r.length?(r.length=0,delete this._events[t]):r.splice(n,1),this._events.removeListener&&this.emit("removeListener",t,e)}return this},n.prototype.removeAllListeners=function(t){var e,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[t]&&delete this._events[t],this;if(0===arguments.length){for(e in this._events)"removeListener"!==e&&this.removeAllListeners(e);return this.removeAllListeners("removeListener"),this._events={},this}if(i(r=this._events[t]))this.removeListener(t,r);else if(r)for(;r.length;)this.removeListener(t,r[r.length-1]);return delete this._events[t],this},n.prototype.listeners=function(t){return this._events&&this._events[t]?i(this._events[t])?[this._events[t]]:this._events[t].slice():[]},n.prototype.listenerCount=function(t){if(this._events){var e=this._events[t];if(i(e))return 1;if(e)return e.length}return 0},n.listenerCount=function(t,e){return t.listenerCount(e)}},{}],196:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n=e||0,i=r||1;return[[t[12]+t[0],t[13]+t[1],t[14]+t[2],t[15]+t[3]],[t[12]-t[0],t[13]-t[1],t[14]-t[2],t[15]-t[3]],[t[12]+t[4],t[13]+t[5],t[14]+t[6],t[15]+t[7]],[t[12]-t[4],t[13]-t[5],t[14]-t[6],t[15]-t[7]],[n*t[12]+t[8],n*t[13]+t[9],n*t[14]+t[10],n*t[15]+t[11]],[i*t[12]-t[8],i*t[13]-t[9],i*t[14]-t[10],i*t[15]-t[11]]]}},{}],197:[function(t,e,r){"use strict";e.exports=function(t){var e=typeof t;if("string"===e){var r=t;if(0===(t=+t)&&function(t){for(var e,r=t.length,n=0;n13)&&32!==e&&133!==e&&160!==e&&5760!==e&&6158!==e&&(e<8192||e>8205)&&8232!==e&&8233!==e&&8239!==e&&8287!==e&&8288!==e&&12288!==e&&65279!==e)return!1;return!0}(r))return!1}else if("number"!==e)return!1;return t-t<1}},{}],198:[function(t,e,r){"use strict";e.exports=function(t,e,r){switch(arguments.length){case 0:return new o([0],[0],0);case 1:if("number"==typeof t){var n=l(t);return new o(n,n,0)}return new o(t,l(t.length),0);case 2:if("number"==typeof e){var n=l(t.length);return new o(t,n,+e)}r=0;case 3:if(t.length!==e.length)throw new Error("state and velocity lengths must match");return new o(t,e,r)}};var n=t("cubic-hermite"),i=t("binary-search-bounds");function a(t,e,r){return Math.min(e,Math.max(t,r))}function o(t,e,r){this.dimension=t.length,this.bounds=[new Array(this.dimension),new Array(this.dimension)];for(var n=0;n=r-1){h=l.length-1;var d=t-e[r-1];for(p=0;p=r-1)for(var u=s.length-1,f=(e[r-1],0);f=0;--r)if(t[--e])return!1;return!0},s.jump=function(t){var e=this.lastT(),r=this.dimension;if(!(t0;--f)n.push(a(l[f-1],c[f-1],arguments[f])),i.push(0)}},s.push=function(t){var e=this.lastT(),r=this.dimension;if(!(t1e-6?1/s:0;this._time.push(t);for(var h=r;h>0;--h){var p=a(c[h-1],u[h-1],arguments[h]);n.push(p),i.push((p-n[o++])*f)}}},s.set=function(t){var e=this.dimension;if(!(t0;--l)r.push(a(o[l-1],s[l-1],arguments[l])),n.push(0)}},s.move=function(t){var e=this.lastT(),r=this.dimension;if(!(t<=e||arguments.length!==r+1)){var n=this._state,i=this._velocity,o=n.length-this.dimension,s=this.bounds,l=s[0],c=s[1],u=t-e,f=u>1e-6?1/u:0;this._time.push(t);for(var h=r;h>0;--h){var p=arguments[h];n.push(a(l[h-1],c[h-1],n[o++]+p)),i.push(p*f)}}},s.idle=function(t){var e=this.lastT();if(!(t=0;--f)n.push(a(l[f],c[f],n[o]+u*i[o])),i.push(0),o+=1}}},{"binary-search-bounds":73,"cubic-hermite":116}],199:[function(t,e,r){var n=t("dtype");e.exports=function(t,e,r){if(!t)throw new TypeError("must specify data as first parameter");if(r=0|+(r||0),Array.isArray(t)&&Array.isArray(t[0])){var i=t[0].length,a=t.length*i;e&&"string"!=typeof e||(e=new(n(e||"float32"))(a+r));var o=e.length-r;if(a!==o)throw new Error("source length "+a+" ("+i+"x"+t.length+") does not match destination length "+o);for(var s=0,l=r;s=0;--p){o=u[p];f[p]<=0?u[p]=new a(o._color,o.key,o.value,u[p+1],o.right,o._count+1):u[p]=new a(o._color,o.key,o.value,o.left,u[p+1],o._count+1)}for(p=u.length-1;p>1;--p){var d=u[p-1];o=u[p];if(d._color===i||o._color===i)break;var g=u[p-2];if(g.left===d)if(d.left===o){if(!(m=g.right)||m._color!==n){if(g._color=n,g.left=d.right,d._color=i,d.right=g,u[p-2]=d,u[p-1]=o,l(g),l(d),p>=3)(v=u[p-3]).left===g?v.left=d:v.right=d;break}d._color=i,g.right=s(i,m),g._color=n,p-=1}else{if(!(m=g.right)||m._color!==n){if(d.right=o.left,g._color=n,g.left=o.right,o._color=i,o.left=d,o.right=g,u[p-2]=o,u[p-1]=d,l(g),l(d),l(o),p>=3)(v=u[p-3]).left===g?v.left=o:v.right=o;break}d._color=i,g.right=s(i,m),g._color=n,p-=1}else if(d.right===o){if(!(m=g.left)||m._color!==n){if(g._color=n,g.right=d.left,d._color=i,d.left=g,u[p-2]=d,u[p-1]=o,l(g),l(d),p>=3)(v=u[p-3]).right===g?v.right=d:v.left=d;break}d._color=i,g.left=s(i,m),g._color=n,p-=1}else{var m;if(!(m=g.left)||m._color!==n){var v;if(d.left=o.right,g._color=n,g.right=o.left,o._color=i,o.right=d,o.left=g,u[p-2]=o,u[p-1]=d,l(g),l(d),l(o),p>=3)(v=u[p-3]).right===g?v.right=o:v.left=o;break}d._color=i,g.left=s(i,m),g._color=n,p-=1}}return u[0]._color=i,new c(r,u[0])},u.forEach=function(t,e,r){if(this.root)switch(arguments.length){case 1:return function t(e,r){var n;if(r.left&&(n=t(e,r.left)))return n;return(n=e(r.key,r.value))||(r.right?t(e,r.right):void 0)}(t,this.root);case 2:return function t(e,r,n,i){if(r(e,i.key)<=0){var a;if(i.left&&(a=t(e,r,n,i.left)))return a;if(a=n(i.key,i.value))return a}if(i.right)return t(e,r,n,i.right)}(e,this._compare,t,this.root);case 3:if(this._compare(e,r)>=0)return;return function t(e,r,n,i,a){var o,s=n(e,a.key),l=n(r,a.key);if(s<=0){if(a.left&&(o=t(e,r,n,i,a.left)))return o;if(l>0&&(o=i(a.key,a.value)))return o}if(l>0&&a.right)return t(e,r,n,i,a.right)}(e,r,this._compare,t,this.root)}},Object.defineProperty(u,"begin",{get:function(){for(var t=[],e=this.root;e;)t.push(e),e=e.left;return new f(this,t)}}),Object.defineProperty(u,"end",{get:function(){for(var t=[],e=this.root;e;)t.push(e),e=e.right;return new f(this,t)}}),u.at=function(t){if(t<0)return new f(this,[]);for(var e=this.root,r=[];;){if(r.push(e),e.left){if(t=e.right._count)break;e=e.right}return new f(this,[])},u.ge=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a<=0&&(i=n.length),r=a<=0?r.left:r.right}return n.length=i,new f(this,n)},u.gt=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a<0&&(i=n.length),r=a<0?r.left:r.right}return n.length=i,new f(this,n)},u.lt=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a>0&&(i=n.length),r=a<=0?r.left:r.right}return n.length=i,new f(this,n)},u.le=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a>=0&&(i=n.length),r=a<0?r.left:r.right}return n.length=i,new f(this,n)},u.find=function(t){for(var e=this._compare,r=this.root,n=[];r;){var i=e(t,r.key);if(n.push(r),0===i)return new f(this,n);r=i<=0?r.left:r.right}return new f(this,[])},u.remove=function(t){var e=this.find(t);return e?e.remove():this},u.get=function(t){for(var e=this._compare,r=this.root;r;){var n=e(t,r.key);if(0===n)return r.value;r=n<=0?r.left:r.right}};var h=f.prototype;function p(t,e){t.key=e.key,t.value=e.value,t.left=e.left,t.right=e.right,t._color=e._color,t._count=e._count}function d(t,e){return te?1:0}Object.defineProperty(h,"valid",{get:function(){return this._stack.length>0}}),Object.defineProperty(h,"node",{get:function(){return this._stack.length>0?this._stack[this._stack.length-1]:null},enumerable:!0}),h.clone=function(){return new f(this.tree,this._stack.slice())},h.remove=function(){var t=this._stack;if(0===t.length)return this.tree;var e=new Array(t.length),r=t[t.length-1];e[e.length-1]=new a(r._color,r.key,r.value,r.left,r.right,r._count);for(var u=t.length-2;u>=0;--u){(r=t[u]).left===t[u+1]?e[u]=new a(r._color,r.key,r.value,e[u+1],r.right,r._count):e[u]=new a(r._color,r.key,r.value,r.left,e[u+1],r._count)}if((r=e[e.length-1]).left&&r.right){var f=e.length;for(r=r.left;r.right;)e.push(r),r=r.right;var h=e[f-1];e.push(new a(r._color,h.key,h.value,r.left,r.right,r._count)),e[f-1].key=r.key,e[f-1].value=r.value;for(u=e.length-2;u>=f;--u)r=e[u],e[u]=new a(r._color,r.key,r.value,r.left,e[u+1],r._count);e[f-1].left=e[f]}if((r=e[e.length-1])._color===n){var d=e[e.length-2];d.left===r?d.left=null:d.right===r&&(d.right=null),e.pop();for(u=0;u=0;--u){if(e=t[u],0===u)return void(e._color=i);if((r=t[u-1]).left===e){if((a=r.right).right&&a.right._color===n)return c=(a=r.right=o(a)).right=o(a.right),r.right=a.left,a.left=r,a.right=c,a._color=r._color,e._color=i,r._color=i,c._color=i,l(r),l(a),u>1&&((f=t[u-2]).left===r?f.left=a:f.right=a),void(t[u-1]=a);if(a.left&&a.left._color===n)return c=(a=r.right=o(a)).left=o(a.left),r.right=c.left,a.left=c.right,c.left=r,c.right=a,c._color=r._color,r._color=i,a._color=i,e._color=i,l(r),l(a),l(c),u>1&&((f=t[u-2]).left===r?f.left=c:f.right=c),void(t[u-1]=c);if(a._color===i){if(r._color===n)return r._color=i,void(r.right=s(n,a));r.right=s(n,a);continue}a=o(a),r.right=a.left,a.left=r,a._color=r._color,r._color=n,l(r),l(a),u>1&&((f=t[u-2]).left===r?f.left=a:f.right=a),t[u-1]=a,t[u]=r,u+11&&((f=t[u-2]).right===r?f.right=a:f.left=a),void(t[u-1]=a);if(a.right&&a.right._color===n)return c=(a=r.left=o(a)).right=o(a.right),r.left=c.right,a.right=c.left,c.right=r,c.left=a,c._color=r._color,r._color=i,a._color=i,e._color=i,l(r),l(a),l(c),u>1&&((f=t[u-2]).right===r?f.right=c:f.left=c),void(t[u-1]=c);if(a._color===i){if(r._color===n)return r._color=i,void(r.left=s(n,a));r.left=s(n,a);continue}var f;a=o(a),r.left=a.right,a.right=r,a._color=r._color,r._color=n,l(r),l(a),u>1&&((f=t[u-2]).right===r?f.right=a:f.left=a),t[u-1]=a,t[u]=r,u+10)return this._stack[this._stack.length-1].key},enumerable:!0}),Object.defineProperty(h,"value",{get:function(){if(this._stack.length>0)return this._stack[this._stack.length-1].value},enumerable:!0}),Object.defineProperty(h,"index",{get:function(){var t=0,e=this._stack;if(0===e.length){var r=this.tree.root;return r?r._count:0}e[e.length-1].left&&(t=e[e.length-1].left._count);for(var n=e.length-2;n>=0;--n)e[n+1]===e[n].right&&(++t,e[n].left&&(t+=e[n].left._count));return t},enumerable:!0}),h.next=function(){var t=this._stack;if(0!==t.length){var e=t[t.length-1];if(e.right)for(e=e.right;e;)t.push(e),e=e.left;else for(t.pop();t.length>0&&t[t.length-1].right===e;)e=t[t.length-1],t.pop()}},Object.defineProperty(h,"hasNext",{get:function(){var t=this._stack;if(0===t.length)return!1;if(t[t.length-1].right)return!0;for(var e=t.length-1;e>0;--e)if(t[e-1].left===t[e])return!0;return!1}}),h.update=function(t){var e=this._stack;if(0===e.length)throw new Error("Can't update empty node!");var r=new Array(e.length),n=e[e.length-1];r[r.length-1]=new a(n._color,n.key,t,n.left,n.right,n._count);for(var i=e.length-2;i>=0;--i)(n=e[i]).left===e[i+1]?r[i]=new a(n._color,n.key,n.value,r[i+1],n.right,n._count):r[i]=new a(n._color,n.key,n.value,n.left,r[i+1],n._count);return new c(this.tree._compare,r[0])},h.prev=function(){var t=this._stack;if(0!==t.length){var e=t[t.length-1];if(e.left)for(e=e.left;e;)t.push(e),e=e.right;else for(t.pop();t.length>0&&t[t.length-1].left===e;)e=t[t.length-1],t.pop()}},Object.defineProperty(h,"hasPrev",{get:function(){var t=this._stack;if(0===t.length)return!1;if(t[t.length-1].left)return!0;for(var e=t.length-1;e>0;--e)if(t[e-1].right===t[e])return!0;return!1}})},{}],201:[function(t,e,r){var n=[.9999999999998099,676.5203681218851,-1259.1392167224028,771.3234287776531,-176.6150291621406,12.507343278686905,-.13857109526572012,9984369578019572e-21,1.5056327351493116e-7],i=607/128,a=[.9999999999999971,57.15623566586292,-59.59796035547549,14.136097974741746,-.4919138160976202,3399464998481189e-20,4652362892704858e-20,-9837447530487956e-20,.0001580887032249125,-.00021026444172410488,.00021743961811521265,-.0001643181065367639,8441822398385275e-20,-26190838401581408e-21,36899182659531625e-22];function o(t){if(t<0)return Number("0/0");for(var e=a[0],r=a.length-1;r>0;--r)e+=a[r]/(t+r);var n=t+i+.5;return.5*Math.log(2*Math.PI)+(t+.5)*Math.log(n)-n+Math.log(e)-Math.log(t)}e.exports=function t(e){if(e<.5)return Math.PI/(Math.sin(Math.PI*e)*t(1-e));if(e>100)return Math.exp(o(e));e-=1;for(var r=n[0],i=1;i<9;i++)r+=n[i]/(e+i);var a=e+7+.5;return Math.sqrt(2*Math.PI)*Math.pow(a,e+.5)*Math.exp(-a)*r},e.exports.log=o},{}],202:[function(t,e,r){e.exports=function(t,e){if("string"!=typeof t)throw new TypeError("must specify type string");if(e=e||{},"undefined"==typeof document&&!e.canvas)return null;var r=e.canvas||document.createElement("canvas");"number"==typeof e.width&&(r.width=e.width);"number"==typeof e.height&&(r.height=e.height);var n,i=e;try{var a=[t];0===t.indexOf("webgl")&&a.push("experimental-"+t);for(var o=0;o0?(p[u]=-1,d[u]=0):(p[u]=0,d[u]=1)}}var g=[0,0,0],m={model:l,view:l,projection:l};f.isOpaque=function(){return!0},f.isTransparent=function(){return!1},f.drawTransparent=function(t){};var v=[0,0,0],y=[0,0,0],x=[0,0,0];f.draw=function(t){t=t||m;for(var e=this.gl,r=t.model||l,n=t.view||l,i=t.projection||l,a=this.bounds,s=o(r,n,i,a),u=s.cubeEdges,f=s.axis,h=n[12],b=n[13],_=n[14],w=n[15],k=this.pixelRatio*(i[3]*h+i[7]*b+i[11]*_+i[15]*w)/e.drawingBufferHeight,M=0;M<3;++M)this.lastCubeProps.cubeEdges[M]=u[M],this.lastCubeProps.axis[M]=f[M];var A=p;for(M=0;M<3;++M)d(p[M],M,this.bounds,u,f);e=this.gl;var T=g;for(M=0;M<3;++M)this.backgroundEnable[M]?T[M]=f[M]:T[M]=0;this._background.draw(r,n,i,a,T,this.backgroundColor),this._lines.bind(r,n,i,this);for(M=0;M<3;++M){var S=[0,0,0];f[M]>0?S[M]=a[1][M]:S[M]=a[0][M];for(var C=0;C<2;++C){var E=(M+1+C)%3,L=(M+1+(1^C))%3;this.gridEnable[E]&&this._lines.drawGrid(E,L,this.bounds,S,this.gridColor[E],this.gridWidth[E]*this.pixelRatio)}for(C=0;C<2;++C){E=(M+1+C)%3,L=(M+1+(1^C))%3;this.zeroEnable[L]&&a[0][L]<=0&&a[1][L]>=0&&this._lines.drawZero(E,L,this.bounds,S,this.zeroLineColor[L],this.zeroLineWidth[L]*this.pixelRatio)}}for(M=0;M<3;++M){this.lineEnable[M]&&this._lines.drawAxisLine(M,this.bounds,A[M].primalOffset,this.lineColor[M],this.lineWidth[M]*this.pixelRatio),this.lineMirror[M]&&this._lines.drawAxisLine(M,this.bounds,A[M].mirrorOffset,this.lineColor[M],this.lineWidth[M]*this.pixelRatio);var z=c(v,A[M].primalMinor),P=c(y,A[M].mirrorMinor),D=this.lineTickLength;for(C=0;C<3;++C){var O=k/r[5*C];z[C]*=D[C]*O,P[C]*=D[C]*O}this.lineTickEnable[M]&&this._lines.drawAxisTicks(M,A[M].primalOffset,z,this.lineTickColor[M],this.lineTickWidth[M]*this.pixelRatio),this.lineTickMirror[M]&&this._lines.drawAxisTicks(M,A[M].mirrorOffset,P,this.lineTickColor[M],this.lineTickWidth[M]*this.pixelRatio)}this._lines.unbind(),this._text.bind(r,n,i,this.pixelRatio);for(M=0;M<3;++M){var I=A[M].primalMinor,R=c(x,A[M].primalOffset);for(C=0;C<3;++C)this.lineTickEnable[M]&&(R[C]+=k*I[C]*Math.max(this.lineTickLength[C],0)/r[5*C]);if(this.tickEnable[M]){for(C=0;C<3;++C)R[C]+=k*I[C]*this.tickPad[C]/r[5*C];this._text.drawTicks(M,this.tickSize[M],this.tickAngle[M],R,this.tickColor[M])}if(this.labelEnable[M]){for(C=0;C<3;++C)R[C]+=k*I[C]*this.labelPad[C]/r[5*C];R[M]+=.5*(a[0][M]+a[1][M]),this._text.drawLabel(M,this.labelSize[M],this.labelAngle[M],R,this.labelColor[M])}}this._text.unbind()},f.dispose=function(){this._text.dispose(),this._lines.dispose(),this._background.dispose(),this._lines=null,this._text=null,this._background=null,this.gl=null}},{"./lib/background.js":204,"./lib/cube.js":205,"./lib/lines.js":206,"./lib/text.js":208,"./lib/ticks.js":209}],204:[function(t,e,r){"use strict";e.exports=function(t){for(var e=[],r=[],s=0,l=0;l<3;++l)for(var c=(l+1)%3,u=(l+2)%3,f=[0,0,0],h=[0,0,0],p=-1;p<=1;p+=2){r.push(s,s+2,s+1,s+1,s+2,s+3),f[l]=p,h[l]=p;for(var d=-1;d<=1;d+=2){f[c]=d;for(var g=-1;g<=1;g+=2)f[u]=g,e.push(f[0],f[1],f[2],h[0],h[1],h[2]),s+=1}var m=c;c=u,u=m}var v=n(t,new Float32Array(e)),y=n(t,new Uint16Array(r),t.ELEMENT_ARRAY_BUFFER),x=i(t,[{buffer:v,type:t.FLOAT,size:3,offset:0,stride:24},{buffer:v,type:t.FLOAT,size:3,offset:12,stride:24}],y),b=a(t);return b.attributes.position.location=0,b.attributes.normal.location=1,new o(t,v,x,b)};var n=t("gl-buffer"),i=t("gl-vao"),a=t("./shaders").bg;function o(t,e,r,n){this.gl=t,this.buffer=e,this.vao=r,this.shader=n}var s=o.prototype;s.draw=function(t,e,r,n,i,a){for(var o=!1,s=0;s<3;++s)o=o||i[s];if(o){var l=this.gl;l.enable(l.POLYGON_OFFSET_FILL),l.polygonOffset(1,2),this.shader.bind(),this.shader.uniforms={model:t,view:e,projection:r,bounds:n,enable:i,colors:a},this.vao.bind(),this.vao.draw(this.gl.TRIANGLES,36),this.vao.unbind(),l.disable(l.POLYGON_OFFSET_FILL)}},s.dispose=function(){this.vao.dispose(),this.buffer.dispose(),this.shader.dispose()}},{"./shaders":207,"gl-buffer":211,"gl-vao":284}],205:[function(t,e,r){"use strict";e.exports=function(t,e,r,a){i(s,e,t),i(s,r,s);for(var p=0,y=0;y<2;++y){u[2]=a[y][2];for(var x=0;x<2;++x){u[1]=a[x][1];for(var b=0;b<2;++b)u[0]=a[b][0],h(l[p],u,s),p+=1}}for(var _=-1,y=0;y<8;++y){for(var w=l[y][3],k=0;k<3;++k)c[y][k]=l[y][k]/w;w<0&&(_<0?_=y:c[y][2]S&&(_|=1<S&&(_|=1<c[y][1]&&(I=y));for(var R=-1,y=0;y<3;++y){var B=I^1<c[F][0]&&(F=B)}}var N=g;N[0]=N[1]=N[2]=0,N[n.log2(R^I)]=I&R,N[n.log2(I^F)]=I&F;var j=7^F;j===_||j===O?(j=7^R,N[n.log2(F^j)]=j&F):N[n.log2(R^j)]=j&R;for(var V=m,U=_,M=0;M<3;++M)V[M]=U&1< 0.0) {\n vec3 nPosition = mix(bounds[0], bounds[1], 0.5 * (position + 1.0));\n gl_Position = projection * view * model * vec4(nPosition, 1.0);\n } else {\n gl_Position = vec4(0,0,0,0);\n }\n colorChannel = abs(normal);\n}"]),u=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec4 colors[3];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n gl_FragColor = colorChannel.x * colors[0] + \n colorChannel.y * colors[1] +\n colorChannel.z * colors[2];\n}"]);r.bg=function(t){return i(t,c,u,null,[{name:"position",type:"vec3"},{name:"normal",type:"vec3"}])}},{"gl-shader":268,glslify:353}],208:[function(t,e,r){(function(r){"use strict";e.exports=function(t,e,r,a,s,l){var u=n(t),f=i(t,[{buffer:u,size:3}]),h=o(t);h.attributes.position.location=0;var p=new c(t,h,u,f);return p.update(e,r,a,s,l),p};var n=t("gl-buffer"),i=t("gl-vao"),a=t("vectorize-text"),o=t("./shaders").text,s=window||r.global||{},l=s.__TEXT_CACHE||{};s.__TEXT_CACHE={};function c(t,e,r,n){this.gl=t,this.shader=e,this.buffer=r,this.vao=n,this.tickOffset=this.tickCount=this.labelOffset=this.labelCount=null}var u=c.prototype,f=[0,0];u.bind=function(t,e,r,n){this.vao.bind(),this.shader.bind();var i=this.shader.uniforms;i.model=t,i.view=e,i.projection=r,i.pixelScale=n,f[0]=this.gl.drawingBufferWidth,f[1]=this.gl.drawingBufferHeight,this.shader.uniforms.resolution=f},u.unbind=function(){this.vao.unbind()},u.update=function(t,e,r,n,i){this.gl;var o=[];function s(t,e,r,n){var i=l[r];i||(i=l[r]={});var s=i[e];s||(s=i[e]=function(t,e){try{return a(t,e)}catch(t){return console.warn("error vectorizing text:",t),{cells:[],positions:[]}}}(e,{triangles:!0,font:r,textAlign:"center",textBaseline:"middle"}));for(var c=(n||12)/12,u=s.positions,f=s.cells,h=0,p=f.length;h=0;--g){var m=u[d[g]];o.push(c*m[0],-c*m[1],t)}}for(var c=[0,0,0],u=[0,0,0],f=[0,0,0],h=[0,0,0],p=0;p<3;++p){f[p]=o.length/3|0,s(.5*(t[0][p]+t[1][p]),e[p],r),h[p]=(o.length/3|0)-f[p],c[p]=o.length/3|0;for(var d=0;d=0&&(i=r.length-n-1);var a=Math.pow(10,i),o=Math.round(t*e*a),s=o+"";if(s.indexOf("e")>=0)return s;var l=o/a,c=o%a;o<0?(l=0|-Math.ceil(l),c=0|-c):(l=0|Math.floor(l),c|=0);var u=""+l;if(o<0&&(u="-"+u),i){for(var f=""+c;f.length=t[0][i];--o)a.push({x:o*e[i],text:n(e[i],o)});r.push(a)}return r},r.equal=function(t,e){for(var r=0;r<3;++r){if(t[r].length!==e[r].length)return!1;for(var n=0;nr)throw new Error("gl-buffer: If resizing buffer, must not specify offset");return t.bufferSubData(e,a,i),r}function u(t,e){for(var r=n.malloc(t.length,e),i=t.length,a=0;a=0;--n){if(e[n]!==r)return!1;r*=t[n]}return!0}(t.shape,t.stride))0===t.offset&&t.data.length===t.shape[0]?this.length=c(this.gl,this.type,this.length,this.usage,t.data,e):this.length=c(this.gl,this.type,this.length,this.usage,t.data.subarray(t.offset,t.shape[0]),e);else{var s=n.malloc(t.size,r),l=a(s,t.shape);i.assign(l,t),this.length=c(this.gl,this.type,this.length,this.usage,e<0?s:s.subarray(0,t.size),e),n.free(s)}}else if(Array.isArray(t)){var f;f=this.type===this.gl.ELEMENT_ARRAY_BUFFER?u(t,"uint16"):u(t,"float32"),this.length=c(this.gl,this.type,this.length,this.usage,e<0?f:f.subarray(0,t.length),e),n.free(f)}else if("object"==typeof t&&"number"==typeof t.length)this.length=c(this.gl,this.type,this.length,this.usage,t,e);else{if("number"!=typeof t&&void 0!==t)throw new Error("gl-buffer: Invalid data type");if(e>=0)throw new Error("gl-buffer: Cannot specify offset when resizing buffer");(t|=0)<=0&&(t=1),this.gl.bufferData(this.type,0|t,this.usage),this.length=t}},e.exports=function(t,e,r,n){if(r=r||t.ARRAY_BUFFER,n=n||t.DYNAMIC_DRAW,r!==t.ARRAY_BUFFER&&r!==t.ELEMENT_ARRAY_BUFFER)throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER");if(n!==t.DYNAMIC_DRAW&&n!==t.STATIC_DRAW&&n!==t.STREAM_DRAW)throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW");var i=new s(t,r,t.createBuffer(),0,n);return i.update(e),i}},{ndarray:393,"ndarray-ops":387,"typedarray-pool":481}],212:[function(t,e,r){"use strict";var n=t("gl-vec3"),i=(t("gl-vec4"),function(t,e){for(var r=0;r=e)return r-1;return r}),a=n.create(),o=n.create(),s=function(t,e,r){return tr?r:t},l=function(t,e,r,l){var c=t[0],u=t[1],f=t[2],h=r[0].length,p=r[1].length,d=r[2].length,g=i(r[0],c),m=i(r[1],u),v=i(r[2],f),y=g+1,x=m+1,b=v+1;if(l&&(g=s(g,0,h-1),y=s(y,0,h-1),m=s(m,0,p-1),x=s(x,0,p-1),v=s(v,0,d-1),b=s(b,0,d-1)),g<0||m<0||v<0||y>=h||x>=p||b>=d)return n.create();var _=(c-r[0][g])/(r[0][y]-r[0][g]),w=(u-r[1][m])/(r[1][x]-r[1][m]),k=(f-r[2][v])/(r[2][b]-r[2][v]);(_<0||_>1||isNaN(_))&&(_=0),(w<0||w>1||isNaN(w))&&(w=0),(k<0||k>1||isNaN(k))&&(k=0);var M=v*h*p,A=b*h*p,T=m*h,S=x*h,C=g,E=y,L=e[T+M+C],z=e[T+M+E],P=e[S+M+C],D=e[S+M+E],O=e[T+A+C],I=e[T+A+E],R=e[S+A+C],B=e[S+A+E],F=n.create();return n.lerp(F,L,z,_),n.lerp(a,P,D,_),n.lerp(F,F,a,w),n.lerp(a,O,I,_),n.lerp(o,R,B,_),n.lerp(a,a,o,w),n.lerp(F,F,a,k),F};e.exports=function(t,e){var r;r=t.positions?t.positions:function(t){for(var e=t[0],r=t[1],n=t[2],i=[],a=0;as&&(s=n.length(x)),g){var _=n.distance(b,g);_1.0001)return null;m+=g[u]}if(Math.abs(m-1)>.001)return null;return[f,function(t,e){for(var r=[0,0,0],n=0;n=1},b.isTransparent=function(){return this.opacity<1},b.pickSlots=1,b.setPickBase=function(t){this.pickId=t},b.highlight=function(t){if(t&&this.contourEnable){for(var e=h(this.cells,this.intensity,t.intensity),r=e.cells,n=e.vertexIds,i=e.vertexWeights,a=r.length,o=p.mallocFloat32(6*a),s=0,l=0;l0&&((f=this.triShader).bind(),f.uniforms=s,this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind());this.edgeCount>0&&this.lineWidth>0&&((f=this.lineShader).bind(),f.uniforms=s,this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind());this.pointCount>0&&((f=this.pointShader).bind(),f.uniforms=s,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind());this.contourEnable&&this.contourCount>0&&this.contourLineWidth>0&&((f=this.contourShader).bind(),f.uniforms=s,this.contourVAO.bind(),e.drawArrays(e.LINES,0,this.contourCount),this.contourVAO.unbind())},b.drawPick=function(t){t=t||{};for(var e=this.gl,r=t.model||y,n=t.view||y,i=t.projection||y,a=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],o=0;o<3;++o)a[0][o]=Math.max(a[0][o],this.clipBounds[0][o]),a[1][o]=Math.min(a[1][o],this.clipBounds[1][o]);this._model=[].slice.call(r),this._view=[].slice.call(n),this._projection=[].slice.call(i),this._resolution=[e.drawingBufferWidth,e.drawingBufferHeight];var s,l={model:r,view:n,projection:i,clipBounds:a,vectorScale:this.vectorScale,coneScale:this.coneScale,coneOffset:this.coneOffset,pickId:this.pickId/255};((s=this.pickShader).bind(),s.uniforms=l,this.triangleCount>0&&(this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind()),this.edgeCount>0&&(this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind()),this.pointCount>0)&&((s=this.pointPickShader).bind(),s.uniforms=l,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind())},b.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;for(var e=t.value[0]+256*t.value[1]+65536*t.value[2],r=this.cells[e],n=this.positions,i=new Array(r.length),a=0;a 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0)); \n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0, \n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n// segment + 0 top vertex\n// segment + 1 perimeter vertex a+1\n// segment + 2 perimeter vertex a\n// segment + 3 center base vertex\n// segment + 4 perimeter vertex a\n// segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float index, out vec3 normal) {\n\n const float segmentCount = 8.0;\n\n index = mod(index, segmentCount * 6.0);\n\n float segment = floor(index/6.0);\n float segmentIndex = index - (segment*6.0);\n\n normal = -normalize(d);\n\n if (segmentIndex == 3.0) {\n return mix(vec3(0.0), -d, coneOffset);\n }\n\n // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)\n float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);\n float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n vec3 v1 = mix(d, vec3(0.0), coneOffset);\n vec3 v2 = v1 - d;\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d)*0.25;\n vec3 y = v * sin(angle) * length(d)*0.25;\n vec3 v3 = v2 + x + y;\n if (segmentIndex <= 2.0) {\n vec3 tx = u * sin(angle);\n vec3 ty = v * -cos(angle);\n vec3 tangent = tx + ty;\n normal = normalize(cross(v3 - v1, tangent));\n }\n\n if (segmentIndex == 0.0) {\n return mix(d, vec3(0.0), coneOffset);\n }\n return v3;\n}\n\nvoid main() {\n // Scale the vector magnitude to stay constant with\n // model & view changes.\n vec3 normal;\n vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, normal), 0.0);\n normal = normalize(normal * inverse(mat3(model)));\n\n // vec4 m_position = model * vec4(conePosition, 1.0);\n vec4 t_position = view * conePosition;\n gl_Position = projection * t_position;\n f_color = color; //vec4(position.w, color.r, 0, 0);\n f_normal = normal;\n f_data = conePosition.xyz;\n f_eyeDirection = eyePosition - conePosition.xyz;\n f_lightDirection = lightPosition - conePosition.xyz;\n f_uv = uv;\n}"]),a=n(["precision mediump float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n float NdotH = max(x, 0.0001);\n float cos2Alpha = NdotH * NdotH;\n float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n float roughness2 = roughness * roughness;\n float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n vec3 lightDirection,\n vec3 viewDirection,\n vec3 surfaceNormal,\n float roughness,\n float fresnel) {\n\n float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n //Half angle vector\n vec3 H = normalize(lightDirection + viewDirection);\n\n //Geometric term\n float NdotH = max(dot(surfaceNormal, H), 0.0);\n float VdotH = max(dot(viewDirection, H), 0.000001);\n float LdotH = max(dot(lightDirection, H), 0.000001);\n float G1 = (2.0 * NdotH * VdotN) / VdotH;\n float G2 = (2.0 * NdotH * LdotN) / LdotH;\n float G = min(1.0, min(G1, G2));\n \n //Distribution term\n float D = beckmannDistribution(NdotH, roughness);\n\n //Fresnel term\n float F = pow(1.0 - VdotN, fresnel);\n\n //Multiply terms and done\n return G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n , fresnel\n , kambient\n , kdiffuse\n , kspecular\n , opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n //if(any(lessThan(f_data, clipBounds[0])) || \n // any(greaterThan(f_data, clipBounds[1]))) {\n // discard;\n //}\n\n vec3 N = normalize(f_normal);\n vec3 L = normalize(f_lightDirection);\n vec3 V = normalize(f_eyeDirection);\n \n if(!gl_FrontFacing) {\n N = -N;\n }\n\n float specular = cookTorranceSpecular(L, V, N, roughness, fresnel);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n vec4 surfaceColor = texture2D(texture, f_uv);\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = litColor * opacity;\n}"]),o=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n f_id = id;\n f_position = position;\n}"]),s=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(f_position, clipBounds[0])) || \n any(greaterThan(f_position, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"]);r.meshShader={vertex:i,fragment:a,attributes:[{name:"position",type:"vec4"},{name:"normal",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"},{name:"vector",type:"vec3"}]},r.pickShader={vertex:o,fragment:s,attributes:[{name:"position",type:"vec3"},{name:"id",type:"vec4"}]}},{glslify:353}],216:[function(t,e,r){e.exports={0:"NONE",1:"ONE",2:"LINE_LOOP",3:"LINE_STRIP",4:"TRIANGLES",5:"TRIANGLE_STRIP",6:"TRIANGLE_FAN",256:"DEPTH_BUFFER_BIT",512:"NEVER",513:"LESS",514:"EQUAL",515:"LEQUAL",516:"GREATER",517:"NOTEQUAL",518:"GEQUAL",519:"ALWAYS",768:"SRC_COLOR",769:"ONE_MINUS_SRC_COLOR",770:"SRC_ALPHA",771:"ONE_MINUS_SRC_ALPHA",772:"DST_ALPHA",773:"ONE_MINUS_DST_ALPHA",774:"DST_COLOR",775:"ONE_MINUS_DST_COLOR",776:"SRC_ALPHA_SATURATE",1024:"STENCIL_BUFFER_BIT",1028:"FRONT",1029:"BACK",1032:"FRONT_AND_BACK",1280:"INVALID_ENUM",1281:"INVALID_VALUE",1282:"INVALID_OPERATION",1285:"OUT_OF_MEMORY",1286:"INVALID_FRAMEBUFFER_OPERATION",2304:"CW",2305:"CCW",2849:"LINE_WIDTH",2884:"CULL_FACE",2885:"CULL_FACE_MODE",2886:"FRONT_FACE",2928:"DEPTH_RANGE",2929:"DEPTH_TEST",2930:"DEPTH_WRITEMASK",2931:"DEPTH_CLEAR_VALUE",2932:"DEPTH_FUNC",2960:"STENCIL_TEST",2961:"STENCIL_CLEAR_VALUE",2962:"STENCIL_FUNC",2963:"STENCIL_VALUE_MASK",2964:"STENCIL_FAIL",2965:"STENCIL_PASS_DEPTH_FAIL",2966:"STENCIL_PASS_DEPTH_PASS",2967:"STENCIL_REF",2968:"STENCIL_WRITEMASK",2978:"VIEWPORT",3024:"DITHER",3042:"BLEND",3088:"SCISSOR_BOX",3089:"SCISSOR_TEST",3106:"COLOR_CLEAR_VALUE",3107:"COLOR_WRITEMASK",3317:"UNPACK_ALIGNMENT",3333:"PACK_ALIGNMENT",3379:"MAX_TEXTURE_SIZE",3386:"MAX_VIEWPORT_DIMS",3408:"SUBPIXEL_BITS",3410:"RED_BITS",3411:"GREEN_BITS",3412:"BLUE_BITS",3413:"ALPHA_BITS",3414:"DEPTH_BITS",3415:"STENCIL_BITS",3553:"TEXTURE_2D",4352:"DONT_CARE",4353:"FASTEST",4354:"NICEST",5120:"BYTE",5121:"UNSIGNED_BYTE",5122:"SHORT",5123:"UNSIGNED_SHORT",5124:"INT",5125:"UNSIGNED_INT",5126:"FLOAT",5386:"INVERT",5890:"TEXTURE",6401:"STENCIL_INDEX",6402:"DEPTH_COMPONENT",6406:"ALPHA",6407:"RGB",6408:"RGBA",6409:"LUMINANCE",6410:"LUMINANCE_ALPHA",7680:"KEEP",7681:"REPLACE",7682:"INCR",7683:"DECR",7936:"VENDOR",7937:"RENDERER",7938:"VERSION",9728:"NEAREST",9729:"LINEAR",9984:"NEAREST_MIPMAP_NEAREST",9985:"LINEAR_MIPMAP_NEAREST",9986:"NEAREST_MIPMAP_LINEAR",9987:"LINEAR_MIPMAP_LINEAR",10240:"TEXTURE_MAG_FILTER",10241:"TEXTURE_MIN_FILTER",10242:"TEXTURE_WRAP_S",10243:"TEXTURE_WRAP_T",10497:"REPEAT",10752:"POLYGON_OFFSET_UNITS",16384:"COLOR_BUFFER_BIT",32769:"CONSTANT_COLOR",32770:"ONE_MINUS_CONSTANT_COLOR",32771:"CONSTANT_ALPHA",32772:"ONE_MINUS_CONSTANT_ALPHA",32773:"BLEND_COLOR",32774:"FUNC_ADD",32777:"BLEND_EQUATION_RGB",32778:"FUNC_SUBTRACT",32779:"FUNC_REVERSE_SUBTRACT",32819:"UNSIGNED_SHORT_4_4_4_4",32820:"UNSIGNED_SHORT_5_5_5_1",32823:"POLYGON_OFFSET_FILL",32824:"POLYGON_OFFSET_FACTOR",32854:"RGBA4",32855:"RGB5_A1",32873:"TEXTURE_BINDING_2D",32926:"SAMPLE_ALPHA_TO_COVERAGE",32928:"SAMPLE_COVERAGE",32936:"SAMPLE_BUFFERS",32937:"SAMPLES",32938:"SAMPLE_COVERAGE_VALUE",32939:"SAMPLE_COVERAGE_INVERT",32968:"BLEND_DST_RGB",32969:"BLEND_SRC_RGB",32970:"BLEND_DST_ALPHA",32971:"BLEND_SRC_ALPHA",33071:"CLAMP_TO_EDGE",33170:"GENERATE_MIPMAP_HINT",33189:"DEPTH_COMPONENT16",33306:"DEPTH_STENCIL_ATTACHMENT",33635:"UNSIGNED_SHORT_5_6_5",33648:"MIRRORED_REPEAT",33901:"ALIASED_POINT_SIZE_RANGE",33902:"ALIASED_LINE_WIDTH_RANGE",33984:"TEXTURE0",33985:"TEXTURE1",33986:"TEXTURE2",33987:"TEXTURE3",33988:"TEXTURE4",33989:"TEXTURE5",33990:"TEXTURE6",33991:"TEXTURE7",33992:"TEXTURE8",33993:"TEXTURE9",33994:"TEXTURE10",33995:"TEXTURE11",33996:"TEXTURE12",33997:"TEXTURE13",33998:"TEXTURE14",33999:"TEXTURE15",34000:"TEXTURE16",34001:"TEXTURE17",34002:"TEXTURE18",34003:"TEXTURE19",34004:"TEXTURE20",34005:"TEXTURE21",34006:"TEXTURE22",34007:"TEXTURE23",34008:"TEXTURE24",34009:"TEXTURE25",34010:"TEXTURE26",34011:"TEXTURE27",34012:"TEXTURE28",34013:"TEXTURE29",34014:"TEXTURE30",34015:"TEXTURE31",34016:"ACTIVE_TEXTURE",34024:"MAX_RENDERBUFFER_SIZE",34041:"DEPTH_STENCIL",34055:"INCR_WRAP",34056:"DECR_WRAP",34067:"TEXTURE_CUBE_MAP",34068:"TEXTURE_BINDING_CUBE_MAP",34069:"TEXTURE_CUBE_MAP_POSITIVE_X",34070:"TEXTURE_CUBE_MAP_NEGATIVE_X",34071:"TEXTURE_CUBE_MAP_POSITIVE_Y",34072:"TEXTURE_CUBE_MAP_NEGATIVE_Y",34073:"TEXTURE_CUBE_MAP_POSITIVE_Z",34074:"TEXTURE_CUBE_MAP_NEGATIVE_Z",34076:"MAX_CUBE_MAP_TEXTURE_SIZE",34338:"VERTEX_ATTRIB_ARRAY_ENABLED",34339:"VERTEX_ATTRIB_ARRAY_SIZE",34340:"VERTEX_ATTRIB_ARRAY_STRIDE",34341:"VERTEX_ATTRIB_ARRAY_TYPE",34342:"CURRENT_VERTEX_ATTRIB",34373:"VERTEX_ATTRIB_ARRAY_POINTER",34466:"NUM_COMPRESSED_TEXTURE_FORMATS",34467:"COMPRESSED_TEXTURE_FORMATS",34660:"BUFFER_SIZE",34661:"BUFFER_USAGE",34816:"STENCIL_BACK_FUNC",34817:"STENCIL_BACK_FAIL",34818:"STENCIL_BACK_PASS_DEPTH_FAIL",34819:"STENCIL_BACK_PASS_DEPTH_PASS",34877:"BLEND_EQUATION_ALPHA",34921:"MAX_VERTEX_ATTRIBS",34922:"VERTEX_ATTRIB_ARRAY_NORMALIZED",34930:"MAX_TEXTURE_IMAGE_UNITS",34962:"ARRAY_BUFFER",34963:"ELEMENT_ARRAY_BUFFER",34964:"ARRAY_BUFFER_BINDING",34965:"ELEMENT_ARRAY_BUFFER_BINDING",34975:"VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",35040:"STREAM_DRAW",35044:"STATIC_DRAW",35048:"DYNAMIC_DRAW",35632:"FRAGMENT_SHADER",35633:"VERTEX_SHADER",35660:"MAX_VERTEX_TEXTURE_IMAGE_UNITS",35661:"MAX_COMBINED_TEXTURE_IMAGE_UNITS",35663:"SHADER_TYPE",35664:"FLOAT_VEC2",35665:"FLOAT_VEC3",35666:"FLOAT_VEC4",35667:"INT_VEC2",35668:"INT_VEC3",35669:"INT_VEC4",35670:"BOOL",35671:"BOOL_VEC2",35672:"BOOL_VEC3",35673:"BOOL_VEC4",35674:"FLOAT_MAT2",35675:"FLOAT_MAT3",35676:"FLOAT_MAT4",35678:"SAMPLER_2D",35680:"SAMPLER_CUBE",35712:"DELETE_STATUS",35713:"COMPILE_STATUS",35714:"LINK_STATUS",35715:"VALIDATE_STATUS",35716:"INFO_LOG_LENGTH",35717:"ATTACHED_SHADERS",35718:"ACTIVE_UNIFORMS",35719:"ACTIVE_UNIFORM_MAX_LENGTH",35720:"SHADER_SOURCE_LENGTH",35721:"ACTIVE_ATTRIBUTES",35722:"ACTIVE_ATTRIBUTE_MAX_LENGTH",35724:"SHADING_LANGUAGE_VERSION",35725:"CURRENT_PROGRAM",36003:"STENCIL_BACK_REF",36004:"STENCIL_BACK_VALUE_MASK",36005:"STENCIL_BACK_WRITEMASK",36006:"FRAMEBUFFER_BINDING",36007:"RENDERBUFFER_BINDING",36048:"FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",36049:"FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",36050:"FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",36051:"FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",36053:"FRAMEBUFFER_COMPLETE",36054:"FRAMEBUFFER_INCOMPLETE_ATTACHMENT",36055:"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",36057:"FRAMEBUFFER_INCOMPLETE_DIMENSIONS",36061:"FRAMEBUFFER_UNSUPPORTED",36064:"COLOR_ATTACHMENT0",36096:"DEPTH_ATTACHMENT",36128:"STENCIL_ATTACHMENT",36160:"FRAMEBUFFER",36161:"RENDERBUFFER",36162:"RENDERBUFFER_WIDTH",36163:"RENDERBUFFER_HEIGHT",36164:"RENDERBUFFER_INTERNAL_FORMAT",36168:"STENCIL_INDEX8",36176:"RENDERBUFFER_RED_SIZE",36177:"RENDERBUFFER_GREEN_SIZE",36178:"RENDERBUFFER_BLUE_SIZE",36179:"RENDERBUFFER_ALPHA_SIZE",36180:"RENDERBUFFER_DEPTH_SIZE",36181:"RENDERBUFFER_STENCIL_SIZE",36194:"RGB565",36336:"LOW_FLOAT",36337:"MEDIUM_FLOAT",36338:"HIGH_FLOAT",36339:"LOW_INT",36340:"MEDIUM_INT",36341:"HIGH_INT",36346:"SHADER_COMPILER",36347:"MAX_VERTEX_UNIFORM_VECTORS",36348:"MAX_VARYING_VECTORS",36349:"MAX_FRAGMENT_UNIFORM_VECTORS",37440:"UNPACK_FLIP_Y_WEBGL",37441:"UNPACK_PREMULTIPLY_ALPHA_WEBGL",37442:"CONTEXT_LOST_WEBGL",37443:"UNPACK_COLORSPACE_CONVERSION_WEBGL",37444:"BROWSER_DEFAULT_WEBGL"}},{}],217:[function(t,e,r){var n=t("./1.0/numbers");e.exports=function(t){return n[t]}},{"./1.0/numbers":216}],218:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl,r=n(e),o=i(e,[{buffer:r,type:e.FLOAT,size:3,offset:0,stride:40},{buffer:r,type:e.FLOAT,size:4,offset:12,stride:40},{buffer:r,type:e.FLOAT,size:3,offset:28,stride:40}]),l=a(e);l.attributes.position.location=0,l.attributes.color.location=1,l.attributes.offset.location=2;var c=new s(e,r,o,l);return c.update(t),c};var n=t("gl-buffer"),i=t("gl-vao"),a=t("./shaders/index"),o=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function s(t,e,r,n){this.gl=t,this.shader=n,this.buffer=e,this.vao=r,this.pixelRatio=1,this.bounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.lineWidth=[1,1,1],this.capSize=[10,10,10],this.lineCount=[0,0,0],this.lineOffset=[0,0,0],this.opacity=1}var l=s.prototype;function c(t,e){for(var r=0;r<3;++r)t[0][r]=Math.min(t[0][r],e[r]),t[1][r]=Math.max(t[1][r],e[r])}l.isOpaque=function(){return this.opacity>=1},l.isTransparent=function(){return this.opacity<1},l.drawTransparent=l.draw=function(t){var e=this.gl,r=this.shader.uniforms;this.shader.bind();var n=r.view=t.view||o,i=r.projection=t.projection||o;r.model=t.model||o,r.clipBounds=this.clipBounds,r.opacity=this.opacity;var a=n[12],s=n[13],l=n[14],c=n[15],u=this.pixelRatio*(i[3]*a+i[7]*s+i[11]*l+i[15]*c)/e.drawingBufferHeight;this.vao.bind();for(var f=0;f<3;++f)e.lineWidth(this.lineWidth[f]),r.capSize=this.capSize[f]*u,this.lineCount[f]&&e.drawArrays(e.LINES,this.lineOffset[f],this.lineCount[f]);this.vao.unbind()};var u=function(){for(var t=new Array(3),e=0;e<3;++e){for(var r=[],n=1;n<=2;++n)for(var i=-1;i<=1;i+=2){var a=[0,0,0];a[(n+e)%3]=i,r.push(a)}t[e]=r}return t}();function f(t,e,r,n){for(var i=u[n],a=0;a0)(g=u.slice())[s]+=p[1][s],i.push(u[0],u[1],u[2],d[0],d[1],d[2],d[3],0,0,0,g[0],g[1],g[2],d[0],d[1],d[2],d[3],0,0,0),c(this.bounds,g),o+=2+f(i,g,d,s)}}this.lineCount[s]=o-this.lineOffset[s]}this.buffer.update(i)}},l.dispose=function(){this.shader.dispose(),this.buffer.dispose(),this.vao.dispose()}},{"./shaders/index":219,"gl-buffer":211,"gl-vao":284}],219:[function(t,e,r){"use strict";var n=t("glslify"),i=t("gl-shader"),a=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, offset;\nattribute vec4 color;\nuniform mat4 model, view, projection;\nuniform float capSize;\nvarying vec4 fragColor;\nvarying vec3 fragPosition;\n\nvoid main() {\n vec4 worldPosition = model * vec4(position, 1.0);\n worldPosition = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);\n gl_Position = projection * view * worldPosition;\n fragColor = color;\n fragPosition = position;\n}"]),o=n(["precision mediump float;\n#define GLSLIFY 1\nuniform vec3 clipBounds[2];\nuniform float opacity;\nvarying vec3 fragPosition;\nvarying vec4 fragColor;\n\nvoid main() {\n if(any(lessThan(fragPosition, clipBounds[0])) || any(greaterThan(fragPosition, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = opacity * fragColor;\n}"]);e.exports=function(t){return i(t,a,o,null,[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"offset",type:"vec3"}])}},{"gl-shader":268,glslify:353}],220:[function(t,e,r){"use strict";var n=t("gl-texture2d");e.exports=function(t,e,r,n){i||(i=t.FRAMEBUFFER_UNSUPPORTED,a=t.FRAMEBUFFER_INCOMPLETE_ATTACHMENT,o=t.FRAMEBUFFER_INCOMPLETE_DIMENSIONS,s=t.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);var c=t.getExtension("WEBGL_draw_buffers");!l&&c&&function(t,e){var r=t.getParameter(e.MAX_COLOR_ATTACHMENTS_WEBGL);l=new Array(r+1);for(var n=0;n<=r;++n){for(var i=new Array(r),a=0;au||r<0||r>u)throw new Error("gl-fbo: Parameters are too large for FBO");var f=1;if("color"in(n=n||{})){if((f=Math.max(0|n.color,0))<0)throw new Error("gl-fbo: Must specify a nonnegative number of colors");if(f>1){if(!c)throw new Error("gl-fbo: Multiple draw buffer extension not supported");if(f>t.getParameter(c.MAX_COLOR_ATTACHMENTS_WEBGL))throw new Error("gl-fbo: Context does not support "+f+" draw buffers")}}var h=t.UNSIGNED_BYTE,p=t.getExtension("OES_texture_float");if(n.float&&f>0){if(!p)throw new Error("gl-fbo: Context does not support floating point textures");h=t.FLOAT}else n.preferFloat&&f>0&&p&&(h=t.FLOAT);var g=!0;"depth"in n&&(g=!!n.depth);var m=!1;"stencil"in n&&(m=!!n.stencil);return new d(t,e,r,h,f,g,m,c)};var i,a,o,s,l=null;function c(t){return[t.getParameter(t.FRAMEBUFFER_BINDING),t.getParameter(t.RENDERBUFFER_BINDING),t.getParameter(t.TEXTURE_BINDING_2D)]}function u(t,e){t.bindFramebuffer(t.FRAMEBUFFER,e[0]),t.bindRenderbuffer(t.RENDERBUFFER,e[1]),t.bindTexture(t.TEXTURE_2D,e[2])}function f(t){switch(t){case i:throw new Error("gl-fbo: Framebuffer unsupported");case a:throw new Error("gl-fbo: Framebuffer incomplete attachment");case o:throw new Error("gl-fbo: Framebuffer incomplete dimensions");case s:throw new Error("gl-fbo: Framebuffer incomplete missing attachment");default:throw new Error("gl-fbo: Framebuffer failed for unspecified reason")}}function h(t,e,r,i,a,o){if(!i)return null;var s=n(t,e,r,a,i);return s.magFilter=t.NEAREST,s.minFilter=t.NEAREST,s.mipSamples=1,s.bind(),t.framebufferTexture2D(t.FRAMEBUFFER,o,t.TEXTURE_2D,s.handle,0),s}function p(t,e,r,n,i){var a=t.createRenderbuffer();return t.bindRenderbuffer(t.RENDERBUFFER,a),t.renderbufferStorage(t.RENDERBUFFER,n,e,r),t.framebufferRenderbuffer(t.FRAMEBUFFER,i,t.RENDERBUFFER,a),a}function d(t,e,r,n,i,a,o,s){this.gl=t,this._shape=[0|e,0|r],this._destroyed=!1,this._ext=s,this.color=new Array(i);for(var d=0;d1&&s.drawBuffersWEBGL(l[o]);var y=r.getExtension("WEBGL_depth_texture");y?d?t.depth=h(r,i,a,y.UNSIGNED_INT_24_8_WEBGL,r.DEPTH_STENCIL,r.DEPTH_STENCIL_ATTACHMENT):g&&(t.depth=h(r,i,a,r.UNSIGNED_SHORT,r.DEPTH_COMPONENT,r.DEPTH_ATTACHMENT)):g&&d?t._depth_rb=p(r,i,a,r.DEPTH_STENCIL,r.DEPTH_STENCIL_ATTACHMENT):g?t._depth_rb=p(r,i,a,r.DEPTH_COMPONENT16,r.DEPTH_ATTACHMENT):d&&(t._depth_rb=p(r,i,a,r.STENCIL_INDEX,r.STENCIL_ATTACHMENT));var x=r.checkFramebufferStatus(r.FRAMEBUFFER);if(x!==r.FRAMEBUFFER_COMPLETE){for(t._destroyed=!0,r.bindFramebuffer(r.FRAMEBUFFER,null),r.deleteFramebuffer(t.handle),t.handle=null,t.depth&&(t.depth.dispose(),t.depth=null),t._depth_rb&&(r.deleteRenderbuffer(t._depth_rb),t._depth_rb=null),v=0;vi||r<0||r>i)throw new Error("gl-fbo: Can't resize FBO, invalid dimensions");t._shape[0]=e,t._shape[1]=r;for(var a=c(n),o=0;o>8*p&255;this.pickOffset=r,i.bind();var d=i.uniforms;d.viewTransform=t,d.pickOffset=e,d.shape=this.shape;var g=i.attributes;return this.positionBuffer.bind(),g.position.pointer(),this.weightBuffer.bind(),g.weight.pointer(s.UNSIGNED_BYTE,!1),this.idBuffer.bind(),g.pickId.pointer(s.UNSIGNED_BYTE,!1),s.drawArrays(s.TRIANGLES,0,o),r+this.shape[0]*this.shape[1]}}}(),f.pick=function(t,e,r){var n=this.pickOffset,i=this.shape[0]*this.shape[1];if(r=n+i)return null;var a=r-n,o=this.xData,s=this.yData;return{object:this,pointId:a,dataCoord:[o[a%this.shape[0]],s[a/this.shape[0]|0]]}},f.update=function(t){var e=(t=t||{}).shape||[0,0],r=t.x||i(e[0]),o=t.y||i(e[1]),s=t.z||new Float32Array(e[0]*e[1]);this.xData=r,this.yData=o;var l=t.colorLevels||[0],c=t.colorValues||[0,0,0,1],u=l.length,f=this.bounds,p=f[0]=r[0],d=f[1]=o[0],g=1/((f[2]=r[r.length-1])-p),m=1/((f[3]=o[o.length-1])-d),v=e[0],y=e[1];this.shape=[v,y];var x=(v-1)*(y-1)*(h.length>>>1);this.numVertices=x;for(var b=a.mallocUint8(4*x),_=a.mallocFloat32(2*x),w=a.mallocUint8(2*x),k=a.mallocUint32(x),M=0,A=0;A FLOAT_MAX) {\n return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;\n } else if(v < -FLOAT_MAX) {\n return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;\n }\n\n highp vec4 c = vec4(0,0,0,0);\n\n //Compute exponent and mantissa\n highp float e = floor(log2(av));\n highp float m = av * pow(2.0, -e) - 1.0;\n \n //Unpack mantissa\n c[1] = floor(128.0 * m);\n m -= c[1] / 128.0;\n c[2] = floor(32768.0 * m);\n m -= c[2] / 32768.0;\n c[3] = floor(8388608.0 * m);\n \n //Unpack exponent\n highp float ebias = e + 127.0;\n c[0] = floor(ebias / 2.0);\n ebias -= c[0] * 2.0;\n c[1] += floor(ebias) * 128.0; \n\n //Unpack sign bit\n c[0] += 128.0 * step(0.0, -v);\n\n //Scale back to range\n return c / 255.0;\n}\n\nuniform float pickId;\nuniform vec3 clipBounds[2];\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n if(any(lessThan(worldPosition, clipBounds[0])) || any(greaterThan(worldPosition, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId/255.0, encode_float_1540259130(pixelArcLength).xyz);\n}"]),l=[{name:"position",type:"vec3"},{name:"nextPosition",type:"vec3"},{name:"arcLength",type:"float"},{name:"lineWidth",type:"float"},{name:"color",type:"vec4"}];r.createShader=function(t){return i(t,a,o,null,l)},r.createPickShader=function(t){return i(t,a,s,null,l)}},{"gl-shader":268,glslify:353}],226:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl||t.scene&&t.scene.gl,r=u(e);r.attributes.position.location=0,r.attributes.nextPosition.location=1,r.attributes.arcLength.location=2,r.attributes.lineWidth.location=3,r.attributes.color.location=4;var o=f(e);o.attributes.position.location=0,o.attributes.nextPosition.location=1,o.attributes.arcLength.location=2,o.attributes.lineWidth.location=3,o.attributes.color.location=4;for(var s=n(e),c=i(e,[{buffer:s,size:3,offset:0,stride:48},{buffer:s,size:3,offset:12,stride:48},{buffer:s,size:1,offset:24,stride:48},{buffer:s,size:1,offset:28,stride:48},{buffer:s,size:4,offset:32,stride:48}]),h=l(new Array(1024),[256,1,4]),p=0;p<1024;++p)h.data[p]=255;var d=a(e,h);d.wrap=e.REPEAT;var g=new m(e,r,o,s,c,d);return g.update(t),g};var n=t("gl-buffer"),i=t("gl-vao"),a=t("gl-texture2d"),o=t("glsl-read-float"),s=t("binary-search-bounds"),l=t("ndarray"),c=t("./lib/shaders"),u=c.createShader,f=c.createPickShader,h=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function p(t,e){for(var r=0,n=0;n<3;++n){var i=t[n]-e[n];r+=i*i}return Math.sqrt(r)}function d(t){for(var e=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],r=0;r<3;++r)e[0][r]=Math.max(t[0][r],e[0][r]),e[1][r]=Math.min(t[1][r],e[1][r]);return e}function g(t,e,r,n){this.arcLength=t,this.position=e,this.index=r,this.dataCoordinate=n}function m(t,e,r,n,i,a){this.gl=t,this.shader=e,this.pickShader=r,this.buffer=n,this.vao=i,this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.points=[],this.arcLength=[],this.vertexCount=0,this.bounds=[[0,0,0],[0,0,0]],this.pickId=0,this.lineWidth=1,this.texture=a,this.dashScale=1,this.opacity=1,this.dirty=!0,this.pixelRatio=1}var v=m.prototype;v.isTransparent=function(){return this.opacity<1},v.isOpaque=function(){return this.opacity>=1},v.pickSlots=1,v.setPickBase=function(t){this.pickId=t},v.drawTransparent=v.draw=function(t){var e=this.gl,r=this.shader,n=this.vao;r.bind(),r.uniforms={model:t.model||h,view:t.view||h,projection:t.projection||h,clipBounds:d(this.clipBounds),dashTexture:this.texture.bind(),dashScale:this.dashScale/this.arcLength[this.arcLength.length-1],opacity:this.opacity,screenShape:[e.drawingBufferWidth,e.drawingBufferHeight],pixelRatio:this.pixelRatio},n.bind(),n.draw(e.TRIANGLE_STRIP,this.vertexCount),n.unbind()},v.drawPick=function(t){var e=this.gl,r=this.pickShader,n=this.vao;r.bind(),r.uniforms={model:t.model||h,view:t.view||h,projection:t.projection||h,pickId:this.pickId,clipBounds:d(this.clipBounds),screenShape:[e.drawingBufferWidth,e.drawingBufferHeight],pixelRatio:this.pixelRatio},n.bind(),n.draw(e.TRIANGLE_STRIP,this.vertexCount),n.unbind()},v.update=function(t){var e,r;this.dirty=!0;var n=!!t.connectGaps;"dashScale"in t&&(this.dashScale=t.dashScale),"opacity"in t&&(this.opacity=+t.opacity);var i=t.position||t.positions;if(i){var a=t.color||t.colors||[0,0,0,1],o=t.lineWidth||1,c=[],u=[],f=[],h=0,d=0,g=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],m=!1;t:for(e=1;e0){for(var w=0;w<24;++w)c.push(c[c.length-12]);d+=2,m=!0}continue t}g[0][r]=Math.min(g[0][r],b[r],_[r]),g[1][r]=Math.max(g[1][r],b[r],_[r])}Array.isArray(a[0])?(v=a[e-1],y=a[e]):v=y=a,3===v.length&&(v=[v[0],v[1],v[2],1]),3===y.length&&(y=[y[0],y[1],y[2],1]),x=Array.isArray(o)?o[e-1]:o;var k=h;if(h+=p(b,_),m){for(r=0;r<2;++r)c.push(b[0],b[1],b[2],_[0],_[1],_[2],k,x,v[0],v[1],v[2],v[3]);d+=2,m=!1}c.push(b[0],b[1],b[2],_[0],_[1],_[2],k,x,v[0],v[1],v[2],v[3],b[0],b[1],b[2],_[0],_[1],_[2],k,-x,v[0],v[1],v[2],v[3],_[0],_[1],_[2],b[0],b[1],b[2],h,-x,y[0],y[1],y[2],y[3],_[0],_[1],_[2],b[0],b[1],b[2],h,x,y[0],y[1],y[2],y[3]),d+=4}if(this.buffer.update(c),u.push(h),f.push(i[i.length-1].slice()),this.bounds=g,this.vertexCount=d,this.points=f,this.arcLength=u,"dashes"in t){var M=t.dashes.slice();for(M.unshift(0),e=1;e1.0001)return null;m+=g[u]}if(Math.abs(m-1)>.001)return null;return[f,function(t,e){for(var r=[0,0,0],n=0;n 0.25) {\n discard;\n }\n gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"]),u=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n f_id = id;\n f_position = position;\n}"]),f=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(f_position, clipBounds[0])) || \n any(greaterThan(f_position, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"]),h=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute float pointSize;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(position, clipBounds[0])) || \n any(greaterThan(position, clipBounds[1]))) {\n gl_Position = vec4(0,0,0,0);\n } else {\n gl_Position = projection * view * model * vec4(position, 1.0);\n gl_PointSize = pointSize;\n }\n f_id = id;\n f_position = position;\n}"]),p=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n}"]),d=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 contourColor;\n\nvoid main() {\n gl_FragColor = vec4(contourColor,1);\n}\n"]);r.meshShader={vertex:i,fragment:a,attributes:[{name:"position",type:"vec3"},{name:"normal",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"}]},r.wireShader={vertex:o,fragment:s,attributes:[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"}]},r.pointShader={vertex:l,fragment:c,attributes:[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"},{name:"pointSize",type:"float"}]},r.pickShader={vertex:u,fragment:f,attributes:[{name:"position",type:"vec3"},{name:"id",type:"vec4"}]},r.pointPickShader={vertex:h,fragment:f,attributes:[{name:"position",type:"vec3"},{name:"pointSize",type:"float"},{name:"id",type:"vec4"}]},r.contourShader={vertex:p,fragment:d,attributes:[{name:"position",type:"vec3"}]}},{glslify:353}],249:[function(t,e,r){"use strict";var n=t("gl-shader"),i=t("gl-buffer"),a=t("gl-vao"),o=t("gl-texture2d"),s=t("normals"),l=t("gl-mat4/multiply"),c=t("gl-mat4/invert"),u=t("ndarray"),f=t("colormap"),h=t("simplicial-complex-contour"),p=t("typedarray-pool"),d=t("./lib/shaders"),g=t("./lib/closest-point"),m=d.meshShader,v=d.wireShader,y=d.pointShader,x=d.pickShader,b=d.pointPickShader,_=d.contourShader,w=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function k(t,e,r,n,i,a,o,s,l,c,u,f,h,p,d,g,m,v,y,x,b,_,k,M,A,T,S){this.gl=t,this.cells=[],this.positions=[],this.intensity=[],this.texture=e,this.dirty=!0,this.triShader=r,this.lineShader=n,this.pointShader=i,this.pickShader=a,this.pointPickShader=o,this.contourShader=s,this.trianglePositions=l,this.triangleColors=u,this.triangleNormals=h,this.triangleUVs=f,this.triangleIds=c,this.triangleVAO=p,this.triangleCount=0,this.lineWidth=1,this.edgePositions=d,this.edgeColors=m,this.edgeUVs=v,this.edgeIds=g,this.edgeVAO=y,this.edgeCount=0,this.pointPositions=x,this.pointColors=_,this.pointUVs=k,this.pointSizes=M,this.pointIds=b,this.pointVAO=A,this.pointCount=0,this.contourLineWidth=1,this.contourPositions=T,this.contourVAO=S,this.contourCount=0,this.contourColor=[0,0,0],this.contourEnable=!0,this.pickId=1,this.bounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.lightPosition=[1e5,1e5,0],this.ambientLight=.8,this.diffuseLight=.8,this.specularLight=2,this.roughness=.5,this.fresnel=1.5,this.opacity=1,this._model=w,this._view=w,this._projection=w,this._resolution=[1,1]}var M=k.prototype;function A(t){var e=n(t,y.vertex,y.fragment);return e.attributes.position.location=0,e.attributes.color.location=2,e.attributes.uv.location=3,e.attributes.pointSize.location=4,e}function T(t){var e=n(t,x.vertex,x.fragment);return e.attributes.position.location=0,e.attributes.id.location=1,e}function S(t){var e=n(t,b.vertex,b.fragment);return e.attributes.position.location=0,e.attributes.id.location=1,e.attributes.pointSize.location=4,e}function C(t){var e=n(t,_.vertex,_.fragment);return e.attributes.position.location=0,e}M.isOpaque=function(){return this.opacity>=1},M.isTransparent=function(){return this.opacity<1},M.pickSlots=1,M.setPickBase=function(t){this.pickId=t},M.highlight=function(t){if(t&&this.contourEnable){for(var e=h(this.cells,this.intensity,t.intensity),r=e.cells,n=e.vertexIds,i=e.vertexWeights,a=r.length,o=p.mallocFloat32(6*a),s=0,l=0;l0&&((f=this.triShader).bind(),f.uniforms=s,this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind());this.edgeCount>0&&this.lineWidth>0&&((f=this.lineShader).bind(),f.uniforms=s,this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind());this.pointCount>0&&((f=this.pointShader).bind(),f.uniforms=s,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind());this.contourEnable&&this.contourCount>0&&this.contourLineWidth>0&&((f=this.contourShader).bind(),f.uniforms=s,this.contourVAO.bind(),e.drawArrays(e.LINES,0,this.contourCount),this.contourVAO.unbind())},M.drawPick=function(t){t=t||{};for(var e=this.gl,r=t.model||w,n=t.view||w,i=t.projection||w,a=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],o=0;o<3;++o)a[0][o]=Math.max(a[0][o],this.clipBounds[0][o]),a[1][o]=Math.min(a[1][o],this.clipBounds[1][o]);this._model=[].slice.call(r),this._view=[].slice.call(n),this._projection=[].slice.call(i),this._resolution=[e.drawingBufferWidth,e.drawingBufferHeight];var s,l={model:r,view:n,projection:i,clipBounds:a,pickId:this.pickId/255};((s=this.pickShader).bind(),s.uniforms=l,this.triangleCount>0&&(this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind()),this.edgeCount>0&&(this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind()),this.pointCount>0)&&((s=this.pointPickShader).bind(),s.uniforms=l,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind())},M.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;for(var e=t.value[0]+256*t.value[1]+65536*t.value[2],r=this.cells[e],n=this.positions,i=new Array(r.length),a=0;ai[M]&&(r.uniforms.dataAxis=c,r.uniforms.screenOffset=u,r.uniforms.color=m[t],r.uniforms.angle=v[t],a.drawArrays(a.TRIANGLES,i[M],i[A]-i[M]))),y[t]&&k&&(u[1^t]-=T*p*x[t],r.uniforms.dataAxis=f,r.uniforms.screenOffset=u,r.uniforms.color=b[t],r.uniforms.angle=_[t],a.drawArrays(a.TRIANGLES,w,k)),u[1^t]=T*s[2+(1^t)]-1,d[t+2]&&(u[1^t]+=T*p*g[t+2],Mi[M]&&(r.uniforms.dataAxis=c,r.uniforms.screenOffset=u,r.uniforms.color=m[t+2],r.uniforms.angle=v[t+2],a.drawArrays(a.TRIANGLES,i[M],i[A]-i[M]))),y[t+2]&&k&&(u[1^t]+=T*p*x[t+2],r.uniforms.dataAxis=f,r.uniforms.screenOffset=u,r.uniforms.color=b[t+2],r.uniforms.angle=_[t+2],a.drawArrays(a.TRIANGLES,w,k))}),g.drawTitle=function(){var t=[0,0],e=[0,0];return function(){var r=this.plot,n=this.shader,i=r.gl,a=r.screenBox,o=r.titleCenter,s=r.titleAngle,l=r.titleColor,c=r.pixelRatio;if(this.titleCount){for(var u=0;u<2;++u)e[u]=2*(o[u]*c-a[u])/(a[2+u]-a[u])-1;n.bind(),n.uniforms.dataAxis=t,n.uniforms.screenOffset=e,n.uniforms.angle=s,n.uniforms.color=l,i.drawArrays(i.TRIANGLES,this.titleOffset,this.titleCount)}}}(),g.bind=(h=[0,0],p=[0,0],d=[0,0],function(){var t=this.plot,e=this.shader,r=t._tickBounds,n=t.dataBox,i=t.screenBox,a=t.viewBox;e.bind();for(var o=0;o<2;++o){var s=r[o],l=r[o+2]-s,c=.5*(n[o+2]+n[o]),u=n[o+2]-n[o],f=a[o],g=a[o+2]-f,m=i[o],v=i[o+2]-m;p[o]=2*l/u*g/v,h[o]=2*(s-c)/u*g/v}d[1]=2*t.pixelRatio/(i[3]-i[1]),d[0]=d[1]*(i[3]-i[1])/(i[2]-i[0]),e.uniforms.dataScale=p,e.uniforms.dataShift=h,e.uniforms.textScale=d,this.vbo.bind(),e.attributes.textCoordinate.pointer()}),g.update=function(t){var e,r,n,i,o,s=[],l=t.ticks,c=t.bounds;for(o=0;o<2;++o){var u=[Math.floor(s.length/3)],f=[-1/0],h=l[o];for(e=0;e=0){var g=e[d]-n[d]*(e[d+2]-e[d])/(n[d+2]-n[d]);0===d?o.drawLine(g,e[1],g,e[3],p[d],h[d]):o.drawLine(e[0],g,e[2],g,p[d],h[d])}}for(d=0;d=0;--t)this.objects[t].dispose();this.objects.length=0;for(t=this.overlays.length-1;t>=0;--t)this.overlays[t].dispose();this.overlays.length=0,this.gl=null},c.addObject=function(t){this.objects.indexOf(t)<0&&(this.objects.push(t),this.setDirty())},c.removeObject=function(t){for(var e=this.objects,r=0;r0&&0===E[e-1];)E.pop(),L.pop().dispose()}window.addEventListener("resize",N),B.update=function(t){e||(t=t||{},z=!0,P=!0)},B.add=function(t){e||(t.axes=M,S.push(t),C.push(-1),z=!0,P=!0,j())},B.remove=function(t){if(!e){var r=S.indexOf(t);r<0||(S.splice(r,1),C.pop(),z=!0,P=!0,j())}},B.dispose=function(){if(!e&&(e=!0,window.removeEventListener("resize",N),r.removeEventListener("webglcontextlost",q),B.mouseListener.enabled=!1,!B.contextLost)){M.dispose(),T.dispose();for(var t=0;tx.distance)continue;for(var u=0;u0){r=Math.round(Math.pow(10,e));return Math.ceil(t/r)*r}return Math.ceil(t)}function g(t){return"boolean"!=typeof t||t}},{"./lib/shader":257,"3d-view-controls":41,"a-big-triangle":44,"gl-axes3d":203,"gl-axes3d/properties":210,"gl-fbo":220,"gl-mat4/perspective":238,"gl-select-static":267,"gl-spikes3d":277,"is-mobile":364,"mouse-change":378}],259:[function(t,e,r){var n=t("glslify");r.pointVertex=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\n\nuniform mat3 matrix;\nuniform float pointSize;\nuniform float pointCloud;\n\nhighp float rand(vec2 co) {\n highp float a = 12.9898;\n highp float b = 78.233;\n highp float c = 43758.5453;\n highp float d = dot(co.xy, vec2(a, b));\n highp float e = mod(d, 3.14);\n return fract(sin(e) * c);\n}\n\nvoid main() {\n vec3 hgPosition = matrix * vec3(position, 1);\n gl_Position = vec4(hgPosition.xy, 0, hgPosition.z);\n // if we don't jitter the point size a bit, overall point cloud\n // saturation 'jumps' on zooming, which is disturbing and confusing\n gl_PointSize = pointSize * ((19.5 + rand(position)) / 20.0);\n if(pointCloud != 0.0) { // pointCloud is truthy\n // get the same square surface as circle would be\n gl_PointSize *= 0.886;\n }\n}"]),r.pointFragment=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec4 color, borderColor;\nuniform float centerFraction;\nuniform float pointCloud;\n\nvoid main() {\n float radius;\n vec4 baseColor;\n if(pointCloud != 0.0) { // pointCloud is truthy\n if(centerFraction == 1.0) {\n gl_FragColor = color;\n } else {\n gl_FragColor = mix(borderColor, color, centerFraction);\n }\n } else {\n radius = length(2.0 * gl_PointCoord.xy - 1.0);\n if(radius > 1.0) {\n discard;\n }\n baseColor = mix(borderColor, color, step(radius, centerFraction));\n gl_FragColor = vec4(baseColor.rgb * baseColor.a, baseColor.a);\n }\n}\n"]),r.pickVertex=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\nattribute vec4 pickId;\n\nuniform mat3 matrix;\nuniform float pointSize;\nuniform vec4 pickOffset;\n\nvarying vec4 fragId;\n\nvoid main() {\n vec3 hgPosition = matrix * vec3(position, 1);\n gl_Position = vec4(hgPosition.xy, 0, hgPosition.z);\n gl_PointSize = pointSize;\n\n vec4 id = pickId + pickOffset;\n id.y += floor(id.x / 256.0);\n id.x -= floor(id.x / 256.0) * 256.0;\n\n id.z += floor(id.y / 256.0);\n id.y -= floor(id.y / 256.0) * 256.0;\n\n id.w += floor(id.z / 256.0);\n id.z -= floor(id.z / 256.0) * 256.0;\n\n fragId = id;\n}\n"]),r.pickFragment=n(["precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragId;\n\nvoid main() {\n float radius = length(2.0 * gl_PointCoord.xy - 1.0);\n if(radius > 1.0) {\n discard;\n }\n gl_FragColor = fragId / 255.0;\n}\n"])},{glslify:353}],260:[function(t,e,r){"use strict";var n=t("gl-shader"),i=t("gl-buffer"),a=t("typedarray-pool"),o=t("./lib/shader");function s(t,e,r,n,i){this.plot=t,this.offsetBuffer=e,this.pickBuffer=r,this.shader=n,this.pickShader=i,this.sizeMin=.5,this.sizeMinCap=2,this.sizeMax=20,this.areaRatio=1,this.pointCount=0,this.color=[1,0,0,1],this.borderColor=[0,0,0,1],this.blend=!1,this.pickOffset=0,this.points=null}e.exports=function(t,e){var r=t.gl,a=i(r),l=i(r),c=n(r,o.pointVertex,o.pointFragment),u=n(r,o.pickVertex,o.pickFragment),f=new s(t,a,l,c,u);return f.update(e),t.addObject(f),f};var l,c,u=s.prototype;u.dispose=function(){this.shader.dispose(),this.pickShader.dispose(),this.offsetBuffer.dispose(),this.pickBuffer.dispose(),this.plot.removeObject(this)},u.update=function(t){var e;function r(e,r){return e in t?t[e]:r}t=t||{},this.sizeMin=r("sizeMin",.5),this.sizeMax=r("sizeMax",20),this.color=r("color",[1,0,0,1]).slice(),this.areaRatio=r("areaRatio",1),this.borderColor=r("borderColor",[0,0,0,1]).slice(),this.blend=r("blend",!1);var n=t.positions.length>>>1,i=t.positions instanceof Float32Array,o=t.idToIndex instanceof Int32Array&&t.idToIndex.length>=n,s=t.positions,l=i?s:a.mallocFloat32(s.length),c=o?t.idToIndex:a.mallocInt32(n);if(i||l.set(s),!o)for(l.set(s),e=0;e>>1;for(r=0;r=e[0]&&a<=e[2]&&o>=e[1]&&o<=e[3]&&n++}return n}(this.points,i),u=this.plot.pickPixelRatio*Math.max(Math.min(this.sizeMinCap,this.sizeMin),Math.min(this.sizeMax,this.sizeMax/Math.pow(s,.33333)));l[0]=2/a,l[4]=2/o,l[6]=-2*i[0]/a-1,l[7]=-2*i[1]/o-1,this.offsetBuffer.bind(),r.bind(),r.attributes.position.pointer(),r.uniforms.matrix=l,r.uniforms.color=this.color,r.uniforms.borderColor=this.borderColor,r.uniforms.pointCloud=u<5,r.uniforms.pointSize=u,r.uniforms.centerFraction=Math.min(1,Math.max(0,Math.sqrt(1-this.areaRatio))),e&&(c[0]=255&t,c[1]=t>>8&255,c[2]=t>>16&255,c[3]=t>>24&255,this.pickBuffer.bind(),r.attributes.pickId.pointer(n.UNSIGNED_BYTE),r.uniforms.pickOffset=c,this.pickOffset=t);var f=n.getParameter(n.BLEND),h=n.getParameter(n.DITHER);return f&&!this.blend&&n.disable(n.BLEND),h&&n.disable(n.DITHER),n.drawArrays(n.POINTS,0,this.pointCount),f&&!this.blend&&n.enable(n.BLEND),h&&n.enable(n.DITHER),t+this.pointCount}),u.draw=u.unifiedDraw,u.drawPick=u.unifiedDraw,u.pick=function(t,e,r){var n=this.pickOffset,i=this.pointCount;if(r=n+i)return null;var a=r-n,o=this.points;return{object:this,pointId:a,dataCoord:[o[2*a],o[2*a+1]]}}},{"./lib/shader":259,"gl-buffer":211,"gl-shader":268,"typedarray-pool":481}],261:[function(t,e,r){e.exports=function(t,e,r,n){var i,a,o,s,l,c=e[0],u=e[1],f=e[2],h=e[3],p=r[0],d=r[1],g=r[2],m=r[3];(a=c*p+u*d+f*g+h*m)<0&&(a=-a,p=-p,d=-d,g=-g,m=-m);1-a>1e-6?(i=Math.acos(a),o=Math.sin(i),s=Math.sin((1-n)*i)/o,l=Math.sin(n*i)/o):(s=1-n,l=n);return t[0]=s*c+l*p,t[1]=s*u+l*d,t[2]=s*f+l*g,t[3]=s*h+l*m,t}},{}],262:[function(t,e,r){"use strict";var n=t("vectorize-text");e.exports=function(t,e){var r=i[e];r||(r=i[e]={});if(t in r)return r[t];for(var a=n(t,{textAlign:"center",textBaseline:"middle",lineHeight:1,font:e}),o=n(t,{triangles:!0,textAlign:"center",textBaseline:"middle",lineHeight:1,font:e}),s=[[1/0,1/0],[-1/0,-1/0]],l=0;l=1)return!0;for(var t=0;t<3;++t)if(this.axesProject[t]&&this.projectOpacity[t]>=1)return!0;return!1};var d=[0,0],g=[0,0,0],m=[0,0,0],v=[0,0,0,1],y=[0,0,0,1],x=c.slice(),b=[0,0,0],_=[[0,0,0],[0,0,0]];function w(t){return t[0]=t[1]=t[2]=0,t}function k(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=1,t}function M(t,e,r,n){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[r]=n,t}function A(t,e,r,n,i){var a,s=e.axesProject,l=e.gl,u=t.uniforms,h=r.model||c,p=r.view||c,A=r.projection||c,T=e.axesBounds,S=function(t){for(var e=_,r=0;r<2;++r)for(var n=0;n<3;++n)e[r][n]=Math.max(Math.min(t[r][n],1e8),-1e8);return e}(e.clipBounds);a=e.axes&&e.axes.lastCubeProps?e.axes.lastCubeProps.axis:[1,1,1],d[0]=2/l.drawingBufferWidth,d[1]=2/l.drawingBufferHeight,t.bind(),u.view=p,u.projection=A,u.screenSize=d,u.highlightId=e.highlightId,u.highlightScale=e.highlightScale,u.clipBounds=S,u.pickGroup=e.pickId/255,u.pixelRatio=e.pixelRatio;for(var C=0;C<3;++C)if(s[C]&&e.projectOpacity[C]<1===n){u.scale=e.projectScale[C],u.opacity=e.projectOpacity[C];for(var E=x,L=0;L<16;++L)E[L]=0;for(L=0;L<4;++L)E[5*L]=1;E[5*C]=0,a[C]<0?E[12+C]=T[0][C]:E[12+C]=T[1][C],o(E,h,E),u.model=E;var z=(C+1)%3,P=(C+2)%3,D=w(g),O=w(m);D[z]=1,O[P]=1;var I=f(0,0,0,k(v,D)),R=f(0,0,0,k(y,O));if(Math.abs(I[1])>Math.abs(R[1])){var B=I;I=R,R=B,B=D,D=O,O=B;var F=z;z=P,P=F}I[0]<0&&(D[z]=-1),R[1]>0&&(O[P]=-1);var N=0,j=0;for(L=0;L<4;++L)N+=Math.pow(h[4*z+L],2),j+=Math.pow(h[4*P+L],2);D[z]/=Math.sqrt(N),O[P]/=Math.sqrt(j),u.axes[0]=D,u.axes[1]=O,u.fragClipBounds[0]=M(b,S[0],C,-1e8),u.fragClipBounds[1]=M(b,S[1],C,1e8),e.vao.draw(l.TRIANGLES,e.vertexCount),e.lineWidth>0&&(l.lineWidth(e.lineWidth),e.vao.draw(l.LINES,e.lineVertexCount,e.vertexCount))}}var T=[[-1e8,-1e8,-1e8],[1e8,1e8,1e8]];function S(t,e,r,n,i,a){var o=r.gl;if(r.vao.bind(),i===r.opacity<1||a){t.bind();var s=t.uniforms;s.model=n.model||c,s.view=n.view||c,s.projection=n.projection||c,d[0]=2/o.drawingBufferWidth,d[1]=2/o.drawingBufferHeight,s.screenSize=d,s.highlightId=r.highlightId,s.highlightScale=r.highlightScale,s.fragClipBounds=T,s.clipBounds=r.axes.bounds,s.opacity=r.opacity,s.pickGroup=r.pickId/255,s.pixelRatio=r.pixelRatio,r.vao.draw(o.TRIANGLES,r.vertexCount),r.lineWidth>0&&(o.lineWidth(r.lineWidth),r.vao.draw(o.LINES,r.lineVertexCount,r.vertexCount))}A(e,r,n,i),r.vao.unbind()}p.draw=function(t){S(this.useOrtho?this.orthoShader:this.shader,this.projectShader,this,t,!1,!1)},p.drawTransparent=function(t){S(this.useOrtho?this.orthoShader:this.shader,this.projectShader,this,t,!0,!1)},p.drawPick=function(t){S(this.useOrtho?this.pickOrthoShader:this.pickPerspectiveShader,this.pickProjectShader,this,t,!1,!0)},p.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;var e=t.value[2]+(t.value[1]<<8)+(t.value[0]<<16);if(e>=this.pointCount||e<0)return null;var r=this.points[e],n=this._selectResult;n.index=e;for(var i=0;i<3;++i)n.position[i]=n.dataCoordinate[i]=r[i];return n},p.highlight=function(t){if(t){var e=t.index,r=255&e,n=e>>8&255,i=e>>16&255;this.highlightId=[r/255,n/255,i/255,0]}else this.highlightId=[1,1,1,1]},p.update=function(t){if("perspective"in(t=t||{})&&(this.useOrtho=!t.perspective),"orthographic"in t&&(this.useOrtho=!!t.orthographic),"lineWidth"in t&&(this.lineWidth=t.lineWidth),"project"in t)if(Array.isArray(t.project))this.axesProject=t.project;else{var e=!!t.project;this.axesProject=[e,e,e]}if("projectScale"in t)if(Array.isArray(t.projectScale))this.projectScale=t.projectScale.slice();else{var r=+t.projectScale;this.projectScale=[r,r,r]}if("projectOpacity"in t)if(Array.isArray(t.projectOpacity))this.projectOpacity=t.projectOpacity.slice();else{r=+t.projectOpacity;this.projectOpacity=[r,r,r]}"opacity"in t&&(this.opacity=t.opacity),this.dirty=!0;var n=t.position;if(n){var i=t.font||"normal",o=t.alignment||[0,0],s=[1/0,1/0,1/0],c=[-1/0,-1/0,-1/0],u=t.glyph,f=t.color,h=t.size,p=t.angle,d=t.lineColor,g=0,m=0,v=0,y=n.length;t:for(var x=0;x0&&(L[0]=-o[0]*(1+M[0][0]));var q=w.cells,H=w.positions;for(_=0;_0){var v=r*u;o.drawBox(f-v,h-v,p+v,h+v,a),o.drawBox(f-v,d-v,p+v,d+v,a),o.drawBox(f-v,h-v,f+v,d+v,a),o.drawBox(p-v,h-v,p+v,d+v,a)}}}},s.update=function(t){t=t||{},this.innerFill=!!t.innerFill,this.outerFill=!!t.outerFill,this.innerColor=(t.innerColor||[0,0,0,.5]).slice(),this.outerColor=(t.outerColor||[0,0,0,.5]).slice(),this.borderColor=(t.borderColor||[0,0,0,1]).slice(),this.borderWidth=t.borderWidth||0,this.selectBox=(t.selectBox||this.selectBox).slice()},s.dispose=function(){this.boxBuffer.dispose(),this.boxShader.dispose(),this.plot.removeOverlay(this)}},{"./lib/shaders":265,"gl-buffer":211,"gl-shader":268}],267:[function(t,e,r){"use strict";e.exports=function(t,e){var r=n(t,e),a=i.mallocUint8(e[0]*e[1]*4);return new l(t,r,a)};var n=t("gl-fbo"),i=t("typedarray-pool"),a=t("ndarray"),o=t("bit-twiddle").nextPow2,s=t("cwise/lib/wrapper")({args:["array",{offset:[0,0,1],array:0},{offset:[0,0,2],array:0},{offset:[0,0,3],array:0},"scalar","scalar","index"],pre:{body:"{this_closestD2=1e8,this_closestX=-1,this_closestY=-1}",args:[],thisVars:["this_closestD2","this_closestX","this_closestY"],localVars:[]},body:{body:"{if(_inline_16_arg0_<255||_inline_16_arg1_<255||_inline_16_arg2_<255||_inline_16_arg3_<255){var _inline_16_l=_inline_16_arg4_-_inline_16_arg6_[0],_inline_16_a=_inline_16_arg5_-_inline_16_arg6_[1],_inline_16_f=_inline_16_l*_inline_16_l+_inline_16_a*_inline_16_a;_inline_16_fthis.buffer.length){i.free(this.buffer);for(var n=this.buffer=i.mallocUint8(o(r*e*4)),a=0;ar)for(t=r;te)for(t=e;t=0){for(var k=0|w.type.charAt(w.type.length-1),M=new Array(k),A=0;A=0;)T+=1;_[y]=T}var S=new Array(r.length);function C(){h.program=o.program(p,h._vref,h._fref,b,_);for(var t=0;t=0){var d=h.charCodeAt(h.length-1)-48;if(d<2||d>4)throw new n("","Invalid data type for attribute "+f+": "+h);o(t,e,p[0],i,d,a,f)}else{if(!(h.indexOf("mat")>=0))throw new n("","Unknown data type for attribute "+f+": "+h);var d=h.charCodeAt(h.length-1)-48;if(d<2||d>4)throw new n("","Invalid data type for attribute "+f+": "+h);s(t,e,p,i,d,a,f)}}}return a};var n=t("./GLError");function i(t,e,r,n,i,a){this._gl=t,this._wrapper=e,this._index=r,this._locations=n,this._dimension=i,this._constFunc=a}var a=i.prototype;function o(t,e,r,n,a,o,s){for(var l=["gl","v"],c=[],u=0;u4)throw new i("","Invalid uniform dimension type for matrix "+name+": "+r);return"gl.uniformMatrix"+a+"fv(locations["+e+"],false,obj"+t+")"}throw new i("","Unknown uniform data type for "+name+": "+r)}var a=r.charCodeAt(r.length-1)-48;if(a<2||a>4)throw new i("","Invalid data type");switch(r.charAt(0)){case"b":case"i":return"gl.uniform"+a+"iv(locations["+e+"],obj"+t+")";case"v":return"gl.uniform"+a+"fv(locations["+e+"],obj"+t+")";default:throw new i("","Unrecognized data type for vector "+name+": "+r)}}}function c(e){for(var n=["return function updateProperty(obj){"],i=function t(e,r){if("object"!=typeof r)return[[e,r]];var n=[];for(var i in r){var a=r[i],o=e;parseInt(i)+""===i?o+="["+i+"]":o+="."+i,"object"==typeof a?n.push.apply(n,t(o,a)):n.push([o,a])}return n}("",e),a=0;a4)throw new i("","Invalid data type");return"b"===t.charAt(0)?o(r,!1):o(r,0)}if(0===t.indexOf("mat")&&4===t.length){var r=t.charCodeAt(t.length-1)-48;if(r<2||r>4)throw new i("","Invalid uniform dimension type for matrix "+name+": "+t);return o(r*r,0)}throw new i("","Unknown uniform data type for "+name+": "+t)}}(r[u].type);var p}function f(t){var e;if(Array.isArray(t)){e=new Array(t.length);for(var r=0;r1){l[0]in o||(o[l[0]]=[]),o=o[l[0]];for(var c=1;c1)for(var l=0;l 0.0 ||\n any(lessThan(worldCoordinate, clipBounds[0])) || any(greaterThan(worldCoordinate, clipBounds[1]))) {\n discard;\n }\n\n vec3 N = normalize(surfaceNormal);\n vec3 V = normalize(eyeDirection);\n vec3 L = normalize(lightDirection);\n\n if(gl_FrontFacing) {\n N = -N;\n }\n\n float specular = max(beckmannSpecular(L, V, N, roughness), 0.);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n //decide how to interpolate color \u2014 in vertex or in fragment\n vec4 surfaceColor = step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) + step(.5, vertexColor) * vColor;\n\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;\n}\n"]),s=i(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute float f;\n\nuniform mat3 permutation;\nuniform mat4 model, view, projection;\nuniform float height, zOffset;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n vec3 dataCoordinate = permutation * vec3(uv.xy, height);\n vec4 worldPosition = model * vec4(dataCoordinate, 1.0);\n\n vec4 clipPosition = projection * view * worldPosition;\n clipPosition.z = clipPosition.z + zOffset;\n\n gl_Position = clipPosition;\n value = f;\n kill = -1.0;\n worldCoordinate = dataCoordinate;\n planeCoordinate = uv.zw;\n\n vColor = texture2D(colormap, vec2(value, value));\n\n //Don't do lighting for contours\n surfaceNormal = vec3(1,0,0);\n eyeDirection = vec3(0,1,0);\n lightDirection = vec3(0,0,1);\n}\n"]),l=i(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec2 shape;\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 surfaceNormal;\n\nvec2 splitFloat(float v) {\n float vh = 255.0 * v;\n float upper = floor(vh);\n float lower = fract(vh);\n return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);\n}\n\nvoid main() {\n if(kill > 0.0 ||\n any(lessThan(worldCoordinate, clipBounds[0])) || any(greaterThan(worldCoordinate, clipBounds[1]))) {\n discard;\n }\n vec2 ux = splitFloat(planeCoordinate.x / shape.x);\n vec2 uy = splitFloat(planeCoordinate.y / shape.y);\n gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));\n}\n"]);r.createShader=function(t){var e=n(t,a,o,null,[{name:"uv",type:"vec4"},{name:"f",type:"vec3"},{name:"normal",type:"vec3"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e.attributes.normal.location=2,e},r.createPickShader=function(t){var e=n(t,a,l,null,[{name:"uv",type:"vec4"},{name:"f",type:"vec3"},{name:"normal",type:"vec3"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e.attributes.normal.location=2,e},r.createContourShader=function(t){var e=n(t,s,o,null,[{name:"uv",type:"vec4"},{name:"f",type:"float"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e},r.createPickContourShader=function(t){var e=n(t,s,l,null,[{name:"uv",type:"vec4"},{name:"f",type:"float"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e}},{"gl-shader":268,glslify:353}],279:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl,r=y(e),n=b(e),s=x(e),l=_(e),c=i(e),u=a(e,[{buffer:c,size:4,stride:w,offset:0},{buffer:c,size:3,stride:w,offset:16},{buffer:c,size:3,stride:w,offset:28}]),f=i(e),h=a(e,[{buffer:f,size:4,stride:20,offset:0},{buffer:f,size:1,stride:20,offset:16}]),p=i(e),d=a(e,[{buffer:p,size:2,type:e.FLOAT}]),g=o(e,1,T,e.RGBA,e.UNSIGNED_BYTE);g.minFilter=e.LINEAR,g.magFilter=e.LINEAR;var m=new S(e,[0,0],[[0,0,0],[0,0,0]],r,n,c,u,g,s,l,f,h,p,d),v={levels:[[],[],[]]};for(var k in t)v[k]=t[k];return v.colormap=v.colormap||"jet",m.update(v),m};var n=t("bit-twiddle"),i=t("gl-buffer"),a=t("gl-vao"),o=t("gl-texture2d"),s=t("typedarray-pool"),l=t("colormap"),c=t("ndarray-ops"),u=t("ndarray-pack"),f=t("ndarray"),h=t("surface-nets"),p=t("gl-mat4/multiply"),d=t("gl-mat4/invert"),g=t("binary-search-bounds"),m=t("ndarray-gradient"),v=t("./lib/shaders"),y=v.createShader,x=v.createContourShader,b=v.createPickShader,_=v.createPickContourShader,w=40,k=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],M=[[0,0],[0,1],[1,0],[1,1],[1,0],[0,1]],A=[[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0]];!function(){for(var t=0;t<3;++t){var e=A[t],r=(t+2)%3;e[(t+1)%3+0]=1,e[r+3]=1,e[t+6]=1}}();var T=256;function S(t,e,r,n,i,a,o,l,c,u,h,p,d,g){this.gl=t,this.shape=e,this.bounds=r,this.intensityBounds=[],this._shader=n,this._pickShader=i,this._coordinateBuffer=a,this._vao=o,this._colorMap=l,this._contourShader=c,this._contourPickShader=u,this._contourBuffer=h,this._contourVAO=p,this._contourOffsets=[[],[],[]],this._contourCounts=[[],[],[]],this._vertexCount=0,this._pickResult=new function(t,e,r,n,i){this.position=t,this.index=e,this.uv=r,this.level=n,this.dataCoordinate=i}([0,0,0],[0,0],[0,0],[0,0,0],[0,0,0]),this._dynamicBuffer=d,this._dynamicVAO=g,this._dynamicOffsets=[0,0,0],this._dynamicCounts=[0,0,0],this.contourWidth=[1,1,1],this.contourLevels=[[1],[1],[1]],this.contourTint=[0,0,0],this.contourColor=[[.5,.5,.5,1],[.5,.5,.5,1],[.5,.5,.5,1]],this.showContour=!0,this.showSurface=!0,this.enableHighlight=[!0,!0,!0],this.highlightColor=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.highlightTint=[1,1,1],this.highlightLevel=[-1,-1,-1],this.enableDynamic=[!0,!0,!0],this.dynamicLevel=[NaN,NaN,NaN],this.dynamicColor=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.dynamicTint=[1,1,1],this.dynamicWidth=[1,1,1],this.axesBounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.surfaceProject=[!1,!1,!1],this.contourProject=[[!1,!1,!1],[!1,!1,!1],[!1,!1,!1]],this.colorBounds=[!1,!1],this._field=[f(s.mallocFloat(1024),[0,0]),f(s.mallocFloat(1024),[0,0]),f(s.mallocFloat(1024),[0,0])],this.pickId=1,this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.snapToData=!1,this.opacity=1,this.lightPosition=[10,1e4,0],this.ambientLight=.8,this.diffuseLight=.8,this.specularLight=2,this.roughness=.5,this.fresnel=1.5,this.vertexColor=0,this.dirty=!0}var C=S.prototype;C.isTransparent=function(){return this.opacity<1},C.isOpaque=function(){if(this.opacity>=1)return!0;for(var t=0;t<3;++t)if(this._contourCounts[t].length>0||this._dynamicCounts[t]>0)return!0;return!1},C.pickSlots=1,C.setPickBase=function(t){this.pickId=t};var E=[0,0,0],L={showSurface:!1,showContour:!1,projections:[k.slice(),k.slice(),k.slice()],clipBounds:[[[0,0,0],[0,0,0]],[[0,0,0],[0,0,0]],[[0,0,0],[0,0,0]]]};function z(t,e){var r,n,i,a=e.axes&&e.axes.lastCubeProps.axis||E,o=e.showSurface,s=e.showContour;for(r=0;r<3;++r)for(o=o||e.surfaceProject[r],n=0;n<3;++n)s=s||e.contourProject[r][n];for(r=0;r<3;++r){var l=L.projections[r];for(n=0;n<16;++n)l[n]=0;for(n=0;n<4;++n)l[5*n]=1;l[5*r]=0,l[12+r]=e.axesBounds[+(a[r]>0)][r],p(l,t.model,l);var c=L.clipBounds[r];for(i=0;i<2;++i)for(n=0;n<3;++n)c[i][n]=t.clipBounds[i][n];c[0][r]=-1e8,c[1][r]=1e8}return L.showSurface=o,L.showContour=s,L}var P={model:k,view:k,projection:k,inverseModel:k.slice(),lowerBound:[0,0,0],upperBound:[0,0,0],colorMap:0,clipBounds:[[0,0,0],[0,0,0]],height:0,contourTint:0,contourColor:[0,0,0,1],permutation:[1,0,0,0,1,0,0,0,1],zOffset:-1e-4,kambient:1,kdiffuse:1,kspecular:1,lightPosition:[1e3,1e3,1e3],eyePosition:[0,0,0],roughness:1,fresnel:1,opacity:1,vertexColor:0},D=k.slice(),O=[1,0,0,0,1,0,0,0,1];function I(t,e){t=t||{};var r=this.gl;r.disable(r.CULL_FACE),this._colorMap.bind(0);var n=P;n.model=t.model||k,n.view=t.view||k,n.projection=t.projection||k,n.lowerBound=[this.bounds[0][0],this.bounds[0][1],this.colorBounds[0]||this.bounds[0][2]],n.upperBound=[this.bounds[1][0],this.bounds[1][1],this.colorBounds[1]||this.bounds[1][2]],n.contourColor=this.contourColor[0],n.inverseModel=d(n.inverseModel,n.model);for(var i=0;i<2;++i)for(var a=n.clipBounds[i],o=0;o<3;++o)a[o]=Math.min(Math.max(this.clipBounds[i][o],-1e8),1e8);n.kambient=this.ambientLight,n.kdiffuse=this.diffuseLight,n.kspecular=this.specularLight,n.roughness=this.roughness,n.fresnel=this.fresnel,n.opacity=this.opacity,n.height=0,n.permutation=O,n.vertexColor=this.vertexColor;var s=D;for(p(s,n.view,n.model),p(s,n.projection,s),d(s,s),i=0;i<3;++i)n.eyePosition[i]=s[12+i]/s[15];var l=s[15];for(i=0;i<3;++i)l+=this.lightPosition[i]*s[4*i+3];for(i=0;i<3;++i){var c=s[12+i];for(o=0;o<3;++o)c+=s[4*o+i]*this.lightPosition[o];n.lightPosition[i]=c/l}var u=z(n,this);if(u.showSurface&&e===this.opacity<1){for(this._shader.bind(),this._shader.uniforms=n,this._vao.bind(),this.showSurface&&this._vertexCount&&this._vao.draw(r.TRIANGLES,this._vertexCount),i=0;i<3;++i)this.surfaceProject[i]&&this.vertexCount&&(this._shader.uniforms.model=u.projections[i],this._shader.uniforms.clipBounds=u.clipBounds[i],this._vao.draw(r.TRIANGLES,this._vertexCount));this._vao.unbind()}if(u.showContour&&!e){var f=this._contourShader;n.kambient=1,n.kdiffuse=0,n.kspecular=0,n.opacity=1,f.bind(),f.uniforms=n;var h=this._contourVAO;for(h.bind(),i=0;i<3;++i)for(f.uniforms.permutation=A[i],r.lineWidth(this.contourWidth[i]),o=0;o>4)/16)/255,i=Math.floor(n),a=n-i,o=e[1]*(t.value[1]+(15&t.value[2])/16)/255,s=Math.floor(o),l=o-s;i+=1,s+=1;var c=r.position;c[0]=c[1]=c[2]=0;for(var u=0;u<2;++u)for(var f=u?a:1-a,h=0;h<2;++h)for(var p=i+u,d=s+h,m=f*(h?l:1-l),v=0;v<3;++v)c[v]+=this._field[v].get(p,d)*m;for(var y=this._pickResult.level,x=0;x<3;++x)if(y[x]=g.le(this.contourLevels[x],c[x]),y[x]<0)this.contourLevels[x].length>0&&(y[x]=0);else if(y[x]Math.abs(_-c[x])&&(y[x]+=1)}for(r.index[0]=a<.5?i:i+1,r.index[1]=l<.5?s:s+1,r.uv[0]=n/e[0],r.uv[1]=o/e[1],v=0;v<3;++v)r.dataCoordinate[v]=this._field[v].get(r.index[0],r.index[1]);return r},C.update=function(t){t=t||{},this.dirty=!0,"contourWidth"in t&&(this.contourWidth=F(t.contourWidth,Number)),"showContour"in t&&(this.showContour=F(t.showContour,Boolean)),"showSurface"in t&&(this.showSurface=!!t.showSurface),"contourTint"in t&&(this.contourTint=F(t.contourTint,Boolean)),"contourColor"in t&&(this.contourColor=j(t.contourColor)),"contourProject"in t&&(this.contourProject=F(t.contourProject,function(t){return F(t,Boolean)})),"surfaceProject"in t&&(this.surfaceProject=t.surfaceProject),"dynamicColor"in t&&(this.dynamicColor=j(t.dynamicColor)),"dynamicTint"in t&&(this.dynamicTint=F(t.dynamicTint,Number)),"dynamicWidth"in t&&(this.dynamicWidth=F(t.dynamicWidth,Number)),"opacity"in t&&(this.opacity=t.opacity),"colorBounds"in t&&(this.colorBounds=t.colorBounds),"vertexColor"in t&&(this.vertexColor=t.vertexColor?1:0);var e=t.field||t.coords&&t.coords[2]||null,r=!1;if(e||(e=this._field[2].shape[0]||this._field[2].shape[2]?this._field[2].lo(1,1).hi(this._field[2].shape[0]-2,this._field[2].shape[1]-2):this._field[2].hi(0,0)),"field"in t||"coords"in t){var i=(e.shape[0]+2)*(e.shape[1]+2);i>this._field[2].data.length&&(s.freeFloat(this._field[2].data),this._field[2].data=s.mallocFloat(n.nextPow2(i))),this._field[2]=f(this._field[2].data,[e.shape[0]+2,e.shape[1]+2]),B(this._field[2],e),this.shape=e.shape.slice();for(var a=this.shape,o=0;o<2;++o)this._field[2].size>this._field[o].data.length&&(s.freeFloat(this._field[o].data),this._field[o].data=s.mallocFloat(this._field[2].size)),this._field[o]=f(this._field[o].data,[a[0]+2,a[1]+2]);if(t.coords){var p=t.coords;if(!Array.isArray(p)||3!==p.length)throw new Error("gl-surface: invalid coordinates for x/y");for(o=0;o<2;++o){var d=p[o];for(b=0;b<2;++b)if(d.shape[b]!==a[b])throw new Error("gl-surface: coords have incorrect shape");B(this._field[o],d)}}else if(t.ticks){var g=t.ticks;if(!Array.isArray(g)||2!==g.length)throw new Error("gl-surface: invalid ticks");for(o=0;o<2;++o){var v=g[o];if((Array.isArray(v)||v.length)&&(v=f(v)),v.shape[0]!==a[o])throw new Error("gl-surface: invalid tick length");var y=f(v.data,a);y.stride[o]=v.stride[0],y.stride[1^o]=0,B(this._field[o],y)}}else{for(o=0;o<2;++o){var x=[0,0];x[o]=1,this._field[o]=f(this._field[o].data,[a[0]+2,a[1]+2],x,0)}this._field[0].set(0,0,0);for(var b=0;b0){for(var kt=0;kt<5;++kt)nt.pop();W-=1}continue t}nt.push(st[0],st[1],ut[0],ut[1],st[2]),W+=1}}ot.push(W)}this._contourOffsets[it]=at,this._contourCounts[it]=ot}var Mt=s.mallocFloat(nt.length);for(o=0;os||o[1]<0||o[1]>s)throw new Error("gl-texture2d: Invalid texture size");var l=d(o,e.stride.slice()),c=0;"float32"===r?c=t.FLOAT:"float64"===r?(c=t.FLOAT,l=!1,r="float32"):"uint8"===r?c=t.UNSIGNED_BYTE:(c=t.UNSIGNED_BYTE,l=!1,r="uint8");var f,p,m=0;if(2===o.length)m=t.LUMINANCE,o=[o[0],o[1],1],e=n(e.data,o,[e.stride[0],e.stride[1],1],e.offset);else{if(3!==o.length)throw new Error("gl-texture2d: Invalid shape for texture");if(1===o[2])m=t.ALPHA;else if(2===o[2])m=t.LUMINANCE_ALPHA;else if(3===o[2])m=t.RGB;else{if(4!==o[2])throw new Error("gl-texture2d: Invalid shape for pixel coords");m=t.RGBA}}c!==t.FLOAT||t.getExtension("OES_texture_float")||(c=t.UNSIGNED_BYTE,l=!1);var v=e.size;if(l)f=0===e.offset&&e.data.length===v?e.data:e.data.subarray(e.offset,e.offset+v);else{var y=[o[2],o[2]*o[0],1];p=a.malloc(v,r);var x=n(p,o,y,0);"float32"!==r&&"float64"!==r||c!==t.UNSIGNED_BYTE?i.assign(x,e):u(x,e),f=p.subarray(0,v)}var b=g(t);t.texImage2D(t.TEXTURE_2D,0,m,o[0],o[1],0,m,c,f),l||a.free(p);return new h(t,b,o[0],o[1],m,c)}(t,e)}throw new Error("gl-texture2d: Invalid arguments for texture2d constructor")};var o=null,s=null,l=null;function c(t){return"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLVideoElement&&t instanceof HTMLVideoElement||"undefined"!=typeof ImageData&&t instanceof ImageData}var u=function(t,e){i.muls(t,e,255)};function f(t,e,r){var n=t.gl,i=n.getParameter(n.MAX_TEXTURE_SIZE);if(e<0||e>i||r<0||r>i)throw new Error("gl-texture2d: Invalid texture size");return t._shape=[e,r],t.bind(),n.texImage2D(n.TEXTURE_2D,0,t.format,e,r,0,t.format,t.type,null),t._mipLevels=[0],t}function h(t,e,r,n,i,a){this.gl=t,this.handle=e,this.format=i,this.type=a,this._shape=[r,n],this._mipLevels=[0],this._magFilter=t.NEAREST,this._minFilter=t.NEAREST,this._wrapS=t.CLAMP_TO_EDGE,this._wrapT=t.CLAMP_TO_EDGE,this._anisoSamples=1;var o=this,s=[this._wrapS,this._wrapT];Object.defineProperties(s,[{get:function(){return o._wrapS},set:function(t){return o.wrapS=t}},{get:function(){return o._wrapT},set:function(t){return o.wrapT=t}}]),this._wrapVector=s;var l=[this._shape[0],this._shape[1]];Object.defineProperties(l,[{get:function(){return o._shape[0]},set:function(t){return o.width=t}},{get:function(){return o._shape[1]},set:function(t){return o.height=t}}]),this._shapeVector=l}var p=h.prototype;function d(t,e){return 3===t.length?1===e[2]&&e[1]===t[0]*t[2]&&e[0]===t[2]:1===e[0]&&e[1]===t[0]}function g(t){var e=t.createTexture();return t.bindTexture(t.TEXTURE_2D,e),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MIN_FILTER,t.NEAREST),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MAG_FILTER,t.NEAREST),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_S,t.CLAMP_TO_EDGE),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_T,t.CLAMP_TO_EDGE),e}function m(t,e,r,n,i){var a=t.getParameter(t.MAX_TEXTURE_SIZE);if(e<0||e>a||r<0||r>a)throw new Error("gl-texture2d: Invalid texture shape");if(i===t.FLOAT&&!t.getExtension("OES_texture_float"))throw new Error("gl-texture2d: Floating point textures not supported on this platform");var o=g(t);return t.texImage2D(t.TEXTURE_2D,0,n,e,r,0,n,i,null),new h(t,o,e,r,n,i)}Object.defineProperties(p,{minFilter:{get:function(){return this._minFilter},set:function(t){this.bind();var e=this.gl;if(this.type===e.FLOAT&&o.indexOf(t)>=0&&(e.getExtension("OES_texture_float_linear")||(t=e.NEAREST)),s.indexOf(t)<0)throw new Error("gl-texture2d: Unknown filter mode "+t);return e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MIN_FILTER,t),this._minFilter=t}},magFilter:{get:function(){return this._magFilter},set:function(t){this.bind();var e=this.gl;if(this.type===e.FLOAT&&o.indexOf(t)>=0&&(e.getExtension("OES_texture_float_linear")||(t=e.NEAREST)),s.indexOf(t)<0)throw new Error("gl-texture2d: Unknown filter mode "+t);return e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MAG_FILTER,t),this._magFilter=t}},mipSamples:{get:function(){return this._anisoSamples},set:function(t){var e=this._anisoSamples;if(this._anisoSamples=0|Math.max(t,1),e!==this._anisoSamples){var r=this.gl.getExtension("EXT_texture_filter_anisotropic");r&&this.gl.texParameterf(this.gl.TEXTURE_2D,r.TEXTURE_MAX_ANISOTROPY_EXT,this._anisoSamples)}return this._anisoSamples}},wrapS:{get:function(){return this._wrapS},set:function(t){if(this.bind(),l.indexOf(t)<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);return this.gl.texParameteri(this.gl.TEXTURE_2D,this.gl.TEXTURE_WRAP_S,t),this._wrapS=t}},wrapT:{get:function(){return this._wrapT},set:function(t){if(this.bind(),l.indexOf(t)<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);return this.gl.texParameteri(this.gl.TEXTURE_2D,this.gl.TEXTURE_WRAP_T,t),this._wrapT=t}},wrap:{get:function(){return this._wrapVector},set:function(t){if(Array.isArray(t)||(t=[t,t]),2!==t.length)throw new Error("gl-texture2d: Must specify wrap mode for rows and columns");for(var e=0;e<2;++e)if(l.indexOf(t[e])<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);this._wrapS=t[0],this._wrapT=t[1];var r=this.gl;return this.bind(),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,this._wrapS),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,this._wrapT),t}},shape:{get:function(){return this._shapeVector},set:function(t){if(Array.isArray(t)){if(2!==t.length)throw new Error("gl-texture2d: Invalid texture shape")}else t=[0|t,0|t];return f(this,0|t[0],0|t[1]),[0|t[0],0|t[1]]}},width:{get:function(){return this._shape[0]},set:function(t){return f(this,t|=0,this._shape[1]),t}},height:{get:function(){return this._shape[1]},set:function(t){return t|=0,f(this,this._shape[0],t),t}}}),p.bind=function(t){var e=this.gl;return void 0!==t&&e.activeTexture(e.TEXTURE0+(0|t)),e.bindTexture(e.TEXTURE_2D,this.handle),void 0!==t?0|t:e.getParameter(e.ACTIVE_TEXTURE)-e.TEXTURE0},p.dispose=function(){this.gl.deleteTexture(this.handle)},p.generateMipmap=function(){this.bind(),this.gl.generateMipmap(this.gl.TEXTURE_2D);for(var t=Math.min(this._shape[0],this._shape[1]),e=0;t>0;++e,t>>>=1)this._mipLevels.indexOf(e)<0&&this._mipLevels.push(e)},p.setPixels=function(t,e,r,o){var s=this.gl;this.bind(),Array.isArray(e)?(o=r,r=0|e[1],e=0|e[0]):(e=e||0,r=r||0),o=o||0;var l=c(t)?t:t.raw;if(l){this._mipLevels.indexOf(o)<0?(s.texImage2D(s.TEXTURE_2D,0,this.format,this.format,this.type,l),this._mipLevels.push(o)):s.texSubImage2D(s.TEXTURE_2D,o,e,r,this.format,this.type,l)}else{if(!(t.shape&&t.stride&&t.data))throw new Error("gl-texture2d: Unsupported data type");if(t.shape.length<2||e+t.shape[1]>this._shape[1]>>>o||r+t.shape[0]>this._shape[0]>>>o||e<0||r<0)throw new Error("gl-texture2d: Texture dimensions are out of bounds");!function(t,e,r,o,s,l,c,f){var h=f.dtype,p=f.shape.slice();if(p.length<2||p.length>3)throw new Error("gl-texture2d: Invalid ndarray, must be 2d or 3d");var g=0,m=0,v=d(p,f.stride.slice());"float32"===h?g=t.FLOAT:"float64"===h?(g=t.FLOAT,v=!1,h="float32"):"uint8"===h?g=t.UNSIGNED_BYTE:(g=t.UNSIGNED_BYTE,v=!1,h="uint8");if(2===p.length)m=t.LUMINANCE,p=[p[0],p[1],1],f=n(f.data,p,[f.stride[0],f.stride[1],1],f.offset);else{if(3!==p.length)throw new Error("gl-texture2d: Invalid shape for texture");if(1===p[2])m=t.ALPHA;else if(2===p[2])m=t.LUMINANCE_ALPHA;else if(3===p[2])m=t.RGB;else{if(4!==p[2])throw new Error("gl-texture2d: Invalid shape for pixel coords");m=t.RGBA}p[2]}m!==t.LUMINANCE&&m!==t.ALPHA||s!==t.LUMINANCE&&s!==t.ALPHA||(m=s);if(m!==s)throw new Error("gl-texture2d: Incompatible texture format for setPixels");var y=f.size,x=c.indexOf(o)<0;x&&c.push(o);if(g===l&&v)0===f.offset&&f.data.length===y?x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,f.data):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,f.data):x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,f.data.subarray(f.offset,f.offset+y)):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,f.data.subarray(f.offset,f.offset+y));else{var b;b=l===t.FLOAT?a.mallocFloat32(y):a.mallocUint8(y);var _=n(b,p,[p[2],p[2]*p[0],1]);g===t.FLOAT&&l===t.UNSIGNED_BYTE?u(_,f):i.assign(_,f),x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,b.subarray(0,y)):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,b.subarray(0,y)),l===t.FLOAT?a.freeFloat32(b):a.freeUint8(b)}}(s,e,r,o,this.format,this.type,this._mipLevels,t)}}},{ndarray:393,"ndarray-ops":387,"typedarray-pool":481}],281:[function(t,e,r){"use strict";e.exports=function(t,e,r){e?e.bind():t.bindBuffer(t.ELEMENT_ARRAY_BUFFER,null);var n=0|t.getParameter(t.MAX_VERTEX_ATTRIBS);if(r){if(r.length>n)throw new Error("gl-vao: Too many vertex attributes");for(var i=0;i1?0:Math.acos(s)};var n=t("./fromValues"),i=t("./normalize"),a=t("./dot")},{"./dot":293,"./fromValues":295,"./normalize":304}],287:[function(t,e,r){e.exports=function(t){var e=new Float32Array(3);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e}},{}],288:[function(t,e,r){e.exports=function(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t}},{}],289:[function(t,e,r){e.exports=function(){var t=new Float32Array(3);return t[0]=0,t[1]=0,t[2]=0,t}},{}],290:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2];return t[0]=i*l-a*s,t[1]=a*o-n*l,t[2]=n*s-i*o,t}},{}],291:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2];return Math.sqrt(r*r+n*n+i*i)}},{}],292:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]/r[0],t[1]=e[1]/r[1],t[2]=e[2]/r[2],t}},{}],293:[function(t,e,r){e.exports=function(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}},{}],294:[function(t,e,r){e.exports=function(t,e,r,i,a,o){var s,l;e||(e=3);r||(r=0);l=i?Math.min(i*e+r,t.length):t.length;for(s=r;s0&&(a=1/Math.sqrt(a),t[0]=e[0]*a,t[1]=e[1]*a,t[2]=e[2]*a);return t}},{}],305:[function(t,e,r){e.exports=function(t,e){e=e||1;var r=2*Math.random()*Math.PI,n=2*Math.random()-1,i=Math.sqrt(1-n*n)*e;return t[0]=Math.cos(r)*i,t[1]=Math.sin(r)*i,t[2]=n*e,t}},{}],306:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[0],a[1]=i[1]*Math.cos(n)-i[2]*Math.sin(n),a[2]=i[1]*Math.sin(n)+i[2]*Math.cos(n),t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],307:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[2]*Math.sin(n)+i[0]*Math.cos(n),a[1]=i[1],a[2]=i[2]*Math.cos(n)-i[0]*Math.sin(n),t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],308:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[0]*Math.cos(n)-i[1]*Math.sin(n),a[1]=i[0]*Math.sin(n)+i[1]*Math.cos(n),a[2]=i[2],t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],309:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t}},{}],310:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e[0]+r[0]*n,t[1]=e[1]+r[1]*n,t[2]=e[2]+r[2]*n,t}},{}],311:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e,t[1]=r,t[2]=n,t}},{}],312:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2];return r*r+n*n+i*i}},{}],313:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2];return e*e+r*r+n*n}},{}],314:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t}},{}],315:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2];return t[0]=n*r[0]+i*r[3]+a*r[6],t[1]=n*r[1]+i*r[4]+a*r[7],t[2]=n*r[2]+i*r[5]+a*r[8],t}},{}],316:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[3]*n+r[7]*i+r[11]*a+r[15];return o=o||1,t[0]=(r[0]*n+r[4]*i+r[8]*a+r[12])/o,t[1]=(r[1]*n+r[5]*i+r[9]*a+r[13])/o,t[2]=(r[2]*n+r[6]*i+r[10]*a+r[14])/o,t}},{}],317:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2],c=r[3],u=c*n+s*a-l*i,f=c*i+l*n-o*a,h=c*a+o*i-s*n,p=-o*n-s*i-l*a;return t[0]=u*c+p*-o+f*-l-h*-s,t[1]=f*c+p*-s+h*-o-u*-l,t[2]=h*c+p*-l+u*-s-f*-o,t}},{}],318:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]+r[0],t[1]=e[1]+r[1],t[2]=e[2]+r[2],t[3]=e[3]+r[3],t}},{}],319:[function(t,e,r){e.exports=function(t){var e=new Float32Array(4);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e}},{}],320:[function(t,e,r){e.exports=function(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t}},{}],321:[function(t,e,r){e.exports=function(){var t=new Float32Array(4);return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}},{}],322:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return Math.sqrt(r*r+n*n+i*i+a*a)}},{}],323:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]/r[0],t[1]=e[1]/r[1],t[2]=e[2]/r[2],t[3]=e[3]/r[3],t}},{}],324:[function(t,e,r){e.exports=function(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]+t[3]*e[3]}},{}],325:[function(t,e,r){e.exports=function(t,e,r,n){var i=new Float32Array(4);return i[0]=t,i[1]=e,i[2]=r,i[3]=n,i}},{}],326:[function(t,e,r){e.exports={create:t("./create"),clone:t("./clone"),fromValues:t("./fromValues"),copy:t("./copy"),set:t("./set"),add:t("./add"),subtract:t("./subtract"),multiply:t("./multiply"),divide:t("./divide"),min:t("./min"),max:t("./max"),scale:t("./scale"),scaleAndAdd:t("./scaleAndAdd"),distance:t("./distance"),squaredDistance:t("./squaredDistance"),length:t("./length"),squaredLength:t("./squaredLength"),negate:t("./negate"),inverse:t("./inverse"),normalize:t("./normalize"),dot:t("./dot"),lerp:t("./lerp"),random:t("./random"),transformMat4:t("./transformMat4"),transformQuat:t("./transformQuat")}},{"./add":318,"./clone":319,"./copy":320,"./create":321,"./distance":322,"./divide":323,"./dot":324,"./fromValues":325,"./inverse":327,"./length":328,"./lerp":329,"./max":330,"./min":331,"./multiply":332,"./negate":333,"./normalize":334,"./random":335,"./scale":336,"./scaleAndAdd":337,"./set":338,"./squaredDistance":339,"./squaredLength":340,"./subtract":341,"./transformMat4":342,"./transformQuat":343}],327:[function(t,e,r){e.exports=function(t,e){return t[0]=1/e[0],t[1]=1/e[1],t[2]=1/e[2],t[3]=1/e[3],t}},{}],328:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2],i=t[3];return Math.sqrt(e*e+r*r+n*n+i*i)}},{}],329:[function(t,e,r){e.exports=function(t,e,r,n){var i=e[0],a=e[1],o=e[2],s=e[3];return t[0]=i+n*(r[0]-i),t[1]=a+n*(r[1]-a),t[2]=o+n*(r[2]-o),t[3]=s+n*(r[3]-s),t}},{}],330:[function(t,e,r){e.exports=function(t,e,r){return t[0]=Math.max(e[0],r[0]),t[1]=Math.max(e[1],r[1]),t[2]=Math.max(e[2],r[2]),t[3]=Math.max(e[3],r[3]),t}},{}],331:[function(t,e,r){e.exports=function(t,e,r){return t[0]=Math.min(e[0],r[0]),t[1]=Math.min(e[1],r[1]),t[2]=Math.min(e[2],r[2]),t[3]=Math.min(e[3],r[3]),t}},{}],332:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r[0],t[1]=e[1]*r[1],t[2]=e[2]*r[2],t[3]=e[3]*r[3],t}},{}],333:[function(t,e,r){e.exports=function(t,e){return t[0]=-e[0],t[1]=-e[1],t[2]=-e[2],t[3]=-e[3],t}},{}],334:[function(t,e,r){e.exports=function(t,e){var r=e[0],n=e[1],i=e[2],a=e[3],o=r*r+n*n+i*i+a*a;o>0&&(o=1/Math.sqrt(o),t[0]=r*o,t[1]=n*o,t[2]=i*o,t[3]=a*o);return t}},{}],335:[function(t,e,r){var n=t("./normalize"),i=t("./scale");e.exports=function(t,e){return e=e||1,t[0]=Math.random(),t[1]=Math.random(),t[2]=Math.random(),t[3]=Math.random(),n(t,t),i(t,t,e),t}},{"./normalize":334,"./scale":336}],336:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t[3]=e[3]*r,t}},{}],337:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e[0]+r[0]*n,t[1]=e[1]+r[1]*n,t[2]=e[2]+r[2]*n,t[3]=e[3]+r[3]*n,t}},{}],338:[function(t,e,r){e.exports=function(t,e,r,n,i){return t[0]=e,t[1]=r,t[2]=n,t[3]=i,t}},{}],339:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return r*r+n*n+i*i+a*a}},{}],340:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2],i=t[3];return e*e+r*r+n*n+i*i}},{}],341:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t[3]=e[3]-r[3],t}},{}],342:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=e[3];return t[0]=r[0]*n+r[4]*i+r[8]*a+r[12]*o,t[1]=r[1]*n+r[5]*i+r[9]*a+r[13]*o,t[2]=r[2]*n+r[6]*i+r[10]*a+r[14]*o,t[3]=r[3]*n+r[7]*i+r[11]*a+r[15]*o,t}},{}],343:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2],c=r[3],u=c*n+s*a-l*i,f=c*i+l*n-o*a,h=c*a+o*i-s*n,p=-o*n-s*i-l*a;return t[0]=u*c+p*-o+f*-l-h*-s,t[1]=f*c+p*-s+h*-o-u*-l,t[2]=h*c+p*-l+u*-s-f*-o,t[3]=e[3],t}},{}],344:[function(t,e,r){e.exports=function(t,e,r,a){return n[0]=a,n[1]=r,n[2]=e,n[3]=t,i[0]};var n=new Uint8Array(4),i=new Float32Array(n.buffer)},{}],345:[function(t,e,r){var n=t("glsl-tokenizer"),i=t("atob-lite");e.exports=function(t){for(var e=Array.isArray(t)?t:n(t),r=0;r0)continue;r=t.slice(0,1).join("")}return B(r),z+=r.length,(S=S.slice(r.length)).length}}function H(){return/[^a-fA-F0-9]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function G(){return"."===e?(S.push(e),T=g,r=e,M+1):/[eE]/.test(e)?(S.push(e),T=g,r=e,M+1):"x"===e&&1===S.length&&"0"===S[0]?(T=_,S.push(e),r=e,M+1):/[^\d]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function W(){return"f"===e&&(S.push(e),r=e,M+=1),/[eE]/.test(e)?(S.push(e),r=e,M+1):"-"===e&&/[eE]/.test(r)?(S.push(e),r=e,M+1):/[^\d]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function Y(){if(/[^\d\w_]/.test(e)){var t=S.join("");return T=R.indexOf(t)>-1?y:I.indexOf(t)>-1?v:m,B(S.join("")),T=l,M}return S.push(e),r=e,M+1}};var n=t("./lib/literals"),i=t("./lib/operators"),a=t("./lib/builtins"),o=t("./lib/literals-300es"),s=t("./lib/builtins-300es"),l=999,c=9999,u=0,f=1,h=2,p=3,d=4,g=5,m=6,v=7,y=8,x=9,b=10,_=11,w=["block-comment","line-comment","preprocessor","operator","integer","float","ident","builtin","keyword","whitespace","eof","integer"]},{"./lib/builtins":348,"./lib/builtins-300es":347,"./lib/literals":350,"./lib/literals-300es":349,"./lib/operators":351}],347:[function(t,e,r){var n=t("./builtins");n=n.slice().filter(function(t){return!/^(gl\_|texture)/.test(t)}),e.exports=n.concat(["gl_VertexID","gl_InstanceID","gl_Position","gl_PointSize","gl_FragCoord","gl_FrontFacing","gl_FragDepth","gl_PointCoord","gl_MaxVertexAttribs","gl_MaxVertexUniformVectors","gl_MaxVertexOutputVectors","gl_MaxFragmentInputVectors","gl_MaxVertexTextureImageUnits","gl_MaxCombinedTextureImageUnits","gl_MaxTextureImageUnits","gl_MaxFragmentUniformVectors","gl_MaxDrawBuffers","gl_MinProgramTexelOffset","gl_MaxProgramTexelOffset","gl_DepthRangeParameters","gl_DepthRange","trunc","round","roundEven","isnan","isinf","floatBitsToInt","floatBitsToUint","intBitsToFloat","uintBitsToFloat","packSnorm2x16","unpackSnorm2x16","packUnorm2x16","unpackUnorm2x16","packHalf2x16","unpackHalf2x16","outerProduct","transpose","determinant","inverse","texture","textureSize","textureProj","textureLod","textureOffset","texelFetch","texelFetchOffset","textureProjOffset","textureLodOffset","textureProjLod","textureProjLodOffset","textureGrad","textureGradOffset","textureProjGrad","textureProjGradOffset"])},{"./builtins":348}],348:[function(t,e,r){e.exports=["abs","acos","all","any","asin","atan","ceil","clamp","cos","cross","dFdx","dFdy","degrees","distance","dot","equal","exp","exp2","faceforward","floor","fract","gl_BackColor","gl_BackLightModelProduct","gl_BackLightProduct","gl_BackMaterial","gl_BackSecondaryColor","gl_ClipPlane","gl_ClipVertex","gl_Color","gl_DepthRange","gl_DepthRangeParameters","gl_EyePlaneQ","gl_EyePlaneR","gl_EyePlaneS","gl_EyePlaneT","gl_Fog","gl_FogCoord","gl_FogFragCoord","gl_FogParameters","gl_FragColor","gl_FragCoord","gl_FragData","gl_FragDepth","gl_FragDepthEXT","gl_FrontColor","gl_FrontFacing","gl_FrontLightModelProduct","gl_FrontLightProduct","gl_FrontMaterial","gl_FrontSecondaryColor","gl_LightModel","gl_LightModelParameters","gl_LightModelProducts","gl_LightProducts","gl_LightSource","gl_LightSourceParameters","gl_MaterialParameters","gl_MaxClipPlanes","gl_MaxCombinedTextureImageUnits","gl_MaxDrawBuffers","gl_MaxFragmentUniformComponents","gl_MaxLights","gl_MaxTextureCoords","gl_MaxTextureImageUnits","gl_MaxTextureUnits","gl_MaxVaryingFloats","gl_MaxVertexAttribs","gl_MaxVertexTextureImageUnits","gl_MaxVertexUniformComponents","gl_ModelViewMatrix","gl_ModelViewMatrixInverse","gl_ModelViewMatrixInverseTranspose","gl_ModelViewMatrixTranspose","gl_ModelViewProjectionMatrix","gl_ModelViewProjectionMatrixInverse","gl_ModelViewProjectionMatrixInverseTranspose","gl_ModelViewProjectionMatrixTranspose","gl_MultiTexCoord0","gl_MultiTexCoord1","gl_MultiTexCoord2","gl_MultiTexCoord3","gl_MultiTexCoord4","gl_MultiTexCoord5","gl_MultiTexCoord6","gl_MultiTexCoord7","gl_Normal","gl_NormalMatrix","gl_NormalScale","gl_ObjectPlaneQ","gl_ObjectPlaneR","gl_ObjectPlaneS","gl_ObjectPlaneT","gl_Point","gl_PointCoord","gl_PointParameters","gl_PointSize","gl_Position","gl_ProjectionMatrix","gl_ProjectionMatrixInverse","gl_ProjectionMatrixInverseTranspose","gl_ProjectionMatrixTranspose","gl_SecondaryColor","gl_TexCoord","gl_TextureEnvColor","gl_TextureMatrix","gl_TextureMatrixInverse","gl_TextureMatrixInverseTranspose","gl_TextureMatrixTranspose","gl_Vertex","greaterThan","greaterThanEqual","inversesqrt","length","lessThan","lessThanEqual","log","log2","matrixCompMult","max","min","mix","mod","normalize","not","notEqual","pow","radians","reflect","refract","sign","sin","smoothstep","sqrt","step","tan","texture2D","texture2DLod","texture2DProj","texture2DProjLod","textureCube","textureCubeLod","texture2DLodEXT","texture2DProjLodEXT","textureCubeLodEXT","texture2DGradEXT","texture2DProjGradEXT","textureCubeGradEXT"]},{}],349:[function(t,e,r){var n=t("./literals");e.exports=n.slice().concat(["layout","centroid","smooth","case","mat2x2","mat2x3","mat2x4","mat3x2","mat3x3","mat3x4","mat4x2","mat4x3","mat4x4","uint","uvec2","uvec3","uvec4","samplerCubeShadow","sampler2DArray","sampler2DArrayShadow","isampler2D","isampler3D","isamplerCube","isampler2DArray","usampler2D","usampler3D","usamplerCube","usampler2DArray","coherent","restrict","readonly","writeonly","resource","atomic_uint","noperspective","patch","sample","subroutine","common","partition","active","filter","image1D","image2D","image3D","imageCube","iimage1D","iimage2D","iimage3D","iimageCube","uimage1D","uimage2D","uimage3D","uimageCube","image1DArray","image2DArray","iimage1DArray","iimage2DArray","uimage1DArray","uimage2DArray","image1DShadow","image2DShadow","image1DArrayShadow","image2DArrayShadow","imageBuffer","iimageBuffer","uimageBuffer","sampler1DArray","sampler1DArrayShadow","isampler1D","isampler1DArray","usampler1D","usampler1DArray","isampler2DRect","usampler2DRect","samplerBuffer","isamplerBuffer","usamplerBuffer","sampler2DMS","isampler2DMS","usampler2DMS","sampler2DMSArray","isampler2DMSArray","usampler2DMSArray"])},{"./literals":350}],350:[function(t,e,r){e.exports=["precision","highp","mediump","lowp","attribute","const","uniform","varying","break","continue","do","for","while","if","else","in","out","inout","float","int","void","bool","true","false","discard","return","mat2","mat3","mat4","vec2","vec3","vec4","ivec2","ivec3","ivec4","bvec2","bvec3","bvec4","sampler1D","sampler2D","sampler3D","samplerCube","sampler1DShadow","sampler2DShadow","struct","asm","class","union","enum","typedef","template","this","packed","goto","switch","default","inline","noinline","volatile","public","static","extern","external","interface","long","short","double","half","fixed","unsigned","input","output","hvec2","hvec3","hvec4","dvec2","dvec3","dvec4","fvec2","fvec3","fvec4","sampler2DRect","sampler3DRect","sampler2DRectShadow","sizeof","cast","namespace","using"]},{}],351:[function(t,e,r){e.exports=["<<=",">>=","++","--","<<",">>","<=",">=","==","!=","&&","||","+=","-=","*=","/=","%=","&=","^^","^=","|=","(",")","[","]",".","!","~","*","/","%","+","-","<",">","&","^","|","?",":","=",",",";","{","}"]},{}],352:[function(t,e,r){var n=t("./index");e.exports=function(t,e){var r=n(e),i=[];return i=(i=i.concat(r(t))).concat(r(null))}},{"./index":346}],353:[function(t,e,r){e.exports=function(t){"string"==typeof t&&(t=[t]);for(var e=[].slice.call(arguments,1),r=[],n=0;n>1,u=-7,f=r?i-1:0,h=r?-1:1,p=t[e+f];for(f+=h,a=p&(1<<-u)-1,p>>=-u,u+=s;u>0;a=256*a+t[e+f],f+=h,u-=8);for(o=a&(1<<-u)-1,a>>=-u,u+=n;u>0;o=256*o+t[e+f],f+=h,u-=8);if(0===a)a=1-c;else{if(a===l)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,n),a-=c}return(p?-1:1)*o*Math.pow(2,a-n)},r.write=function(t,e,r,n,i,a){var o,s,l,c=8*a-i-1,u=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:a-1,d=n?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,o=u):(o=Math.floor(Math.log(e)/Math.LN2),e*(l=Math.pow(2,-o))<1&&(o--,l*=2),(e+=o+f>=1?h/l:h*Math.pow(2,1-f))*l>=2&&(o++,l/=2),o+f>=u?(s=0,o=u):o+f>=1?(s=(e*l-1)*Math.pow(2,i),o+=f):(s=e*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;t[r+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;t[r+p]=255&o,p+=d,o/=256,c-=8);t[r+p-d]|=128*g}},{}],357:[function(t,e,r){"use strict";e.exports=function(t,e){var r=t.length;if(0===r)throw new Error("Must have at least d+1 points");var i=t[0].length;if(r<=i)throw new Error("Must input at least d+1 points");var o=t.slice(0,i+1),s=n.apply(void 0,o);if(0===s)throw new Error("Input not in general position");for(var l=new Array(i+1),u=0;u<=i;++u)l[u]=u;s<0&&(l[0]=1,l[1]=0);for(var f=new a(l,new Array(i+1),!1),h=f.adjacent,p=new Array(i+2),u=0;u<=i;++u){for(var d=l.slice(),g=0;g<=i;++g)g===u&&(d[g]=-1);var m=d[0];d[0]=d[1],d[1]=m;var v=new a(d,new Array(i+1),!0);h[u]=v,p[u]=v}p[i+1]=f;for(var u=0;u<=i;++u)for(var d=h[u].vertices,y=h[u].adjacent,g=0;g<=i;++g){var x=d[g];if(x<0)y[g]=f;else for(var b=0;b<=i;++b)h[b].vertices.indexOf(x)<0&&(y[g]=h[b])}for(var _=new c(i,o,p),w=!!e,u=i+1;u0&&e.push(","),e.push("tuple[",r,"]");e.push(")}return orient");var i=new Function("test",e.join("")),a=n[t+1];return a||(a=n),i(a)}(t)),this.orient=a}var u=c.prototype;u.handleBoundaryDegeneracy=function(t,e){var r=this.dimension,n=this.vertices.length-1,i=this.tuple,a=this.vertices,o=[t];for(t.lastVisited=-n;o.length>0;){(t=o.pop()).vertices;for(var s=t.adjacent,l=0;l<=r;++l){var c=s[l];if(c.boundary&&!(c.lastVisited<=-n)){for(var u=c.vertices,f=0;f<=r;++f){var h=u[f];i[f]=h<0?e:a[h]}var p=this.orient();if(p>0)return c;c.lastVisited=-n,0===p&&o.push(c)}}}return null},u.walk=function(t,e){var r=this.vertices.length-1,n=this.dimension,i=this.vertices,a=this.tuple,o=e?this.interior.length*Math.random()|0:this.interior.length-1,s=this.interior[o];t:for(;!s.boundary;){for(var l=s.vertices,c=s.adjacent,u=0;u<=n;++u)a[u]=i[l[u]];s.lastVisited=r;for(u=0;u<=n;++u){var f=c[u];if(!(f.lastVisited>=r)){var h=a[u];a[u]=t;var p=this.orient();if(a[u]=h,p<0){s=f;continue t}f.boundary?f.lastVisited=-r:f.lastVisited=r}}return}return s},u.addPeaks=function(t,e){var r=this.vertices.length-1,n=this.dimension,i=this.vertices,l=this.tuple,c=this.interior,u=this.simplices,f=[e];e.lastVisited=r,e.vertices[e.vertices.indexOf(-1)]=r,e.boundary=!1,c.push(e);for(var h=[];f.length>0;){var p=(e=f.pop()).vertices,d=e.adjacent,g=p.indexOf(r);if(!(g<0))for(var m=0;m<=n;++m)if(m!==g){var v=d[m];if(v.boundary&&!(v.lastVisited>=r)){var y=v.vertices;if(v.lastVisited!==-r){for(var x=0,b=0;b<=n;++b)y[b]<0?(x=b,l[b]=t):l[b]=i[y[b]];if(this.orient()>0){y[x]=r,v.boundary=!1,c.push(v),f.push(v),v.lastVisited=r;continue}v.lastVisited=-r}var _=v.adjacent,w=p.slice(),k=d.slice(),M=new a(w,k,!0);u.push(M);var A=_.indexOf(e);if(!(A<0)){_[A]=M,k[g]=v,w[m]=-1,k[m]=e,d[m]=M,M.flip();for(b=0;b<=n;++b){var T=w[b];if(!(T<0||T===r)){for(var S=new Array(n-1),C=0,E=0;E<=n;++E){var L=w[E];L<0||E===b||(S[C++]=L)}h.push(new o(S,M,b))}}}}}}h.sort(s);for(m=0;m+1=0?o[l++]=s[u]:c=1&u;if(c===(1&t)){var f=o[0];o[0]=o[1],o[1]=f}e.push(o)}}return e}},{"robust-orientation":446,"simplicial-complex":456}],358:[function(t,e,r){"use strict";var n=t("binary-search-bounds"),i=0,a=1;function o(t,e,r,n,i){this.mid=t,this.left=e,this.right=r,this.leftPoints=n,this.rightPoints=i,this.count=(e?e.count:0)+(r?r.count:0)+n.length}e.exports=function(t){if(!t||0===t.length)return new x(null);return new x(y(t))};var s=o.prototype;function l(t,e){t.mid=e.mid,t.left=e.left,t.right=e.right,t.leftPoints=e.leftPoints,t.rightPoints=e.rightPoints,t.count=e.count}function c(t,e){var r=y(e);t.mid=r.mid,t.left=r.left,t.right=r.right,t.leftPoints=r.leftPoints,t.rightPoints=r.rightPoints,t.count=r.count}function u(t,e){var r=t.intervals([]);r.push(e),c(t,r)}function f(t,e){var r=t.intervals([]),n=r.indexOf(e);return n<0?i:(r.splice(n,1),c(t,r),a)}function h(t,e,r){for(var n=0;n=0&&t[n][1]>=e;--n){var i=r(t[n]);if(i)return i}}function d(t,e){for(var r=0;r>1],i=[],a=[],s=[];for(r=0;r3*(e+1)?u(this,t):this.left.insert(t):this.left=y([t]);else if(t[0]>this.mid)this.right?4*(this.right.count+1)>3*(e+1)?u(this,t):this.right.insert(t):this.right=y([t]);else{var r=n.ge(this.leftPoints,t,m),i=n.ge(this.rightPoints,t,v);this.leftPoints.splice(r,0,t),this.rightPoints.splice(i,0,t)}},s.remove=function(t){var e=this.count-this.leftPoints;if(t[1]3*(e-1)?f(this,t):2===(c=this.left.remove(t))?(this.left=null,this.count-=1,a):(c===a&&(this.count-=1),c):i}else{if(!(t[0]>this.mid)){if(1===this.count)return this.leftPoints[0]===t?2:i;if(1===this.leftPoints.length&&this.leftPoints[0]===t){if(this.left&&this.right){for(var r=this,o=this.left;o.right;)r=o,o=o.right;if(r===this)o.right=this.right;else{var s=this.left;c=this.right;r.count-=o.count,r.right=o.left,o.left=s,o.right=c}l(this,o),this.count=(this.left?this.left.count:0)+(this.right?this.right.count:0)+this.leftPoints.length}else this.left?l(this,this.left):l(this,this.right);return a}for(s=n.ge(this.leftPoints,t,m);s3*(e-1)?f(this,t):2===(c=this.right.remove(t))?(this.right=null,this.count-=1,a):(c===a&&(this.count-=1),c):i;var c}},s.queryPoint=function(t,e){if(tthis.mid){var r;if(this.right)if(r=this.right.queryPoint(t,e))return r;return p(this.rightPoints,t,e)}return d(this.leftPoints,e)},s.queryInterval=function(t,e,r){var n;if(tthis.mid&&this.right&&(n=this.right.queryInterval(t,e,r)))return n;return ethis.mid?p(this.rightPoints,t,r):d(this.leftPoints,r)};var b=x.prototype;b.insert=function(t){this.root?this.root.insert(t):this.root=new o(t[0],null,null,[t],[t])},b.remove=function(t){if(this.root){var e=this.root.remove(t);return 2===e&&(this.root=null),e!==i}return!1},b.queryPoint=function(t,e){if(this.root)return this.root.queryPoint(t,e)},b.queryInterval=function(t,e,r){if(t<=e&&this.root)return this.root.queryInterval(t,e,r)},Object.defineProperty(b,"count",{get:function(){return this.root?this.root.count:0}}),Object.defineProperty(b,"intervals",{get:function(){return this.root?this.root.intervals([]):[]}})},{"binary-search-bounds":73}],359:[function(t,e,r){"use strict";e.exports=function(t,e){e=e||new Array(t.length);for(var r=0;r4))}},{}],368:[function(t,e,r){e.exports=function(t,e,r){return t*(1-r)+e*r}},{}],369:[function(t,e,r){(function(n){"use strict";!function(t){"object"==typeof r&&void 0!==e?e.exports=t():("undefined"!=typeof window?window:void 0!==n?n:"undefined"!=typeof self?self:this).mapboxgl=t()}(function(){return function e(r,n,i){function a(s,l){if(!n[s]){if(!r[s]){var c="function"==typeof t&&t;if(!l&&c)return c(s,!0);if(o)return o(s,!0);var u=new Error("Cannot find module '"+s+"'");throw u.code="MODULE_NOT_FOUND",u}var f=n[s]={exports:{}};r[s][0].call(f.exports,function(t){var e=r[s][1][t];return a(e||t)},f,f.exports,e,r,n,i)}return n[s].exports}for(var o="function"==typeof t&&t,s=0;s0){e+=Math.abs(i(t[0]));for(var r=1;r2){for(l=0;li.maxh||t>i.maxw||r<=i.maxh&&t<=i.maxw&&(o=i.maxw*i.maxh-t*r)a.free)){if(r===a.h)return this.allocShelf(s,t,r,n);r>a.h||ru)&&(f=2*Math.max(t,u)),(ll)&&(c=2*Math.max(r,l)),this.resize(f,c),this.packOne(t,r,n)):null},t.prototype.allocFreebin=function(t,e,r,n){var i=this.freebins.splice(t,1)[0];return i.id=n,i.w=e,i.h=r,i.refcount=0,this.bins[n]=i,this.ref(i),i},t.prototype.allocShelf=function(t,e,r,n){var i=this.shelves[t].alloc(e,r,n);return this.bins[n]=i,this.ref(i),i},t.prototype.shrink=function(){if(this.shelves.length>0){for(var t=0,e=0,r=0;rthis.free||e>this.h)return null;var n=this.x;return this.x+=t,this.free-=t,new function(t,e,r,n,i,a,o){this.id=t,this.x=e,this.y=r,this.w=n,this.h=i,this.maxw=a||n,this.maxh=o||i,this.refcount=0}(r,n,this.y,t,e,t,this.h)},e.prototype.resize=function(t){return this.free+=t-this.w,this.w=t,!0},t},"object"==typeof r&&void 0!==e?e.exports=i():n.ShelfPack=i()},{}],6:[function(t,e,r){function n(t,e,r,n,i,a){this.fontSize=t||24,this.buffer=void 0===e?3:e,this.cutoff=n||.25,this.fontFamily=i||"sans-serif",this.fontWeight=a||"normal",this.radius=r||8;var o=this.size=this.fontSize+2*this.buffer;this.canvas=document.createElement("canvas"),this.canvas.width=this.canvas.height=o,this.ctx=this.canvas.getContext("2d"),this.ctx.font=this.fontWeight+" "+this.fontSize+"px "+this.fontFamily,this.ctx.textBaseline="middle",this.ctx.fillStyle="black",this.gridOuter=new Float64Array(o*o),this.gridInner=new Float64Array(o*o),this.f=new Float64Array(o),this.d=new Float64Array(o),this.z=new Float64Array(o+1),this.v=new Int16Array(o),this.middle=Math.round(o/2*(navigator.userAgent.indexOf("Gecko/")>=0?1.2:1))}function i(t,e,r,n,i,o,s){for(var l=0;ln)return n;for(;ra?r=i:n=i,i=.5*(n-r)+r}return i},n.prototype.solve=function(t,e){return this.sampleCurveY(this.solveCurveX(t,e))}},{}],8:[function(t,e,r){e.exports.VectorTile=t("./lib/vectortile.js"),e.exports.VectorTileFeature=t("./lib/vectortilefeature.js"),e.exports.VectorTileLayer=t("./lib/vectortilelayer.js")},{"./lib/vectortile.js":9,"./lib/vectortilefeature.js":10,"./lib/vectortilelayer.js":11}],9:[function(t,e,r){function n(t,e,r){if(3===t){var n=new i(r,r.readVarint()+r.pos);n.length&&(e[n.name]=n)}}var i=t("./vectortilelayer");e.exports=function(t,e){this.layers=t.readFields(n,{},e)}},{"./vectortilelayer":11}],10:[function(t,e,r){function n(t,e,r,n,a){this.properties={},this.extent=r,this.type=0,this._pbf=t,this._geometry=-1,this._keys=n,this._values=a,t.readFields(i,this,e)}function i(t,e,r){1==t?e.id=r.readVarint():2==t?function(t,e){for(var r=t.readVarint()+t.pos;t.pos>3}if(i--,1===n||2===n)a+=t.readSVarint(),s+=t.readSVarint(),1===n&&(e&&l.push(e),e=[]),e.push(new o(a,s));else{if(7!==n)throw new Error("unknown command "+n);e&&e.push(e[0].clone())}}return e&&l.push(e),l},n.prototype.bbox=function(){var t=this._pbf;t.pos=this._geometry;for(var e=t.readVarint()+t.pos,r=1,n=0,i=0,a=0,o=1/0,s=-1/0,l=1/0,c=-1/0;t.pos>3}if(n--,1===r||2===r)i+=t.readSVarint(),a+=t.readSVarint(),is&&(s=i),ac&&(c=a);else if(7!==r)throw new Error("unknown command "+r)}return[o,l,s,c]},n.prototype.toGeoJSON=function(t,e,r){function i(t){for(var e=0;e>3;e=1===n?t.readString():2===n?t.readFloat():3===n?t.readDouble():4===n?t.readVarint64():5===n?t.readVarint():6===n?t.readSVarint():7===n?t.readBoolean():null}return e}(r))}var a=t("./vectortilefeature.js");e.exports=n,n.prototype.feature=function(t){if(t<0||t>=this._features.length)throw new Error("feature index out of bounds");this._pbf.pos=this._features[t];var e=this._pbf.readVarint()+this._pbf.pos;return new a(this._pbf,e,this.extent,this._keys,this._values)}},{"./vectortilefeature.js":10}],12:[function(t,e,r){var n;n=this,function(t){function e(t,e,n){var i=r(256*t,256*(e=Math.pow(2,n)-e-1),n),a=r(256*(t+1),256*(e+1),n);return i[0]+","+i[1]+","+a[0]+","+a[1]}function r(t,e,r){var n=2*Math.PI*6378137/256/Math.pow(2,r);return[t*n-2*Math.PI*6378137/2,e*n-2*Math.PI*6378137/2]}t.getURL=function(t,r,n,i,a,o){return o=o||{},t+"?"+["bbox="+e(n,i,a),"format="+(o.format||"image/png"),"service="+(o.service||"WMS"),"version="+(o.version||"1.1.1"),"request="+(o.request||"GetMap"),"srs="+(o.srs||"EPSG:3857"),"width="+(o.width||256),"height="+(o.height||256),"layers="+r].join("&")},t.getTileBBox=e,t.getMercCoords=r,Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.WhooTS=n.WhooTS||{})},{}],13:[function(t,e,r){function n(t){return(t=Math.round(t))<0?0:t>255?255:t}function i(t){return n("%"===t[t.length-1]?parseFloat(t)/100*255:parseInt(t))}function a(t){return function(t){return t<0?0:t>1?1:t}("%"===t[t.length-1]?parseFloat(t)/100:parseFloat(t))}function o(t,e,r){return r<0?r+=1:r>1&&(r-=1),6*r<1?t+(e-t)*r*6:2*r<1?e:3*r<2?t+(e-t)*(2/3-r)*6:t}var s={transparent:[0,0,0,0],aliceblue:[240,248,255,1],antiquewhite:[250,235,215,1],aqua:[0,255,255,1],aquamarine:[127,255,212,1],azure:[240,255,255,1],beige:[245,245,220,1],bisque:[255,228,196,1],black:[0,0,0,1],blanchedalmond:[255,235,205,1],blue:[0,0,255,1],blueviolet:[138,43,226,1],brown:[165,42,42,1],burlywood:[222,184,135,1],cadetblue:[95,158,160,1],chartreuse:[127,255,0,1],chocolate:[210,105,30,1],coral:[255,127,80,1],cornflowerblue:[100,149,237,1],cornsilk:[255,248,220,1],crimson:[220,20,60,1],cyan:[0,255,255,1],darkblue:[0,0,139,1],darkcyan:[0,139,139,1],darkgoldenrod:[184,134,11,1],darkgray:[169,169,169,1],darkgreen:[0,100,0,1],darkgrey:[169,169,169,1],darkkhaki:[189,183,107,1],darkmagenta:[139,0,139,1],darkolivegreen:[85,107,47,1],darkorange:[255,140,0,1],darkorchid:[153,50,204,1],darkred:[139,0,0,1],darksalmon:[233,150,122,1],darkseagreen:[143,188,143,1],darkslateblue:[72,61,139,1],darkslategray:[47,79,79,1],darkslategrey:[47,79,79,1],darkturquoise:[0,206,209,1],darkviolet:[148,0,211,1],deeppink:[255,20,147,1],deepskyblue:[0,191,255,1],dimgray:[105,105,105,1],dimgrey:[105,105,105,1],dodgerblue:[30,144,255,1],firebrick:[178,34,34,1],floralwhite:[255,250,240,1],forestgreen:[34,139,34,1],fuchsia:[255,0,255,1],gainsboro:[220,220,220,1],ghostwhite:[248,248,255,1],gold:[255,215,0,1],goldenrod:[218,165,32,1],gray:[128,128,128,1],green:[0,128,0,1],greenyellow:[173,255,47,1],grey:[128,128,128,1],honeydew:[240,255,240,1],hotpink:[255,105,180,1],indianred:[205,92,92,1],indigo:[75,0,130,1],ivory:[255,255,240,1],khaki:[240,230,140,1],lavender:[230,230,250,1],lavenderblush:[255,240,245,1],lawngreen:[124,252,0,1],lemonchiffon:[255,250,205,1],lightblue:[173,216,230,1],lightcoral:[240,128,128,1],lightcyan:[224,255,255,1],lightgoldenrodyellow:[250,250,210,1],lightgray:[211,211,211,1],lightgreen:[144,238,144,1],lightgrey:[211,211,211,1],lightpink:[255,182,193,1],lightsalmon:[255,160,122,1],lightseagreen:[32,178,170,1],lightskyblue:[135,206,250,1],lightslategray:[119,136,153,1],lightslategrey:[119,136,153,1],lightsteelblue:[176,196,222,1],lightyellow:[255,255,224,1],lime:[0,255,0,1],limegreen:[50,205,50,1],linen:[250,240,230,1],magenta:[255,0,255,1],maroon:[128,0,0,1],mediumaquamarine:[102,205,170,1],mediumblue:[0,0,205,1],mediumorchid:[186,85,211,1],mediumpurple:[147,112,219,1],mediumseagreen:[60,179,113,1],mediumslateblue:[123,104,238,1],mediumspringgreen:[0,250,154,1],mediumturquoise:[72,209,204,1],mediumvioletred:[199,21,133,1],midnightblue:[25,25,112,1],mintcream:[245,255,250,1],mistyrose:[255,228,225,1],moccasin:[255,228,181,1],navajowhite:[255,222,173,1],navy:[0,0,128,1],oldlace:[253,245,230,1],olive:[128,128,0,1],olivedrab:[107,142,35,1],orange:[255,165,0,1],orangered:[255,69,0,1],orchid:[218,112,214,1],palegoldenrod:[238,232,170,1],palegreen:[152,251,152,1],paleturquoise:[175,238,238,1],palevioletred:[219,112,147,1],papayawhip:[255,239,213,1],peachpuff:[255,218,185,1],peru:[205,133,63,1],pink:[255,192,203,1],plum:[221,160,221,1],powderblue:[176,224,230,1],purple:[128,0,128,1],rebeccapurple:[102,51,153,1],red:[255,0,0,1],rosybrown:[188,143,143,1],royalblue:[65,105,225,1],saddlebrown:[139,69,19,1],salmon:[250,128,114,1],sandybrown:[244,164,96,1],seagreen:[46,139,87,1],seashell:[255,245,238,1],sienna:[160,82,45,1],silver:[192,192,192,1],skyblue:[135,206,235,1],slateblue:[106,90,205,1],slategray:[112,128,144,1],slategrey:[112,128,144,1],snow:[255,250,250,1],springgreen:[0,255,127,1],steelblue:[70,130,180,1],tan:[210,180,140,1],teal:[0,128,128,1],thistle:[216,191,216,1],tomato:[255,99,71,1],turquoise:[64,224,208,1],violet:[238,130,238,1],wheat:[245,222,179,1],white:[255,255,255,1],whitesmoke:[245,245,245,1],yellow:[255,255,0,1],yellowgreen:[154,205,50,1]};try{r.parseCSSColor=function(t){var e,r=t.replace(/ /g,"").toLowerCase();if(r in s)return s[r].slice();if("#"===r[0])return 4===r.length?(e=parseInt(r.substr(1),16))>=0&&e<=4095?[(3840&e)>>4|(3840&e)>>8,240&e|(240&e)>>4,15&e|(15&e)<<4,1]:null:7===r.length&&(e=parseInt(r.substr(1),16))>=0&&e<=16777215?[(16711680&e)>>16,(65280&e)>>8,255&e,1]:null;var l=r.indexOf("("),c=r.indexOf(")");if(-1!==l&&c+1===r.length){var u=r.substr(0,l),f=r.substr(l+1,c-(l+1)).split(","),h=1;switch(u){case"rgba":if(4!==f.length)return null;h=a(f.pop());case"rgb":return 3!==f.length?null:[i(f[0]),i(f[1]),i(f[2]),h];case"hsla":if(4!==f.length)return null;h=a(f.pop());case"hsl":if(3!==f.length)return null;var p=(parseFloat(f[0])%360+360)%360/360,d=a(f[1]),g=a(f[2]),m=g<=.5?g*(d+1):g+d-g*d,v=2*g-m;return[n(255*o(v,m,p+1/3)),n(255*o(v,m,p)),n(255*o(v,m,p-1/3)),h];default:return null}}return null}}catch(t){}},{}],14:[function(t,e,r){function n(t,e,r){r=r||2;var n,s,l,c,u,p,g,m=e&&e.length,v=m?e[0]*r:t.length,y=i(t,0,v,r,!0),x=[];if(!y)return x;if(m&&(y=function(t,e,r,n){var o,s,l,c,u,p=[];for(o=0,s=e.length;o80*r){n=l=t[0],s=c=t[1];for(var b=r;bl&&(l=u),p>c&&(c=p);g=0!==(g=Math.max(l-n,c-s))?1/g:0}return o(y,x,r,n,s,g),x}function i(t,e,r,n,i){var a,o;if(i===A(t,e,r,n)>0)for(a=e;a=e;a-=n)o=w(a,t[a],t[a+1],o);return o&&y(o,o.next)&&(k(o),o=o.next),o}function a(t,e){if(!t)return t;e||(e=t);var r,n=t;do{if(r=!1,n.steiner||!y(n,n.next)&&0!==v(n.prev,n,n.next))n=n.next;else{if(k(n),(n=e=n.prev)===n.next)break;r=!0}}while(r||n!==e);return e}function o(t,e,r,n,i,f,h){if(t){!h&&f&&function(t,e,r,n){var i=t;do{null===i.z&&(i.z=p(i.x,i.y,e,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next}while(i!==t);i.prevZ.nextZ=null,i.prevZ=null,function(t){var e,r,n,i,a,o,s,l,c=1;do{for(r=t,t=null,a=null,o=0;r;){for(o++,n=r,s=0,e=0;e0||l>0&&n;)0!==s&&(0===l||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),a?a.nextZ=i:t=i,i.prevZ=a,a=i;r=n}a.nextZ=null,c*=2}while(o>1)}(i)}(t,n,i,f);for(var d,g,m=t;t.prev!==t.next;)if(d=t.prev,g=t.next,f?l(t,n,i,f):s(t))e.push(d.i/r),e.push(t.i/r),e.push(g.i/r),k(t),t=g.next,m=g.next;else if((t=g)===m){h?1===h?o(t=c(t,e,r),e,r,n,i,f,2):2===h&&u(t,e,r,n,i,f):o(a(t),e,r,n,i,f,1);break}}}function s(t){var e=t.prev,r=t,n=t.next;if(v(e,r,n)>=0)return!1;for(var i=t.next.next;i!==t.prev;){if(g(e.x,e.y,r.x,r.y,n.x,n.y,i.x,i.y)&&v(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function l(t,e,r,n){var i=t.prev,a=t,o=t.next;if(v(i,a,o)>=0)return!1;for(var s=i.xa.x?i.x>o.x?i.x:o.x:a.x>o.x?a.x:o.x,u=i.y>a.y?i.y>o.y?i.y:o.y:a.y>o.y?a.y:o.y,f=p(s,l,e,r,n),h=p(c,u,e,r,n),d=t.prevZ,m=t.nextZ;d&&d.z>=f&&m&&m.z<=h;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;if(d=d.prevZ,m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}for(;d&&d.z>=f;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;m&&m.z<=h;){if(m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function c(t,e,r){var n=t;do{var i=n.prev,a=n.next.next;!y(i,a)&&x(i,n,n.next,a)&&b(i,a)&&b(a,i)&&(e.push(i.i/r),e.push(n.i/r),e.push(a.i/r),k(n),k(n.next),n=t=a),n=n.next}while(n!==t);return n}function u(t,e,r,n,i,s){var l=t;do{for(var c=l.next.next;c!==l.prev;){if(l.i!==c.i&&m(l,c)){var u=_(l,c);return l=a(l,l.next),u=a(u,u.next),o(l,e,r,n,i,s),void o(u,e,r,n,i,s)}c=c.next}l=l.next}while(l!==t)}function f(t,e){return t.x-e.x}function h(t,e){if(e=function(t,e){var r,n=e,i=t.x,a=t.y,o=-1/0;do{if(a<=n.y&&a>=n.next.y&&n.next.y!==n.y){var s=n.x+(a-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(s<=i&&s>o){if(o=s,s===i){if(a===n.y)return n;if(a===n.next.y)return n.next}r=n.x=n.x&&n.x>=u&&i!==n.x&&g(ar.x)&&b(n,t)&&(r=n,h=l),n=n.next;return r}(t,e)){var r=_(e,t);a(r,r.next)}}function p(t,e,r,n,i){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-r)*i)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-n)*i)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function d(t){var e=t,r=t;do{e.x=0&&(t-o)*(n-s)-(r-o)*(e-s)>=0&&(r-o)*(a-s)-(i-o)*(n-s)>=0}function m(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){var r=t;do{if(r.i!==t.i&&r.next.i!==t.i&&r.i!==e.i&&r.next.i!==e.i&&x(r,r.next,t,e))return!0;r=r.next}while(r!==t);return!1}(t,e)&&b(t,e)&&b(e,t)&&function(t,e){var r=t,n=!1,i=(t.x+e.x)/2,a=(t.y+e.y)/2;do{r.y>a!=r.next.y>a&&r.next.y!==r.y&&i<(r.next.x-r.x)*(a-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next}while(r!==t);return n}(t,e)}function v(t,e,r){return(e.y-t.y)*(r.x-e.x)-(e.x-t.x)*(r.y-e.y)}function y(t,e){return t.x===e.x&&t.y===e.y}function x(t,e,r,n){return!!(y(t,e)&&y(r,n)||y(t,n)&&y(r,e))||v(t,e,r)>0!=v(t,e,n)>0&&v(r,n,t)>0!=v(r,n,e)>0}function b(t,e){return v(t.prev,t,t.next)<0?v(t,e,t.next)>=0&&v(t,t.prev,e)>=0:v(t,e,t.prev)<0||v(t,t.next,e)<0}function _(t,e){var r=new M(t.i,t.x,t.y),n=new M(e.i,e.x,e.y),i=t.next,a=e.prev;return t.next=e,e.prev=t,r.next=i,i.prev=r,n.next=r,r.prev=n,a.next=n,n.prev=a,n}function w(t,e,r,n){var i=new M(t,e,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function k(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function M(t,e,r){this.i=t,this.x=e,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function A(t,e,r,n){for(var i=0,a=e,o=r-n;a0&&(n+=t[i-1].length,r.holes.push(n))}return r}},{}],15:[function(t,e,r){function n(t,e){return function(r){return t(r,e)}}function i(t,e){e=!!e,t[0]=a(t[0],e);for(var r=1;r=0}(t)===e?t:t.reverse()}var o=t("@mapbox/geojson-area");e.exports=function t(e,r){switch(e&&e.type||null){case"FeatureCollection":return e.features=e.features.map(n(t,r)),e;case"Feature":return e.geometry=t(e.geometry,r),e;case"Polygon":case"MultiPolygon":return function(t,e){return"Polygon"===t.type?t.coordinates=i(t.coordinates,e):"MultiPolygon"===t.type&&(t.coordinates=t.coordinates.map(n(i,e))),t}(e,r);default:return e}}},{"@mapbox/geojson-area":1}],16:[function(t,e,r){function n(t,e,r,n,i){for(var a=0;a=r&&o<=n&&(e.push(t[a]),e.push(t[a+1]),e.push(t[a+2]))}}function i(t,e,r,n,i,a){for(var c=[],u=0===i?s:l,f=0;f=r&&u(c,h,p,g,m,r):v>n?y<=n&&u(c,h,p,g,m,n):o(c,h,p,d),y=r&&(u(c,h,p,g,m,r),x=!0),y>n&&v<=n&&(u(c,h,p,g,m,n),x=!0),!a&&x&&(c.size=t.size,e.push(c),c=[])}var b=t.length-3;h=t[b],p=t[b+1],d=t[b+2],(v=0===i?h:p)>=r&&v<=n&&o(c,h,p,d),b=c.length-3,a&&b>=3&&(c[b]!==c[0]||c[b+1]!==c[1])&&o(c,c[0],c[1],c[2]),c.length&&(c.size=t.size,e.push(c))}function a(t,e,r,n,a,o){for(var s=0;s=(r/=e)&&u<=o)return t;if(l>o||u=r&&v<=o)f.push(p);else if(!(m>o||v0&&(o+=n?(i*h-f*a)/2:Math.sqrt(Math.pow(f-i,2)+Math.pow(h-a,2))),i=f,a=h}var p=e.length-3;e[2]=1,c(e,0,p,r),e[p+2]=1,e.size=Math.abs(o)}function o(t,e,r,n){for(var i=0;i1?1:r}e.exports=function(t,e){var r=[];if("FeatureCollection"===t.type)for(var i=0;i24)throw new Error("maxZoom should be in the 0-24 range");var n=1<1&&console.time("creation"),g=this.tiles[d]=c(t,p,r,n,m,e===f.maxZoom),this.tileCoords.push({z:e,x:r,y:n}),h)){h>1&&(console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",e,r,n,g.numFeatures,g.numPoints,g.numSimplified),console.timeEnd("creation"));var v="z"+e;this.stats[v]=(this.stats[v]||0)+1,this.total++}if(g.source=t,a){if(e===f.maxZoom||e===a)continue;var y=1<1&&console.time("clipping");var x,b,_,w,k,M,A=.5*f.buffer/f.extent,T=.5-A,S=.5+A,C=1+A;x=b=_=w=null,k=s(t,p,r-A,r+S,0,g.minX,g.maxX),M=s(t,p,r+T,r+C,0,g.minX,g.maxX),t=null,k&&(x=s(k,p,n-A,n+S,1,g.minY,g.maxY),b=s(k,p,n+T,n+C,1,g.minY,g.maxY),k=null),M&&(_=s(M,p,n-A,n+S,1,g.minY,g.maxY),w=s(M,p,n+T,n+C,1,g.minY,g.maxY),M=null),h>1&&console.timeEnd("clipping"),u.push(x||[],e+1,2*r,2*n),u.push(b||[],e+1,2*r,2*n+1),u.push(_||[],e+1,2*r+1,2*n),u.push(w||[],e+1,2*r+1,2*n+1)}}},n.prototype.getTile=function(t,e,r){var n=this.options,a=n.extent,s=n.debug;if(t<0||t>24)return null;var l=1<1&&console.log("drilling down to z%d-%d-%d",t,e,r);for(var u,f=t,h=e,p=r;!u&&f>0;)f--,h=Math.floor(h/2),p=Math.floor(p/2),u=this.tiles[i(f,h,p)];return u&&u.source?(s>1&&console.log("found parent tile z%d-%d-%d",f,h,p),s>1&&console.time("drilling down"),this.splitTile(u.source,f,h,p,t,e,r),s>1&&console.timeEnd("drilling down"),this.tiles[c]?o.tile(this.tiles[c],a):null):null}},{"./clip":16,"./convert":17,"./tile":21,"./transform":22,"./wrap":23}],20:[function(t,e,r){function n(t,e,r,n,i,a){var o=i-r,s=a-n;if(0!==o||0!==s){var l=((t-r)*o+(e-n)*s)/(o*o+s*s);l>1?(r=i,n=a):l>0&&(r+=o*l,n+=s*l)}return(o=t-r)*o+(s=e-n)*s}e.exports=function t(e,r,i,a){for(var o,s=a,l=e[r],c=e[r+1],u=e[i],f=e[i+1],h=r+3;hs&&(o=h,s=p)}s>a&&(o-r>3&&t(e,r,o,a),e[o+2]=s,i-o>3&&t(e,o,i,a))}},{}],21:[function(t,e,r){function n(t,e,r,n){var a=e.geometry,o=e.type,s=[];if("Point"===o||"MultiPoint"===o)for(var l=0;ls)&&(r.numSimplified++,l.push(e[c]),l.push(e[c+1])),r.numPoints++;a&&function(t,e){for(var r=0,n=0,i=t.length,a=i-2;n0===e)for(n=0,i=t.length;ns.maxX&&(s.maxX=f),h>s.maxY&&(s.maxY=h)}return s}},{}],22:[function(t,e,r){function n(t,e,r,n,i,a){return[Math.round(r*(t*n-i)),Math.round(r*(e*n-a))]}r.tile=function(t,e){if(t.transformed)return t;var r,i,a,o=t.z2,s=t.x,l=t.y;for(r=0;r=c[h+0]&&n>=c[h+1]?(o[f]=!0,a.push(l[f])):o[f]=!1}}},n.prototype._forEachCell=function(t,e,r,n,i,a,o){for(var s=this._convertToCellCoord(t),l=this._convertToCellCoord(e),c=this._convertToCellCoord(r),u=this._convertToCellCoord(n),f=s;f<=c;f++)for(var h=l;h<=u;h++){var p=this.d*h+f;if(i.call(this,t,e,r,n,p,a,o))return}},n.prototype._convertToCellCoord=function(t){return Math.max(0,Math.min(this.d-1,Math.floor(t*this.scale)+this.padding))},n.prototype.toArrayBuffer=function(){if(this.arrayBuffer)return this.arrayBuffer;for(var t=this.cells,e=i+this.cells.length+1+1,r=0,n=0;n>1,u=-7,f=r?i-1:0,h=r?-1:1,p=t[e+f];for(f+=h,a=p&(1<<-u)-1,p>>=-u,u+=s;u>0;a=256*a+t[e+f],f+=h,u-=8);for(o=a&(1<<-u)-1,a>>=-u,u+=n;u>0;o=256*o+t[e+f],f+=h,u-=8);if(0===a)a=1-c;else{if(a===l)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,n),a-=c}return(p?-1:1)*o*Math.pow(2,a-n)},r.write=function(t,e,r,n,i,a){var o,s,l,c=8*a-i-1,u=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:a-1,d=n?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,o=u):(o=Math.floor(Math.log(e)/Math.LN2),e*(l=Math.pow(2,-o))<1&&(o--,l*=2),(e+=o+f>=1?h/l:h*Math.pow(2,1-f))*l>=2&&(o++,l/=2),o+f>=u?(s=0,o=u):o+f>=1?(s=(e*l-1)*Math.pow(2,i),o+=f):(s=e*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;t[r+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;t[r+p]=255&o,p+=d,o/=256,c-=8);t[r+p-d]|=128*g}},{}],26:[function(t,e,r){function n(t,e,r,n,s){e=e||i,r=r||a,s=s||Array,this.nodeSize=n||64,this.points=t,this.ids=new s(t.length),this.coords=new s(2*t.length);for(var l=0;l=r&&s<=i&&l>=n&&l<=a&&u.push(t[d]);else{var g=Math.floor((p+h)/2);s=e[2*g],l=e[2*g+1],s>=r&&s<=i&&l>=n&&l<=a&&u.push(t[g]);var m=(f+1)%2;(0===f?r<=s:n<=l)&&(c.push(p),c.push(g-1),c.push(m)),(0===f?i>=s:a>=l)&&(c.push(g+1),c.push(h),c.push(m))}}return u}},{}],28:[function(t,e,r){function n(t,e,r,n){i(t,r,n),i(e,2*r,2*n),i(e,2*r+1,2*n+1)}function i(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}e.exports=function t(e,r,i,a,o,s){if(!(o-a<=i)){var l=Math.floor((a+o)/2);(function t(e,r,i,a,o,s){for(;o>a;){if(o-a>600){var l=o-a+1,c=i-a+1,u=Math.log(l),f=.5*Math.exp(2*u/3),h=.5*Math.sqrt(u*f*(l-f)/l)*(c-l/2<0?-1:1);t(e,r,i,Math.max(a,Math.floor(i-c*f/l+h)),Math.min(o,Math.floor(i+(l-c)*f/l+h)),s)}var p=r[2*i+s],d=a,g=o;for(n(e,r,a,i),r[2*o+s]>p&&n(e,r,a,o);dp;)g--}r[2*a+s]===p?n(e,r,a,g):n(e,r,++g,o),g<=i&&(a=g+1),i<=g&&(o=g-1)}})(e,r,l,a,o,s%2),t(e,r,i,a,l-1,s+1),t(e,r,i,l+1,o,s+1)}}},{}],29:[function(t,e,r){function n(t,e,r,n){var i=t-r,a=e-n;return i*i+a*a}e.exports=function(t,e,r,i,a,o){for(var s=[0,t.length-1,0],l=[],c=a*a;s.length;){var u=s.pop(),f=s.pop(),h=s.pop();if(f-h<=o)for(var p=h;p<=f;p++)n(e[2*p],e[2*p+1],r,i)<=c&&l.push(t[p]);else{var d=Math.floor((h+f)/2),g=e[2*d],m=e[2*d+1];n(g,m,r,i)<=c&&l.push(t[d]);var v=(u+1)%2;(0===u?r-a<=g:i-a<=m)&&(s.push(h),s.push(d-1),s.push(v)),(0===u?r+a>=g:i+a>=m)&&(s.push(d+1),s.push(f),s.push(v))}}return l}},{}],30:[function(t,e,r){function n(t){this.buf=ArrayBuffer.isView&&ArrayBuffer.isView(t)?t:new Uint8Array(t||0),this.pos=0,this.type=0,this.length=this.buf.length}function i(t){return t.type===n.Bytes?t.readVarint()+t.pos:t.pos+1}function a(t,e,r){return r?4294967296*e+(t>>>0):4294967296*(e>>>0)+(t>>>0)}function o(t,e,r){var n=e<=16383?1:e<=2097151?2:e<=268435455?3:Math.ceil(Math.log(e)/(7*Math.LN2));r.realloc(n);for(var i=r.pos-1;i>=t;i--)r.buf[i+n]=r.buf[i]}function s(t,e){for(var r=0;r>>8,t[r+2]=e>>>16,t[r+3]=e>>>24}function y(t,e){return(t[e]|t[e+1]<<8|t[e+2]<<16)+(t[e+3]<<24)}e.exports=n;var x=t("ieee754");n.Varint=0,n.Fixed64=1,n.Bytes=2,n.Fixed32=5;n.prototype={destroy:function(){this.buf=null},readFields:function(t,e,r){for(r=r||this.length;this.pos>3,a=this.pos;this.type=7&n,t(i,e,this),this.pos===a&&this.skip(n)}return e},readMessage:function(t,e){return this.readFields(t,e,this.readVarint()+this.pos)},readFixed32:function(){var t=m(this.buf,this.pos);return this.pos+=4,t},readSFixed32:function(){var t=y(this.buf,this.pos);return this.pos+=4,t},readFixed64:function(){var t=m(this.buf,this.pos)+4294967296*m(this.buf,this.pos+4);return this.pos+=8,t},readSFixed64:function(){var t=m(this.buf,this.pos)+4294967296*y(this.buf,this.pos+4);return this.pos+=8,t},readFloat:function(){var t=x.read(this.buf,this.pos,!0,23,4);return this.pos+=4,t},readDouble:function(){var t=x.read(this.buf,this.pos,!0,52,8);return this.pos+=8,t},readVarint:function(t){var e,r,n=this.buf;return e=127&(r=n[this.pos++]),r<128?e:(e|=(127&(r=n[this.pos++]))<<7,r<128?e:(e|=(127&(r=n[this.pos++]))<<14,r<128?e:(e|=(127&(r=n[this.pos++]))<<21,r<128?e:function(t,e,r){var n,i,o=r.buf;if(n=(112&(i=o[r.pos++]))>>4,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<3,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<10,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<17,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<24,i<128)return a(t,n,e);if(n|=(1&(i=o[r.pos++]))<<31,i<128)return a(t,n,e);throw new Error("Expected varint not more than 10 bytes")}(e|=(15&(r=n[this.pos]))<<28,t,this))))},readVarint64:function(){return this.readVarint(!0)},readSVarint:function(){var t=this.readVarint();return t%2==1?(t+1)/-2:t/2},readBoolean:function(){return Boolean(this.readVarint())},readString:function(){var t=this.readVarint()+this.pos,e=function(t,e,r){for(var n="",i=e;i239?4:l>223?3:l>191?2:1;if(i+u>r)break;1===u?l<128&&(c=l):2===u?128==(192&(a=t[i+1]))&&(c=(31&l)<<6|63&a)<=127&&(c=null):3===u?(a=t[i+1],o=t[i+2],128==(192&a)&&128==(192&o)&&((c=(15&l)<<12|(63&a)<<6|63&o)<=2047||c>=55296&&c<=57343)&&(c=null)):4===u&&(a=t[i+1],o=t[i+2],s=t[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&((c=(15&l)<<18|(63&a)<<12|(63&o)<<6|63&s)<=65535||c>=1114112)&&(c=null)),null===c?(c=65533,u=1):c>65535&&(c-=65536,n+=String.fromCharCode(c>>>10&1023|55296),c=56320|1023&c),n+=String.fromCharCode(c),i+=u}return n}(this.buf,this.pos,t);return this.pos=t,e},readBytes:function(){var t=this.readVarint()+this.pos,e=this.buf.subarray(this.pos,t);return this.pos=t,e},readPackedVarint:function(t,e){var r=i(this);for(t=t||[];this.pos127;);else if(e===n.Bytes)this.pos=this.readVarint()+this.pos;else if(e===n.Fixed32)this.pos+=4;else{if(e!==n.Fixed64)throw new Error("Unimplemented type: "+e);this.pos+=8}},writeTag:function(t,e){this.writeVarint(t<<3|e)},realloc:function(t){for(var e=this.length||16;e268435455||t<0?function(t,e){var r,n;if(t>=0?(r=t%4294967296|0,n=t/4294967296|0):(n=~(-t/4294967296),4294967295^(r=~(-t%4294967296))?r=r+1|0:(r=0,n=n+1|0)),t>=0x10000000000000000||t<-0x10000000000000000)throw new Error("Given varint doesn't fit into 10 bytes");e.realloc(10),function(t,e,r){r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos]=127&t}(r,0,e),function(t,e){var r=(7&t)<<4;e.buf[e.pos++]|=r|((t>>>=3)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t)))))}(n,e)}(t,this):(this.realloc(4),this.buf[this.pos++]=127&t|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=t>>>7&127))))},writeSVarint:function(t){this.writeVarint(t<0?2*-t-1:2*t)},writeBoolean:function(t){this.writeVarint(Boolean(t))},writeString:function(t){t=String(t),this.realloc(4*t.length),this.pos++;var e=this.pos;this.pos=function(t,e,r){for(var n,i,a=0;a55295&&n<57344){if(!i){n>56319||a+1===e.length?(t[r++]=239,t[r++]=191,t[r++]=189):i=n;continue}if(n<56320){t[r++]=239,t[r++]=191,t[r++]=189,i=n;continue}n=i-55296<<10|n-56320|65536,i=null}else i&&(t[r++]=239,t[r++]=191,t[r++]=189,i=null);n<128?t[r++]=n:(n<2048?t[r++]=n>>6|192:(n<65536?t[r++]=n>>12|224:(t[r++]=n>>18|240,t[r++]=n>>12&63|128),t[r++]=n>>6&63|128),t[r++]=63&n|128)}return r}(this.buf,t,this.pos);var r=this.pos-e;r>=128&&o(e,r,this),this.pos=e-1,this.writeVarint(r),this.pos+=r},writeFloat:function(t){this.realloc(4),x.write(this.buf,t,this.pos,!0,23,4),this.pos+=4},writeDouble:function(t){this.realloc(8),x.write(this.buf,t,this.pos,!0,52,8),this.pos+=8},writeBytes:function(t){var e=t.length;this.writeVarint(e),this.realloc(e);for(var r=0;r=128&&o(r,n,this),this.pos=r-1,this.writeVarint(n),this.pos+=n},writeMessage:function(t,e,r){this.writeTag(t,n.Bytes),this.writeRawMessage(e,r)},writePackedVarint:function(t,e){this.writeMessage(t,s,e)},writePackedSVarint:function(t,e){this.writeMessage(t,l,e)},writePackedBoolean:function(t,e){this.writeMessage(t,f,e)},writePackedFloat:function(t,e){this.writeMessage(t,c,e)},writePackedDouble:function(t,e){this.writeMessage(t,u,e)},writePackedFixed32:function(t,e){this.writeMessage(t,h,e)},writePackedSFixed32:function(t,e){this.writeMessage(t,p,e)},writePackedFixed64:function(t,e){this.writeMessage(t,d,e)},writePackedSFixed64:function(t,e){this.writeMessage(t,g,e)},writeBytesField:function(t,e){this.writeTag(t,n.Bytes),this.writeBytes(e)},writeFixed32Field:function(t,e){this.writeTag(t,n.Fixed32),this.writeFixed32(e)},writeSFixed32Field:function(t,e){this.writeTag(t,n.Fixed32),this.writeSFixed32(e)},writeFixed64Field:function(t,e){this.writeTag(t,n.Fixed64),this.writeFixed64(e)},writeSFixed64Field:function(t,e){this.writeTag(t,n.Fixed64),this.writeSFixed64(e)},writeVarintField:function(t,e){this.writeTag(t,n.Varint),this.writeVarint(e)},writeSVarintField:function(t,e){this.writeTag(t,n.Varint),this.writeSVarint(e)},writeStringField:function(t,e){this.writeTag(t,n.Bytes),this.writeString(e)},writeFloatField:function(t,e){this.writeTag(t,n.Fixed32),this.writeFloat(e)},writeDoubleField:function(t,e){this.writeTag(t,n.Fixed64),this.writeDouble(e)},writeBooleanField:function(t,e){this.writeVarintField(t,Boolean(e))}}},{ieee754:25}],31:[function(t,e,r){function n(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function i(t,e){return te?1:0}e.exports=function t(e,r,a,o,s){for(a=a||0,o=o||e.length-1,s=s||i;o>a;){if(o-a>600){var l=o-a+1,c=r-a+1,u=Math.log(l),f=.5*Math.exp(2*u/3),h=.5*Math.sqrt(u*f*(l-f)/l)*(c-l/2<0?-1:1);t(e,r,Math.max(a,Math.floor(r-c*f/l+h)),Math.min(o,Math.floor(r+(l-c)*f/l+h)),s)}var p=e[r],d=a,g=o;for(n(e,a,r),s(e[o],p)>0&&n(e,a,o);d0;)g--}0===s(e[a],p)?n(e,a,g):n(e,++g,o),g<=r&&(a=g+1),r<=g&&(o=g-1)}}},{}],32:[function(t,e,r){function n(t){this.options=u(Object.create(this.options),t),this.trees=new Array(this.options.maxZoom+1)}function i(t,e,r,n,i){return{x:t,y:e,zoom:1/0,id:n,properties:i,parentId:-1,numPoints:r}}function a(t,e){var r=t.geometry.coordinates;return{x:l(r[0]),y:c(r[1]),zoom:1/0,id:e,parentId:-1}}function o(t){return{type:"Feature",properties:s(t),geometry:{type:"Point",coordinates:[function(t){return 360*(t-.5)}(t.x),function(t){var e=(180-360*t)*Math.PI/180;return 360*Math.atan(Math.exp(e))/Math.PI-90}(t.y)]}}}function s(t){var e=t.numPoints,r=e>=1e4?Math.round(e/1e3)+"k":e>=1e3?Math.round(e/100)/10+"k":e;return u(u({},t.properties),{cluster:!0,cluster_id:t.id,point_count:e,point_count_abbreviated:r})}function l(t){return t/360+.5}function c(t){var e=Math.sin(t*Math.PI/180),r=.5-.25*Math.log((1+e)/(1-e))/Math.PI;return r<0?0:r>1?1:r}function u(t,e){for(var r in e)t[r]=e[r];return t}function f(t){return t.x}function h(t){return t.y}var p=t("kdbush");e.exports=function(t){return new n(t)},n.prototype={options:{minZoom:0,maxZoom:16,radius:40,extent:512,nodeSize:64,log:!1,reduce:null,initial:function(){return{}},map:function(t){return t}},load:function(t){var e=this.options.log;e&&console.time("total time");var r="prepare "+t.length+" points";e&&console.time(r),this.points=t;var n=t.map(a);e&&console.timeEnd(r);for(var i=this.options.maxZoom;i>=this.options.minZoom;i--){var o=+Date.now();this.trees[i+1]=p(n,f,h,this.options.nodeSize,Float32Array),n=this._cluster(n,i),e&&console.log("z%d: %d clusters in %dms",i,n.length,+Date.now()-o)}return this.trees[this.options.minZoom]=p(n,f,h,this.options.nodeSize,Float32Array),e&&console.timeEnd("total time"),this},getClusters:function(t,e){for(var r=this.trees[this._limitZoom(e)],n=r.range(l(t[0]),c(t[3]),l(t[2]),c(t[1])),i=[],a=0;a0)for(var r=this.length>>1;r>=0;r--)this._down(r)}function i(t,e){return te?1:0}e.exports=n,n.prototype={push:function(t){this.data.push(t),this.length++,this._up(this.length-1)},pop:function(){if(0!==this.length){var t=this.data[0];return this.length--,this.length>0&&(this.data[0]=this.data[this.length],this._down(0)),this.data.pop(),t}},peek:function(){return this.data[0]},_up:function(t){for(var e=this.data,r=this.compare,n=e[t];t>0;){var i=t-1>>1,a=e[i];if(r(n,a)>=0)break;e[t]=a,t=i}e[t]=n},_down:function(t){for(var e=this.data,r=this.compare,n=this.length,i=n>>1,a=e[t];t=0)break;e[t]=l,t=o}e[t]=a}}},{}],34:[function(t,e,r){function n(t){var e=new f;return function(t,e){for(var r in t.layers)e.writeMessage(3,i,t.layers[r])}(t,e),e.finish()}function i(t,e){e.writeVarintField(15,t.version||1),e.writeStringField(1,t.name||""),e.writeVarintField(5,t.extent||4096);var r,n={keys:[],values:[],keycache:{},valuecache:{}};for(r=0;r>31}function c(t,e){for(var r=t.loadGeometry(),n=t.type,i=0,a=0,o=r.length,c=0;c=u||f<0||f>=u)){var h=r.segments.prepareSegment(4,r.layoutVertexArray,r.indexArray),p=h.vertexLength;n(r.layoutVertexArray,c,f,-1,-1),n(r.layoutVertexArray,c,f,1,-1),n(r.layoutVertexArray,c,f,1,1),n(r.layoutVertexArray,c,f,-1,1),r.indexArray.emplaceBack(p,p+1,p+2),r.indexArray.emplaceBack(p,p+3,p+2),h.vertexLength+=4,h.primitiveLength+=2}}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,t)},f("CircleBucket",h,{omit:["layers"]}),e.exports=h},{"../../util/web_worker_transfer":278,"../array_types":39,"../extent":53,"../index_array_type":55,"../load_geometry":56,"../program_configuration":58,"../segment":60,"./circle_attributes":41}],43:[function(t,e,r){arguments[4][41][0].apply(r,arguments)},{"../../util/struct_array":271,dup:41}],44:[function(t,e,r){var n=t("../array_types").FillLayoutArray,i=t("./fill_attributes").members,a=t("../segment").SegmentVector,o=t("../program_configuration").ProgramConfigurationSet,s=t("../index_array_type"),l=s.LineIndexArray,c=s.TriangleIndexArray,u=t("../load_geometry"),f=t("earcut"),h=t("../../util/classify_rings"),p=t("../../util/web_worker_transfer").register,d=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new n,this.indexArray=new c,this.indexArray2=new l,this.programConfigurations=new o(i,t.layers,t.zoom),this.segments=new a,this.segments2=new a};d.prototype.populate=function(t,e){for(var r=this,n=0,i=t;nd)||t.y===e.y&&(t.y<0||t.y>d)}function a(t){return t.every(function(t){return t.x<0})||t.every(function(t){return t.x>d})||t.every(function(t){return t.y<0})||t.every(function(t){return t.y>d})}var o=t("../array_types").FillExtrusionLayoutArray,s=t("./fill_extrusion_attributes").members,l=t("../segment"),c=l.SegmentVector,u=l.MAX_VERTEX_ARRAY_LENGTH,f=t("../program_configuration").ProgramConfigurationSet,h=t("../index_array_type").TriangleIndexArray,p=t("../load_geometry"),d=t("../extent"),g=t("earcut"),m=t("../../util/classify_rings"),v=t("../../util/web_worker_transfer").register,y=Math.pow(2,13),x=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new o,this.indexArray=new h,this.programConfigurations=new f(s,t.layers,t.zoom),this.segments=new c};x.prototype.populate=function(t,e){for(var r=this,n=0,i=t;n=1){var w=y[b-1];if(!i(_,w)){p.vertexLength+4>u&&(p=r.segments.prepareSegment(4,r.layoutVertexArray,r.indexArray));var k=_.sub(w)._perp()._unit(),M=w.dist(_);x+M>32768&&(x=0),n(r.layoutVertexArray,_.x,_.y,k.x,k.y,0,0,x),n(r.layoutVertexArray,_.x,_.y,k.x,k.y,0,1,x),x+=M,n(r.layoutVertexArray,w.x,w.y,k.x,k.y,0,0,x),n(r.layoutVertexArray,w.x,w.y,k.x,k.y,0,1,x);var A=p.vertexLength;r.indexArray.emplaceBack(A,A+1,A+2),r.indexArray.emplaceBack(A+1,A+2,A+3),p.vertexLength+=4,p.primitiveLength+=2}}}}p.vertexLength+c>u&&(p=r.segments.prepareSegment(c,r.layoutVertexArray,r.indexArray));for(var T=[],S=[],C=p.vertexLength,E=0,L=l;E>6)}var i=t("../array_types").LineLayoutArray,a=t("./line_attributes").members,o=t("../segment").SegmentVector,s=t("../program_configuration").ProgramConfigurationSet,l=t("../index_array_type").TriangleIndexArray,c=t("../load_geometry"),u=t("../extent"),f=t("@mapbox/vector-tile").VectorTileFeature.types,h=t("../../util/web_worker_transfer").register,p=63,d=Math.cos(Math.PI/180*37.5),g=.5,m=Math.pow(2,14)/g,v=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new i,this.indexArray=new l,this.programConfigurations=new s(a,t.layers,t.zoom),this.segments=new o};v.prototype.populate=function(t,e){for(var r=this,n=0,i=t;n=2&&t[l-1].equals(t[l-2]);)l--;for(var c=0;cc){var z=m.dist(w);if(z>2*h){var P=m.sub(m.sub(w)._mult(h/z)._round());o.distance+=P.dist(w),o.addCurrentVertex(P,o.distance,M.mult(1),0,0,!1,g),w=P}}var D=w&&k,O=D?r:k?x:b;if(D&&"round"===O&&(Ei&&(O="bevel"),"bevel"===O&&(E>2&&(O="flipbevel"),E100)S=A.clone().mult(-1);else{var I=M.x*A.y-M.y*A.x>0?-1:1,R=E*M.add(A).mag()/M.sub(A).mag();S._perp()._mult(R*I)}o.addCurrentVertex(m,o.distance,S,0,0,!1,g),o.addCurrentVertex(m,o.distance,S.mult(-1),0,0,!1,g)}else if("bevel"===O||"fakeround"===O){var B=M.x*A.y-M.y*A.x>0,F=-Math.sqrt(E*E-1);if(B?(y=0,v=F):(v=0,y=F),_||o.addCurrentVertex(m,o.distance,M,v,y,!1,g),"fakeround"===O){for(var N=Math.floor(8*(.5-(C-.5))),j=void 0,V=0;V=0;U--)j=M.mult((U+1)/(N+1))._add(A)._unit(),o.addPieSliceVertex(m,o.distance,j,B,g)}k&&o.addCurrentVertex(m,o.distance,A,-v,-y,!1,g)}else"butt"===O?(_||o.addCurrentVertex(m,o.distance,M,0,0,!1,g),k&&o.addCurrentVertex(m,o.distance,A,0,0,!1,g)):"square"===O?(_||(o.addCurrentVertex(m,o.distance,M,1,1,!1,g),o.e1=o.e2=-1),k&&o.addCurrentVertex(m,o.distance,A,-1,-1,!1,g)):"round"===O&&(_||(o.addCurrentVertex(m,o.distance,M,0,0,!1,g),o.addCurrentVertex(m,o.distance,M,1,1,!0,g),o.e1=o.e2=-1),k&&(o.addCurrentVertex(m,o.distance,A,-1,-1,!0,g),o.addCurrentVertex(m,o.distance,A,0,0,!1,g)));if(L&&T2*h){var H=m.add(k.sub(m)._mult(h/q)._round());o.distance+=H.dist(m),o.addCurrentVertex(H,o.distance,A.mult(1),0,0,!1,g),m=H}}_=!1}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,e)}},v.prototype.addCurrentVertex=function(t,e,r,i,a,o,s){var l,c=this.layoutVertexArray,u=this.indexArray;l=r.clone(),i&&l._sub(r.perp()._mult(i)),n(c,t,l,o,!1,i,e),this.e3=s.vertexLength++,this.e1>=0&&this.e2>=0&&(u.emplaceBack(this.e1,this.e2,this.e3),s.primitiveLength++),this.e1=this.e2,this.e2=this.e3,l=r.mult(-1),a&&l._sub(r.perp()._mult(a)),n(c,t,l,o,!0,-a,e),this.e3=s.vertexLength++,this.e1>=0&&this.e2>=0&&(u.emplaceBack(this.e1,this.e2,this.e3),s.primitiveLength++),this.e1=this.e2,this.e2=this.e3,e>m/2&&(this.distance=0,this.addCurrentVertex(t,this.distance,r,i,a,o,s))},v.prototype.addPieSliceVertex=function(t,e,r,i,a){r=r.mult(i?-1:1);var o=this.layoutVertexArray,s=this.indexArray;n(o,t,r,!1,i,0,e),this.e3=a.vertexLength++,this.e1>=0&&this.e2>=0&&(s.emplaceBack(this.e1,this.e2,this.e3),a.primitiveLength++),i?this.e2=this.e3:this.e1=this.e3},h("LineBucket",v,{omit:["layers"]}),e.exports=v},{"../../util/web_worker_transfer":278,"../array_types":39,"../extent":53,"../index_array_type":55,"../load_geometry":56,"../program_configuration":58,"../segment":60,"./line_attributes":48,"@mapbox/vector-tile":8}],50:[function(t,e,r){var n=t("../../util/struct_array").createLayout,i={symbolLayoutAttributes:n([{name:"a_pos_offset",components:4,type:"Int16"},{name:"a_data",components:4,type:"Uint16"}]),dynamicLayoutAttributes:n([{name:"a_projected_pos",components:3,type:"Float32"}],4),placementOpacityAttributes:n([{name:"a_fade_opacity",components:1,type:"Uint32"}],4),collisionVertexAttributes:n([{name:"a_placed",components:2,type:"Uint8"}],4),collisionBox:n([{type:"Int16",name:"anchorPointX"},{type:"Int16",name:"anchorPointY"},{type:"Int16",name:"x1"},{type:"Int16",name:"y1"},{type:"Int16",name:"x2"},{type:"Int16",name:"y2"},{type:"Uint32",name:"featureIndex"},{type:"Uint16",name:"sourceLayerIndex"},{type:"Uint16",name:"bucketIndex"},{type:"Int16",name:"radius"},{type:"Int16",name:"signedDistanceFromAnchor"}]),collisionBoxLayout:n([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4),collisionCircleLayout:n([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4),placement:n([{type:"Int16",name:"anchorX"},{type:"Int16",name:"anchorY"},{type:"Uint16",name:"glyphStartIndex"},{type:"Uint16",name:"numGlyphs"},{type:"Uint32",name:"vertexStartIndex"},{type:"Uint32",name:"lineStartIndex"},{type:"Uint32",name:"lineLength"},{type:"Uint16",name:"segment"},{type:"Uint16",name:"lowerSize"},{type:"Uint16",name:"upperSize"},{type:"Float32",name:"lineOffsetX"},{type:"Float32",name:"lineOffsetY"},{type:"Uint8",name:"writingMode"},{type:"Uint8",name:"hidden"}]),glyphOffset:n([{type:"Float32",name:"offsetX"}]),lineVertex:n([{type:"Int16",name:"x"},{type:"Int16",name:"y"},{type:"Int16",name:"tileUnitDistanceFromAnchor"}])};e.exports=i},{"../../util/struct_array":271}],51:[function(t,e,r){function n(t,e,r,n,i,a,o,s){t.emplaceBack(e,r,Math.round(64*n),Math.round(64*i),a,o,s?s[0]:0,s?s[1]:0)}function i(t,e,r){t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r)}var a=t("./symbol_attributes"),o=a.symbolLayoutAttributes,s=a.collisionVertexAttributes,l=a.collisionBoxLayout,c=a.collisionCircleLayout,u=a.dynamicLayoutAttributes,f=t("../array_types"),h=f.SymbolLayoutArray,p=f.SymbolDynamicLayoutArray,d=f.SymbolOpacityArray,g=f.CollisionBoxLayoutArray,m=f.CollisionCircleLayoutArray,v=f.CollisionVertexArray,y=f.PlacedSymbolArray,x=f.GlyphOffsetArray,b=f.SymbolLineVertexArray,_=t("@mapbox/point-geometry"),w=t("../segment").SegmentVector,k=t("../program_configuration").ProgramConfigurationSet,M=t("../index_array_type"),A=M.TriangleIndexArray,T=M.LineIndexArray,S=t("../../symbol/transform_text"),C=t("../../symbol/mergelines"),E=t("../../util/script_detection"),L=t("../load_geometry"),z=t("@mapbox/vector-tile").VectorTileFeature.types,P=t("../../util/verticalize_punctuation"),D=(t("../../symbol/anchor"),t("../../symbol/symbol_size").getSizeData),O=t("../../util/web_worker_transfer").register,I=[{name:"a_fade_opacity",components:1,type:"Uint8",offset:0}],R=function(t){this.layoutVertexArray=new h,this.indexArray=new A,this.programConfigurations=t,this.segments=new w,this.dynamicLayoutVertexArray=new p,this.opacityVertexArray=new d,this.placedSymbolArray=new y};R.prototype.upload=function(t,e){this.layoutVertexBuffer=t.createVertexBuffer(this.layoutVertexArray,o.members),this.indexBuffer=t.createIndexBuffer(this.indexArray,e),this.programConfigurations.upload(t),this.dynamicLayoutVertexBuffer=t.createVertexBuffer(this.dynamicLayoutVertexArray,u.members,!0),this.opacityVertexBuffer=t.createVertexBuffer(this.opacityVertexArray,I,!0),this.opacityVertexBuffer.itemSize=1},R.prototype.destroy=function(){this.layoutVertexBuffer&&(this.layoutVertexBuffer.destroy(),this.indexBuffer.destroy(),this.programConfigurations.destroy(),this.segments.destroy(),this.dynamicLayoutVertexBuffer.destroy(),this.opacityVertexBuffer.destroy())},O("SymbolBuffers",R);var B=function(t,e,r){this.layoutVertexArray=new t,this.layoutAttributes=e,this.indexArray=new r,this.segments=new w,this.collisionVertexArray=new v};B.prototype.upload=function(t){this.layoutVertexBuffer=t.createVertexBuffer(this.layoutVertexArray,this.layoutAttributes),this.indexBuffer=t.createIndexBuffer(this.indexArray),this.collisionVertexBuffer=t.createVertexBuffer(this.collisionVertexArray,s.members,!0)},B.prototype.destroy=function(){this.layoutVertexBuffer&&(this.layoutVertexBuffer.destroy(),this.indexBuffer.destroy(),this.segments.destroy(),this.collisionVertexBuffer.destroy())},O("CollisionBuffers",B);var F=function(t){this.collisionBoxArray=t.collisionBoxArray,this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.pixelRatio=t.pixelRatio;var e=this.layers[0]._unevaluatedLayout._values;this.textSizeData=D(this.zoom,e["text-size"]),this.iconSizeData=D(this.zoom,e["icon-size"]);var r=this.layers[0].layout;this.sortFeaturesByY=r.get("text-allow-overlap")||r.get("icon-allow-overlap")||r.get("text-ignore-placement")||r.get("icon-ignore-placement")};F.prototype.createArrays=function(){this.text=new R(new k(o.members,this.layers,this.zoom,function(t){return/^text/.test(t)})),this.icon=new R(new k(o.members,this.layers,this.zoom,function(t){return/^icon/.test(t)})),this.collisionBox=new B(g,l.members,T),this.collisionCircle=new B(m,c.members,A),this.glyphOffsetArray=new x,this.lineVertexArray=new b},F.prototype.populate=function(t,e){var r=this.layers[0],n=r.layout,i=n.get("text-font"),a=n.get("text-field"),o=n.get("icon-image"),s=("constant"!==a.value.kind||a.value.value.length>0)&&("constant"!==i.value.kind||i.value.value.length>0),l="constant"!==o.value.kind||o.value.value&&o.value.value.length>0;if(this.features=[],s||l){for(var c=e.iconDependencies,u=e.glyphDependencies,f={zoom:this.zoom},h=0,p=t;h=0;s--)a[s]={x:e[s].x,y:e[s].y,tileUnitDistanceFromAnchor:i},s>0&&(i+=e[s-1].dist(e[s]));for(var l=0;l0;t.addCollisionDebugVertices(l,c,u,f,h?t.collisionCircle:t.collisionBox,s.anchorPoint,n,h)}}}},F.prototype.deserializeCollisionBoxes=function(t,e,r,n,i){for(var a={},o=e;o0},F.prototype.hasIconData=function(){return this.icon.segments.get().length>0},F.prototype.hasCollisionBoxData=function(){return this.collisionBox.segments.get().length>0},F.prototype.hasCollisionCircleData=function(){return this.collisionCircle.segments.get().length>0},F.prototype.sortFeatures=function(t){var e=this;if(this.sortFeaturesByY&&this.sortedAngle!==t&&(this.sortedAngle=t,!(this.text.segments.get().length>1||this.icon.segments.get().length>1))){for(var r=[],n=0;n=this.dim+this.border||e<-this.border||e>=this.dim+this.border)throw new RangeError("out of range source coordinates for DEM data");return(e+this.border)*this.stride+(t+this.border)},a("Level",o);var s=function(t,e,r){this.uid=t,this.scale=e||1,this.level=r||new o(256,512),this.loaded=!!r};s.prototype.loadFromImage=function(t){if(t.height!==t.width)throw new RangeError("DEM tiles must be square");for(var e=this.level=new o(t.width,t.width/2),r=t.data,n=0;no.max||c.yo.max)&&i.warnOnce("Geometry exceeds allowed extent, reduce your vector tile buffer size")}return r}},{"../util/util":275,"./extent":53}],57:[function(t,e,r){var n=t("../util/struct_array").createLayout;e.exports=n([{name:"a_pos",type:"Int16",components:2}])},{"../util/struct_array":271}],58:[function(t,e,r){function n(t){return[a(255*t.r,255*t.g),a(255*t.b,255*t.a)]}function i(t,e){return{"text-opacity":"opacity","icon-opacity":"opacity","text-color":"fill_color","icon-color":"fill_color","text-halo-color":"halo_color","icon-halo-color":"halo_color","text-halo-blur":"halo_blur","icon-halo-blur":"halo_blur","text-halo-width":"halo_width","icon-halo-width":"halo_width","line-gap-width":"gapwidth"}[t]||t.replace(e+"-","").replace(/-/g,"_")}var a=t("../shaders/encode_attribute").packUint8ToFloat,o=(t("../style-spec/util/color"),t("../util/web_worker_transfer").register),s=t("../style/properties").PossiblyEvaluatedPropertyValue,l=t("./array_types"),c=l.StructArrayLayout1f4,u=l.StructArrayLayout2f8,f=l.StructArrayLayout4f16,h=function(t,e,r){this.value=t,this.name=e,this.type=r,this.statistics={max:-1/0}};h.prototype.defines=function(){return["#define HAS_UNIFORM_u_"+this.name]},h.prototype.populatePaintArray=function(){},h.prototype.upload=function(){},h.prototype.destroy=function(){},h.prototype.setUniforms=function(t,e,r,n){var i=n.constantOr(this.value),a=t.gl;"color"===this.type?a.uniform4f(e.uniforms["u_"+this.name],i.r,i.g,i.b,i.a):a.uniform1f(e.uniforms["u_"+this.name],i)};var p=function(t,e,r){this.expression=t,this.name=e,this.type=r,this.statistics={max:-1/0};var n="color"===r?u:c;this.paintVertexAttributes=[{name:"a_"+e,type:"Float32",components:"color"===r?2:1,offset:0}],this.paintVertexArray=new n};p.prototype.defines=function(){return[]},p.prototype.populatePaintArray=function(t,e){var r=this.paintVertexArray,i=r.length;r.reserve(t);var a=this.expression.evaluate({zoom:0},e);if("color"===this.type)for(var o=n(a),s=i;sa&&n("Max vertices per segment is "+a+": bucket requested "+t),(!o||o.vertexLength+t>e.exports.MAX_VERTEX_ARRAY_LENGTH)&&(o={vertexOffset:r.length,primitiveOffset:i.length,vertexLength:0,primitiveLength:0},this.segments.push(o)),o},o.prototype.get=function(){return this.segments},o.prototype.destroy=function(){for(var t=0,e=this.segments;t90||this.lat<-90)throw new Error("Invalid LngLat latitude value: must be between -90 and 90")};i.prototype.wrap=function(){return new i(n(this.lng,-180,180),this.lat)},i.prototype.toArray=function(){return[this.lng,this.lat]},i.prototype.toString=function(){return"LngLat("+this.lng+", "+this.lat+")"},i.prototype.toBounds=function(e){var r=360*e/40075017,n=r/Math.cos(Math.PI/180*this.lat);return new(t("./lng_lat_bounds"))(new i(this.lng-n,this.lat-r),new i(this.lng+n,this.lat+r))},i.convert=function(t){if(t instanceof i)return t;if(Array.isArray(t)&&(2===t.length||3===t.length))return new i(Number(t[0]),Number(t[1]));if(!Array.isArray(t)&&"object"==typeof t&&null!==t)return new i(Number(t.lng),Number(t.lat));throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: , lat: }, or an array of [, ]")},e.exports=i},{"../util/util":275,"./lng_lat_bounds":63}],63:[function(t,e,r){var n=t("./lng_lat"),i=function(t,e){t&&(e?this.setSouthWest(t).setNorthEast(e):4===t.length?this.setSouthWest([t[0],t[1]]).setNorthEast([t[2],t[3]]):this.setSouthWest(t[0]).setNorthEast(t[1]))};i.prototype.setNorthEast=function(t){return this._ne=t instanceof n?new n(t.lng,t.lat):n.convert(t),this},i.prototype.setSouthWest=function(t){return this._sw=t instanceof n?new n(t.lng,t.lat):n.convert(t),this},i.prototype.extend=function(t){var e,r,a=this._sw,o=this._ne;if(t instanceof n)e=t,r=t;else{if(!(t instanceof i))return Array.isArray(t)?t.every(Array.isArray)?this.extend(i.convert(t)):this.extend(n.convert(t)):this;if(e=t._sw,r=t._ne,!e||!r)return this}return a||o?(a.lng=Math.min(e.lng,a.lng),a.lat=Math.min(e.lat,a.lat),o.lng=Math.max(r.lng,o.lng),o.lat=Math.max(r.lat,o.lat)):(this._sw=new n(e.lng,e.lat),this._ne=new n(r.lng,r.lat)),this},i.prototype.getCenter=function(){return new n((this._sw.lng+this._ne.lng)/2,(this._sw.lat+this._ne.lat)/2)},i.prototype.getSouthWest=function(){return this._sw},i.prototype.getNorthEast=function(){return this._ne},i.prototype.getNorthWest=function(){return new n(this.getWest(),this.getNorth())},i.prototype.getSouthEast=function(){return new n(this.getEast(),this.getSouth())},i.prototype.getWest=function(){return this._sw.lng},i.prototype.getSouth=function(){return this._sw.lat},i.prototype.getEast=function(){return this._ne.lng},i.prototype.getNorth=function(){return this._ne.lat},i.prototype.toArray=function(){return[this._sw.toArray(),this._ne.toArray()]},i.prototype.toString=function(){return"LngLatBounds("+this._sw.toString()+", "+this._ne.toString()+")"},i.prototype.isEmpty=function(){return!(this._sw&&this._ne)},i.convert=function(t){return!t||t instanceof i?t:new i(t)},e.exports=i},{"./lng_lat":62}],64:[function(t,e,r){var n=t("./lng_lat"),i=t("@mapbox/point-geometry"),a=t("./coordinate"),o=t("../util/util"),s=t("../style-spec/util/interpolate").number,l=t("../util/tile_cover"),c=t("../source/tile_id"),u=(c.CanonicalTileID,c.UnwrappedTileID),f=t("../data/extent"),h=t("@mapbox/gl-matrix"),p=h.vec4,d=h.mat4,g=h.mat2,m=function(t,e,r){this.tileSize=512,this._renderWorldCopies=void 0===r||r,this._minZoom=t||0,this._maxZoom=e||22,this.latRange=[-85.05113,85.05113],this.width=0,this.height=0,this._center=new n(0,0),this.zoom=0,this.angle=0,this._fov=.6435011087932844,this._pitch=0,this._unmodified=!0,this._posMatrixCache={},this._alignedPosMatrixCache={}},v={minZoom:{},maxZoom:{},renderWorldCopies:{},worldSize:{},centerPoint:{},size:{},bearing:{},pitch:{},fov:{},zoom:{},center:{},unmodified:{},x:{},y:{},point:{}};m.prototype.clone=function(){var t=new m(this._minZoom,this._maxZoom,this._renderWorldCopies);return t.tileSize=this.tileSize,t.latRange=this.latRange,t.width=this.width,t.height=this.height,t._center=this._center,t.zoom=this.zoom,t.angle=this.angle,t._fov=this._fov,t._pitch=this._pitch,t._unmodified=this._unmodified,t._calcMatrices(),t},v.minZoom.get=function(){return this._minZoom},v.minZoom.set=function(t){this._minZoom!==t&&(this._minZoom=t,this.zoom=Math.max(this.zoom,t))},v.maxZoom.get=function(){return this._maxZoom},v.maxZoom.set=function(t){this._maxZoom!==t&&(this._maxZoom=t,this.zoom=Math.min(this.zoom,t))},v.renderWorldCopies.get=function(){return this._renderWorldCopies},v.worldSize.get=function(){return this.tileSize*this.scale},v.centerPoint.get=function(){return this.size._div(2)},v.size.get=function(){return new i(this.width,this.height)},v.bearing.get=function(){return-this.angle/Math.PI*180},v.bearing.set=function(t){var e=-o.wrap(t,-180,180)*Math.PI/180;this.angle!==e&&(this._unmodified=!1,this.angle=e,this._calcMatrices(),this.rotationMatrix=g.create(),g.rotate(this.rotationMatrix,this.rotationMatrix,this.angle))},v.pitch.get=function(){return this._pitch/Math.PI*180},v.pitch.set=function(t){var e=o.clamp(t,0,60)/180*Math.PI;this._pitch!==e&&(this._unmodified=!1,this._pitch=e,this._calcMatrices())},v.fov.get=function(){return this._fov/Math.PI*180},v.fov.set=function(t){t=Math.max(.01,Math.min(60,t)),this._fov!==t&&(this._unmodified=!1,this._fov=t/180*Math.PI,this._calcMatrices())},v.zoom.get=function(){return this._zoom},v.zoom.set=function(t){var e=Math.min(Math.max(t,this.minZoom),this.maxZoom);this._zoom!==e&&(this._unmodified=!1,this._zoom=e,this.scale=this.zoomScale(e),this.tileZoom=Math.floor(e),this.zoomFraction=e-this.tileZoom,this._constrain(),this._calcMatrices())},v.center.get=function(){return this._center},v.center.set=function(t){t.lat===this._center.lat&&t.lng===this._center.lng||(this._unmodified=!1,this._center=t,this._constrain(),this._calcMatrices())},m.prototype.coveringZoomLevel=function(t){return(t.roundZoom?Math.round:Math.floor)(this.zoom+this.scaleZoom(this.tileSize/t.tileSize))},m.prototype.getVisibleUnwrappedCoordinates=function(t){var e=this.pointCoordinate(new i(0,0),0),r=this.pointCoordinate(new i(this.width,0),0),n=Math.floor(e.column),a=Math.floor(r.column),o=[new u(0,t)];if(this._renderWorldCopies)for(var s=n;s<=a;s++)0!==s&&o.push(new u(s,t));return o},m.prototype.coveringTiles=function(t){var e=this.coveringZoomLevel(t),r=e;if(void 0!==t.minzoom&&et.maxzoom&&(e=t.maxzoom);var n=this.pointCoordinate(this.centerPoint,e),a=new i(n.column-.5,n.row-.5),o=[this.pointCoordinate(new i(0,0),e),this.pointCoordinate(new i(this.width,0),e),this.pointCoordinate(new i(this.width,this.height),e),this.pointCoordinate(new i(0,this.height),e)];return l(e,o,t.reparseOverscaled?r:e,this._renderWorldCopies).sort(function(t,e){return a.dist(t.canonical)-a.dist(e.canonical)})},m.prototype.resize=function(t,e){this.width=t,this.height=e,this.pixelsToGLUnits=[2/t,-2/e],this._constrain(),this._calcMatrices()},v.unmodified.get=function(){return this._unmodified},m.prototype.zoomScale=function(t){return Math.pow(2,t)},m.prototype.scaleZoom=function(t){return Math.log(t)/Math.LN2},m.prototype.project=function(t){return new i(this.lngX(t.lng),this.latY(t.lat))},m.prototype.unproject=function(t){return new n(this.xLng(t.x),this.yLat(t.y))},v.x.get=function(){return this.lngX(this.center.lng)},v.y.get=function(){return this.latY(this.center.lat)},v.point.get=function(){return new i(this.x,this.y)},m.prototype.lngX=function(t){return(180+t)*this.worldSize/360},m.prototype.latY=function(t){return(180-180/Math.PI*Math.log(Math.tan(Math.PI/4+t*Math.PI/360)))*this.worldSize/360},m.prototype.xLng=function(t){return 360*t/this.worldSize-180},m.prototype.yLat=function(t){var e=180-360*t/this.worldSize;return 360/Math.PI*Math.atan(Math.exp(e*Math.PI/180))-90},m.prototype.setLocationAtPoint=function(t,e){var r=this.pointCoordinate(e)._sub(this.pointCoordinate(this.centerPoint));this.center=this.coordinateLocation(this.locationCoordinate(t)._sub(r)),this._renderWorldCopies&&(this.center=this.center.wrap())},m.prototype.locationPoint=function(t){return this.coordinatePoint(this.locationCoordinate(t))},m.prototype.pointLocation=function(t){return this.coordinateLocation(this.pointCoordinate(t))},m.prototype.locationCoordinate=function(t){return new a(this.lngX(t.lng)/this.tileSize,this.latY(t.lat)/this.tileSize,this.zoom).zoomTo(this.tileZoom)},m.prototype.coordinateLocation=function(t){var e=t.zoomTo(this.zoom);return new n(this.xLng(e.column*this.tileSize),this.yLat(e.row*this.tileSize))},m.prototype.pointCoordinate=function(t,e){void 0===e&&(e=this.tileZoom);var r=[t.x,t.y,0,1],n=[t.x,t.y,1,1];p.transformMat4(r,r,this.pixelMatrixInverse),p.transformMat4(n,n,this.pixelMatrixInverse);var i=r[3],o=n[3],l=r[1]/i,c=n[1]/o,u=r[2]/i,f=n[2]/o,h=u===f?0:(0-u)/(f-u);return new a(s(r[0]/i,n[0]/o,h)/this.tileSize,s(l,c,h)/this.tileSize,this.zoom)._zoomTo(e)},m.prototype.coordinatePoint=function(t){var e=t.zoomTo(this.zoom),r=[e.column*this.tileSize,e.row*this.tileSize,0,1];return p.transformMat4(r,r,this.pixelMatrix),new i(r[0]/r[3],r[1]/r[3])},m.prototype.calculatePosMatrix=function(t,e){void 0===e&&(e=!1);var r=t.key,n=e?this._alignedPosMatrixCache:this._posMatrixCache;if(n[r])return n[r];var i=t.canonical,a=this.worldSize/this.zoomScale(i.z),o=i.x+Math.pow(2,i.z)*t.wrap,s=d.identity(new Float64Array(16));return d.translate(s,s,[o*a,i.y*a,0]),d.scale(s,s,[a/f,a/f,1]),d.multiply(s,e?this.alignedProjMatrix:this.projMatrix,s),n[r]=new Float32Array(s),n[r]},m.prototype._constrain=function(){if(this.center&&this.width&&this.height&&!this._constraining){this._constraining=!0;var t,e,r,n,a=-90,o=90,s=-180,l=180,c=this.size,u=this._unmodified;if(this.latRange){var f=this.latRange;a=this.latY(f[1]),t=(o=this.latY(f[0]))-ao&&(n=o-g)}if(this.lngRange){var m=this.x,v=c.x/2;m-vl&&(r=l-v)}void 0===r&&void 0===n||(this.center=this.unproject(new i(void 0!==r?r:this.x,void 0!==n?n:this.y))),this._unmodified=u,this._constraining=!1}},m.prototype._calcMatrices=function(){if(this.height){this.cameraToCenterDistance=.5/Math.tan(this._fov/2)*this.height;var t=this._fov/2,e=Math.PI/2+this._pitch,r=Math.sin(t)*this.cameraToCenterDistance/Math.sin(Math.PI-e-t),n=this.x,i=this.y,a=1.01*(Math.cos(Math.PI/2-this._pitch)*r+this.cameraToCenterDistance),o=new Float64Array(16);d.perspective(o,this._fov,this.width/this.height,1,a),d.scale(o,o,[1,-1,1]),d.translate(o,o,[0,0,-this.cameraToCenterDistance]),d.rotateX(o,o,this._pitch),d.rotateZ(o,o,this.angle),d.translate(o,o,[-n,-i,0]);var s=this.worldSize/(2*Math.PI*6378137*Math.abs(Math.cos(this.center.lat*(Math.PI/180))));d.scale(o,o,[1,1,s,1]),this.projMatrix=o;var l=this.width%2/2,c=this.height%2/2,u=Math.cos(this.angle),f=Math.sin(this.angle),h=n-Math.round(n)+u*l+f*c,p=i-Math.round(i)+u*c+f*l,g=new Float64Array(o);if(d.translate(g,g,[h>.5?h-1:h,p>.5?p-1:p,0]),this.alignedProjMatrix=g,o=d.create(),d.scale(o,o,[this.width/2,-this.height/2,1]),d.translate(o,o,[1,-1,0]),this.pixelMatrix=d.multiply(new Float64Array(16),o,this.projMatrix),!(o=d.invert(new Float64Array(16),this.pixelMatrix)))throw new Error("failed to invert matrix");this.pixelMatrixInverse=o,this._posMatrixCache={},this._alignedPosMatrixCache={}}},Object.defineProperties(m.prototype,v),e.exports=m},{"../data/extent":53,"../source/tile_id":114,"../style-spec/util/interpolate":158,"../util/tile_cover":273,"../util/util":275,"./coordinate":61,"./lng_lat":62,"@mapbox/gl-matrix":2,"@mapbox/point-geometry":4}],65:[function(t,e,r){var n=t("../style-spec/util/color"),i=function(t,e,r){this.blendFunction=t,this.blendColor=e,this.mask=r};i.disabled=new i(i.Replace=[1,0],n.transparent,[!1,!1,!1,!1]),i.unblended=new i(i.Replace,n.transparent,[!0,!0,!0,!0]),i.alphaBlended=new i([1,771],n.transparent,[!0,!0,!0,!0]),e.exports=i},{"../style-spec/util/color":153}],66:[function(t,e,r){var n=t("./index_buffer"),i=t("./vertex_buffer"),a=t("./framebuffer"),o=(t("./depth_mode"),t("./stencil_mode"),t("./color_mode")),s=t("../util/util"),l=t("./value"),c=l.ClearColor,u=l.ClearDepth,f=l.ClearStencil,h=l.ColorMask,p=l.DepthMask,d=l.StencilMask,g=l.StencilFunc,m=l.StencilOp,v=l.StencilTest,y=l.DepthRange,x=l.DepthTest,b=l.DepthFunc,_=l.Blend,w=l.BlendFunc,k=l.BlendColor,M=l.Program,A=l.LineWidth,T=l.ActiveTextureUnit,S=l.Viewport,C=l.BindFramebuffer,E=l.BindRenderbuffer,L=l.BindTexture,z=l.BindVertexBuffer,P=l.BindElementBuffer,D=l.BindVertexArrayOES,O=l.PixelStoreUnpack,I=l.PixelStoreUnpackPremultiplyAlpha,R=function(t){this.gl=t,this.extVertexArrayObject=this.gl.getExtension("OES_vertex_array_object"),this.lineWidthRange=t.getParameter(t.ALIASED_LINE_WIDTH_RANGE),this.clearColor=new c(this),this.clearDepth=new u(this),this.clearStencil=new f(this),this.colorMask=new h(this),this.depthMask=new p(this),this.stencilMask=new d(this),this.stencilFunc=new g(this),this.stencilOp=new m(this),this.stencilTest=new v(this),this.depthRange=new y(this),this.depthTest=new x(this),this.depthFunc=new b(this),this.blend=new _(this),this.blendFunc=new w(this),this.blendColor=new k(this),this.program=new M(this),this.lineWidth=new A(this),this.activeTexture=new T(this),this.viewport=new S(this),this.bindFramebuffer=new C(this),this.bindRenderbuffer=new E(this),this.bindTexture=new L(this),this.bindVertexBuffer=new z(this),this.bindElementBuffer=new P(this),this.bindVertexArrayOES=this.extVertexArrayObject&&new D(this),this.pixelStoreUnpack=new O(this),this.pixelStoreUnpackPremultiplyAlpha=new I(this),this.extTextureFilterAnisotropic=t.getExtension("EXT_texture_filter_anisotropic")||t.getExtension("MOZ_EXT_texture_filter_anisotropic")||t.getExtension("WEBKIT_EXT_texture_filter_anisotropic"),this.extTextureFilterAnisotropic&&(this.extTextureFilterAnisotropicMax=t.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)),this.extTextureHalfFloat=t.getExtension("OES_texture_half_float"),this.extTextureHalfFloat&&t.getExtension("OES_texture_half_float_linear")};R.prototype.createIndexBuffer=function(t,e){return new n(this,t,e)},R.prototype.createVertexBuffer=function(t,e,r){return new i(this,t,e,r)},R.prototype.createRenderbuffer=function(t,e,r){var n=this.gl,i=n.createRenderbuffer();return this.bindRenderbuffer.set(i),n.renderbufferStorage(n.RENDERBUFFER,t,e,r),this.bindRenderbuffer.set(null),i},R.prototype.createFramebuffer=function(t,e){return new a(this,t,e)},R.prototype.clear=function(t){var e=t.color,r=t.depth,n=this.gl,i=0;e&&(i|=n.COLOR_BUFFER_BIT,this.clearColor.set(e),this.colorMask.set([!0,!0,!0,!0])),void 0!==r&&(i|=n.DEPTH_BUFFER_BIT,this.clearDepth.set(r),this.depthMask.set(!0)),n.clear(i)},R.prototype.setDepthMode=function(t){t.func!==this.gl.ALWAYS||t.mask?(this.depthTest.set(!0),this.depthFunc.set(t.func),this.depthMask.set(t.mask),this.depthRange.set(t.range)):this.depthTest.set(!1)},R.prototype.setStencilMode=function(t){t.func!==this.gl.ALWAYS||t.mask?(this.stencilTest.set(!0),this.stencilMask.set(t.mask),this.stencilOp.set([t.fail,t.depthFail,t.pass]),this.stencilFunc.set({func:t.test.func,ref:t.ref,mask:t.test.mask})):this.stencilTest.set(!1)},R.prototype.setColorMode=function(t){s.deepEqual(t.blendFunction,o.Replace)?this.blend.set(!1):(this.blend.set(!0),this.blendFunc.set(t.blendFunction),this.blendColor.set(t.blendColor)),this.colorMask.set(t.mask)},e.exports=R},{"../util/util":275,"./color_mode":65,"./depth_mode":67,"./framebuffer":68,"./index_buffer":69,"./stencil_mode":70,"./value":71,"./vertex_buffer":72}],67:[function(t,e,r){var n=function(t,e,r){this.func=t,this.mask=e,this.range=r};n.ReadOnly=!1,n.ReadWrite=!0,n.disabled=new n(519,n.ReadOnly,[0,1]),e.exports=n},{}],68:[function(t,e,r){var n=t("./value"),i=n.ColorAttachment,a=n.DepthAttachment,o=function(t,e,r){this.context=t,this.width=e,this.height=r;var n=t.gl,o=this.framebuffer=n.createFramebuffer();this.colorAttachment=new i(t,o),this.depthAttachment=new a(t,o)};o.prototype.destroy=function(){var t=this.context.gl,e=this.colorAttachment.get();e&&t.deleteTexture(e);var r=this.depthAttachment.get();r&&t.deleteRenderbuffer(r),t.deleteFramebuffer(this.framebuffer)},e.exports=o},{"./value":71}],69:[function(t,e,r){var n=function(t,e,r){this.context=t;var n=t.gl;this.buffer=n.createBuffer(),this.dynamicDraw=Boolean(r),this.unbindVAO(),t.bindElementBuffer.set(this.buffer),n.bufferData(n.ELEMENT_ARRAY_BUFFER,e.arrayBuffer,this.dynamicDraw?n.DYNAMIC_DRAW:n.STATIC_DRAW),this.dynamicDraw||delete e.arrayBuffer};n.prototype.unbindVAO=function(){this.context.extVertexArrayObject&&this.context.bindVertexArrayOES.set(null)},n.prototype.bind=function(){this.context.bindElementBuffer.set(this.buffer)},n.prototype.updateData=function(t){var e=this.context.gl;this.unbindVAO(),this.bind(),e.bufferSubData(e.ELEMENT_ARRAY_BUFFER,0,t.arrayBuffer)},n.prototype.destroy=function(){var t=this.context.gl;this.buffer&&(t.deleteBuffer(this.buffer),delete this.buffer)},e.exports=n},{}],70:[function(t,e,r){var n=function(t,e,r,n,i,a){this.test=t,this.ref=e,this.mask=r,this.fail=n,this.depthFail=i,this.pass=a};n.disabled=new n({func:519,mask:0},0,0,7680,7680,7680),e.exports=n},{}],71:[function(t,e,r){var n=t("../style-spec/util/color"),i=t("../util/util"),a=function(t){this.context=t,this.current=n.transparent};a.prototype.get=function(){return this.current},a.prototype.set=function(t){var e=this.current;t.r===e.r&&t.g===e.g&&t.b===e.b&&t.a===e.a||(this.context.gl.clearColor(t.r,t.g,t.b,t.a),this.current=t)};var o=function(t){this.context=t,this.current=1};o.prototype.get=function(){return this.current},o.prototype.set=function(t){this.current!==t&&(this.context.gl.clearDepth(t),this.current=t)};var s=function(t){this.context=t,this.current=0};s.prototype.get=function(){return this.current},s.prototype.set=function(t){this.current!==t&&(this.context.gl.clearStencil(t),this.current=t)};var l=function(t){this.context=t,this.current=[!0,!0,!0,!0]};l.prototype.get=function(){return this.current},l.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]||(this.context.gl.colorMask(t[0],t[1],t[2],t[3]),this.current=t)};var c=function(t){this.context=t,this.current=!0};c.prototype.get=function(){return this.current},c.prototype.set=function(t){this.current!==t&&(this.context.gl.depthMask(t),this.current=t)};var u=function(t){this.context=t,this.current=255};u.prototype.get=function(){return this.current},u.prototype.set=function(t){this.current!==t&&(this.context.gl.stencilMask(t),this.current=t)};var f=function(t){this.context=t,this.current={func:t.gl.ALWAYS,ref:0,mask:255}};f.prototype.get=function(){return this.current},f.prototype.set=function(t){var e=this.current;t.func===e.func&&t.ref===e.ref&&t.mask===e.mask||(this.context.gl.stencilFunc(t.func,t.ref,t.mask),this.current=t)};var h=function(t){this.context=t;var e=this.context.gl;this.current=[e.KEEP,e.KEEP,e.KEEP]};h.prototype.get=function(){return this.current},h.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]||(this.context.gl.stencilOp(t[0],t[1],t[2]),this.current=t)};var p=function(t){this.context=t,this.current=!1};p.prototype.get=function(){return this.current},p.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.STENCIL_TEST):e.disable(e.STENCIL_TEST),this.current=t}};var d=function(t){this.context=t,this.current=[0,1]};d.prototype.get=function(){return this.current},d.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]||(this.context.gl.depthRange(t[0],t[1]),this.current=t)};var g=function(t){this.context=t,this.current=!1};g.prototype.get=function(){return this.current},g.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.DEPTH_TEST):e.disable(e.DEPTH_TEST),this.current=t}};var m=function(t){this.context=t,this.current=t.gl.LESS};m.prototype.get=function(){return this.current},m.prototype.set=function(t){this.current!==t&&(this.context.gl.depthFunc(t),this.current=t)};var v=function(t){this.context=t,this.current=!1};v.prototype.get=function(){return this.current},v.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.BLEND):e.disable(e.BLEND),this.current=t}};var y=function(t){this.context=t;var e=this.context.gl;this.current=[e.ONE,e.ZERO]};y.prototype.get=function(){return this.current},y.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]||(this.context.gl.blendFunc(t[0],t[1]),this.current=t)};var x=function(t){this.context=t,this.current=n.transparent};x.prototype.get=function(){return this.current},x.prototype.set=function(t){var e=this.current;t.r===e.r&&t.g===e.g&&t.b===e.b&&t.a===e.a||(this.context.gl.blendColor(t.r,t.g,t.b,t.a),this.current=t)};var b=function(t){this.context=t,this.current=null};b.prototype.get=function(){return this.current},b.prototype.set=function(t){this.current!==t&&(this.context.gl.useProgram(t),this.current=t)};var _=function(t){this.context=t,this.current=1};_.prototype.get=function(){return this.current},_.prototype.set=function(t){var e=this.context.lineWidthRange,r=i.clamp(t,e[0],e[1]);this.current!==r&&(this.context.gl.lineWidth(r),this.current=t)};var w=function(t){this.context=t,this.current=t.gl.TEXTURE0};w.prototype.get=function(){return this.current},w.prototype.set=function(t){this.current!==t&&(this.context.gl.activeTexture(t),this.current=t)};var k=function(t){this.context=t;var e=this.context.gl;this.current=[0,0,e.drawingBufferWidth,e.drawingBufferHeight]};k.prototype.get=function(){return this.current},k.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]||(this.context.gl.viewport(t[0],t[1],t[2],t[3]),this.current=t)};var M=function(t){this.context=t,this.current=null};M.prototype.get=function(){return this.current},M.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindFramebuffer(e.FRAMEBUFFER,t),this.current=t}};var A=function(t){this.context=t,this.current=null};A.prototype.get=function(){return this.current},A.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindRenderbuffer(e.RENDERBUFFER,t),this.current=t}};var T=function(t){this.context=t,this.current=null};T.prototype.get=function(){return this.current},T.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindTexture(e.TEXTURE_2D,t),this.current=t}};var S=function(t){this.context=t,this.current=null};S.prototype.get=function(){return this.current},S.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindBuffer(e.ARRAY_BUFFER,t),this.current=t}};var C=function(t){this.context=t,this.current=null};C.prototype.get=function(){return this.current},C.prototype.set=function(t){var e=this.context.gl;e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,t),this.current=t};var E=function(t){this.context=t,this.current=null};E.prototype.get=function(){return this.current},E.prototype.set=function(t){this.current!==t&&this.context.extVertexArrayObject&&(this.context.extVertexArrayObject.bindVertexArrayOES(t),this.current=t)};var L=function(t){this.context=t,this.current=4};L.prototype.get=function(){return this.current},L.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.pixelStorei(e.UNPACK_ALIGNMENT,t),this.current=t}};var z=function(t){this.context=t,this.current=!1};z.prototype.get=function(){return this.current},z.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,t),this.current=t}};var P=function(t,e){this.context=t,this.current=null,this.parent=e};P.prototype.get=function(){return this.current};var D=function(t){function e(e,r){t.call(this,e,r),this.dirty=!1}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.set=function(t){if(this.dirty||this.current!==t){var e=this.context.gl;this.context.bindFramebuffer.set(this.parent),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,t,0),this.current=t,this.dirty=!1}},e.prototype.setDirty=function(){this.dirty=!0},e}(P),O=function(t){function e(){t.apply(this,arguments)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;this.context.bindFramebuffer.set(this.parent),e.framebufferRenderbuffer(e.FRAMEBUFFER,e.DEPTH_ATTACHMENT,e.RENDERBUFFER,t),this.current=t}},e}(P);e.exports={ClearColor:a,ClearDepth:o,ClearStencil:s,ColorMask:l,DepthMask:c,StencilMask:u,StencilFunc:f,StencilOp:h,StencilTest:p,DepthRange:d,DepthTest:g,DepthFunc:m,Blend:v,BlendFunc:y,BlendColor:x,Program:b,LineWidth:_,ActiveTextureUnit:w,Viewport:k,BindFramebuffer:M,BindRenderbuffer:A,BindTexture:T,BindVertexBuffer:S,BindElementBuffer:C,BindVertexArrayOES:E,PixelStoreUnpack:L,PixelStoreUnpackPremultiplyAlpha:z,ColorAttachment:D,DepthAttachment:O}},{"../style-spec/util/color":153,"../util/util":275}],72:[function(t,e,r){var n={Int8:"BYTE",Uint8:"UNSIGNED_BYTE",Int16:"SHORT",Uint16:"UNSIGNED_SHORT",Int32:"INT",Uint32:"UNSIGNED_INT",Float32:"FLOAT"},i=function(t,e,r,n){this.length=e.length,this.attributes=r,this.itemSize=e.bytesPerElement,this.dynamicDraw=n,this.context=t;var i=t.gl;this.buffer=i.createBuffer(),t.bindVertexBuffer.set(this.buffer),i.bufferData(i.ARRAY_BUFFER,e.arrayBuffer,this.dynamicDraw?i.DYNAMIC_DRAW:i.STATIC_DRAW),this.dynamicDraw||delete e.arrayBuffer};i.prototype.bind=function(){this.context.bindVertexBuffer.set(this.buffer)},i.prototype.updateData=function(t){var e=this.context.gl;this.bind(),e.bufferSubData(e.ARRAY_BUFFER,0,t.arrayBuffer)},i.prototype.enableAttributes=function(t,e){for(var r=0;r":[24,[4,18,20,9,4,0]],"?":[18,[3,16,3,17,4,19,5,20,7,21,11,21,13,20,14,19,15,17,15,15,14,13,13,12,9,10,9,7,-1,-1,9,2,8,1,9,0,10,1,9,2]],"@":[27,[18,13,17,15,15,16,12,16,10,15,9,14,8,11,8,8,9,6,11,5,14,5,16,6,17,8,-1,-1,12,16,10,14,9,11,9,8,10,6,11,5,-1,-1,18,16,17,8,17,6,19,5,21,5,23,7,24,10,24,12,23,15,22,17,20,19,18,20,15,21,12,21,9,20,7,19,5,17,4,15,3,12,3,9,4,6,5,4,7,2,9,1,12,0,15,0,18,1,20,2,21,3,-1,-1,19,16,18,8,18,6,19,5]],A:[18,[9,21,1,0,-1,-1,9,21,17,0,-1,-1,4,7,14,7]],B:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,15,17,13,16,12,13,11,-1,-1,4,11,13,11,16,10,17,9,18,7,18,4,17,2,16,1,13,0,4,0]],C:[21,[18,16,17,18,15,20,13,21,9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5]],D:[21,[4,21,4,0,-1,-1,4,21,11,21,14,20,16,18,17,16,18,13,18,8,17,5,16,3,14,1,11,0,4,0]],E:[19,[4,21,4,0,-1,-1,4,21,17,21,-1,-1,4,11,12,11,-1,-1,4,0,17,0]],F:[18,[4,21,4,0,-1,-1,4,21,17,21,-1,-1,4,11,12,11]],G:[21,[18,16,17,18,15,20,13,21,9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,18,8,-1,-1,13,8,18,8]],H:[22,[4,21,4,0,-1,-1,18,21,18,0,-1,-1,4,11,18,11]],I:[8,[4,21,4,0]],J:[16,[12,21,12,5,11,2,10,1,8,0,6,0,4,1,3,2,2,5,2,7]],K:[21,[4,21,4,0,-1,-1,18,21,4,7,-1,-1,9,12,18,0]],L:[17,[4,21,4,0,-1,-1,4,0,16,0]],M:[24,[4,21,4,0,-1,-1,4,21,12,0,-1,-1,20,21,12,0,-1,-1,20,21,20,0]],N:[22,[4,21,4,0,-1,-1,4,21,18,0,-1,-1,18,21,18,0]],O:[22,[9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,19,8,19,13,18,16,17,18,15,20,13,21,9,21]],P:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,14,17,12,16,11,13,10,4,10]],Q:[22,[9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,19,8,19,13,18,16,17,18,15,20,13,21,9,21,-1,-1,12,4,18,-2]],R:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,15,17,13,16,12,13,11,4,11,-1,-1,11,11,18,0]],S:[20,[17,18,15,20,12,21,8,21,5,20,3,18,3,16,4,14,5,13,7,12,13,10,15,9,16,8,17,6,17,3,15,1,12,0,8,0,5,1,3,3]],T:[16,[8,21,8,0,-1,-1,1,21,15,21]],U:[22,[4,21,4,6,5,3,7,1,10,0,12,0,15,1,17,3,18,6,18,21]],V:[18,[1,21,9,0,-1,-1,17,21,9,0]],W:[24,[2,21,7,0,-1,-1,12,21,7,0,-1,-1,12,21,17,0,-1,-1,22,21,17,0]],X:[20,[3,21,17,0,-1,-1,17,21,3,0]],Y:[18,[1,21,9,11,9,0,-1,-1,17,21,9,11]],Z:[20,[17,21,3,0,-1,-1,3,21,17,21,-1,-1,3,0,17,0]],"[":[14,[4,25,4,-7,-1,-1,5,25,5,-7,-1,-1,4,25,11,25,-1,-1,4,-7,11,-7]],"\\":[14,[0,21,14,-3]],"]":[14,[9,25,9,-7,-1,-1,10,25,10,-7,-1,-1,3,25,10,25,-1,-1,3,-7,10,-7]],"^":[16,[6,15,8,18,10,15,-1,-1,3,12,8,17,13,12,-1,-1,8,17,8,0]],_:[16,[0,-2,16,-2]],"`":[10,[6,21,5,20,4,18,4,16,5,15,6,16,5,17]],a:[19,[15,14,15,0,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],b:[19,[4,21,4,0,-1,-1,4,11,6,13,8,14,11,14,13,13,15,11,16,8,16,6,15,3,13,1,11,0,8,0,6,1,4,3]],c:[18,[15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],d:[19,[15,21,15,0,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],e:[18,[3,8,15,8,15,10,14,12,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],f:[12,[10,21,8,21,6,20,5,17,5,0,-1,-1,2,14,9,14]],g:[19,[15,14,15,-2,14,-5,13,-6,11,-7,8,-7,6,-6,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],h:[19,[4,21,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0]],i:[8,[3,21,4,20,5,21,4,22,3,21,-1,-1,4,14,4,0]],j:[10,[5,21,6,20,7,21,6,22,5,21,-1,-1,6,14,6,-3,5,-6,3,-7,1,-7]],k:[17,[4,21,4,0,-1,-1,14,14,4,4,-1,-1,8,8,15,0]],l:[8,[4,21,4,0]],m:[30,[4,14,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0,-1,-1,15,10,18,13,20,14,23,14,25,13,26,10,26,0]],n:[19,[4,14,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0]],o:[19,[8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3,16,6,16,8,15,11,13,13,11,14,8,14]],p:[19,[4,14,4,-7,-1,-1,4,11,6,13,8,14,11,14,13,13,15,11,16,8,16,6,15,3,13,1,11,0,8,0,6,1,4,3]],q:[19,[15,14,15,-7,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],r:[13,[4,14,4,0,-1,-1,4,8,5,11,7,13,9,14,12,14]],s:[17,[14,11,13,13,10,14,7,14,4,13,3,11,4,9,6,8,11,7,13,6,14,4,14,3,13,1,10,0,7,0,4,1,3,3]],t:[12,[5,21,5,4,6,1,8,0,10,0,-1,-1,2,14,9,14]],u:[19,[4,14,4,4,5,1,7,0,10,0,12,1,15,4,-1,-1,15,14,15,0]],v:[16,[2,14,8,0,-1,-1,14,14,8,0]],w:[22,[3,14,7,0,-1,-1,11,14,7,0,-1,-1,11,14,15,0,-1,-1,19,14,15,0]],x:[17,[3,14,14,0,-1,-1,14,14,3,0]],y:[16,[2,14,8,0,-1,-1,14,14,8,0,6,-4,4,-6,2,-7,1,-7]],z:[17,[14,14,3,0,-1,-1,3,14,14,14,-1,-1,3,0,14,0]],"{":[14,[9,25,7,24,6,23,5,21,5,19,6,17,7,16,8,14,8,12,6,10,-1,-1,7,24,6,22,6,20,7,18,8,17,9,15,9,13,8,11,4,9,8,7,9,5,9,3,8,1,7,0,6,-2,6,-4,7,-6,-1,-1,6,8,8,6,8,4,7,2,6,1,5,-1,5,-3,6,-5,7,-6,9,-7]],"|":[8,[4,25,4,-7]],"}":[14,[5,25,7,24,8,23,9,21,9,19,8,17,7,16,6,14,6,12,8,10,-1,-1,7,24,8,22,8,20,7,18,6,17,5,15,5,13,6,11,10,9,6,7,5,5,5,3,6,1,7,0,8,-2,8,-4,7,-6,-1,-1,8,8,6,6,6,4,7,2,8,1,9,-1,9,-3,8,-5,7,-6,5,-7]],"~":[24,[3,6,3,8,4,11,6,12,8,12,10,11,14,8,16,7,18,7,20,8,21,10,-1,-1,3,8,4,10,6,11,8,11,10,10,14,7,16,6,18,6,20,7,21,10,21,12]]}},{"../data/array_types":39,"../data/extent":53,"../data/pos_attributes":57,"../gl/depth_mode":67,"../gl/stencil_mode":70,"../util/browser":252,"./vertex_array_object":95,"@mapbox/gl-matrix":2}],78:[function(t,e,r){function n(t,e,r,n,i){if(!s.isPatternMissing(r.paint.get("fill-pattern"),t))for(var a=!0,o=0,l=n;o0){var l=o.now(),c=(l-t.timeAdded)/s,u=e?(l-e.timeAdded)/s:-1,f=r.getSource(),h=a.coveringZoomLevel({tileSize:f.tileSize,roundZoom:f.roundZoom}),p=!e||Math.abs(e.tileID.overscaledZ-h)>Math.abs(t.tileID.overscaledZ-h),d=p&&t.refreshedUponExpiration?1:i.clamp(p?c:1-u,0,1);return t.refreshedUponExpiration&&c>=1&&(t.refreshedUponExpiration=!1),e?{opacity:1,mix:1-d}:{opacity:d,mix:0}}return{opacity:1,mix:0}}var i=t("../util/util"),a=t("../source/image_source"),o=t("../util/browser"),s=t("../gl/stencil_mode"),l=t("../gl/depth_mode");e.exports=function(t,e,r,i){if("translucent"===t.renderPass&&0!==r.paint.get("raster-opacity")){var o=t.context,c=o.gl,u=e.getSource(),f=t.useProgram("raster");o.setStencilMode(s.disabled),o.setColorMode(t.colorModeForRenderPass()),c.uniform1f(f.uniforms.u_brightness_low,r.paint.get("raster-brightness-min")),c.uniform1f(f.uniforms.u_brightness_high,r.paint.get("raster-brightness-max")),c.uniform1f(f.uniforms.u_saturation_factor,function(t){return t>0?1-1/(1.001-t):-t}(r.paint.get("raster-saturation"))),c.uniform1f(f.uniforms.u_contrast_factor,function(t){return t>0?1/(1-t):1+t}(r.paint.get("raster-contrast"))),c.uniform3fv(f.uniforms.u_spin_weights,function(t){t*=Math.PI/180;var e=Math.sin(t),r=Math.cos(t);return[(2*r+1)/3,(-Math.sqrt(3)*e-r+1)/3,(Math.sqrt(3)*e-r+1)/3]}(r.paint.get("raster-hue-rotate"))),c.uniform1f(f.uniforms.u_buffer_scale,1),c.uniform1i(f.uniforms.u_image0,0),c.uniform1i(f.uniforms.u_image1,1);for(var h=i.length&&i[0].overscaledZ,p=0,d=i;p65535)e(new Error("glyphs > 65535 not supported"));else{var c=o.requests[l];c||(c=o.requests[l]=[],n(i,l,r.url,r.requestTransform,function(t,e){if(e)for(var r in e)o.glyphs[+r]=e[+r];for(var n=0,i=c;nthis.height)return n.warnOnce("LineAtlas out of space"),null;for(var o=0,s=0;s=0;this.currentLayer--){var m=r.style._layers[o[r.currentLayer]];m.source!==(d&&d.id)&&(g=[],(d=r.style.sourceCaches[m.source])&&(r.clearStencil(),g=d.getVisibleCoordinates(),d.getSource().isTileClipped&&r._renderTileClippingMasks(g))),r.renderLayer(r,d,m,g)}this.renderPass="translucent";var v,y=[];for(this.currentLayer=0,this.currentLayer;this.currentLayer0?e.pop():null},T.prototype._createProgramCached=function(t,e){this.cache=this.cache||{};var r=""+t+(e.cacheKey||"")+(this._showOverdrawInspector?"/overdraw":"");return this.cache[r]||(this.cache[r]=new y(this.context,v[t],e,this._showOverdrawInspector)),this.cache[r]},T.prototype.useProgram=function(t,e){var r=this._createProgramCached(t,e||this.emptyProgramConfiguration);return this.context.program.set(r.program),r},e.exports=T},{"../data/array_types":39,"../data/extent":53,"../data/pos_attributes":57,"../data/program_configuration":58,"../data/raster_bounds_attributes":59,"../gl/color_mode":65,"../gl/context":66,"../gl/depth_mode":67,"../gl/stencil_mode":70,"../shaders":97,"../source/pixels_to_tile_units":104,"../source/source_cache":111,"../style-spec/util/color":153,"../symbol/cross_tile_symbol_index":218,"../util/browser":252,"../util/util":275,"./draw_background":74,"./draw_circle":75,"./draw_debug":77,"./draw_fill":78,"./draw_fill_extrusion":79,"./draw_heatmap":80,"./draw_hillshade":81,"./draw_line":82,"./draw_raster":83,"./draw_symbol":84,"./program":92,"./texture":93,"./tile_mask":94,"./vertex_array_object":95,"@mapbox/gl-matrix":2}],91:[function(t,e,r){var n=t("../source/pixels_to_tile_units");r.isPatternMissing=function(t,e){if(!t)return!1;var r=e.imageManager.getPattern(t.from),n=e.imageManager.getPattern(t.to);return!r||!n},r.prepare=function(t,e,r){var n=e.context,i=n.gl,a=e.imageManager.getPattern(t.from),o=e.imageManager.getPattern(t.to);i.uniform1i(r.uniforms.u_image,0),i.uniform2fv(r.uniforms.u_pattern_tl_a,a.tl),i.uniform2fv(r.uniforms.u_pattern_br_a,a.br),i.uniform2fv(r.uniforms.u_pattern_tl_b,o.tl),i.uniform2fv(r.uniforms.u_pattern_br_b,o.br);var s=e.imageManager.getPixelSize(),l=s.width,c=s.height;i.uniform2fv(r.uniforms.u_texsize,[l,c]),i.uniform1f(r.uniforms.u_mix,t.t),i.uniform2fv(r.uniforms.u_pattern_size_a,a.displaySize),i.uniform2fv(r.uniforms.u_pattern_size_b,o.displaySize),i.uniform1f(r.uniforms.u_scale_a,t.fromScale),i.uniform1f(r.uniforms.u_scale_b,t.toScale),n.activeTexture.set(i.TEXTURE0),e.imageManager.bind(e.context)},r.setTile=function(t,e,r){var i=e.context.gl;i.uniform1f(r.uniforms.u_tile_units_to_pixels,1/n(t,1,e.transform.tileZoom));var a=Math.pow(2,t.tileID.overscaledZ),o=t.tileSize*Math.pow(2,e.transform.tileZoom)/a,s=o*(t.tileID.canonical.x+t.tileID.wrap*a),l=o*t.tileID.canonical.y;i.uniform2f(r.uniforms.u_pixel_coord_upper,s>>16,l>>16),i.uniform2f(r.uniforms.u_pixel_coord_lower,65535&s,65535&l)}},{"../source/pixels_to_tile_units":104}],92:[function(t,e,r){var n=t("../util/browser"),i=t("../shaders"),a=(t("../data/program_configuration").ProgramConfiguration,t("./vertex_array_object")),o=(t("../gl/context"),function(t,e,r,a){var o=this,s=t.gl;this.program=s.createProgram();var l=r.defines().concat("#define DEVICE_PIXEL_RATIO "+n.devicePixelRatio.toFixed(1));a&&l.push("#define OVERDRAW_INSPECTOR;");var c=l.concat(i.prelude.fragmentSource,e.fragmentSource).join("\n"),u=l.concat(i.prelude.vertexSource,e.vertexSource).join("\n"),f=s.createShader(s.FRAGMENT_SHADER);s.shaderSource(f,c),s.compileShader(f),s.attachShader(this.program,f);var h=s.createShader(s.VERTEX_SHADER);s.shaderSource(h,u),s.compileShader(h),s.attachShader(this.program,h);for(var p=r.layoutAttributes||[],d=0;d 0.5) {\n gl_FragColor = vec4(0.0, 0.0, 1.0, 0.5) * alpha;\n }\n\n if (v_notUsed > 0.5) {\n // This box not used, fade it out\n gl_FragColor *= .1;\n }\n}",vertexSource:"attribute vec2 a_pos;\nattribute vec2 a_anchor_pos;\nattribute vec2 a_extrude;\nattribute vec2 a_placed;\n\nuniform mat4 u_matrix;\nuniform vec2 u_extrude_scale;\nuniform float u_camera_to_center_distance;\n\nvarying float v_placed;\nvarying float v_notUsed;\n\nvoid main() {\n vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n highp float collision_perspective_ratio = 0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance);\n\n gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);\n gl_Position.xy += a_extrude * u_extrude_scale * gl_Position.w * collision_perspective_ratio;\n\n v_placed = a_placed.x;\n v_notUsed = a_placed.y;\n}\n"},collisionCircle:{fragmentSource:"\nvarying float v_placed;\nvarying float v_notUsed;\nvarying float v_radius;\nvarying vec2 v_extrude;\nvarying vec2 v_extrude_scale;\n\nvoid main() {\n float alpha = 0.5;\n\n // Red = collision, hide label\n vec4 color = vec4(1.0, 0.0, 0.0, 1.0) * alpha;\n\n // Blue = no collision, label is showing\n if (v_placed > 0.5) {\n color = vec4(0.0, 0.0, 1.0, 0.5) * alpha;\n }\n\n if (v_notUsed > 0.5) {\n // This box not used, fade it out\n color *= .2;\n }\n\n float extrude_scale_length = length(v_extrude_scale);\n float extrude_length = length(v_extrude) * extrude_scale_length;\n float stroke_width = 15.0 * extrude_scale_length;\n float radius = v_radius * extrude_scale_length;\n\n float distance_to_edge = abs(extrude_length - radius);\n float opacity_t = smoothstep(-stroke_width, 0.0, -distance_to_edge);\n\n gl_FragColor = opacity_t * color;\n}\n",vertexSource:"attribute vec2 a_pos;\nattribute vec2 a_anchor_pos;\nattribute vec2 a_extrude;\nattribute vec2 a_placed;\n\nuniform mat4 u_matrix;\nuniform vec2 u_extrude_scale;\nuniform float u_camera_to_center_distance;\n\nvarying float v_placed;\nvarying float v_notUsed;\nvarying float v_radius;\n\nvarying vec2 v_extrude;\nvarying vec2 v_extrude_scale;\n\nvoid main() {\n vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n highp float collision_perspective_ratio = 0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance);\n\n gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);\n\n highp float padding_factor = 1.2; // Pad the vertices slightly to make room for anti-alias blur\n gl_Position.xy += a_extrude * u_extrude_scale * padding_factor * gl_Position.w * collision_perspective_ratio;\n\n v_placed = a_placed.x;\n v_notUsed = a_placed.y;\n v_radius = abs(a_extrude.y); // We don't pitch the circles, so both units of the extrusion vector are equal in magnitude to the radius\n\n v_extrude = a_extrude * padding_factor;\n v_extrude_scale = u_extrude_scale * u_camera_to_center_distance * collision_perspective_ratio;\n}\n"},debug:{fragmentSource:"uniform highp vec4 u_color;\n\nvoid main() {\n gl_FragColor = u_color;\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n}\n"},fill:{fragmentSource:"#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float opacity\n\n gl_FragColor = color * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n}\n"},fillOutline:{fragmentSource:"#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_pos;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 outline_color\n #pragma mapbox: initialize lowp float opacity\n\n float dist = length(v_pos - gl_FragCoord.xy);\n float alpha = 1.0 - smoothstep(0.0, 1.0, dist);\n gl_FragColor = outline_color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\nuniform vec2 u_world;\n\nvarying vec2 v_pos;\n\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 outline_color\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;\n}\n"},fillOutlinePattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec2 v_pos;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n // find distance to outline for alpha interpolation\n\n float dist = length(v_pos - gl_FragCoord.xy);\n float alpha = 1.0 - smoothstep(0.0, 1.0, dist);\n\n\n gl_FragColor = mix(color1, color2, u_mix) * alpha * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_world;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\n\nattribute vec2 a_pos;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec2 v_pos;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, a_pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);\n\n v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;\n}\n"},fillPattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n gl_FragColor = mix(color1, color2, u_mix) * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\n\nattribute vec2 a_pos;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, a_pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);\n}\n"},fillExtrusion:{fragmentSource:"varying vec4 v_color;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define highp vec4 color\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n #pragma mapbox: initialize highp vec4 color\n\n gl_FragColor = v_color;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec3 u_lightcolor;\nuniform lowp vec3 u_lightpos;\nuniform lowp float u_lightintensity;\n\nattribute vec2 a_pos;\nattribute vec4 a_normal_ed;\n\nvarying vec4 v_color;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\n#pragma mapbox: define highp vec4 color\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n #pragma mapbox: initialize highp vec4 color\n\n vec3 normal = a_normal_ed.xyz;\n\n base = max(0.0, base);\n height = max(0.0, height);\n\n float t = mod(normal.x, 2.0);\n\n gl_Position = u_matrix * vec4(a_pos, t > 0.0 ? height : base, 1);\n\n // Relative luminance (how dark/bright is the surface color?)\n float colorvalue = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;\n\n v_color = vec4(0.0, 0.0, 0.0, 1.0);\n\n // Add slight ambient lighting so no extrusions are totally black\n vec4 ambientlight = vec4(0.03, 0.03, 0.03, 1.0);\n color += ambientlight;\n\n // Calculate cos(theta), where theta is the angle between surface normal and diffuse light ray\n float directional = clamp(dot(normal / 16384.0, u_lightpos), 0.0, 1.0);\n\n // Adjust directional so that\n // the range of values for highlight/shading is narrower\n // with lower light intensity\n // and with lighter/brighter surface colors\n directional = mix((1.0 - u_lightintensity), max((1.0 - colorvalue + u_lightintensity), 1.0), directional);\n\n // Add gradient along z axis of side surfaces\n if (normal.y != 0.0) {\n directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);\n }\n\n // Assign final color based on surface + ambient light color, diffuse light directional, and light color\n // with lower bounds adjusted to hue of light\n // so that shading is tinted with the complementary (opposite) color to the light color\n v_color.r += clamp(color.r * directional * u_lightcolor.r, mix(0.0, 0.3, 1.0 - u_lightcolor.r), 1.0);\n v_color.g += clamp(color.g * directional * u_lightcolor.g, mix(0.0, 0.3, 1.0 - u_lightcolor.g), 1.0);\n v_color.b += clamp(color.b * directional * u_lightcolor.b, mix(0.0, 0.3, 1.0 - u_lightcolor.b), 1.0);\n}\n"},fillExtrusionPattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec4 v_lighting;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n vec4 mixedColor = mix(color1, color2, u_mix);\n\n gl_FragColor = mixedColor * v_lighting;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\nuniform float u_height_factor;\n\nuniform vec3 u_lightcolor;\nuniform lowp vec3 u_lightpos;\nuniform lowp float u_lightintensity;\n\nattribute vec2 a_pos;\nattribute vec4 a_normal_ed;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec4 v_lighting;\nvarying float v_directional;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n\n vec3 normal = a_normal_ed.xyz;\n float edgedistance = a_normal_ed.w;\n\n base = max(0.0, base);\n height = max(0.0, height);\n\n float t = mod(normal.x, 2.0);\n float z = t > 0.0 ? height : base;\n\n gl_Position = u_matrix * vec4(a_pos, z, 1);\n\n vec2 pos = normal.x == 1.0 && normal.y == 0.0 && normal.z == 16384.0\n ? a_pos // extrusion top\n : vec2(edgedistance, z * u_height_factor); // extrusion side\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, pos);\n\n v_lighting = vec4(0.0, 0.0, 0.0, 1.0);\n float directional = clamp(dot(normal / 16383.0, u_lightpos), 0.0, 1.0);\n directional = mix((1.0 - u_lightintensity), max((0.5 + u_lightintensity), 1.0), directional);\n\n if (normal.y != 0.0) {\n directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);\n }\n\n v_lighting.rgb += clamp(directional * u_lightcolor, mix(vec3(0.0), vec3(0.3), 1.0 - u_lightcolor), vec3(1.0));\n}\n"},extrusionTexture:{fragmentSource:"uniform sampler2D u_image;\nuniform float u_opacity;\nvarying vec2 v_pos;\n\nvoid main() {\n gl_FragColor = texture2D(u_image, v_pos) * u_opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(0.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_world;\nattribute vec2 a_pos;\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos * u_world, 0, 1);\n\n v_pos.x = a_pos.x;\n v_pos.y = 1.0 - a_pos.y;\n}\n"},hillshadePrepare:{fragmentSource:"#ifdef GL_ES\nprecision highp float;\n#endif\n\nuniform sampler2D u_image;\nvarying vec2 v_pos;\nuniform vec2 u_dimension;\nuniform float u_zoom;\n\nfloat getElevation(vec2 coord, float bias) {\n // Convert encoded elevation value to meters\n vec4 data = texture2D(u_image, coord) * 255.0;\n return (data.r + data.g * 256.0 + data.b * 256.0 * 256.0) / 4.0;\n}\n\nvoid main() {\n vec2 epsilon = 1.0 / u_dimension;\n\n // queried pixels:\n // +-----------+\n // | | | |\n // | a | b | c |\n // | | | |\n // +-----------+\n // | | | |\n // | d | e | f |\n // | | | |\n // +-----------+\n // | | | |\n // | g | h | i |\n // | | | |\n // +-----------+\n\n float a = getElevation(v_pos + vec2(-epsilon.x, -epsilon.y), 0.0);\n float b = getElevation(v_pos + vec2(0, -epsilon.y), 0.0);\n float c = getElevation(v_pos + vec2(epsilon.x, -epsilon.y), 0.0);\n float d = getElevation(v_pos + vec2(-epsilon.x, 0), 0.0);\n float e = getElevation(v_pos, 0.0);\n float f = getElevation(v_pos + vec2(epsilon.x, 0), 0.0);\n float g = getElevation(v_pos + vec2(-epsilon.x, epsilon.y), 0.0);\n float h = getElevation(v_pos + vec2(0, epsilon.y), 0.0);\n float i = getElevation(v_pos + vec2(epsilon.x, epsilon.y), 0.0);\n\n // here we divide the x and y slopes by 8 * pixel size\n // where pixel size (aka meters/pixel) is:\n // circumference of the world / (pixels per tile * number of tiles)\n // which is equivalent to: 8 * 40075016.6855785 / (512 * pow(2, u_zoom))\n // which can be reduced to: pow(2, 19.25619978527 - u_zoom)\n // we want to vertically exaggerate the hillshading though, because otherwise\n // it is barely noticeable at low zooms. to do this, we multiply this by some\n // scale factor pow(2, (u_zoom - 14) * a) where a is an arbitrary value and 14 is the\n // maxzoom of the tile source. here we use a=0.3 which works out to the\n // expression below. see nickidlugash's awesome breakdown for more info\n // https://github.com/mapbox/mapbox-gl-js/pull/5286#discussion_r148419556\n float exaggeration = u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;\n\n vec2 deriv = vec2(\n (c + f + f + i) - (a + d + d + g),\n (g + h + h + i) - (a + b + b + c)\n ) / pow(2.0, (u_zoom - 14.0) * exaggeration + 19.2562 - u_zoom);\n\n gl_FragColor = clamp(vec4(\n deriv.x / 2.0 + 0.5,\n deriv.y / 2.0 + 0.5,\n 1.0,\n 1.0), 0.0, 1.0);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = (a_texture_pos / 8192.0) / 2.0 + 0.25;\n}\n"},hillshade:{fragmentSource:"uniform sampler2D u_image;\nvarying vec2 v_pos;\n\nuniform vec2 u_latrange;\nuniform vec2 u_light;\nuniform vec4 u_shadow;\nuniform vec4 u_highlight;\nuniform vec4 u_accent;\n\n#define PI 3.141592653589793\n\nvoid main() {\n vec4 pixel = texture2D(u_image, v_pos);\n\n vec2 deriv = ((pixel.rg * 2.0) - 1.0);\n\n // We divide the slope by a scale factor based on the cosin of the pixel's approximate latitude\n // to account for mercator projection distortion. see #4807 for details\n float scaleFactor = cos(radians((u_latrange[0] - u_latrange[1]) * (1.0 - v_pos.y) + u_latrange[1]));\n // We also multiply the slope by an arbitrary z-factor of 1.25\n float slope = atan(1.25 * length(deriv) / scaleFactor);\n float aspect = deriv.x != 0.0 ? atan(deriv.y, -deriv.x) : PI / 2.0 * (deriv.y > 0.0 ? 1.0 : -1.0);\n\n float intensity = u_light.x;\n // We add PI to make this property match the global light object, which adds PI/2 to the light's azimuthal\n // position property to account for 0deg corresponding to north/the top of the viewport in the style spec\n // and the original shader was written to accept (-illuminationDirection - 90) as the azimuthal.\n float azimuth = u_light.y + PI;\n\n // We scale the slope exponentially based on intensity, using a calculation similar to\n // the exponential interpolation function in the style spec:\n // https://github.com/mapbox/mapbox-gl-js/blob/master/src/style-spec/expression/definitions/interpolate.js#L217-L228\n // so that higher intensity values create more opaque hillshading.\n float base = 1.875 - intensity * 1.75;\n float maxValue = 0.5 * PI;\n float scaledSlope = intensity != 0.5 ? ((pow(base, slope) - 1.0) / (pow(base, maxValue) - 1.0)) * maxValue : slope;\n\n // The accent color is calculated with the cosine of the slope while the shade color is calculated with the sine\n // so that the accent color's rate of change eases in while the shade color's eases out.\n float accent = cos(scaledSlope);\n // We multiply both the accent and shade color by a clamped intensity value\n // so that intensities >= 0.5 do not additionally affect the color values\n // while intensity values < 0.5 make the overall color more transparent.\n vec4 accent_color = (1.0 - accent) * u_accent * clamp(intensity * 2.0, 0.0, 1.0);\n float shade = abs(mod((aspect + azimuth) / PI + 0.5, 2.0) - 1.0);\n vec4 shade_color = mix(u_shadow, u_highlight, shade) * sin(scaledSlope) * clamp(intensity * 2.0, 0.0, 1.0);\n gl_FragColor = accent_color * (1.0 - shade_color.a) + shade_color;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = a_texture_pos / 8192.0;\n}\n"},line:{fragmentSource:"#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_width2;\nvarying vec2 v_normal;\nvarying float v_gamma_scale;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n gl_FragColor = color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\n// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float width\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist = outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_width2 = vec2(outset, inset);\n}\n"},linePattern:{fragmentSource:"uniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_fade;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_linesofar;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n float x_a = mod(v_linesofar / u_pattern_size_a.x, 1.0);\n float x_b = mod(v_linesofar / u_pattern_size_b.x, 1.0);\n float y_a = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_a.y);\n float y_b = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_b.y);\n vec2 pos_a = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, vec2(x_a, y_a));\n vec2 pos_b = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, vec2(x_b, y_b));\n\n vec4 color = mix(texture2D(u_image, pos_a), texture2D(u_image, pos_b), u_fade);\n\n gl_FragColor = color * alpha * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\n// We scale the distance before adding it to the buffers so that we can store\n// long distances for long segments. Use this value to unscale the distance.\n#define LINE_DISTANCE_SCALE 2.0\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_linesofar;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n\nvoid main() {\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize mediump float width\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n float a_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * LINE_DISTANCE_SCALE;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist = outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_linesofar = a_linesofar;\n v_width2 = vec2(outset, inset);\n}\n"},lineSDF:{fragmentSource:"\nuniform sampler2D u_image;\nuniform float u_sdfgamma;\nuniform float u_mix;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying vec2 v_tex_a;\nvarying vec2 v_tex_b;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float width\n #pragma mapbox: initialize lowp float floorwidth\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n float sdfdist_a = texture2D(u_image, v_tex_a).a;\n float sdfdist_b = texture2D(u_image, v_tex_b).a;\n float sdfdist = mix(sdfdist_a, sdfdist_b, u_mix);\n alpha *= smoothstep(0.5 - u_sdfgamma / floorwidth, 0.5 + u_sdfgamma / floorwidth, sdfdist);\n\n gl_FragColor = color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\n// We scale the distance before adding it to the buffers so that we can store\n// long distances for long segments. Use this value to unscale the distance.\n#define LINE_DISTANCE_SCALE 2.0\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_patternscale_a;\nuniform float u_tex_y_a;\nuniform vec2 u_patternscale_b;\nuniform float u_tex_y_b;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying vec2 v_tex_a;\nvarying vec2 v_tex_b;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float width\n #pragma mapbox: initialize lowp float floorwidth\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n float a_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * LINE_DISTANCE_SCALE;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist =outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_tex_a = vec2(a_linesofar * u_patternscale_a.x / floorwidth, normal.y * u_patternscale_a.y + u_tex_y_a);\n v_tex_b = vec2(a_linesofar * u_patternscale_b.x / floorwidth, normal.y * u_patternscale_b.y + u_tex_y_b);\n\n v_width2 = vec2(outset, inset);\n}\n"},raster:{fragmentSource:"uniform float u_fade_t;\nuniform float u_opacity;\nuniform sampler2D u_image0;\nuniform sampler2D u_image1;\nvarying vec2 v_pos0;\nvarying vec2 v_pos1;\n\nuniform float u_brightness_low;\nuniform float u_brightness_high;\n\nuniform float u_saturation_factor;\nuniform float u_contrast_factor;\nuniform vec3 u_spin_weights;\n\nvoid main() {\n\n // read and cross-fade colors from the main and parent tiles\n vec4 color0 = texture2D(u_image0, v_pos0);\n vec4 color1 = texture2D(u_image1, v_pos1);\n if (color0.a > 0.0) {\n color0.rgb = color0.rgb / color0.a;\n }\n if (color1.a > 0.0) {\n color1.rgb = color1.rgb / color1.a;\n }\n vec4 color = mix(color0, color1, u_fade_t);\n color.a *= u_opacity;\n vec3 rgb = color.rgb;\n\n // spin\n rgb = vec3(\n dot(rgb, u_spin_weights.xyz),\n dot(rgb, u_spin_weights.zxy),\n dot(rgb, u_spin_weights.yzx));\n\n // saturation\n float average = (color.r + color.g + color.b) / 3.0;\n rgb += (average - rgb) * u_saturation_factor;\n\n // contrast\n rgb = (rgb - 0.5) * u_contrast_factor + 0.5;\n\n // brightness\n vec3 u_high_vec = vec3(u_brightness_low, u_brightness_low, u_brightness_low);\n vec3 u_low_vec = vec3(u_brightness_high, u_brightness_high, u_brightness_high);\n\n gl_FragColor = vec4(mix(u_high_vec, u_low_vec, rgb) * color.a, color.a);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_tl_parent;\nuniform float u_scale_parent;\nuniform float u_buffer_scale;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos0;\nvarying vec2 v_pos1;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n // We are using Int16 for texture position coordinates to give us enough precision for\n // fractional coordinates. We use 8192 to scale the texture coordinates in the buffer\n // as an arbitrarily high number to preserve adequate precision when rendering.\n // This is also the same value as the EXTENT we are using for our tile buffer pos coordinates,\n // so math for modifying either is consistent.\n v_pos0 = (((a_texture_pos / 8192.0) - 0.5) / u_buffer_scale ) + 0.5;\n v_pos1 = (v_pos0 * u_scale_parent) + u_tl_parent;\n}\n"},symbolIcon:{fragmentSource:"uniform sampler2D u_texture;\n\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_tex;\nvarying float v_fade_opacity;\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n lowp float alpha = opacity * v_fade_opacity;\n gl_FragColor = texture2D(u_texture, v_tex) * alpha;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"const float PI = 3.141592653589793;\n\nattribute vec4 a_pos_offset;\nattribute vec4 a_data;\nattribute vec3 a_projected_pos;\nattribute float a_fade_opacity;\n\nuniform bool u_is_size_zoom_constant;\nuniform bool u_is_size_feature_constant;\nuniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function\nuniform highp float u_size; // used when size is both zoom and feature constant\nuniform highp float u_camera_to_center_distance;\nuniform highp float u_pitch;\nuniform bool u_rotate_symbol;\nuniform highp float u_aspect_ratio;\nuniform float u_fade_change;\n\n#pragma mapbox: define lowp float opacity\n\nuniform mat4 u_matrix;\nuniform mat4 u_label_plane_matrix;\nuniform mat4 u_gl_coord_matrix;\n\nuniform bool u_is_text;\nuniform bool u_pitch_with_map;\n\nuniform vec2 u_texsize;\n\nvarying vec2 v_tex;\nvarying float v_fade_opacity;\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 a_pos = a_pos_offset.xy;\n vec2 a_offset = a_pos_offset.zw;\n\n vec2 a_tex = a_data.xy;\n vec2 a_size = a_data.zw;\n\n highp float segment_angle = -a_projected_pos[2];\n\n float size;\n if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = mix(a_size[0], a_size[1], u_size_t) / 10.0;\n } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = a_size[0] / 10.0;\n } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {\n size = u_size;\n } else {\n size = u_size;\n }\n\n vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n // See comments in symbol_sdf.vertex\n highp float distance_ratio = u_pitch_with_map ?\n camera_to_anchor_distance / u_camera_to_center_distance :\n u_camera_to_center_distance / camera_to_anchor_distance;\n highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;\n\n size *= perspective_ratio;\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n highp float symbol_rotation = 0.0;\n if (u_rotate_symbol) {\n // See comments in symbol_sdf.vertex\n vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);\n\n vec2 a = projectedPoint.xy / projectedPoint.w;\n vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;\n\n symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);\n }\n\n highp float angle_sin = sin(segment_angle + symbol_rotation);\n highp float angle_cos = cos(segment_angle + symbol_rotation);\n mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);\n\n vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);\n gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);\n\n v_tex = a_tex / u_texsize;\n vec2 fade_opacity = unpack_opacity(a_fade_opacity);\n float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;\n v_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));\n}\n"},symbolSDF:{fragmentSource:"#define SDF_PX 8.0\n#define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO\n\nuniform bool u_is_halo;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\n\nuniform sampler2D u_texture;\nuniform highp float u_gamma_scale;\nuniform bool u_is_text;\n\nvarying vec2 v_data0;\nvarying vec3 v_data1;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 fill_color\n #pragma mapbox: initialize highp vec4 halo_color\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float halo_width\n #pragma mapbox: initialize lowp float halo_blur\n\n vec2 tex = v_data0.xy;\n float gamma_scale = v_data1.x;\n float size = v_data1.y;\n float fade_opacity = v_data1[2];\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n lowp vec4 color = fill_color;\n highp float gamma = EDGE_GAMMA / (fontScale * u_gamma_scale);\n lowp float buff = (256.0 - 64.0) / 256.0;\n if (u_is_halo) {\n color = halo_color;\n gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (fontScale * u_gamma_scale);\n buff = (6.0 - halo_width / fontScale) / SDF_PX;\n }\n\n lowp float dist = texture2D(u_texture, tex).a;\n highp float gamma_scaled = gamma * gamma_scale;\n highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist);\n\n gl_FragColor = color * (alpha * opacity * fade_opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"const float PI = 3.141592653589793;\n\nattribute vec4 a_pos_offset;\nattribute vec4 a_data;\nattribute vec3 a_projected_pos;\nattribute float a_fade_opacity;\n\n// contents of a_size vary based on the type of property value\n// used for {text,icon}-size.\n// For constants, a_size is disabled.\n// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature.\n// For composite functions:\n// [ text-size(lowerZoomStop, feature),\n// text-size(upperZoomStop, feature) ]\nuniform bool u_is_size_zoom_constant;\nuniform bool u_is_size_feature_constant;\nuniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function\nuniform highp float u_size; // used when size is both zoom and feature constant\n\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\n\nuniform mat4 u_matrix;\nuniform mat4 u_label_plane_matrix;\nuniform mat4 u_gl_coord_matrix;\n\nuniform bool u_is_text;\nuniform bool u_pitch_with_map;\nuniform highp float u_pitch;\nuniform bool u_rotate_symbol;\nuniform highp float u_aspect_ratio;\nuniform highp float u_camera_to_center_distance;\nuniform float u_fade_change;\n\nuniform vec2 u_texsize;\n\nvarying vec2 v_data0;\nvarying vec3 v_data1;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 fill_color\n #pragma mapbox: initialize highp vec4 halo_color\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float halo_width\n #pragma mapbox: initialize lowp float halo_blur\n\n vec2 a_pos = a_pos_offset.xy;\n vec2 a_offset = a_pos_offset.zw;\n\n vec2 a_tex = a_data.xy;\n vec2 a_size = a_data.zw;\n\n highp float segment_angle = -a_projected_pos[2];\n float size;\n\n if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = mix(a_size[0], a_size[1], u_size_t) / 10.0;\n } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = a_size[0] / 10.0;\n } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {\n size = u_size;\n } else {\n size = u_size;\n }\n\n vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n // If the label is pitched with the map, layout is done in pitched space,\n // which makes labels in the distance smaller relative to viewport space.\n // We counteract part of that effect by multiplying by the perspective ratio.\n // If the label isn't pitched with the map, we do layout in viewport space,\n // which makes labels in the distance larger relative to the features around\n // them. We counteract part of that effect by dividing by the perspective ratio.\n highp float distance_ratio = u_pitch_with_map ?\n camera_to_anchor_distance / u_camera_to_center_distance :\n u_camera_to_center_distance / camera_to_anchor_distance;\n highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;\n\n size *= perspective_ratio;\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n highp float symbol_rotation = 0.0;\n if (u_rotate_symbol) {\n // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units\n // To figure out that angle in projected space, we draw a short horizontal line in tile\n // space, project it, and measure its angle in projected space.\n vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);\n\n vec2 a = projectedPoint.xy / projectedPoint.w;\n vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;\n\n symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);\n }\n\n highp float angle_sin = sin(segment_angle + symbol_rotation);\n highp float angle_cos = cos(segment_angle + symbol_rotation);\n mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);\n\n vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);\n gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);\n float gamma_scale = gl_Position.w;\n\n vec2 tex = a_tex / u_texsize;\n vec2 fade_opacity = unpack_opacity(a_fade_opacity);\n float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;\n float interpolated_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));\n\n v_data0 = vec2(tex.x, tex.y);\n v_data1 = vec3(gamma_scale, size, interpolated_fade_opacity);\n}\n"}},i=/#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g,a=function(t){var e=n[t],r={};e.fragmentSource=e.fragmentSource.replace(i,function(t,e,n,i,a){return r[a]=!0,"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nvarying "+n+" "+i+" "+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifdef HAS_UNIFORM_u_"+a+"\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n"}),e.vertexSource=e.vertexSource.replace(i,function(t,e,n,i,a){var o="float"===i?"vec2":"vec4";return r[a]?"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nuniform lowp float a_"+a+"_t;\nattribute "+n+" "+o+" a_"+a+";\nvarying "+n+" "+i+" "+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifndef HAS_UNIFORM_u_"+a+"\n "+a+" = unpack_mix_"+o+"(a_"+a+", a_"+a+"_t);\n#else\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n":"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nuniform lowp float a_"+a+"_t;\nattribute "+n+" "+o+" a_"+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifndef HAS_UNIFORM_u_"+a+"\n "+n+" "+i+" "+a+" = unpack_mix_"+o+"(a_"+a+", a_"+a+"_t);\n#else\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n"})};for(var o in n)a(o);e.exports=n},{}],98:[function(t,e,r){var n=t("./image_source"),i=t("../util/window"),a=t("../data/raster_bounds_attributes"),o=t("../render/vertex_array_object"),s=t("../render/texture"),l=function(t){function e(e,r,n,i){t.call(this,e,r,n,i),this.options=r,this.animate=void 0===r.animate||r.animate}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.load=function(){this.canvas=this.canvas||i.document.getElementById(this.options.canvas),this.width=this.canvas.width,this.height=this.canvas.height,this._hasInvalidDimensions()?this.fire("error",new Error("Canvas dimensions cannot be less than or equal to zero.")):(this.play=function(){this._playing=!0,this.map._rerender()},this.pause=function(){this._playing=!1},this._finishLoading())},e.prototype.getCanvas=function(){return this.canvas},e.prototype.onAdd=function(t){this.map=t,this.load(),this.canvas&&this.animate&&this.play()},e.prototype.onRemove=function(){this.pause()},e.prototype.prepare=function(){var t=this,e=!1;if(this.canvas.width!==this.width&&(this.width=this.canvas.width,e=!0),this.canvas.height!==this.height&&(this.height=this.canvas.height,e=!0),!this._hasInvalidDimensions()&&0!==Object.keys(this.tiles).length){var r=this.map.painter.context,n=r.gl;for(var i in this.boundsBuffer||(this.boundsBuffer=r.createVertexBuffer(this._boundsArray,a.members)),this.boundsVAO||(this.boundsVAO=new o),this.texture?e?this.texture.update(this.canvas):this._playing&&(this.texture.bind(n.LINEAR,n.CLAMP_TO_EDGE),n.texSubImage2D(n.TEXTURE_2D,0,0,0,n.RGBA,n.UNSIGNED_BYTE,this.canvas)):(this.texture=new s(r,this.canvas,n.RGBA),this.texture.bind(n.LINEAR,n.CLAMP_TO_EDGE)),t.tiles){var l=t.tiles[i];"loaded"!==l.state&&(l.state="loaded",l.texture=t.texture)}}},e.prototype.serialize=function(){return{type:"canvas",canvas:this.canvas,coordinates:this.coordinates}},e.prototype.hasTransition=function(){return this._playing},e.prototype._hasInvalidDimensions=function(){for(var t=0,e=[this.canvas.width,this.canvas.height];t0&&(r.resourceTiming=t._resourceTiming,t._resourceTiming=[]),t.fire("data",r)}})},e.prototype.onAdd=function(t){this.map=t,this.load()},e.prototype.setData=function(t){var e=this;return this._data=t,this.fire("dataloading",{dataType:"source"}),this._updateWorkerData(function(t){if(t)return e.fire("error",{error:t});var r={dataType:"source",sourceDataType:"content"};e._collectResourceTiming&&e._resourceTiming&&e._resourceTiming.length>0&&(r.resourceTiming=e._resourceTiming,e._resourceTiming=[]),e.fire("data",r)}),this},e.prototype._updateWorkerData=function(t){var e=this,r=i.extend({},this.workerOptions),n=this._data;"string"==typeof n?(r.request=this.map._transformRequest(function(t){var e=a.document.createElement("a");return e.href=t,e.href}(n),s.Source),r.request.collectResourceTiming=this._collectResourceTiming):r.data=JSON.stringify(n),this.workerID=this.dispatcher.send(this.type+".loadData",r,function(r,n){e._loaded=!0,n&&n.resourceTiming&&n.resourceTiming[e.id]&&(e._resourceTiming=n.resourceTiming[e.id].slice(0)),t(r)},this.workerID)},e.prototype.loadTile=function(t,e){var r=this,n=void 0===t.workerID||"expired"===t.state?"loadTile":"reloadTile",i={type:this.type,uid:t.uid,tileID:t.tileID,zoom:t.tileID.overscaledZ,maxZoom:this.maxzoom,tileSize:this.tileSize,source:this.id,pixelRatio:l.devicePixelRatio,overscaling:t.tileID.overscaleFactor(),showCollisionBoxes:this.map.showCollisionBoxes};t.workerID=this.dispatcher.send(n,i,function(i,a){return t.unloadVectorData(),t.aborted?e(null):i?e(i):(t.loadVectorData(a,r.map.painter,"reloadTile"===n),e(null))},this.workerID)},e.prototype.abortTile=function(t){t.aborted=!0},e.prototype.unloadTile=function(t){t.unloadVectorData(),this.dispatcher.send("removeTile",{uid:t.uid,type:this.type,source:this.id},null,t.workerID)},e.prototype.onRemove=function(){this.dispatcher.broadcast("removeSource",{type:this.type,source:this.id})},e.prototype.serialize=function(){return i.extend({},this._options,{type:this.type,data:this._data})},e.prototype.hasTransition=function(){return!1},e}(n);e.exports=c},{"../data/extent":53,"../util/ajax":251,"../util/browser":252,"../util/evented":260,"../util/util":275,"../util/window":254}],100:[function(t,e,r){function n(t,e){var r=t.source,n=t.tileID.canonical;if(!this._geoJSONIndexes[r])return e(null,null);var i=this._geoJSONIndexes[r].getTile(n.z,n.x,n.y);if(!i)return e(null,null);var a=new s(i.features),o=l(a);0===o.byteOffset&&o.byteLength===o.buffer.byteLength||(o=new Uint8Array(o)),e(null,{vectorTile:a,rawData:o.buffer})}var i=t("../util/ajax"),a=t("../util/performance"),o=t("geojson-rewind"),s=t("./geojson_wrapper"),l=t("vt-pbf"),c=t("supercluster"),u=t("geojson-vt"),f=function(t){function e(e,r,i){t.call(this,e,r,n),i&&(this.loadGeoJSON=i),this._geoJSONIndexes={}}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.loadData=function(t,e){var r=this;this.loadGeoJSON(t,function(n,i){if(n||!i)return e(n);if("object"!=typeof i)return e(new Error("Input data is not a valid GeoJSON object."));o(i,!0);try{r._geoJSONIndexes[t.source]=t.cluster?c(t.superclusterOptions).load(i.features):u(i,t.geojsonVtOptions)}catch(n){return e(n)}r.loaded[t.source]={};var s={};if(t.request&&t.request.collectResourceTiming){var l=a.getEntriesByName(t.request.url);l&&(s.resourceTiming={},s.resourceTiming[t.source]=JSON.parse(JSON.stringify(l)))}e(null,s)})},e.prototype.reloadTile=function(e,r){var n=this.loaded[e.source],i=e.uid;return n&&n[i]?t.prototype.reloadTile.call(this,e,r):this.loadTile(e,r)},e.prototype.loadGeoJSON=function(t,e){if(t.request)i.getJSON(t.request,e);else{if("string"!=typeof t.data)return e(new Error("Input data is not a valid GeoJSON object."));try{return e(null,JSON.parse(t.data))}catch(t){return e(new Error("Input data is not a valid GeoJSON object."))}}},e.prototype.removeSource=function(t,e){this._geoJSONIndexes[t.source]&&delete this._geoJSONIndexes[t.source],e()},e}(t("./vector_tile_worker_source"));e.exports=f},{"../util/ajax":251,"../util/performance":268,"./geojson_wrapper":101,"./vector_tile_worker_source":116,"geojson-rewind":15,"geojson-vt":19,supercluster:32,"vt-pbf":34}],101:[function(t,e,r){var n=t("@mapbox/point-geometry"),i=t("@mapbox/vector-tile").VectorTileFeature.prototype.toGeoJSON,a=t("../data/extent"),o=function(t){this._feature=t,this.extent=a,this.type=t.type,this.properties=t.tags,"id"in t&&!isNaN(t.id)&&(this.id=parseInt(t.id,10))};o.prototype.loadGeometry=function(){if(1===this._feature.type){for(var t=[],e=0,r=this._feature.geometry;e0&&(l[new s(t.overscaledZ,i,e.z,n,e.y-1).key]={backfilled:!1},l[new s(t.overscaledZ,t.wrap,e.z,e.x,e.y-1).key]={backfilled:!1},l[new s(t.overscaledZ,o,e.z,a,e.y-1).key]={backfilled:!1}),e.y+11||(Math.abs(r)>1&&(1===Math.abs(r+i)?r+=i:1===Math.abs(r-i)&&(r-=i)),e.dem&&t.dem&&(t.dem.backfillBorder(e.dem,r,n),t.neighboringTiles&&t.neighboringTiles[a]&&(t.neighboringTiles[a].backfilled=!0)))}for(var r=this.getRenderableIds(),n=0;ne)){var s=Math.pow(2,o.tileID.canonical.z-t.canonical.z);if(Math.floor(o.tileID.canonical.x/s)===t.canonical.x&&Math.floor(o.tileID.canonical.y/s)===t.canonical.y)for(r[a]=o.tileID,i=!0;o&&o.tileID.overscaledZ-1>t.overscaledZ;){var l=o.tileID.scaledTo(o.tileID.overscaledZ-1);if(!l)break;(o=n._tiles[l.key])&&o.hasData()&&(delete r[a],r[l.key]=l)}}}return i},e.prototype.findLoadedParent=function(t,e,r){for(var n=this,i=t.overscaledZ-1;i>=e;i--){var a=t.scaledTo(i);if(!a)return;var o=String(a.key),s=n._tiles[o];if(s&&s.hasData())return r[o]=a,s;if(n._cache.has(o))return r[o]=a,n._cache.get(o)}},e.prototype.updateCacheSize=function(t){var e=(Math.ceil(t.width/this._source.tileSize)+1)*(Math.ceil(t.height/this._source.tileSize)+1),r=Math.floor(5*e),n="number"==typeof this._maxTileCacheSize?Math.min(this._maxTileCacheSize,r):r;this._cache.setMaxSize(n)},e.prototype.update=function(t){var r=this;if(this.transform=t,this._sourceLoaded&&!this._paused){var n;this.updateCacheSize(t),this._coveredTiles={},this.used?this._source.tileID?n=t.getVisibleUnwrappedCoordinates(this._source.tileID).map(function(t){return new d(t.canonical.z,t.wrap,t.canonical.z,t.canonical.x,t.canonical.y)}):(n=t.coveringTiles({tileSize:this._source.tileSize,minzoom:this._source.minzoom,maxzoom:this._source.maxzoom,roundZoom:this._source.roundZoom,reparseOverscaled:this._source.reparseOverscaled}),this._source.hasTile&&(n=n.filter(function(t){return r._source.hasTile(t)}))):n=[];var a,o=(this._source.roundZoom?Math.round:Math.floor)(this.getZoom(t)),s=Math.max(o-e.maxOverzooming,this._source.minzoom),l=Math.max(o+e.maxUnderzooming,this._source.minzoom),c=this._updateRetainedTiles(n,o),f={};if(i(this._source.type))for(var h=Object.keys(c),g=0;g=p.now())){r._findLoadedChildren(v,l,c)&&(c[m]=v);var x=r.findLoadedParent(v,s,f);x&&r._addTile(x.tileID)}}for(a in f)c[a]||(r._coveredTiles[a]=!0);for(a in f)c[a]=f[a];for(var b=u.keysDifference(this._tiles,c),_=0;_n._source.maxzoom){var p=c.children(n._source.maxzoom)[0],d=n.getTile(p);d&&d.hasData()?i[p.key]=p:h=!1}else{n._findLoadedChildren(c,s,i);for(var g=c.children(n._source.maxzoom),m=0;m=o;--v){var y=c.scaledTo(v);if(a[y.key])break;if(a[y.key]=!0,!(u=n.getTile(y))&&f&&(u=n._addTile(y)),u&&(i[y.key]=y,f=u.wasRequested(),u.hasData()))break}}}return i},e.prototype._addTile=function(t){var e=this._tiles[t.key];if(e)return e;(e=this._cache.getAndRemove(t.key))&&this._cacheTimers[t.key]&&(clearTimeout(this._cacheTimers[t.key]),delete this._cacheTimers[t.key],this._setTileReloadTimer(t.key,e));var r=Boolean(e);return r||(e=new o(t,this._source.tileSize*t.overscaleFactor()),this._loadTile(e,this._tileLoaded.bind(this,e,t.key,e.state))),e?(e.uses++,this._tiles[t.key]=e,r||this._source.fire("dataloading",{tile:e,coord:e.tileID,dataType:"source"}),e):null},e.prototype._setTileReloadTimer=function(t,e){var r=this;t in this._timers&&(clearTimeout(this._timers[t]),delete this._timers[t]);var n=e.getExpiryTimeout();n&&(this._timers[t]=setTimeout(function(){r._reloadTile(t,"expired"),delete r._timers[t]},n))},e.prototype._setCacheInvalidationTimer=function(t,e){var r=this;t in this._cacheTimers&&(clearTimeout(this._cacheTimers[t]),delete this._cacheTimers[t]);var n=e.getExpiryTimeout();n&&(this._cacheTimers[t]=setTimeout(function(){r._cache.remove(t),delete r._cacheTimers[t]},n))},e.prototype._removeTile=function(t){var e=this._tiles[t];if(e&&(e.uses--,delete this._tiles[t],this._timers[t]&&(clearTimeout(this._timers[t]),delete this._timers[t]),!(e.uses>0)))if(e.hasData()){e.tileID=e.tileID.wrapped();var r=e.tileID.key;this._cache.add(r,e),this._setCacheInvalidationTimer(r,e)}else e.aborted=!0,this._abortTile(e),this._unloadTile(e)},e.prototype.clearTiles=function(){for(var t in this._shouldReloadOnResume=!1,this._paused=!1,this._tiles)this._removeTile(t);this._resetCache()},e.prototype._resetCache=function(){for(var t in this._cacheTimers)clearTimeout(this._cacheTimers[t]);this._cacheTimers={},this._cache.reset()},e.prototype.tilesIn=function(t){for(var e=[],r=this.getIds(),i=1/0,a=1/0,o=-1/0,s=-1/0,l=t[0].zoom,u=0;u=0&&m[1].y>=0){for(var v=[],y=0;y=p.now())return!0}return!1},e}(s);g.maxOverzooming=10,g.maxUnderzooming=3,e.exports=g},{"../data/extent":53,"../geo/coordinate":61,"../gl/context":66,"../util/browser":252,"../util/evented":260,"../util/lru_cache":266,"../util/util":275,"./source":110,"./tile":112,"./tile_id":114,"@mapbox/point-geometry":4}],112:[function(t,e,r){var n=t("../util/util"),i=t("../data/bucket").deserialize,a=(t("../data/feature_index"),t("@mapbox/vector-tile")),o=t("pbf"),s=t("../util/vectortile_to_geojson"),l=t("../style-spec/feature_filter"),c=(t("../symbol/collision_index"),t("../data/bucket/symbol_bucket")),u=t("../data/array_types"),f=u.RasterBoundsArray,h=u.CollisionBoxArray,p=t("../data/raster_bounds_attributes"),d=t("../data/extent"),g=t("@mapbox/point-geometry"),m=t("../render/texture"),v=t("../data/segment").SegmentVector,y=t("../data/index_array_type").TriangleIndexArray,x=t("../util/browser"),b=function(t,e){this.tileID=t,this.uid=n.uniqueId(),this.uses=0,this.tileSize=e,this.buckets={},this.expirationTime=null,this.expiredRequestCount=0,this.state="loading"};b.prototype.registerFadeDuration=function(t){var e=t+this.timeAdded;e>s.z,c=new g(s.x*l,s.y*l),u=new g(c.x+l,c.y+l),h=this.segments.prepareSegment(4,r,i);r.emplaceBack(c.x,c.y,c.x,c.y),r.emplaceBack(u.x,c.y,u.x,c.y),r.emplaceBack(c.x,u.y,c.x,u.y),r.emplaceBack(u.x,u.y,u.x,u.y);var m=h.vertexLength;i.emplaceBack(m,m+1,m+2),i.emplaceBack(m+1,m+2,m+3),h.vertexLength+=4,h.primitiveLength+=2}this.maskedBoundsBuffer=e.createVertexBuffer(r,p.members),this.maskedIndexBuffer=e.createIndexBuffer(i)}},b.prototype.hasData=function(){return"loaded"===this.state||"reloading"===this.state||"expired"===this.state},b.prototype.setExpiryData=function(t){var e=this.expirationTime;if(t.cacheControl){var r=n.parseCacheControl(t.cacheControl);r["max-age"]&&(this.expirationTime=Date.now()+1e3*r["max-age"])}else t.expires&&(this.expirationTime=new Date(t.expires).getTime());if(this.expirationTime){var i=Date.now(),a=!1;if(this.expirationTime>i)a=!1;else if(e)if(this.expirationTime=e&&t.x=r&&t.y0;a--)i+=(e&(n=1<this.canonical.z?new c(t,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y):new c(t,this.wrap,t,this.canonical.x>>e,this.canonical.y>>e)},c.prototype.isChildOf=function(t){var e=this.canonical.z-t.canonical.z;return 0===t.overscaledZ||t.overscaledZ>e&&t.canonical.y===this.canonical.y>>e},c.prototype.children=function(t){if(this.overscaledZ>=t)return[new c(this.overscaledZ+1,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y)];var e=this.canonical.z+1,r=2*this.canonical.x,n=2*this.canonical.y;return[new c(e,this.wrap,e,r,n),new c(e,this.wrap,e,r+1,n),new c(e,this.wrap,e,r,n+1),new c(e,this.wrap,e,r+1,n+1)]},c.prototype.isLessThan=function(t){return this.wrapt.wrap)&&(this.overscaledZt.overscaledZ)&&(this.canonical.xt.canonical.x)&&this.canonical.y=E.maxzoom||"none"===E.visibility||(n(C,d.zoom),(v[E.id]=E.createBucket({index:m.bucketLayerIDs.length,layers:C,zoom:d.zoom,pixelRatio:d.pixelRatio,overscaling:d.overscaling,collisionBoxArray:d.collisionBoxArray})).populate(k,y),m.bucketLayerIDs.push(C.map(function(t){return t.id})))}}}var L,z,P,D=c.mapObject(y.glyphDependencies,function(t){return Object.keys(t).map(Number)});Object.keys(D).length?r.send("getGlyphs",{uid:this.uid,stacks:D},function(t,e){L||(L=t,z=e,p.call(d))}):z={};var O=Object.keys(y.iconDependencies);O.length?r.send("getImages",{icons:O},function(t,e){L||(L=t,P=e,p.call(d))}):P={},p.call(this)},e.exports=d},{"../data/array_types":39,"../data/bucket/symbol_bucket":51,"../data/feature_index":54,"../render/glyph_atlas":85,"../render/image_atlas":87,"../style/evaluation_parameters":182,"../symbol/symbol_layout":227,"../util/dictionary_coder":257,"../util/util":275,"./tile_id":114}],120:[function(t,e,r){function n(t,e){var r={};for(var n in t)"ref"!==n&&(r[n]=t[n]);return i.forEach(function(t){t in e&&(r[t]=e[t])}),r}var i=t("./util/ref_properties");e.exports=function(t){t=t.slice();for(var e=Object.create(null),r=0;r4)return e.error("Expected 1, 2, or 3 arguments, but found "+(t.length-1)+" instead.");var r,n;if(t.length>2){var i=t[1];if("string"!=typeof i||!(i in p))return e.error('The item type argument of "array" must be one of string, number, boolean',1);r=p[i]}else r=o;if(t.length>3){if("number"!=typeof t[2]||t[2]<0||t[2]!==Math.floor(t[2]))return e.error('The length argument to "array" must be a positive integer literal',2);n=t[2]}var s=a(r,n),l=e.parse(t[t.length-1],t.length-1,o);return l?new d(s,l):null},d.prototype.evaluate=function(t){var e=this.input.evaluate(t);if(u(this.type,f(e)))throw new h("Expected value to be of type "+i(this.type)+", but found "+i(f(e))+" instead.");return e},d.prototype.eachChild=function(t){t(this.input)},d.prototype.possibleOutputs=function(){return this.input.possibleOutputs()},e.exports=d},{"../runtime_error":143,"../types":146,"../values":147}],125:[function(t,e,r){var n=t("../types"),i=n.ObjectType,a=n.ValueType,o=n.StringType,s=n.NumberType,l=n.BooleanType,c=t("../runtime_error"),u=t("../types"),f=u.checkSubtype,h=u.toString,p=t("../values").typeOf,d={string:o,number:s,boolean:l,object:i},g=function(t,e){this.type=t,this.args=e};g.parse=function(t,e){if(t.length<2)return e.error("Expected at least one argument.");for(var r=t[0],n=d[r],i=[],o=1;o=r.length)throw new s("Array index out of bounds: "+e+" > "+r.length+".");if(e!==Math.floor(e))throw new s("Array index must be an integer, but found "+e+" instead.");return r[e]},l.prototype.eachChild=function(t){t(this.index),t(this.input)},l.prototype.possibleOutputs=function(){return[void 0]},e.exports=l},{"../runtime_error":143,"../types":146}],127:[function(t,e,r){var n=t("../types").BooleanType,i=function(t,e,r){this.type=t,this.branches=e,this.otherwise=r};i.parse=function(t,e){if(t.length<4)return e.error("Expected at least 3 arguments, but found only "+(t.length-1)+".");if(t.length%2!=0)return e.error("Expected an odd number of arguments.");var r;e.expectedType&&"value"!==e.expectedType.kind&&(r=e.expectedType);for(var a=[],o=1;o4?"Invalid rbga value "+JSON.stringify(e)+": expected an array containing either three or four numeric values.":c(e[0],e[1],e[2],e[3])))return new l(e[0]/255,e[1]/255,e[2]/255,e[3]);throw new u(r||"Could not parse color from value '"+("string"==typeof e?e:JSON.stringify(e))+"'")}for(var o=null,s=0,f=this.args;sn.evaluate(t)}function c(t,e){var r=e[0],n=e[1];return r.evaluate(t)<=n.evaluate(t)}function u(t,e){var r=e[0],n=e[1];return r.evaluate(t)>=n.evaluate(t)}var f=t("../types"),h=f.NumberType,p=f.StringType,d=f.BooleanType,g=f.ColorType,m=f.ObjectType,v=f.ValueType,y=f.ErrorType,x=f.array,b=f.toString,_=t("../values"),w=_.typeOf,k=_.Color,M=_.validateRGBA,A=t("../compound_expression"),T=A.CompoundExpression,S=A.varargs,C=t("../runtime_error"),E=t("./let"),L=t("./var"),z=t("./literal"),P=t("./assertion"),D=t("./array"),O=t("./coercion"),I=t("./at"),R=t("./match"),B=t("./case"),F=t("./step"),N=t("./interpolate"),j=t("./coalesce"),V=t("./equals"),U={"==":V.Equals,"!=":V.NotEquals,array:D,at:I,boolean:P,case:B,coalesce:j,interpolate:N,let:E,literal:z,match:R,number:P,object:P,step:F,string:P,"to-color":O,"to-number":O,var:L};T.register(U,{error:[y,[p],function(t,e){var r=e[0];throw new C(r.evaluate(t))}],typeof:[p,[v],function(t,e){var r=e[0];return b(w(r.evaluate(t)))}],"to-string":[p,[v],function(t,e){var r=e[0],n=typeof(r=r.evaluate(t));return null===r||"string"===n||"number"===n||"boolean"===n?String(r):r instanceof k?r.toString():JSON.stringify(r)}],"to-boolean":[d,[v],function(t,e){var r=e[0];return Boolean(r.evaluate(t))}],"to-rgba":[x(h,4),[g],function(t,e){var r=e[0].evaluate(t),n=r.r,i=r.g,a=r.b,o=r.a;return[255*n/o,255*i/o,255*a/o,o]}],rgb:[g,[h,h,h],n],rgba:[g,[h,h,h,h],n],length:{type:h,overloads:[[[p],o],[[x(v)],o]]},has:{type:d,overloads:[[[p],function(t,e){return i(e[0].evaluate(t),t.properties())}],[[p,m],function(t,e){var r=e[0],n=e[1];return i(r.evaluate(t),n.evaluate(t))}]]},get:{type:v,overloads:[[[p],function(t,e){return a(e[0].evaluate(t),t.properties())}],[[p,m],function(t,e){var r=e[0],n=e[1];return a(r.evaluate(t),n.evaluate(t))}]]},properties:[m,[],function(t){return t.properties()}],"geometry-type":[p,[],function(t){return t.geometryType()}],id:[v,[],function(t){return t.id()}],zoom:[h,[],function(t){return t.globals.zoom}],"heatmap-density":[h,[],function(t){return t.globals.heatmapDensity||0}],"+":[h,S(h),function(t,e){for(var r=0,n=0,i=e;n":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i>a}],"filter-id->":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>i}],"filter-<=":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i<=a}],"filter-id-<=":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n<=i}],"filter->=":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i>=a}],"filter-id->=":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>=i}],"filter-has":[d,[v],function(t,e){return e[0].value in t.properties()}],"filter-has-id":[d,[],function(t){return null!==t.id()}],"filter-type-in":[d,[x(p)],function(t,e){return e[0].value.indexOf(t.geometryType())>=0}],"filter-id-in":[d,[x(v)],function(t,e){return e[0].value.indexOf(t.id())>=0}],"filter-in-small":[d,[p,x(v)],function(t,e){var r=e[0];return e[1].value.indexOf(t.properties()[r.value])>=0}],"filter-in-large":[d,[p,x(v)],function(t,e){var r=e[0],n=e[1];return function(t,e,r,n){for(;r<=n;){var i=r+n>>1;if(e[i]===t)return!0;e[i]>t?n=i-1:r=i+1}return!1}(t.properties()[r.value],n.value,0,n.value.length-1)}],">":{type:d,overloads:[[[h,h],l],[[p,p],l]]},"<":{type:d,overloads:[[[h,h],s],[[p,p],s]]},">=":{type:d,overloads:[[[h,h],u],[[p,p],u]]},"<=":{type:d,overloads:[[[h,h],c],[[p,p],c]]},all:{type:d,overloads:[[[d,d],function(t,e){var r=e[0],n=e[1];return r.evaluate(t)&&n.evaluate(t)}],[S(d),function(t,e){for(var r=0,n=e;r1}))return e.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.",1);r={name:"cubic-bezier",controlPoints:o}}if(t.length-1<4)return e.error("Expected at least 4 arguments, but found only "+(t.length-1)+".");if((t.length-1)%2!=0)return e.error("Expected an even number of arguments.");if(!(n=e.parse(n,2,l)))return null;var c=[],f=null;e.expectedType&&"value"!==e.expectedType.kind&&(f=e.expectedType);for(var h=0;h=p)return e.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.',g);var v=e.parse(d,m,f);if(!v)return null;f=f||v.type,c.push([p,v])}return"number"===f.kind||"color"===f.kind||"array"===f.kind&&"number"===f.itemType.kind&&"number"==typeof f.N?new u(f,r,n,c):e.error("Type "+s(f)+" is not interpolatable.")},u.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var i=e.length;if(n>=e[i-1])return r[i-1].evaluate(t);var o=c(e,n),s=e[o],l=e[o+1],f=u.interpolationFactor(this.interpolation,n,s,l),h=r[o].evaluate(t),p=r[o+1].evaluate(t);return a[this.type.kind.toLowerCase()](h,p,f)},u.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;eNumber.MAX_SAFE_INTEGER)return f.error("Branch labels must be integers no larger than "+Number.MAX_SAFE_INTEGER+".");if("number"==typeof d&&Math.floor(d)!==d)return f.error("Numeric branch labels must be integer values.");if(r){if(f.checkSubtype(r,n(d)))return null}else r=n(d);if(void 0!==o[String(d)])return f.error("Branch labels must be unique.");o[String(d)]=s.length}var g=e.parse(u,l,a);if(!g)return null;a=a||g.type,s.push(g)}var m=e.parse(t[1],1,r);if(!m)return null;var v=e.parse(t[t.length-1],t.length-1,a);return v?new i(r,a,m,o,s,v):null},i.prototype.evaluate=function(t){var e=this.input.evaluate(t);return(this.outputs[this.cases[e]]||this.otherwise).evaluate(t)},i.prototype.eachChild=function(t){t(this.input),this.outputs.forEach(t),t(this.otherwise)},i.prototype.possibleOutputs=function(){return(t=[]).concat.apply(t,this.outputs.map(function(t){return t.possibleOutputs()})).concat(this.otherwise.possibleOutputs());var t},e.exports=i},{"../values":147}],136:[function(t,e,r){var n=t("../types").NumberType,i=t("../stops").findStopLessThanOrEqualTo,a=function(t,e,r){this.type=t,this.input=e,this.labels=[],this.outputs=[];for(var n=0,i=r;n=c)return e.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.',f);var p=e.parse(u,h,s);if(!p)return null;s=s||p.type,o.push([c,p])}return new a(s,r,o)},a.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var a=e.length;return n>=e[a-1]?r[a-1].evaluate(t):r[i(e,n)].evaluate(t)},a.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;e0&&"string"==typeof t[0]&&t[0]in g}function i(t,e,r){void 0===r&&(r={});var n=new l(g,[],function(t){var e={color:z,string:P,number:D,enum:P,boolean:O};return"array"===t.type?R(e[t.value]||I,t.length):e[t.type]||null}(e)),i=n.parse(t);return i?x(!1===r.handleErrors?new _(i):new w(i,e)):b(n.errors)}function a(t,e,r){if(void 0===r&&(r={}),"error"===(t=i(t,e,r)).result)return t;var n=t.value.expression,a=m.isFeatureConstant(n);if(!a&&!e["property-function"])return b([new s("","property expressions not supported")]);var o=m.isGlobalPropertyConstant(n,["zoom"]);if(!o&&!1===e["zoom-function"])return b([new s("","zoom expressions not supported")]);var l=function t(e){var r=null;if(e instanceof d)r=t(e.result);else if(e instanceof p)for(var n=0,i=e.args;n=0)return!1;var i=!0;return e.eachChild(function(e){i&&!t(e,r)&&(i=!1)}),i}}},{"./compound_expression":123}],141:[function(t,e,r){var n=t("./scope"),i=t("./types").checkSubtype,a=t("./parsing_error"),o=t("./definitions/literal"),s=t("./definitions/assertion"),l=t("./definitions/array"),c=t("./definitions/coercion"),u=function(t,e,r,i,a){void 0===e&&(e=[]),void 0===i&&(i=new n),void 0===a&&(a=[]),this.registry=t,this.path=e,this.key=e.map(function(t){return"["+t+"]"}).join(""),this.scope=i,this.errors=a,this.expectedType=r};u.prototype.parse=function(e,r,n,i,a){void 0===a&&(a={});var u=this;if(r&&(u=u.concat(r,n,i)),null!==e&&"string"!=typeof e&&"boolean"!=typeof e&&"number"!=typeof e||(e=["literal",e]),Array.isArray(e)){if(0===e.length)return u.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');var f=e[0];if("string"!=typeof f)return u.error("Expression name must be a string, but found "+typeof f+' instead. If you wanted a literal array, use ["literal", [...]].',0),null;var h=u.registry[f];if(h){var p=h.parse(e,u);if(!p)return null;if(u.expectedType){var d=u.expectedType,g=p.type;if("string"!==d.kind&&"number"!==d.kind&&"boolean"!==d.kind||"value"!==g.kind)if("array"===d.kind&&"value"===g.kind)a.omitTypeAnnotations||(p=new l(d,p));else if("color"!==d.kind||"value"!==g.kind&&"string"!==g.kind){if(u.checkSubtype(u.expectedType,p.type))return null}else a.omitTypeAnnotations||(p=new c(d,[p]));else a.omitTypeAnnotations||(p=new s(d,[p]))}if(!(p instanceof o)&&function(e){var r=t("./compound_expression").CompoundExpression,n=t("./is_constant"),i=n.isGlobalPropertyConstant,a=n.isFeatureConstant;if(e instanceof t("./definitions/var"))return!1;if(e instanceof r&&"error"===e.name)return!1;var s=!0;return e.eachChild(function(t){t instanceof o||(s=!1)}),!!s&&a(e)&&i(e,["zoom","heatmap-density"])}(p)){var m=new(t("./evaluation_context"));try{p=new o(p.type,p.evaluate(m))}catch(e){return u.error(e.message),null}}return p}return u.error('Unknown expression "'+f+'". If you wanted a literal array, use ["literal", [...]].',0)}return void 0===e?u.error("'undefined' value invalid. Use null instead."):"object"==typeof e?u.error('Bare objects invalid. Use ["literal", {...}] instead.'):u.error("Expected an array, but found "+typeof e+" instead.")},u.prototype.concat=function(t,e,r){var n="number"==typeof t?this.path.concat(t):this.path,i=r?this.scope.concat(r):this.scope;return new u(this.registry,n,e||null,i,this.errors)},u.prototype.error=function(t){for(var e=arguments,r=[],n=arguments.length-1;n-- >0;)r[n]=e[n+1];var i=""+this.key+r.map(function(t){return"["+t+"]"}).join("");this.errors.push(new a(i,t))},u.prototype.checkSubtype=function(t,e){var r=i(t,e);return r&&this.error(r),r},e.exports=u},{"./compound_expression":123,"./definitions/array":124,"./definitions/assertion":125,"./definitions/coercion":129,"./definitions/literal":134,"./definitions/var":137,"./evaluation_context":138,"./is_constant":140,"./parsing_error":142,"./scope":144,"./types":146}],142:[function(t,e,r){var n=function(t){function e(e,r){t.call(this,r),this.message=r,this.key=e}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(Error);e.exports=n},{}],143:[function(t,e,r){var n=function(t){this.name="ExpressionEvaluationError",this.message=t};n.prototype.toJSON=function(){return this.message},e.exports=n},{}],144:[function(t,e,r){var n=function(t,e){void 0===e&&(e=[]),this.parent=t,this.bindings={};for(var r=0,n=e;rr&&ee))throw new n("Input is not a number.");o=s-1}}return Math.max(s-1,0)}}},{"./runtime_error":143}],146:[function(t,e,r){function n(t,e){return{kind:"array",itemType:t,N:e}}function i(t){if("array"===t.kind){var e=i(t.itemType);return"number"==typeof t.N?"array<"+e+", "+t.N+">":"value"===t.itemType.kind?"array":"array<"+e+">"}return t.kind}var a={kind:"null"},o={kind:"number"},s={kind:"string"},l={kind:"boolean"},c={kind:"color"},u={kind:"object"},f={kind:"value"},h=[a,o,s,l,c,u,n(f)];e.exports={NullType:a,NumberType:o,StringType:s,BooleanType:l,ColorType:c,ObjectType:u,ValueType:f,array:n,ErrorType:{kind:"error"},toString:i,checkSubtype:function t(e,r){if("error"===r.kind)return null;if("array"===e.kind){if("array"===r.kind&&!t(e.itemType,r.itemType)&&("number"!=typeof e.N||e.N===r.N))return null}else{if(e.kind===r.kind)return null;if("value"===e.kind)for(var n=0,a=h;n=0&&t<=255&&"number"==typeof e&&e>=0&&e<=255&&"number"==typeof r&&r>=0&&r<=255?void 0===n||"number"==typeof n&&n>=0&&n<=1?null:"Invalid rgba value ["+[t,e,r,n].join(", ")+"]: 'a' must be between 0 and 1.":"Invalid rgba value ["+("number"==typeof n?[t,e,r,n]:[t,e,r]).join(", ")+"]: 'r', 'g', and 'b' must be between 0 and 255."},isValue:function t(e){if(null===e)return!0;if("string"==typeof e)return!0;if("boolean"==typeof e)return!0;if("number"==typeof e)return!0;if(e instanceof n)return!0;if(Array.isArray(e)){for(var r=0,i=e;r=2&&"$id"!==t[1]&&"$type"!==t[1];case"in":case"!in":case"!has":case"none":return!1;case"==":case"!=":case">":case">=":case"<":case"<=":return 3===t.length&&(Array.isArray(t[1])||Array.isArray(t[2]));case"any":case"all":for(var e=0,r=t.slice(1);ee?1:0}function a(t){if(!t)return!0;var e=t[0];return t.length<=1?"any"!==e:"=="===e?o(t[1],t[2],"=="):"!="===e?c(o(t[1],t[2],"==")):"<"===e||">"===e||"<="===e||">="===e?o(t[1],t[2],e):"any"===e?function(t){return["any"].concat(t.map(a))}(t.slice(1)):"all"===e?["all"].concat(t.slice(1).map(a)):"none"===e?["all"].concat(t.slice(1).map(a).map(c)):"in"===e?s(t[1],t.slice(2)):"!in"===e?c(s(t[1],t.slice(2))):"has"===e?l(t[1]):"!has"!==e||c(l(t[1]))}function o(t,e,r){switch(t){case"$type":return["filter-type-"+r,e];case"$id":return["filter-id-"+r,e];default:return["filter-"+r,t,e]}}function s(t,e){if(0===e.length)return!1;switch(t){case"$type":return["filter-type-in",["literal",e]];case"$id":return["filter-id-in",["literal",e]];default:return e.length>200&&!e.some(function(t){return typeof t!=typeof e[0]})?["filter-in-large",t,["literal",e.sort(i)]]:["filter-in-small",t,["literal",e]]}}function l(t){switch(t){case"$type":return!0;case"$id":return["filter-has-id"];default:return["filter-has",t]}}function c(t){return["!",t]}var u=t("../expression").createExpression;e.exports=function(t){if(!t)return function(){return!0};n(t)||(t=a(t));var e=u(t,f);if("error"===e.result)throw new Error(e.value.map(function(t){return t.key+": "+t.message}).join(", "));return function(t,r){return e.value.evaluate(t,r)}},e.exports.isExpressionFilter=n;var f={type:"boolean",default:!1,function:!0,"property-function":!0,"zoom-function":!0}},{"../expression":139}],149:[function(t,e,r){function n(t){return t}function i(t,e,r){return void 0!==t?t:void 0!==e?e:void 0!==r?r:void 0}function a(t,e,r,n,a){return i(typeof r===a?n[r]:void 0,t.default,e.default)}function o(t,e,r){if("number"!==p(r))return i(t.default,e.default);var n=t.stops.length;if(1===n)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[n-1][0])return t.stops[n-1][1];var a=c(t.stops,r);return t.stops[a][1]}function s(t,e,r){var a=void 0!==t.base?t.base:1;if("number"!==p(r))return i(t.default,e.default);var o=t.stops.length;if(1===o)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[o-1][0])return t.stops[o-1][1];var s=c(t.stops,r),l=function(t,e,r,n){var i=n-r,a=t-r;return 0===i?0:1===e?a/i:(Math.pow(e,a)-1)/(Math.pow(e,i)-1)}(r,a,t.stops[s][0],t.stops[s+1][0]),f=t.stops[s][1],h=t.stops[s+1][1],g=d[e.type]||n;if(t.colorSpace&&"rgb"!==t.colorSpace){var m=u[t.colorSpace];g=function(t,e){return m.reverse(m.interpolate(m.forward(t),m.forward(e),l))}}return"function"==typeof f.evaluate?{evaluate:function(){for(var t=arguments,e=[],r=arguments.length;r--;)e[r]=t[r];var n=f.evaluate.apply(void 0,e),i=h.evaluate.apply(void 0,e);if(void 0!==n&&void 0!==i)return g(n,i,l)}}:g(f,h,l)}function l(t,e,r){return"color"===e.type?r=f.parse(r):p(r)===e.type||"enum"===e.type&&e.values[r]||(r=void 0),i(r,t.default,e.default)}function c(t,e){for(var r,n,i=0,a=t.length-1,o=0;i<=a;){if(r=t[o=Math.floor((i+a)/2)][0],n=t[o+1][0],e===r||e>r&&ee&&(a=o-1)}return Math.max(o-1,0)}var u=t("../util/color_spaces"),f=t("../util/color"),h=t("../util/extend"),p=t("../util/get_type"),d=t("../util/interpolate"),g=t("../expression/definitions/interpolate");e.exports={createFunction:function t(e,r){var n,c,p,d="color"===r.type,m=e.stops&&"object"==typeof e.stops[0][0],v=m||void 0!==e.property,y=m||!v,x=e.type||("interpolated"===r.function?"exponential":"interval");if(d&&((e=h({},e)).stops&&(e.stops=e.stops.map(function(t){return[t[0],f.parse(t[1])]})),e.default?e.default=f.parse(e.default):e.default=f.parse(r.default)),e.colorSpace&&"rgb"!==e.colorSpace&&!u[e.colorSpace])throw new Error("Unknown color space: "+e.colorSpace);if("exponential"===x)n=s;else if("interval"===x)n=o;else if("categorical"===x){n=a,c=Object.create(null);for(var b=0,_=e.stops;b<_.length;b+=1){var w=_[b];c[w[0]]=w[1]}p=typeof e.stops[0][0]}else{if("identity"!==x)throw new Error('Unknown function type "'+x+'"');n=l}if(m){for(var k={},M=[],A=0;A":{},">=":{},"<":{},"<=":{},in:{},"!in":{},all:{},any:{},none:{},has:{},"!has":{}}},geometry_type:{type:"enum",values:{Point:{},LineString:{},Polygon:{}}},function:{expression:{type:"expression"},stops:{type:"array",value:"function_stop"},base:{type:"number",default:1,minimum:0},property:{type:"string",default:"$zoom"},type:{type:"enum",values:{identity:{},exponential:{},interval:{},categorical:{}},default:"exponential"},colorSpace:{type:"enum",values:{rgb:{},lab:{},hcl:{}},default:"rgb"},default:{type:"*",required:!1}},function_stop:{type:"array",minimum:0,maximum:22,value:["number","color"],length:2},expression:{type:"array",value:"*",minimum:1},expression_name:{type:"enum",values:{let:{group:"Variable binding"},var:{group:"Variable binding"},literal:{group:"Types"},array:{group:"Types"},at:{group:"Lookup"},case:{group:"Decision"},match:{group:"Decision"},coalesce:{group:"Decision"},step:{group:"Ramps, scales, curves"},interpolate:{group:"Ramps, scales, curves"},ln2:{group:"Math"},pi:{group:"Math"},e:{group:"Math"},typeof:{group:"Types"},string:{group:"Types"},number:{group:"Types"},boolean:{group:"Types"},object:{group:"Types"},"to-string":{group:"Types"},"to-number":{group:"Types"},"to-boolean":{group:"Types"},"to-rgba":{group:"Color"},"to-color":{group:"Types"},rgb:{group:"Color"},rgba:{group:"Color"},get:{group:"Lookup"},has:{group:"Lookup"},length:{group:"Lookup"},properties:{group:"Feature data"},"geometry-type":{group:"Feature data"},id:{group:"Feature data"},zoom:{group:"Zoom"},"heatmap-density":{group:"Heatmap"},"+":{group:"Math"},"*":{group:"Math"},"-":{group:"Math"},"/":{group:"Math"},"%":{group:"Math"},"^":{group:"Math"},sqrt:{group:"Math"},log10:{group:"Math"},ln:{group:"Math"},log2:{group:"Math"},sin:{group:"Math"},cos:{group:"Math"},tan:{group:"Math"},asin:{group:"Math"},acos:{group:"Math"},atan:{group:"Math"},min:{group:"Math"},max:{group:"Math"},"==":{group:"Decision"},"!=":{group:"Decision"},">":{group:"Decision"},"<":{group:"Decision"},">=":{group:"Decision"},"<=":{group:"Decision"},all:{group:"Decision"},any:{group:"Decision"},"!":{group:"Decision"},upcase:{group:"String"},downcase:{group:"String"},concat:{group:"String"}}},light:{anchor:{type:"enum",default:"viewport",values:{map:{},viewport:{}},transition:!1,"zoom-function":!0,"property-function":!1,function:"piecewise-constant"},position:{type:"array",default:[1.15,210,30],length:3,value:"number",transition:!0,function:"interpolated","zoom-function":!0,"property-function":!1},color:{type:"color",default:"#ffffff",function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},intensity:{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint:["paint_fill","paint_line","paint_circle","paint_heatmap","paint_fill-extrusion","paint_symbol","paint_raster","paint_hillshade","paint_background"],paint_fill:{"fill-antialias":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!0},"fill-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"fill-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"}]},"fill-outline-color":{type:"color",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"},{"fill-antialias":!0}]},"fill-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-translate"]},"fill-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0}},"paint_fill-extrusion":{"fill-extrusion-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!1,default:1,minimum:0,maximum:1,transition:!0},"fill-extrusion-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-extrusion-pattern"}]},"fill-extrusion-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-extrusion-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-extrusion-translate"]},"fill-extrusion-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"fill-extrusion-height":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0},"fill-extrusion-base":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0,requires:["fill-extrusion-height"]}},paint_line:{"line-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"line-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"line-pattern"}]},"line-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"line-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["line-translate"]},"line-width":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-gap-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-offset":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-dasharray":{type:"array",value:"number",function:"piecewise-constant","zoom-function":!0,minimum:0,transition:!0,units:"line widths",requires:[{"!":"line-pattern"}]},"line-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0}},paint_circle:{"circle-radius":{type:"number",default:5,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-blur":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"circle-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["circle-translate"]},"circle-pitch-scale":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map"},"circle-pitch-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"circle-stroke-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-stroke-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-stroke-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0}},paint_heatmap:{"heatmap-radius":{type:"number",default:30,minimum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"heatmap-weight":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!1},"heatmap-intensity":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},"heatmap-color":{type:"color",default:["interpolate",["linear"],["heatmap-density"],0,"rgba(0, 0, 255, 0)",.1,"royalblue",.3,"cyan",.5,"lime",.7,"yellow",1,"red"],function:"interpolated","zoom-function":!1,"property-function":!1,transition:!1},"heatmap-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint_symbol:{"icon-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["icon-image","icon-translate"]},"text-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["text-field","text-translate"]}},paint_raster:{"raster-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-hue-rotate":{type:"number",default:0,period:360,function:"interpolated","zoom-function":!0,transition:!0,units:"degrees"},"raster-brightness-min":{type:"number",function:"interpolated","zoom-function":!0,default:0,minimum:0,maximum:1,transition:!0},"raster-brightness-max":{type:"number",function:"interpolated","zoom-function":!0,default:1,minimum:0,maximum:1,transition:!0},"raster-saturation":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-contrast":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-fade-duration":{type:"number",default:300,minimum:0,function:"interpolated","zoom-function":!0,transition:!1,units:"milliseconds"}},paint_hillshade:{"hillshade-illumination-direction":{type:"number",default:335,minimum:0,maximum:359,function:"interpolated","zoom-function":!0,transition:!1},"hillshade-illumination-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"hillshade-exaggeration":{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"hillshade-shadow-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-highlight-color":{type:"color",default:"#FFFFFF",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-accent-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0}},paint_background:{"background-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0,requires:[{"!":"background-pattern"}]},"background-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"background-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0}},transition:{duration:{type:"number",default:300,minimum:0,units:"milliseconds"},delay:{type:"number",default:0,minimum:0,units:"milliseconds"}}}},{}],153:[function(t,e,r){var n=t("csscolorparser").parseCSSColor,i=function(t,e,r,n){void 0===n&&(n=1),this.r=t,this.g=e,this.b=r,this.a=n};i.parse=function(t){if(t){if(t instanceof i)return t;if("string"==typeof t){var e=n(t);if(e)return new i(e[0]/255*e[3],e[1]/255*e[3],e[2]/255*e[3],e[3])}}},i.prototype.toString=function(){var t=this;return"rgba("+[this.r,this.g,this.b].map(function(e){return Math.round(255*e/t.a)}).concat(this.a).join(",")+")"},i.black=new i(0,0,0,1),i.white=new i(1,1,1,1),i.transparent=new i(0,0,0,0),e.exports=i},{csscolorparser:13}],154:[function(t,e,r){function n(t){return t>v?Math.pow(t,1/3):t/m+d}function i(t){return t>g?t*t*t:m*(t-d)}function a(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function o(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function s(t){var e=o(t.r),r=o(t.g),i=o(t.b),a=n((.4124564*e+.3575761*r+.1804375*i)/f),s=n((.2126729*e+.7151522*r+.072175*i)/h);return{l:116*s-16,a:500*(a-s),b:200*(s-n((.0193339*e+.119192*r+.9503041*i)/p)),alpha:t.a}}function l(t){var e=(t.l+16)/116,r=isNaN(t.a)?e:e+t.a/500,n=isNaN(t.b)?e:e-t.b/200;return e=h*i(e),r=f*i(r),n=p*i(n),new c(a(3.2404542*r-1.5371385*e-.4985314*n),a(-.969266*r+1.8760108*e+.041556*n),a(.0556434*r-.2040259*e+1.0572252*n),t.alpha)}var c=t("./color"),u=t("./interpolate").number,f=.95047,h=1,p=1.08883,d=4/29,g=6/29,m=3*g*g,v=g*g*g,y=Math.PI/180,x=180/Math.PI;e.exports={lab:{forward:s,reverse:l,interpolate:function(t,e,r){return{l:u(t.l,e.l,r),a:u(t.a,e.a,r),b:u(t.b,e.b,r),alpha:u(t.alpha,e.alpha,r)}}},hcl:{forward:function(t){var e=s(t),r=e.l,n=e.a,i=e.b,a=Math.atan2(i,n)*x;return{h:a<0?a+360:a,c:Math.sqrt(n*n+i*i),l:r,alpha:t.a}},reverse:function(t){var e=t.h*y,r=t.c;return l({l:t.l,a:Math.cos(e)*r,b:Math.sin(e)*r,alpha:t.alpha})},interpolate:function(t,e,r){return{h:function(t,e,r){var n=e-t;return t+r*(n>180||n<-180?n-360*Math.round(n/360):n)}(t.h,e.h,r),c:u(t.c,e.c,r),l:u(t.l,e.l,r),alpha:u(t.alpha,e.alpha,r)}}}}},{"./color":153,"./interpolate":158}],155:[function(t,e,r){e.exports=function t(e,r){if(Array.isArray(e)){if(!Array.isArray(r)||e.length!==r.length)return!1;for(var n=0;n0;)r[n]=e[n+1];for(var i=0,a=r;i":case">=":r.length>=2&&"$type"===s(r[1])&&u.push(new n(i,r,'"$type" cannot be use with operator "'+r[0]+'"'));case"==":case"!=":3!==r.length&&u.push(new n(i,r,'filter array for operator "'+r[0]+'" must have 3 elements'));case"in":case"!in":r.length>=2&&"string"!==(l=o(r[1]))&&u.push(new n(i+"[1]",r[1],"string expected, "+l+" found"));for(var f=2;fc(s[0].zoom))return[new n(u,s[0].zoom,"stop zoom values must appear in ascending order")];c(s[0].zoom)!==h&&(h=c(s[0].zoom),f=void 0,g={}),e=e.concat(o({key:u+"[0]",value:s[0],valueSpec:{zoom:{}},style:t.style,styleSpec:t.styleSpec,objectElementValidators:{zoom:l,value:r}}))}else e=e.concat(r({key:u+"[0]",value:s[0],valueSpec:{},style:t.style,styleSpec:t.styleSpec},s));return e.concat(a({key:u+"[1]",value:s[1],valueSpec:p,style:t.style,styleSpec:t.styleSpec}))}function r(t,e){var r=i(t.value),a=c(t.value),o=null!==t.value?t.value:e;if(u){if(r!==u)return[new n(t.key,o,r+" stop domain type must match previous stop domain type "+u)]}else u=r;if("number"!==r&&"string"!==r&&"boolean"!==r)return[new n(t.key,o,"stop domain value must be a number, string, or boolean")];if("number"!==r&&"categorical"!==d){var s="number expected, "+r+" found";return p["property-function"]&&void 0===d&&(s+='\nIf you intended to use a categorical function, specify `"type": "categorical"`.'),[new n(t.key,o,s)]}return"categorical"!==d||"number"!==r||isFinite(a)&&Math.floor(a)===a?"categorical"!==d&&"number"===r&&void 0!==f&&a=8&&(v&&!t.valueSpec["property-function"]?x.push(new n(t.key,t.value,"property functions not supported")):m&&!t.valueSpec["zoom-function"]&&"heatmap-color"!==t.objectKey&&x.push(new n(t.key,t.value,"zoom functions not supported"))),"categorical"!==d&&!y||void 0!==t.value.property||x.push(new n(t.key,t.value,'"property" property is required')),x}},{"../error/validation_error":122,"../util/get_type":157,"../util/unbundle_jsonlint":161,"./validate":162,"./validate_array":163,"./validate_number":175,"./validate_object":176}],171:[function(t,e,r){var n=t("../error/validation_error"),i=t("./validate_string");e.exports=function(t){var e=t.value,r=t.key,a=i(t);return a.length?a:(-1===e.indexOf("{fontstack}")&&a.push(new n(r,e,'"glyphs" url must include a "{fontstack}" token')),-1===e.indexOf("{range}")&&a.push(new n(r,e,'"glyphs" url must include a "{range}" token')),a)}},{"../error/validation_error":122,"./validate_string":180}],172:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/unbundle_jsonlint"),a=t("./validate_object"),o=t("./validate_filter"),s=t("./validate_paint_property"),l=t("./validate_layout_property"),c=t("./validate"),u=t("../util/extend");e.exports=function(t){var e=[],r=t.value,f=t.key,h=t.style,p=t.styleSpec;r.type||r.ref||e.push(new n(f,r,'either "type" or "ref" is required'));var d,g=i(r.type),m=i(r.ref);if(r.id)for(var v=i(r.id),y=0;ya.maximum?[new i(e,r,r+" is greater than the maximum value "+a.maximum)]:[]}},{"../error/validation_error":122,"../util/get_type":157}],176:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/get_type"),a=t("./validate");e.exports=function(t){var e=t.key,r=t.value,o=t.valueSpec||{},s=t.objectElementValidators||{},l=t.style,c=t.styleSpec,u=[],f=i(r);if("object"!==f)return[new n(e,r,"object expected, "+f+" found")];for(var h in r){var p=h.split(".")[0],d=o[p]||o["*"],g=void 0;if(s[p])g=s[p];else if(o[p])g=a;else if(s["*"])g=s["*"];else{if(!o["*"]){u.push(new n(e,r[h],'unknown property "'+h+'"'));continue}g=a}u=u.concat(g({key:(e?e+".":e)+h,value:r[h],valueSpec:d,style:l,styleSpec:c,object:r,objectKey:h},r))}for(var m in o)s[m]||o[m].required&&void 0===o[m].default&&void 0===r[m]&&u.push(new n(e,r,'missing required property "'+m+'"'));return u}},{"../error/validation_error":122,"../util/get_type":157,"./validate":162}],177:[function(t,e,r){var n=t("./validate_property");e.exports=function(t){return n(t,"paint")}},{"./validate_property":178}],178:[function(t,e,r){var n=t("./validate"),i=t("../error/validation_error"),a=t("../util/get_type"),o=t("../function").isFunction,s=t("../util/unbundle_jsonlint");e.exports=function(t,e){var r=t.key,l=t.style,c=t.styleSpec,u=t.value,f=t.objectKey,h=c[e+"_"+t.layerType];if(!h)return[];var p=f.match(/^(.*)-transition$/);if("paint"===e&&p&&h[p[1]]&&h[p[1]].transition)return n({key:r,value:u,valueSpec:c.transition,style:l,styleSpec:c});var d,g=t.valueSpec||h[f];if(!g)return[new i(r,u,'unknown property "'+f+'"')];if("string"===a(u)&&g["property-function"]&&!g.tokens&&(d=/^{([^}]+)}$/.exec(u)))return[new i(r,u,'"'+f+'" does not support interpolation syntax\nUse an identity property function instead: `{ "type": "identity", "property": '+JSON.stringify(d[1])+" }`.")];var m=[];return"symbol"===t.layerType&&("text-field"===f&&l&&!l.glyphs&&m.push(new i(r,u,'use of "text-field" requires a style "glyphs" property')),"text-font"===f&&o(s.deep(u))&&"identity"===s(u.type)&&m.push(new i(r,u,'"text-font" does not support identity functions'))),m.concat(n({key:t.key,value:u,valueSpec:g,style:l,styleSpec:c,expressionContext:"property",propertyKey:f}))}},{"../error/validation_error":122,"../function":149,"../util/get_type":157,"../util/unbundle_jsonlint":161,"./validate":162}],179:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/unbundle_jsonlint"),a=t("./validate_object"),o=t("./validate_enum");e.exports=function(t){var e=t.value,r=t.key,s=t.styleSpec,l=t.style;if(!e.type)return[new n(r,e,'"type" is required')];var c=i(e.type),u=[];switch(c){case"vector":case"raster":case"raster-dem":if(u=u.concat(a({key:r,value:e,valueSpec:s["source_"+c.replace("-","_")],style:t.style,styleSpec:s})),"url"in e)for(var f in e)["type","url","tileSize"].indexOf(f)<0&&u.push(new n(r+"."+f,e[f],'a source with a "url" property may not include a "'+f+'" property'));return u;case"geojson":return a({key:r,value:e,valueSpec:s.source_geojson,style:l,styleSpec:s});case"video":return a({key:r,value:e,valueSpec:s.source_video,style:l,styleSpec:s});case"image":return a({key:r,value:e,valueSpec:s.source_image,style:l,styleSpec:s});case"canvas":return a({key:r,value:e,valueSpec:s.source_canvas,style:l,styleSpec:s});default:return o({key:r+".type",value:e.type,valueSpec:{values:["vector","raster","raster-dem","geojson","video","image","canvas"]},style:l,styleSpec:s})}}},{"../error/validation_error":122,"../util/unbundle_jsonlint":161,"./validate_enum":167,"./validate_object":176}],180:[function(t,e,r){var n=t("../util/get_type"),i=t("../error/validation_error");e.exports=function(t){var e=t.value,r=t.key,a=n(e);return"string"!==a?[new i(r,e,"string expected, "+a+" found")]:[]}},{"../error/validation_error":122,"../util/get_type":157}],181:[function(t,e,r){function n(t,e){e=e||l;var r=[];return r=r.concat(s({key:"",value:t,valueSpec:e.$root,styleSpec:e,style:t,objectElementValidators:{glyphs:c,"*":function(){return[]}}})),t.constants&&(r=r.concat(o({key:"constants",value:t.constants,style:t,styleSpec:e}))),i(r)}function i(t){return[].concat(t).sort(function(t,e){return t.line-e.line})}function a(t){return function(){return i(t.apply(this,arguments))}}var o=t("./validate/validate_constants"),s=t("./validate/validate"),l=t("./reference/latest"),c=t("./validate/validate_glyphs_url");n.source=a(t("./validate/validate_source")),n.light=a(t("./validate/validate_light")),n.layer=a(t("./validate/validate_layer")),n.filter=a(t("./validate/validate_filter")),n.paintProperty=a(t("./validate/validate_paint_property")),n.layoutProperty=a(t("./validate/validate_layout_property")),e.exports=n},{"./reference/latest":151,"./validate/validate":162,"./validate/validate_constants":166,"./validate/validate_filter":169,"./validate/validate_glyphs_url":171,"./validate/validate_layer":172,"./validate/validate_layout_property":173,"./validate/validate_light":174,"./validate/validate_paint_property":177,"./validate/validate_source":179}],182:[function(t,e,r){var n=t("./zoom_history"),i=function(t,e){this.zoom=t,e?(this.now=e.now,this.fadeDuration=e.fadeDuration,this.zoomHistory=e.zoomHistory,this.transition=e.transition):(this.now=0,this.fadeDuration=0,this.zoomHistory=new n,this.transition={})};i.prototype.crossFadingFactor=function(){return 0===this.fadeDuration?1:Math.min((this.now-this.zoomHistory.lastIntegerZoomTime)/this.fadeDuration,1)},e.exports=i},{"./zoom_history":212}],183:[function(t,e,r){var n=t("../style-spec/reference/latest"),i=t("../util/util"),a=t("../util/evented"),o=t("./validate_style"),s=t("../util/util").sphericalToCartesian,l=(t("../style-spec/util/color"),t("../style-spec/util/interpolate")),c=t("./properties"),u=c.Properties,f=c.Transitionable,h=(c.Transitioning,c.PossiblyEvaluated,c.DataConstantProperty),p=function(){this.specification=n.light.position};p.prototype.possiblyEvaluate=function(t,e){return s(t.expression.evaluate(e))},p.prototype.interpolate=function(t,e,r){return{x:l.number(t.x,e.x,r),y:l.number(t.y,e.y,r),z:l.number(t.z,e.z,r)}};var d=new u({anchor:new h(n.light.anchor),position:new p,color:new h(n.light.color),intensity:new h(n.light.intensity)}),g=function(t){function e(e){t.call(this),this._transitionable=new f(d),this.setLight(e),this._transitioning=this._transitionable.untransitioned()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getLight=function(){return this._transitionable.serialize()},e.prototype.setLight=function(t){if(!this._validate(o.light,t))for(var e in t){var r=t[e];i.endsWith(e,"-transition")?this._transitionable.setTransition(e.slice(0,-"-transition".length),r):this._transitionable.setValue(e,r)}},e.prototype.updateTransitions=function(t){this._transitioning=this._transitionable.transitioned(t,this._transitioning)},e.prototype.hasTransition=function(){return this._transitioning.hasTransition()},e.prototype.recalculate=function(t){this.properties=this._transitioning.possiblyEvaluate(t)},e.prototype._validate=function(t,e){return o.emitErrors(this,t.call(o,i.extend({value:e,style:{glyphs:!0,sprite:!0},styleSpec:n})))},e}(a);e.exports=g},{"../style-spec/reference/latest":151,"../style-spec/util/color":153,"../style-spec/util/interpolate":158,"../util/evented":260,"../util/util":275,"./properties":188,"./validate_style":211}],184:[function(t,e,r){var n=t("../util/mapbox").normalizeGlyphsURL,i=t("../util/ajax"),a=t("./parse_glyph_pbf");e.exports=function(t,e,r,o,s){var l=256*e,c=l+255,u=o(n(r).replace("{fontstack}",t).replace("{range}",l+"-"+c),i.ResourceType.Glyphs);i.getArrayBuffer(u,function(t,e){if(t)s(t);else if(e){for(var r={},n=0,i=a(e.data);n1?"@2x":"";n.getJSON(e(a(t,f,".json"),n.ResourceType.SpriteJSON),function(t,e){u||(u=t,l=e,s())}),n.getImage(e(a(t,f,".png"),n.ResourceType.SpriteImage),function(t,e){u||(u=t,c=e,s())})}},{"../util/ajax":251,"../util/browser":252,"../util/image":263,"../util/mapbox":267}],186:[function(t,e,r){function n(t,e,r){1===t&&r.readMessage(i,e)}function i(t,e,r){if(3===t){var n=r.readMessage(a,{}),i=n.id,s=n.bitmap,c=n.width,u=n.height,f=n.left,h=n.top,p=n.advance;e.push({id:i,bitmap:new o({width:c+2*l,height:u+2*l},s),metrics:{width:c,height:u,left:f,top:h,advance:p}})}}function a(t,e,r){1===t?e.id=r.readVarint():2===t?e.bitmap=r.readBytes():3===t?e.width=r.readVarint():4===t?e.height=r.readVarint():5===t?e.left=r.readSVarint():6===t?e.top=r.readSVarint():7===t&&(e.advance=r.readVarint())}var o=t("../util/image").AlphaImage,s=t("pbf"),l=3;e.exports=function(t){return new s(t).readFields(n,[])},e.exports.GLYPH_PBF_BORDER=l},{"../util/image":263,pbf:30}],187:[function(t,e,r){var n=t("../util/browser"),i=t("../symbol/placement"),a=function(){this._currentTileIndex=0,this._seenCrossTileIDs={}};a.prototype.continuePlacement=function(t,e,r,n,i){for(var a=this;this._currentTileIndex2};this._currentPlacementIndex>=0;){var l=e[t[i._currentPlacementIndex]],c=i.placement.collisionIndex.transform.zoom;if("symbol"===l.type&&(!l.minzoom||l.minzoom<=c)&&(!l.maxzoom||l.maxzoom>c)){if(i._inProgressLayer||(i._inProgressLayer=new a),i._inProgressLayer.continuePlacement(r[l.source],i.placement,i._showCollisionBoxes,l,s))return;delete i._inProgressLayer}i._currentPlacementIndex--}this._done=!0},o.prototype.commit=function(t,e){return this.placement.commit(t,e),this.placement},e.exports=o},{"../symbol/placement":223,"../util/browser":252}],188:[function(t,e,r){var n=t("../util/util"),i=n.clone,a=n.extend,o=n.easeCubicInOut,s=t("../style-spec/util/interpolate"),l=t("../style-spec/expression").normalizePropertyExpression,c=(t("../style-spec/util/color"),t("../util/web_worker_transfer").register),u=function(t,e){this.property=t,this.value=e,this.expression=l(void 0===e?t.specification.default:e,t.specification)};u.prototype.isDataDriven=function(){return"source"===this.expression.kind||"composite"===this.expression.kind},u.prototype.possiblyEvaluate=function(t){return this.property.possiblyEvaluate(this,t)};var f=function(t){this.property=t,this.value=new u(t,void 0)};f.prototype.transitioned=function(t,e){return new p(this.property,this.value,e,a({},t.transition,this.transition),t.now)},f.prototype.untransitioned=function(){return new p(this.property,this.value,null,{},0)};var h=function(t){this._properties=t,this._values=Object.create(t.defaultTransitionablePropertyValues)};h.prototype.getValue=function(t){return i(this._values[t].value.value)},h.prototype.setValue=function(t,e){this._values.hasOwnProperty(t)||(this._values[t]=new f(this._values[t].property)),this._values[t].value=new u(this._values[t].property,null===e?void 0:i(e))},h.prototype.getTransition=function(t){return i(this._values[t].transition)},h.prototype.setTransition=function(t,e){this._values.hasOwnProperty(t)||(this._values[t]=new f(this._values[t].property)),this._values[t].transition=i(e)||void 0},h.prototype.serialize=function(){for(var t=this,e={},r=0,n=Object.keys(t._values);rthis.end)return this.prior=null,r;if(this.value.isDataDriven())return this.prior=null,r;if(en.zoomHistory.lastIntegerZoom?{from:t,to:e,fromScale:2,toScale:1,t:a+(1-a)*o}:{from:r,to:e,fromScale:.5,toScale:1,t:1-(1-o)*a}},b.prototype.interpolate=function(t){return t};var _=function(t){this.specification=t};_.prototype.possiblyEvaluate=function(){},_.prototype.interpolate=function(){};c("DataDrivenProperty",x),c("DataConstantProperty",y),c("CrossFadedProperty",b),c("HeatmapColorProperty",_),e.exports={PropertyValue:u,Transitionable:h,Transitioning:d,Layout:g,PossiblyEvaluatedPropertyValue:m,PossiblyEvaluated:v,DataConstantProperty:y,DataDrivenProperty:x,CrossFadedProperty:b,HeatmapColorProperty:_,Properties:function(t){var e=this;for(var r in this.properties=t,this.defaultPropertyValues={},this.defaultTransitionablePropertyValues={},this.defaultTransitioningPropertyValues={},this.defaultPossiblyEvaluatedValues={},t){var n=t[r],i=e.defaultPropertyValues[r]=new u(n,void 0),a=e.defaultTransitionablePropertyValues[r]=new f(n);e.defaultTransitioningPropertyValues[r]=a.untransitioned(),e.defaultPossiblyEvaluatedValues[r]=i.possiblyEvaluate({})}}}},{"../style-spec/expression":139,"../style-spec/util/color":153,"../style-spec/util/interpolate":158,"../util/util":275,"../util/web_worker_transfer":278}],189:[function(t,e,r){var n=t("@mapbox/point-geometry");e.exports={getMaximumPaintValue:function(t,e,r){var n=e.paint.get(t).value;return"constant"===n.kind?n.value:r.programConfigurations.get(e.id).binders[t].statistics.max},translateDistance:function(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1])},translate:function(t,e,r,i,a){if(!e[0]&&!e[1])return t;var o=n.convert(e);"viewport"===r&&o._rotate(-i);for(var s=[],l=0;l0)throw new Error("Unimplemented: "+n.map(function(t){return t.command}).join(", ")+".");return r.forEach(function(t){"setTransition"!==t.command&&e[t.command].apply(e,t.args)}),this.stylesheet=t,!0},e.prototype.addImage=function(t,e){if(this.getImage(t))return this.fire("error",{error:new Error("An image with this name already exists.")});this.imageManager.addImage(t,e),this.fire("data",{dataType:"style"})},e.prototype.getImage=function(t){return this.imageManager.getImage(t)},e.prototype.removeImage=function(t){if(!this.getImage(t))return this.fire("error",{error:new Error("No image with this name exists.")});this.imageManager.removeImage(t),this.fire("data",{dataType:"style"})},e.prototype.addSource=function(t,e,r){var n=this;if(this._checkLoaded(),void 0!==this.sourceCaches[t])throw new Error("There is already a source with this ID");if(!e.type)throw new Error("The type property must be defined, but the only the following properties were given: "+Object.keys(e).join(", ")+".");if(!(["vector","raster","geojson","video","image","canvas"].indexOf(e.type)>=0&&this._validate(g.source,"sources."+t,e,null,r))){this.map&&this.map._collectResourceTiming&&(e.collectResourceTiming=!0);var i=this.sourceCaches[t]=new x(t,e,this.dispatcher);i.style=this,i.setEventedParent(this,function(){return{isSourceLoaded:n.loaded(),source:i.serialize(),sourceId:t}}),i.onAdd(this.map),this._changed=!0}},e.prototype.removeSource=function(t){var e=this;if(this._checkLoaded(),void 0===this.sourceCaches[t])throw new Error("There is no source with this ID");for(var r in e._layers)if(e._layers[r].source===t)return e.fire("error",{error:new Error('Source "'+t+'" cannot be removed while layer "'+r+'" is using it.')});var n=this.sourceCaches[t];delete this.sourceCaches[t],delete this._updatedSources[t],n.fire("data",{sourceDataType:"metadata",dataType:"source",sourceId:t}),n.setEventedParent(null),n.clearTiles(),n.onRemove&&n.onRemove(this.map),this._changed=!0},e.prototype.setGeoJSONSourceData=function(t,e){this._checkLoaded(),this.sourceCaches[t].getSource().setData(e),this._changed=!0},e.prototype.getSource=function(t){return this.sourceCaches[t]&&this.sourceCaches[t].getSource()},e.prototype.addLayer=function(t,e,r){this._checkLoaded();var n=t.id;if("object"==typeof t.source&&(this.addSource(n,t.source),t=u.clone(t),t=u.extend(t,{source:n})),!this._validate(g.layer,"layers."+n,t,{arrayIndex:-1},r)){var a=i.create(t);this._validateLayer(a),a.setEventedParent(this,{layer:{id:n}});var o=e?this._order.indexOf(e):this._order.length;if(e&&-1===o)return void this.fire("error",{error:new Error('Layer with id "'+e+'" does not exist on this map.')});if(this._order.splice(o,0,n),this._layerOrderChanged=!0,this._layers[n]=a,this._removedLayers[n]&&a.source){var s=this._removedLayers[n];delete this._removedLayers[n],s.type!==a.type?this._updatedSources[a.source]="clear":(this._updatedSources[a.source]="reload",this.sourceCaches[a.source].pause())}this._updateLayer(a)}},e.prototype.moveLayer=function(t,e){if(this._checkLoaded(),this._changed=!0,this._layers[t]){var r=this._order.indexOf(t);this._order.splice(r,1);var n=e?this._order.indexOf(e):this._order.length;e&&-1===n?this.fire("error",{error:new Error('Layer with id "'+e+'" does not exist on this map.')}):(this._order.splice(n,0,t),this._layerOrderChanged=!0)}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be moved.")})},e.prototype.removeLayer=function(t){this._checkLoaded();var e=this._layers[t];if(e){e.setEventedParent(null);var r=this._order.indexOf(t);this._order.splice(r,1),this._layerOrderChanged=!0,this._changed=!0,this._removedLayers[t]=e,delete this._layers[t],delete this._updatedLayers[t],delete this._updatedPaintProps[t]}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be removed.")})},e.prototype.getLayer=function(t){return this._layers[t]},e.prototype.setLayerZoomRange=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);n?n.minzoom===e&&n.maxzoom===r||(null!=e&&(n.minzoom=e),null!=r&&(n.maxzoom=r),this._updateLayer(n)):this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot have zoom extent.")})},e.prototype.setFilter=function(t,e){this._checkLoaded();var r=this.getLayer(t);if(r)return u.deepEqual(r.filter,e)?void 0:null===e||void 0===e?(r.filter=void 0,void this._updateLayer(r)):void(this._validate(g.filter,"layers."+r.id+".filter",e)||(r.filter=u.clone(e),this._updateLayer(r)));this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be filtered.")})},e.prototype.getFilter=function(t){return u.clone(this.getLayer(t).filter)},e.prototype.setLayoutProperty=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);n?u.deepEqual(n.getLayoutProperty(e),r)||(n.setLayoutProperty(e,r),this._updateLayer(n)):this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be styled.")})},e.prototype.getLayoutProperty=function(t,e){return this.getLayer(t).getLayoutProperty(e)},e.prototype.setPaintProperty=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);if(n){if(!u.deepEqual(n.getPaintProperty(e),r)){var i=n._transitionablePaint._values[e].value.isDataDriven();n.setPaintProperty(e,r),(n._transitionablePaint._values[e].value.isDataDriven()||i)&&this._updateLayer(n),this._changed=!0,this._updatedPaintProps[t]=!0}}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be styled.")})},e.prototype.getPaintProperty=function(t,e){return this.getLayer(t).getPaintProperty(e)},e.prototype.getTransition=function(){return u.extend({duration:300,delay:0},this.stylesheet&&this.stylesheet.transition)},e.prototype.serialize=function(){var t=this;return u.filterObject({version:this.stylesheet.version,name:this.stylesheet.name,metadata:this.stylesheet.metadata,light:this.stylesheet.light,center:this.stylesheet.center,zoom:this.stylesheet.zoom,bearing:this.stylesheet.bearing,pitch:this.stylesheet.pitch,sprite:this.stylesheet.sprite,glyphs:this.stylesheet.glyphs,transition:this.stylesheet.transition,sources:u.mapObject(this.sourceCaches,function(t){return t.serialize()}),layers:this._order.map(function(e){return t._layers[e].serialize()})},function(t){return void 0!==t})},e.prototype._updateLayer=function(t){this._updatedLayers[t.id]=!0,t.source&&!this._updatedSources[t.source]&&(this._updatedSources[t.source]="reload",this.sourceCaches[t.source].pause()),this._changed=!0},e.prototype._flattenRenderedFeatures=function(t){for(var e=[],r=this._order.length-1;r>=0;r--)for(var n=this._order[r],i=0,a=t;i=this.maxzoom)||"none"===this.visibility},e.prototype.updateTransitions=function(t){this._transitioningPaint=this._transitionablePaint.transitioned(t,this._transitioningPaint)},e.prototype.hasTransition=function(){return this._transitioningPaint.hasTransition()},e.prototype.recalculate=function(t){this._unevaluatedLayout&&(this.layout=this._unevaluatedLayout.possiblyEvaluate(t)),this.paint=this._transitioningPaint.possiblyEvaluate(t)},e.prototype.serialize=function(){var t={id:this.id,type:this.type,source:this.source,"source-layer":this.sourceLayer,metadata:this.metadata,minzoom:this.minzoom,maxzoom:this.maxzoom,filter:this.filter,layout:this._unevaluatedLayout&&this._unevaluatedLayout.serialize(),paint:this._transitionablePaint&&this._transitionablePaint.serialize()};return"none"===this.visibility&&(t.layout=t.layout||{},t.layout.visibility="none"),n.filterObject(t,function(t,e){return!(void 0===t||"layout"===e&&!Object.keys(t).length||"paint"===e&&!Object.keys(t).length)})},e.prototype._validate=function(t,e,r,n,o){return(!o||!1!==o.validate)&&a.emitErrors(this,t.call(a,{key:e,layerType:this.type,objectKey:r,value:n,styleSpec:i,style:{glyphs:!0,sprite:!0}}))},e.prototype.hasOffscreenPass=function(){return!1},e.prototype.resize=function(){},e}(o));e.exports=u;var f={circle:t("./style_layer/circle_style_layer"),heatmap:t("./style_layer/heatmap_style_layer"),hillshade:t("./style_layer/hillshade_style_layer"),fill:t("./style_layer/fill_style_layer"),"fill-extrusion":t("./style_layer/fill_extrusion_style_layer"),line:t("./style_layer/line_style_layer"),symbol:t("./style_layer/symbol_style_layer"),background:t("./style_layer/background_style_layer"),raster:t("./style_layer/raster_style_layer")};u.create=function(t){return new f[t.type](t)}},{"../style-spec/reference/latest":151,"../util/evented":260,"../util/util":275,"./properties":188,"./style_layer/background_style_layer":192,"./style_layer/circle_style_layer":194,"./style_layer/fill_extrusion_style_layer":196,"./style_layer/fill_style_layer":198,"./style_layer/heatmap_style_layer":200,"./style_layer/hillshade_style_layer":202,"./style_layer/line_style_layer":204,"./style_layer/raster_style_layer":206,"./style_layer/symbol_style_layer":208,"./validate_style":211}],192:[function(t,e,r){var n=t("../style_layer"),i=t("./background_style_layer_properties"),a=t("../properties"),o=(a.Transitionable,a.Transitioning,a.PossiblyEvaluated,function(t){function e(e){t.call(this,e,i)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(n));e.exports=o},{"../properties":188,"../style_layer":191,"./background_style_layer_properties":193}],193:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=(i.DataDrivenProperty,i.CrossFadedProperty),l=(i.HeatmapColorProperty,new a({"background-color":new o(n.paint_background["background-color"]),"background-pattern":new s(n.paint_background["background-pattern"]),"background-opacity":new o(n.paint_background["background-opacity"])}));e.exports={paint:l}},{"../../style-spec/reference/latest":151,"../properties":188}],194:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/circle_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsBufferedMultiPoint,o=t("../query_utils"),s=o.getMaximumPaintValue,l=o.translateDistance,c=o.translate,u=t("./circle_style_layer_properties"),f=t("../properties"),h=(f.Transitionable,f.Transitioning,f.PossiblyEvaluated,function(t){function e(e){t.call(this,e,u)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(t){var e=t;return s("circle-radius",this,e)+s("circle-stroke-width",this,e)+l(this.paint.get("circle-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=c(t,this.paint.get("circle-translate"),this.paint.get("circle-translate-anchor"),i,o),l=this.paint.get("circle-radius").evaluate(e)*o,u=this.paint.get("circle-stroke-width").evaluate(e)*o;return a(s,r,l+u)},e}(n));e.exports=h},{"../../data/bucket/circle_bucket":42,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./circle_style_layer_properties":195}],195:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=(i.CrossFadedProperty,i.HeatmapColorProperty,new a({"circle-radius":new s(n.paint_circle["circle-radius"]),"circle-color":new s(n.paint_circle["circle-color"]),"circle-blur":new s(n.paint_circle["circle-blur"]),"circle-opacity":new s(n.paint_circle["circle-opacity"]),"circle-translate":new o(n.paint_circle["circle-translate"]),"circle-translate-anchor":new o(n.paint_circle["circle-translate-anchor"]),"circle-pitch-scale":new o(n.paint_circle["circle-pitch-scale"]),"circle-pitch-alignment":new o(n.paint_circle["circle-pitch-alignment"]),"circle-stroke-width":new s(n.paint_circle["circle-stroke-width"]),"circle-stroke-color":new s(n.paint_circle["circle-stroke-color"]),"circle-stroke-opacity":new s(n.paint_circle["circle-stroke-opacity"])}));e.exports={paint:l}},{"../../style-spec/reference/latest":151,"../properties":188}],196:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/fill_extrusion_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsMultiPolygon,o=t("../query_utils"),s=o.translateDistance,l=o.translate,c=t("./fill_extrusion_style_layer_properties"),u=t("../properties"),f=(u.Transitionable,u.Transitioning,u.PossiblyEvaluated,function(t){function e(e){t.call(this,e,c)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(){return s(this.paint.get("fill-extrusion-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=l(t,this.paint.get("fill-extrusion-translate"),this.paint.get("fill-extrusion-translate-anchor"),i,o);return a(s,r)},e.prototype.hasOffscreenPass=function(){return 0!==this.paint.get("fill-extrusion-opacity")&&"none"!==this.visibility},e.prototype.resize=function(){this.viewportFrame&&(this.viewportFrame.destroy(),this.viewportFrame=null)},e}(n));e.exports=f},{"../../data/bucket/fill_extrusion_bucket":46,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./fill_extrusion_style_layer_properties":197}],197:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=i.CrossFadedProperty,c=(i.HeatmapColorProperty,new a({"fill-extrusion-opacity":new o(n["paint_fill-extrusion"]["fill-extrusion-opacity"]),"fill-extrusion-color":new s(n["paint_fill-extrusion"]["fill-extrusion-color"]),"fill-extrusion-translate":new o(n["paint_fill-extrusion"]["fill-extrusion-translate"]),"fill-extrusion-translate-anchor":new o(n["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]),"fill-extrusion-pattern":new l(n["paint_fill-extrusion"]["fill-extrusion-pattern"]),"fill-extrusion-height":new s(n["paint_fill-extrusion"]["fill-extrusion-height"]),"fill-extrusion-base":new s(n["paint_fill-extrusion"]["fill-extrusion-base"])}));e.exports={paint:c}},{"../../style-spec/reference/latest":151,"../properties":188}],198:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/fill_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsMultiPolygon,o=t("../query_utils"),s=o.translateDistance,l=o.translate,c=t("./fill_style_layer_properties"),u=t("../properties"),f=(u.Transitionable,u.Transitioning,u.PossiblyEvaluated,function(t){function e(e){t.call(this,e,c)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.recalculate=function(t){this.paint=this._transitioningPaint.possiblyEvaluate(t),void 0===this._transitionablePaint.getValue("fill-outline-color")&&(this.paint._values["fill-outline-color"]=this.paint._values["fill-color"])},e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(){return s(this.paint.get("fill-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=l(t,this.paint.get("fill-translate"),this.paint.get("fill-translate-anchor"),i,o);return a(s,r)},e}(n));e.exports=f},{"../../data/bucket/fill_bucket":44,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./fill_style_layer_properties":199}],199:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=i.CrossFadedProperty,c=(i.HeatmapColorProperty,new a({"fill-antialias":new o(n.paint_fill["fill-antialias"]),"fill-opacity":new s(n.paint_fill["fill-opacity"]),"fill-color":new s(n.paint_fill["fill-color"]),"fill-outline-color":new s(n.paint_fill["fill-outline-color"]),"fill-translate":new o(n.paint_fill["fill-translate"]),"fill-translate-anchor":new o(n.paint_fill["fill-translate-anchor"]),"fill-pattern":new l(n.paint_fill["fill-pattern"])}));e.exports={paint:c}},{"../../style-spec/reference/latest":151,"../properties":188}],200:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/heatmap_bucket"),a=t("../../util/image").RGBAImage,o=t("./heatmap_style_layer_properties"),s=t("../properties"),l=(s.Transitionable,s.Transitioning,s.PossiblyEvaluated,function(t){function e(e){t.call(this,e,o),this._updateColorRamp()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.setPaintProperty=function(e,r,n){t.prototype.setPaintProperty.call(this,e,r,n),"heatmap-color"===e&&this._updateColorRamp()},e.prototype._updateColorRamp=function(){for(var t=this._transitionablePaint._values["heatmap-color"].value.expression,e=new Uint8Array(1024),r=e.length,n=4;n0?e+2*t:t}var i=t("@mapbox/point-geometry"),a=t("../style_layer"),o=t("../../data/bucket/line_bucket"),s=t("../../util/intersection_tests").multiPolygonIntersectsBufferedMultiLine,l=t("../query_utils"),c=l.getMaximumPaintValue,u=l.translateDistance,f=l.translate,h=t("./line_style_layer_properties"),p=t("../../util/util").extend,d=t("../evaluation_parameters"),g=t("../properties"),m=(g.Transitionable,g.Transitioning,g.Layout,g.PossiblyEvaluated,new(function(t){function e(){t.apply(this,arguments)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.possiblyEvaluate=function(e,r){return r=new d(Math.floor(r.zoom),{now:r.now,fadeDuration:r.fadeDuration,zoomHistory:r.zoomHistory,transition:r.transition}),t.prototype.possiblyEvaluate.call(this,e,r)},e.prototype.evaluate=function(e,r,n){return r=p({},r,{zoom:Math.floor(r.zoom)}),t.prototype.evaluate.call(this,e,r,n)},e}(g.DataDrivenProperty))(h.paint.properties["line-width"].specification));m.useIntegerZoom=!0;var v=function(t){function e(e){t.call(this,e,h)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.recalculate=function(e){t.prototype.recalculate.call(this,e),this.paint._values["line-floorwidth"]=m.possiblyEvaluate(this._transitioningPaint._values["line-width"].value,e)},e.prototype.createBucket=function(t){return new o(t)},e.prototype.queryRadius=function(t){var e=t,r=n(c("line-width",this,e),c("line-gap-width",this,e)),i=c("line-offset",this,e);return r/2+Math.abs(i)+u(this.paint.get("line-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,a,o,l){var c=f(t,this.paint.get("line-translate"),this.paint.get("line-translate-anchor"),o,l),u=l/2*n(this.paint.get("line-width").evaluate(e),this.paint.get("line-gap-width").evaluate(e)),h=this.paint.get("line-offset").evaluate(e);return h&&(r=function(t,e){for(var r=[],n=new i(0,0),a=0;ar?(this.lastIntegerZoom=r+1,this.lastIntegerZoomTime=e):this.lastFloorZoom-r/2;){if(--o<0)return!1;s-=t[o].dist(a),a=t[o]}s+=t[o].dist(t[o+1]),o++;for(var l=[],c=0;sn;)c-=l.shift().angleDelta;if(c>i)return!1;o++,s+=f.dist(h)}return!0}},{}],215:[function(t,e,r){var n=t("@mapbox/point-geometry");e.exports=function(t,e,r,i,a){for(var o=[],s=0;s=i&&h.x>=i||(f.x>=i?f=new n(i,f.y+(h.y-f.y)*((i-f.x)/(h.x-f.x)))._round():h.x>=i&&(h=new n(i,f.y+(h.y-f.y)*((i-f.x)/(h.x-f.x)))._round()),f.y>=a&&h.y>=a||(f.y>=a?f=new n(f.x+(h.x-f.x)*((a-f.y)/(h.y-f.y)),a)._round():h.y>=a&&(h=new n(f.x+(h.x-f.x)*((a-f.y)/(h.y-f.y)),a)._round()),c&&f.equals(c[c.length-1])||(c=[f],o.push(c)),c.push(h)))))}return o}},{"@mapbox/point-geometry":4}],216:[function(t,e,r){var n=function(t,e,r,n,i,a,o,s,l,c,u){var f=o.top*s-l,h=o.bottom*s+l,p=o.left*s-l,d=o.right*s+l;if(this.boxStartIndex=t.length,c){var g=h-f,m=d-p;g>0&&(g=Math.max(10*s,g),this._addLineCollisionCircles(t,e,r,r.segment,m,g,n,i,a,u))}else t.emplaceBack(r.x,r.y,p,f,d,h,n,i,a,0,0);this.boxEndIndex=t.length};n.prototype._addLineCollisionCircles=function(t,e,r,n,i,a,o,s,l,c){var u=a/2,f=Math.floor(i/u),h=1+.4*Math.log(c)/Math.LN2,p=Math.floor(f*h/2),d=-a/2,g=r,m=n+1,v=d,y=-i/2,x=y-i/4;do{if(--m<0){if(v>y)return;m=0;break}v-=e[m].dist(g),g=e[m]}while(v>x);for(var b=e[m].dist(e[m+1]),_=-p;_i&&(k+=w-i),!(k=e.length)return;b=e[m].dist(e[m+1])}var M=k-v,A=e[m],T=e[m+1].sub(A)._unit()._mult(M)._add(A)._round(),S=Math.abs(k-d)L)n(t,z,!1);else{var R=m.projectPoint(h,P,D),B=O*S;if(v.length>0){var F=R.x-v[v.length-4],N=R.y-v[v.length-3];if(B*B*2>F*F+N*N&&z+8-E&&j=this.screenRightBoundary||n<100||e>this.screenBottomBoundary},e.exports=l},{"../symbol/projection":224,"../util/intersection_tests":264,"./grid_index":220,"@mapbox/gl-matrix":2,"@mapbox/point-geometry":4}],218:[function(t,e,r){var n=t("../data/extent"),i=512/n/2,a=function(t,e,r){var n=this;this.tileID=t,this.indexedSymbolInstances={},this.bucketInstanceId=r;for(var i=0,a=e;it.overscaledZ)for(var c in l){var u=l[c];u.tileID.isChildOf(t)&&u.findMatches(e.symbolInstances,t,o)}else{var f=l[t.scaledTo(Number(s)).key];f&&f.findMatches(e.symbolInstances,t,o)}}for(var h=0,p=e.symbolInstances;h=0&&A=0&&T=0&&v+p<=d){var S=new i(A,T,k,x);S._round(),s&&!a(e,S,c,s,l)||y.push(S)}}m+=w}return f||y.length||u||(y=t(e,m/2,o,s,l,c,u,!0,h)),y}(t,d?e/2*u%e:(p/2+2*l)*c*u%e,e,h,r,p*c,d,!1,f)}},{"../style-spec/util/interpolate":158,"../symbol/anchor":213,"./check_max_angle":214}],220:[function(t,e,r){var n=function(t,e,r){var n=this.boxCells=[],i=this.circleCells=[];this.xCellCount=Math.ceil(t/r),this.yCellCount=Math.ceil(e/r);for(var a=0;athis.width||n<0||e>this.height)return!i&&[];var a=[];if(t<=0&&e<=0&&this.width<=r&&this.height<=n)a=Array.prototype.slice.call(this.boxKeys).concat(this.circleKeys);else{var o={hitTest:i,seenUids:{box:{},circle:{}}};this._forEachCell(t,e,r,n,this._queryCell,a,o)}return i?a.length>0:a},n.prototype._queryCircle=function(t,e,r,n){var i=t-r,a=t+r,o=e-r,s=e+r;if(a<0||i>this.width||s<0||o>this.height)return!n&&[];var l=[],c={hitTest:n,circle:{x:t,y:e,radius:r},seenUids:{box:{},circle:{}}};return this._forEachCell(i,o,a,s,this._queryCellCircle,l,c),n?l.length>0:l},n.prototype.query=function(t,e,r,n){return this._query(t,e,r,n,!1)},n.prototype.hitTest=function(t,e,r,n){return this._query(t,e,r,n,!0)},n.prototype.hitTestCircle=function(t,e,r){return this._queryCircle(t,e,r,!0)},n.prototype._queryCell=function(t,e,r,n,i,a,o){var s=this,l=o.seenUids,c=this.boxCells[i];if(null!==c)for(var u=this.bboxes,f=0,h=c;f=u[d+0]&&n>=u[d+1]){if(o.hitTest)return a.push(!0),!0;a.push(s.boxKeys[p])}}}var g=this.circleCells[i];if(null!==g)for(var m=this.circles,v=0,y=g;vo*o+s*s},n.prototype._circleAndRectCollide=function(t,e,r,n,i,a,o){var s=(a-n)/2,l=Math.abs(t-(n+s));if(l>s+r)return!1;var c=(o-i)/2,u=Math.abs(e-(i+c));if(u>c+r)return!1;if(l<=s||u<=c)return!0;var f=l-s,h=u-c;return f*f+h*h<=r*r},e.exports=n},{}],221:[function(t,e,r){e.exports=function(t){function e(e){s.push(t[e]),l++}function r(t,e,r){var n=o[t];return delete o[t],o[e]=n,s[n].geometry[0].pop(),s[n].geometry[0]=s[n].geometry[0].concat(r[0]),n}function n(t,e,r){var n=a[e];return delete a[e],a[t]=n,s[n].geometry[0].shift(),s[n].geometry[0]=r[0].concat(s[n].geometry[0]),n}function i(t,e,r){var n=r?e[0][e[0].length-1]:e[0][0];return t+":"+n.x+":"+n.y}for(var a={},o={},s=[],l=0,c=0;c0,M=M&&A.offscreen);var C=_.collisionArrays.textCircles;if(C){var E=t.text.placedSymbolArray.get(_.placedTextSymbolIndices[0]),L=s.evaluateSizeForFeature(t.textSizeData,m,E);T=d.collisionIndex.placeCollisionCircles(C,g.get("text-allow-overlap"),i,a,_.key,E,t.lineVertexArray,t.glyphOffsetArray,L,e,r,o,"map"===g.get("text-pitch-alignment")),w=g.get("text-allow-overlap")||T.circles.length>0,M=M&&T.offscreen}_.collisionArrays.iconBox&&(k=(S=d.collisionIndex.placeCollisionBox(_.collisionArrays.iconBox,g.get("icon-allow-overlap"),a,e)).box.length>0,M=M&&S.offscreen),v||y?y?v||(k=k&&w):w=k&&w:k=w=k&&w,w&&A&&d.collisionIndex.insertCollisionBox(A.box,g.get("text-ignore-placement"),f,h,t.bucketInstanceId,_.textBoxStartIndex),k&&S&&d.collisionIndex.insertCollisionBox(S.box,g.get("icon-ignore-placement"),f,h,t.bucketInstanceId,_.iconBoxStartIndex),w&&T&&d.collisionIndex.insertCollisionCircles(T.circles,g.get("text-ignore-placement"),f,h,t.bucketInstanceId,_.textBoxStartIndex),d.placements[_.crossTileID]=new p(w,k,M||t.justReloaded),l[_.crossTileID]=!0}}t.justReloaded=!1},d.prototype.commit=function(t,e){var r=this;this.commitTime=e;var n=!1,i=t&&0!==this.fadeDuration?(this.commitTime-t.commitTime)/this.fadeDuration:1,a=t?t.opacities:{};for(var o in r.placements){var s=r.placements[o],l=a[o];l?(r.opacities[o]=new h(l,i,s.text,s.icon),n=n||s.text!==l.text.placed||s.icon!==l.icon.placed):(r.opacities[o]=new h(null,i,s.text,s.icon,s.skipFade),n=n||s.text||s.icon)}for(var c in a){var u=a[c];if(!r.opacities[c]){var f=new h(u,i,!1,!1);f.isHidden()||(r.opacities[c]=f,n=n||u.text.placed||u.icon.placed)}}n?this.lastPlacementChangeTime=e:"number"!=typeof this.lastPlacementChangeTime&&(this.lastPlacementChangeTime=t?t.lastPlacementChangeTime:e)},d.prototype.updateLayerOpacities=function(t,e){for(var r={},n=0,i=e;n0||l.numVerticalGlyphVertices>0,p=l.numIconVertices>0;if(f){for(var d=i(u.text),g=(l.numGlyphVertices+l.numVerticalGlyphVertices)/4,m=0;mt},d.prototype.setStale=function(){this.stale=!0};var g=Math.pow(2,25),m=Math.pow(2,24),v=Math.pow(2,17),y=Math.pow(2,16),x=Math.pow(2,9),b=Math.pow(2,8),_=Math.pow(2,1);e.exports=d},{"../data/extent":53,"../source/pixels_to_tile_units":104,"../style/style_layer/symbol_style_layer_properties":209,"./collision_index":217,"./projection":224,"./symbol_size":228}],224:[function(t,e,r){function n(t,e){var r=[t.x,t.y,0,1];f(r,r,e);var n=r[3];return{point:new h(r[0]/n,r[1]/n),signedDistanceFromCamera:n}}function i(t,e){var r=t[0]/t[3],n=t[1]/t[3];return r>=-e[0]&&r<=e[0]&&n>=-e[1]&&n<=e[1]}function a(t,e,r,n,i,a,o,s,l,u,f,h){var p=s.glyphStartIndex+s.numGlyphs,d=s.lineStartIndex,g=s.lineStartIndex+s.lineLength,m=e.getoffsetX(s.glyphStartIndex),v=e.getoffsetX(p-1),y=c(t*m,r,n,i,a,o,s.segment,d,g,l,u,f,h);if(!y)return null;var x=c(t*v,r,n,i,a,o,s.segment,d,g,l,u,f,h);return x?{first:y,last:x}:null}function o(t,e,r,n){return t===x.horizontal&&Math.abs(r.y-e.y)>Math.abs(r.x-e.x)*n?{useVertical:!0}:(t===x.vertical?e.yr.x)?{needsFlipping:!0}:null}function s(t,e,r,i,s,u,f,p,d,g,m,y,x,b){var _,w=e/24,k=t.lineOffsetX*e,M=t.lineOffsetY*e;if(t.numGlyphs>1){var A=t.glyphStartIndex+t.numGlyphs,T=t.lineStartIndex,S=t.lineStartIndex+t.lineLength,C=a(w,p,k,M,r,m,y,t,d,u,x,!1);if(!C)return{notEnoughRoom:!0};var E=n(C.first.point,f).point,L=n(C.last.point,f).point;if(i&&!r){var z=o(t.writingMode,E,L,b);if(z)return z}_=[C.first];for(var P=t.glyphStartIndex+1;P0?R.point:l(y,I,D,1,s),F=o(t.writingMode,D,B,b);if(F)return F}var N=c(w*p.getoffsetX(t.glyphStartIndex),k,M,r,m,y,t.segment,t.lineStartIndex,t.lineStartIndex+t.lineLength,d,u,x,!1);if(!N)return{notEnoughRoom:!0};_=[N]}for(var j=0,V=_;j0?1:-1,y=0;i&&(v*=-1,y=Math.PI),v<0&&(y+=Math.PI);for(var x=v>0?c+s:c+s+1,b=x,_=a,w=a,k=0,M=0,A=Math.abs(m);k+M<=A;){if((x+=v)=u)return null;if(w=_,void 0===(_=d[x])){var T=new h(f.getx(x),f.gety(x)),S=n(T,p);if(S.signedDistanceFromCamera>0)_=d[x]=S.point;else{var C=x-v;_=l(0===k?o:new h(f.getx(C),f.gety(C)),T,w,A-k+1,p)}}k+=M,M=w.dist(_)}var E=(A-k)/M,L=_.sub(w),z=L.mult(E)._add(w);return z._add(L._unit()._perp()._mult(r*v)),{point:z,angle:y+Math.atan2(_.y-w.y,_.x-w.x),tileDistance:g?{prevTileDistance:x-v===b?0:f.gettileUnitDistanceFromAnchor(x-v),lastSegmentViewportDistance:A-k}:null}}function u(t,e){for(var r=0;r=w||o.y<0||o.y>=w||t.symbolInstances.push(function(t,e,r,n,a,o,s,l,u,f,h,d,g,x,b,_,w,M,A,T,S,C){var E,L,z=t.addToLineVertexArray(e,r),P=0,D=0,O=0,I=n.horizontal?n.horizontal.text:"",R=[];n.horizontal&&(E=new v(s,r,e,l,u,f,n.horizontal,h,d,g,t.overscaling),D+=i(t,e,n.horizontal,o,g,A,T,x,z,n.vertical?p.horizontal:p.horizontalOnly,R,S,C),n.vertical&&(O+=i(t,e,n.vertical,o,g,A,T,x,z,p.vertical,R,S,C)));var B=E?E.boxStartIndex:t.collisionBoxArray.length,F=E?E.boxEndIndex:t.collisionBoxArray.length;if(a){var N=m(e,a,o,w,n.horizontal,A,T);L=new v(s,r,e,l,u,f,a,b,_,!1,t.overscaling),P=4*N.length;var j=t.iconSizeData,V=null;"source"===j.functionType?V=[10*o.layout.get("icon-size").evaluate(T)]:"composite"===j.functionType&&(V=[10*C.compositeIconSizes[0].evaluate(T),10*C.compositeIconSizes[1].evaluate(T)]),t.addSymbols(t.icon,N,V,M,w,T,!1,e,z.lineStartIndex,z.lineLength)}var U=L?L.boxStartIndex:t.collisionBoxArray.length,q=L?L.boxEndIndex:t.collisionBoxArray.length;return t.glyphOffsetArray.length>=k.MAX_GLYPHS&&y.warnOnce("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"),{key:I,textBoxStartIndex:B,textBoxEndIndex:F,iconBoxStartIndex:U,iconBoxEndIndex:q,textOffset:x,iconOffset:M,anchor:e,line:r,featureIndex:l,feature:T,numGlyphVertices:D,numVerticalGlyphVertices:O,numIconVertices:P,textOpacityState:new c,iconOpacityState:new c,isDuplicate:!1,placedTextSymbolIndices:R,crossTileID:0}}(t,o,a,r,n,t.layers[0],t.collisionBoxArray,e.index,e.sourceLayerIndex,t.index,S,z,O,M,E,P,I,A,{zoom:t.zoom},e,u,f))};if("line"===x.get("symbol-placement"))for(var F=0,N=l(e.geometry,0,0,w,w);F=0;o--)if(n.dist(a[o])1||(h?(clearTimeout(h),h=null,o("dblclick",e)):h=setTimeout(r,300))},!1),l.addEventListener("touchend",function(t){s("touchend",t)},!1),l.addEventListener("touchmove",function(t){s("touchmove",t)},!1),l.addEventListener("touchcancel",function(t){s("touchcancel",t)},!1),l.addEventListener("click",function(t){n.mousePos(l,t).equals(f)&&o("click",t)},!1),l.addEventListener("dblclick",function(t){o("dblclick",t),t.preventDefault()},!1),l.addEventListener("contextmenu",function(e){var r=t.dragRotate&&t.dragRotate.isActive();u||r?u&&(c=e):o("contextmenu",e),e.preventDefault()},!1)}},{"../util/dom":259,"./handler/box_zoom":239,"./handler/dblclick_zoom":240,"./handler/drag_pan":241,"./handler/drag_rotate":242,"./handler/keyboard":243,"./handler/scroll_zoom":244,"./handler/touch_zoom_rotate":245,"@mapbox/point-geometry":4}],231:[function(t,e,r){var n=t("../util/util"),i=t("../style-spec/util/interpolate").number,a=t("../util/browser"),o=t("../geo/lng_lat"),s=t("../geo/lng_lat_bounds"),l=t("@mapbox/point-geometry"),c=function(t){function e(e,r){t.call(this),this.moving=!1,this.transform=e,this._bearingSnap=r.bearingSnap}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getCenter=function(){return this.transform.center},e.prototype.setCenter=function(t,e){return this.jumpTo({center:t},e)},e.prototype.panBy=function(t,e,r){return t=l.convert(t).mult(-1),this.panTo(this.transform.center,n.extend({offset:t},e),r)},e.prototype.panTo=function(t,e,r){return this.easeTo(n.extend({center:t},e),r)},e.prototype.getZoom=function(){return this.transform.zoom},e.prototype.setZoom=function(t,e){return this.jumpTo({zoom:t},e),this},e.prototype.zoomTo=function(t,e,r){return this.easeTo(n.extend({zoom:t},e),r)},e.prototype.zoomIn=function(t,e){return this.zoomTo(this.getZoom()+1,t,e),this},e.prototype.zoomOut=function(t,e){return this.zoomTo(this.getZoom()-1,t,e),this},e.prototype.getBearing=function(){return this.transform.bearing},e.prototype.setBearing=function(t,e){return this.jumpTo({bearing:t},e),this},e.prototype.rotateTo=function(t,e,r){return this.easeTo(n.extend({bearing:t},e),r)},e.prototype.resetNorth=function(t,e){return this.rotateTo(0,n.extend({duration:1e3},t),e),this},e.prototype.snapToNorth=function(t,e){return Math.abs(this.getBearing())e?1:0}),["bottom","left","right","top"]))return n.warnOnce("options.padding must be a positive number, or an Object with keys 'bottom', 'left', 'right', 'top'"),this;t=s.convert(t);var a=[(e.padding.left-e.padding.right)/2,(e.padding.top-e.padding.bottom)/2],o=Math.min(e.padding.right,e.padding.left),c=Math.min(e.padding.top,e.padding.bottom);e.offset=[e.offset[0]+a[0],e.offset[1]+a[1]];var u=l.convert(e.offset),f=this.transform,h=f.project(t.getNorthWest()),p=f.project(t.getSouthEast()),d=p.sub(h),g=(f.width-2*o-2*Math.abs(u.x))/d.x,m=(f.height-2*c-2*Math.abs(u.y))/d.y;return m<0||g<0?(n.warnOnce("Map cannot fit within canvas with the given bounds, padding, and/or offset."),this):(e.center=f.unproject(h.add(p).div(2)),e.zoom=Math.min(f.scaleZoom(f.scale*Math.min(g,m)),e.maxZoom),e.bearing=0,e.linear?this.easeTo(e,r):this.flyTo(e,r))},e.prototype.jumpTo=function(t,e){this.stop();var r=this.transform,n=!1,i=!1,a=!1;return"zoom"in t&&r.zoom!==+t.zoom&&(n=!0,r.zoom=+t.zoom),void 0!==t.center&&(r.center=o.convert(t.center)),"bearing"in t&&r.bearing!==+t.bearing&&(i=!0,r.bearing=+t.bearing),"pitch"in t&&r.pitch!==+t.pitch&&(a=!0,r.pitch=+t.pitch),this.fire("movestart",e).fire("move",e),n&&this.fire("zoomstart",e).fire("zoom",e).fire("zoomend",e),i&&this.fire("rotate",e),a&&this.fire("pitchstart",e).fire("pitch",e).fire("pitchend",e),this.fire("moveend",e)},e.prototype.easeTo=function(t,e){var r=this;this.stop(),!1===(t=n.extend({offset:[0,0],duration:500,easing:n.ease},t)).animate&&(t.duration=0);var a=this.transform,s=this.getZoom(),c=this.getBearing(),u=this.getPitch(),f="zoom"in t?+t.zoom:s,h="bearing"in t?this._normalizeBearing(t.bearing,c):c,p="pitch"in t?+t.pitch:u,d=a.centerPoint.add(l.convert(t.offset)),g=a.pointLocation(d),m=o.convert(t.center||g);this._normalizeCenter(m);var v,y,x=a.project(g),b=a.project(m).sub(x),_=a.zoomScale(f-s);return t.around&&(v=o.convert(t.around),y=a.locationPoint(v)),this.zooming=f!==s,this.rotating=c!==h,this.pitching=p!==u,this._prepareEase(e,t.noMoveStart),clearTimeout(this._onEaseEnd),this._ease(function(t){if(r.zooming&&(a.zoom=i(s,f,t)),r.rotating&&(a.bearing=i(c,h,t)),r.pitching&&(a.pitch=i(u,p,t)),v)a.setLocationAtPoint(v,y);else{var n=a.zoomScale(a.zoom-s),o=f>s?Math.min(2,_):Math.max(.5,_),l=Math.pow(o,1-t),g=a.unproject(x.add(b.mult(t*l)).mult(n));a.setLocationAtPoint(a.renderWorldCopies?g.wrap():g,d)}r._fireMoveEvents(e)},function(){t.delayEndEvents?r._onEaseEnd=setTimeout(function(){return r._afterEase(e)},t.delayEndEvents):r._afterEase(e)},t),this},e.prototype._prepareEase=function(t,e){this.moving=!0,e||this.fire("movestart",t),this.zooming&&this.fire("zoomstart",t),this.pitching&&this.fire("pitchstart",t)},e.prototype._fireMoveEvents=function(t){this.fire("move",t),this.zooming&&this.fire("zoom",t),this.rotating&&this.fire("rotate",t),this.pitching&&this.fire("pitch",t)},e.prototype._afterEase=function(t){var e=this.zooming,r=this.pitching;this.moving=!1,this.zooming=!1,this.rotating=!1,this.pitching=!1,e&&this.fire("zoomend",t),r&&this.fire("pitchend",t),this.fire("moveend",t)},e.prototype.flyTo=function(t,e){function r(t){var e=(A*A-M*M+(t?-1:1)*E*E*T*T)/(2*(t?A:M)*E*T);return Math.log(Math.sqrt(e*e+1)-e)}function a(t){return(Math.exp(t)-Math.exp(-t))/2}function s(t){return(Math.exp(t)+Math.exp(-t))/2}var c=this;this.stop(),t=n.extend({offset:[0,0],speed:1.2,curve:1.42,easing:n.ease},t);var u=this.transform,f=this.getZoom(),h=this.getBearing(),p=this.getPitch(),d="zoom"in t?n.clamp(+t.zoom,u.minZoom,u.maxZoom):f,g="bearing"in t?this._normalizeBearing(t.bearing,h):h,m="pitch"in t?+t.pitch:p,v=u.zoomScale(d-f),y=u.centerPoint.add(l.convert(t.offset)),x=u.pointLocation(y),b=o.convert(t.center||x);this._normalizeCenter(b);var _=u.project(x),w=u.project(b).sub(_),k=t.curve,M=Math.max(u.width,u.height),A=M/v,T=w.mag();if("minZoom"in t){var S=n.clamp(Math.min(t.minZoom,f,d),u.minZoom,u.maxZoom),C=M/u.zoomScale(S-f);k=Math.sqrt(C/T*2)}var E=k*k,L=r(0),z=function(t){return s(L)/s(L+k*t)},P=function(t){return M*((s(L)*function(t){return a(t)/s(t)}(L+k*t)-a(L))/E)/T},D=(r(1)-L)/k;if(Math.abs(T)<1e-6||!isFinite(D)){if(Math.abs(M-A)<1e-6)return this.easeTo(t,e);var O=At.maxDuration&&(t.duration=0),this.zooming=!0,this.rotating=h!==g,this.pitching=m!==p,this._prepareEase(e,!1),this._ease(function(t){var r=t*D,n=1/z(r);u.zoom=f+u.scaleZoom(n),c.rotating&&(u.bearing=i(h,g,t)),c.pitching&&(u.pitch=i(p,m,t));var a=u.unproject(_.add(w.mult(P(r))).mult(n));u.setLocationAtPoint(u.renderWorldCopies?a.wrap():a,y),c._fireMoveEvents(e)},function(){return c._afterEase(e)},t),this},e.prototype.isEasing=function(){return!!this._isEasing},e.prototype.isMoving=function(){return this.moving},e.prototype.stop=function(){return this._onFrame&&this._finishAnimation(),this},e.prototype._ease=function(t,e,r){var n=this;!1===r.animate||0===r.duration?(t(1),e()):(this._easeStart=a.now(),this._isEasing=!0,this._easeOptions=r,this._startAnimation(function(e){var r=Math.min((a.now()-n._easeStart)/n._easeOptions.duration,1);t(n._easeOptions.easing(r)),1===r&&n.stop()},function(){n._isEasing=!1,e()}))},e.prototype._updateCamera=function(){this._onFrame&&this._onFrame(this.transform)},e.prototype._startAnimation=function(t,e){return void 0===e&&(e=function(){}),this.stop(),this._onFrame=t,this._finishFn=e,this._update(),this},e.prototype._finishAnimation=function(){delete this._onFrame;var t=this._finishFn;delete this._finishFn,t.call(this)},e.prototype._normalizeBearing=function(t,e){t=n.wrap(t,-180,180);var r=Math.abs(t-e);return Math.abs(t-360-e)180?-360:r<-180?360:0}},e}(t("../util/evented"));e.exports=c},{"../geo/lng_lat":62,"../geo/lng_lat_bounds":63,"../style-spec/util/interpolate":158,"../util/browser":252,"../util/evented":260,"../util/util":275,"@mapbox/point-geometry":4}],232:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/config"),o=function(t){this.options=t,i.bindAll(["_updateEditLink","_updateData","_updateCompact"],this)};o.prototype.getDefaultPosition=function(){return"bottom-right"},o.prototype.onAdd=function(t){var e=this.options&&this.options.compact;return this._map=t,this._container=n.create("div","mapboxgl-ctrl mapboxgl-ctrl-attrib"),e&&this._container.classList.add("mapboxgl-compact"),this._updateAttributions(),this._updateEditLink(),this._map.on("sourcedata",this._updateData),this._map.on("moveend",this._updateEditLink),void 0===e&&(this._map.on("resize",this._updateCompact),this._updateCompact()),this._container},o.prototype.onRemove=function(){n.remove(this._container),this._map.off("sourcedata",this._updateData),this._map.off("moveend",this._updateEditLink),this._map.off("resize",this._updateCompact),this._map=void 0},o.prototype._updateEditLink=function(){var t=this._editLink;t||(t=this._editLink=this._container.querySelector(".mapbox-improve-map"));var e=[{key:"owner",value:this.styleOwner},{key:"id",value:this.styleId},{key:"access_token",value:a.ACCESS_TOKEN}];if(t){var r=e.reduce(function(t,r,n){return r.value&&(t+=r.key+"="+r.value+(n=0)return!1;return!0})).length?(this._container.innerHTML=t.join(" | "),this._container.classList.remove("mapboxgl-attrib-empty")):this._container.classList.add("mapboxgl-attrib-empty"),this._editLink=null}},o.prototype._updateCompact=function(){this._map.getCanvasContainer().offsetWidth<=640?this._container.classList.add("mapboxgl-compact"):this._container.classList.remove("mapboxgl-compact")},e.exports=o},{"../../util/config":256,"../../util/dom":259,"../../util/util":275}],233:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=function(){this._fullscreen=!1,i.bindAll(["_onClickFullscreen","_changeIcon"],this),"onfullscreenchange"in a.document?this._fullscreenchange="fullscreenchange":"onmozfullscreenchange"in a.document?this._fullscreenchange="mozfullscreenchange":"onwebkitfullscreenchange"in a.document?this._fullscreenchange="webkitfullscreenchange":"onmsfullscreenchange"in a.document&&(this._fullscreenchange="MSFullscreenChange"),this._className="mapboxgl-ctrl"};o.prototype.onAdd=function(t){return this._map=t,this._mapContainer=this._map.getContainer(),this._container=n.create("div",this._className+" mapboxgl-ctrl-group"),this._checkFullscreenSupport()?this._setupUI():(this._container.style.display="none",i.warnOnce("This device does not support fullscreen mode.")),this._container},o.prototype.onRemove=function(){n.remove(this._container),this._map=null,a.document.removeEventListener(this._fullscreenchange,this._changeIcon)},o.prototype._checkFullscreenSupport=function(){return!!(a.document.fullscreenEnabled||a.document.mozFullScreenEnabled||a.document.msFullscreenEnabled||a.document.webkitFullscreenEnabled)},o.prototype._setupUI=function(){var t=this._fullscreenButton=n.create("button",this._className+"-icon "+this._className+"-fullscreen",this._container);t.setAttribute("aria-label","Toggle fullscreen"),t.type="button",this._fullscreenButton.addEventListener("click",this._onClickFullscreen),a.document.addEventListener(this._fullscreenchange,this._changeIcon)},o.prototype._isFullscreen=function(){return this._fullscreen},o.prototype._changeIcon=function(){(a.document.fullscreenElement||a.document.mozFullScreenElement||a.document.webkitFullscreenElement||a.document.msFullscreenElement)===this._mapContainer!==this._fullscreen&&(this._fullscreen=!this._fullscreen,this._fullscreenButton.classList.toggle(this._className+"-shrink"),this._fullscreenButton.classList.toggle(this._className+"-fullscreen"))},o.prototype._onClickFullscreen=function(){this._isFullscreen()?a.document.exitFullscreen?a.document.exitFullscreen():a.document.mozCancelFullScreen?a.document.mozCancelFullScreen():a.document.msExitFullscreen?a.document.msExitFullscreen():a.document.webkitCancelFullScreen&&a.document.webkitCancelFullScreen():this._mapContainer.requestFullscreen?this._mapContainer.requestFullscreen():this._mapContainer.mozRequestFullScreen?this._mapContainer.mozRequestFullScreen():this._mapContainer.msRequestFullscreen?this._mapContainer.msRequestFullscreen():this._mapContainer.webkitRequestFullscreen&&this._mapContainer.webkitRequestFullscreen()},e.exports=o},{"../../util/dom":259,"../../util/util":275,"../../util/window":254}],234:[function(t,e,r){var n,i=t("../../util/evented"),a=t("../../util/dom"),o=t("../../util/window"),s=t("../../util/util"),l=t("../../geo/lng_lat"),c=t("../marker"),u={positionOptions:{enableHighAccuracy:!1,timeout:6e3},fitBoundsOptions:{maxZoom:15},trackUserLocation:!1,showUserLocation:!0},f=function(t){function e(e){t.call(this),this.options=s.extend({},u,e),s.bindAll(["_onSuccess","_onError","_finish","_setupUI","_updateCamera","_updateMarker","_onClickGeolocate"],this)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.onAdd=function(t){return this._map=t,this._container=a.create("div","mapboxgl-ctrl mapboxgl-ctrl-group"),function(t){void 0!==n?t(n):void 0!==o.navigator.permissions?o.navigator.permissions.query({name:"geolocation"}).then(function(e){n="denied"!==e.state,t(n)}):(n=!!o.navigator.geolocation,t(n))}(this._setupUI),this._container},e.prototype.onRemove=function(){void 0!==this._geolocationWatchID&&(o.navigator.geolocation.clearWatch(this._geolocationWatchID),this._geolocationWatchID=void 0),this.options.showUserLocation&&this._userLocationDotMarker.remove(),a.remove(this._container),this._map=void 0},e.prototype._onSuccess=function(t){if(this.options.trackUserLocation)switch(this._lastKnownPosition=t,this._watchState){case"WAITING_ACTIVE":case"ACTIVE_LOCK":case"ACTIVE_ERROR":this._watchState="ACTIVE_LOCK",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"BACKGROUND":case"BACKGROUND_ERROR":this._watchState="BACKGROUND",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background")}this.options.showUserLocation&&"OFF"!==this._watchState&&this._updateMarker(t),this.options.trackUserLocation&&"ACTIVE_LOCK"!==this._watchState||this._updateCamera(t),this.options.showUserLocation&&this._dotElement.classList.remove("mapboxgl-user-location-dot-stale"),this.fire("geolocate",t),this._finish()},e.prototype._updateCamera=function(t){var e=new l(t.coords.longitude,t.coords.latitude),r=t.coords.accuracy;this._map.fitBounds(e.toBounds(r),this.options.fitBoundsOptions,{geolocateSource:!0})},e.prototype._updateMarker=function(t){t?this._userLocationDotMarker.setLngLat([t.coords.longitude,t.coords.latitude]).addTo(this._map):this._userLocationDotMarker.remove()},e.prototype._onError=function(t){if(this.options.trackUserLocation)if(1===t.code)this._watchState="OFF",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),void 0!==this._geolocationWatchID&&this._clearWatch();else switch(this._watchState){case"WAITING_ACTIVE":this._watchState="ACTIVE_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");break;case"ACTIVE_LOCK":this._watchState="ACTIVE_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");break;case"BACKGROUND":this._watchState="BACKGROUND_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting")}"OFF"!==this._watchState&&this.options.showUserLocation&&this._dotElement.classList.add("mapboxgl-user-location-dot-stale"),this.fire("error",t),this._finish()},e.prototype._finish=function(){this._timeoutId&&clearTimeout(this._timeoutId),this._timeoutId=void 0},e.prototype._setupUI=function(t){var e=this;!1!==t&&(this._container.addEventListener("contextmenu",function(t){return t.preventDefault()}),this._geolocateButton=a.create("button","mapboxgl-ctrl-icon mapboxgl-ctrl-geolocate",this._container),this._geolocateButton.type="button",this._geolocateButton.setAttribute("aria-label","Geolocate"),this.options.trackUserLocation&&(this._geolocateButton.setAttribute("aria-pressed","false"),this._watchState="OFF"),this.options.showUserLocation&&(this._dotElement=a.create("div","mapboxgl-user-location-dot"),this._userLocationDotMarker=new c(this._dotElement),this.options.trackUserLocation&&(this._watchState="OFF")),this._geolocateButton.addEventListener("click",this._onClickGeolocate.bind(this)),this.options.trackUserLocation&&this._map.on("movestart",function(t){t.geolocateSource||"ACTIVE_LOCK"!==e._watchState||(e._watchState="BACKGROUND",e._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background"),e._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),e.fire("trackuserlocationend"))}))},e.prototype._onClickGeolocate=function(){if(this.options.trackUserLocation){switch(this._watchState){case"OFF":this._watchState="WAITING_ACTIVE",this.fire("trackuserlocationstart");break;case"WAITING_ACTIVE":case"ACTIVE_LOCK":case"ACTIVE_ERROR":case"BACKGROUND_ERROR":this._watchState="OFF",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),this.fire("trackuserlocationend");break;case"BACKGROUND":this._watchState="ACTIVE_LOCK",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._lastKnownPosition&&this._updateCamera(this._lastKnownPosition),this.fire("trackuserlocationstart")}switch(this._watchState){case"WAITING_ACTIVE":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"ACTIVE_LOCK":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"ACTIVE_ERROR":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");break;case"BACKGROUND":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");break;case"BACKGROUND_ERROR":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error")}"OFF"===this._watchState&&void 0!==this._geolocationWatchID?this._clearWatch():void 0===this._geolocationWatchID&&(this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.setAttribute("aria-pressed","true"),this._geolocationWatchID=o.navigator.geolocation.watchPosition(this._onSuccess,this._onError,this.options.positionOptions))}else o.navigator.geolocation.getCurrentPosition(this._onSuccess,this._onError,this.options.positionOptions),this._timeoutId=setTimeout(this._finish,1e4)},e.prototype._clearWatch=function(){o.navigator.geolocation.clearWatch(this._geolocationWatchID),this._geolocationWatchID=void 0,this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.setAttribute("aria-pressed","false"),this.options.showUserLocation&&this._updateMarker(null)},e}(i);e.exports=f},{"../../geo/lng_lat":62,"../../util/dom":259,"../../util/evented":260,"../../util/util":275,"../../util/window":254,"../marker":248}],235:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=function(){i.bindAll(["_updateLogo"],this)};a.prototype.onAdd=function(t){this._map=t,this._container=n.create("div","mapboxgl-ctrl");var e=n.create("a","mapboxgl-ctrl-logo");return e.target="_blank",e.href="https://www.mapbox.com/",e.setAttribute("aria-label","Mapbox logo"),this._container.appendChild(e),this._container.style.display="none",this._map.on("sourcedata",this._updateLogo),this._updateLogo(),this._container},a.prototype.onRemove=function(){n.remove(this._container),this._map.off("sourcedata",this._updateLogo)},a.prototype.getDefaultPosition=function(){return"bottom-left"},a.prototype._updateLogo=function(t){t&&"metadata"!==t.sourceDataType||(this._container.style.display=this._logoRequired()?"block":"none")},a.prototype._logoRequired=function(){if(this._map.style){var t=this._map.style.sourceCaches;for(var e in t)if(t[e].getSource().mapbox_logo)return!0;return!1}},e.exports=a},{"../../util/dom":259,"../../util/util":275}],236:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../handler/drag_rotate"),o={showCompass:!0,showZoom:!0},s=function(t){var e=this;this.options=i.extend({},o,t),this._container=n.create("div","mapboxgl-ctrl mapboxgl-ctrl-group"),this._container.addEventListener("contextmenu",function(t){return t.preventDefault()}),this.options.showZoom&&(this._zoomInButton=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-zoom-in","Zoom In",function(){return e._map.zoomIn()}),this._zoomOutButton=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-zoom-out","Zoom Out",function(){return e._map.zoomOut()})),this.options.showCompass&&(i.bindAll(["_rotateCompassArrow"],this),this._compass=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-compass","Reset North",function(){return e._map.resetNorth()}),this._compassArrow=n.create("span","mapboxgl-ctrl-compass-arrow",this._compass))};s.prototype._rotateCompassArrow=function(){var t="rotate("+this._map.transform.angle*(180/Math.PI)+"deg)";this._compassArrow.style.transform=t},s.prototype.onAdd=function(t){return this._map=t,this.options.showCompass&&(this._map.on("rotate",this._rotateCompassArrow),this._rotateCompassArrow(),this._handler=new a(t,{button:"left",element:this._compass}),this._handler.enable()),this._container},s.prototype.onRemove=function(){n.remove(this._container),this.options.showCompass&&(this._map.off("rotate",this._rotateCompassArrow),this._handler.disable(),delete this._handler),delete this._map},s.prototype._createButton=function(t,e,r){var i=n.create("button",t,this._container);return i.type="button",i.setAttribute("aria-label",e),i.addEventListener("click",r),i},e.exports=s},{"../../util/dom":259,"../../util/util":275,"../handler/drag_rotate":242}],237:[function(t,e,r){function n(t,e,r){var n=r&&r.maxWidth||100,a=t._container.clientHeight/2,o=function(t,e){var r=Math.PI/180,n=t.lat*r,i=e.lat*r,a=Math.sin(n)*Math.sin(i)+Math.cos(n)*Math.cos(i)*Math.cos((e.lng-t.lng)*r);return 6371e3*Math.acos(Math.min(a,1))}(t.unproject([0,a]),t.unproject([n,a]));if(r&&"imperial"===r.unit){var s=3.2808*o;s>5280?i(e,n,s/5280,"mi"):i(e,n,s,"ft")}else if(r&&"nautical"===r.unit){i(e,n,o/1852,"nm")}else i(e,n,o,"m")}function i(t,e,r,n){var i=function(t){var e=Math.pow(10,(""+Math.floor(t)).length-1),r=t/e;return e*(r=r>=10?10:r>=5?5:r>=3?3:r>=2?2:1)}(r),a=i/r;"m"===n&&i>=1e3&&(i/=1e3,n="km"),t.style.width=e*a+"px",t.innerHTML=i+n}var a=t("../../util/dom"),o=t("../../util/util"),s=function(t){this.options=t,o.bindAll(["_onMove"],this)};s.prototype.getDefaultPosition=function(){return"bottom-left"},s.prototype._onMove=function(){n(this._map,this._container,this.options)},s.prototype.onAdd=function(t){return this._map=t,this._container=a.create("div","mapboxgl-ctrl mapboxgl-ctrl-scale",t.getContainer()),this._map.on("move",this._onMove),this._onMove(),this._container},s.prototype.onRemove=function(){a.remove(this._container),this._map.off("move",this._onMove),this._map=void 0},e.exports=s},{"../../util/dom":259,"../../util/util":275}],238:[function(t,e,r){},{}],239:[function(t,e,r){var n=t("../../util/dom"),i=t("../../geo/lng_lat_bounds"),a=t("../../util/util"),o=t("../../util/window"),s=function(t){this._map=t,this._el=t.getCanvasContainer(),this._container=t.getContainer(),a.bindAll(["_onMouseDown","_onMouseMove","_onMouseUp","_onKeyDown"],this)};s.prototype.isEnabled=function(){return!!this._enabled},s.prototype.isActive=function(){return!!this._active},s.prototype.enable=function(){this.isEnabled()||(this._map.dragPan&&this._map.dragPan.disable(),this._el.addEventListener("mousedown",this._onMouseDown,!1),this._map.dragPan&&this._map.dragPan.enable(),this._enabled=!0)},s.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("mousedown",this._onMouseDown),this._enabled=!1)},s.prototype._onMouseDown=function(t){t.shiftKey&&0===t.button&&(o.document.addEventListener("mousemove",this._onMouseMove,!1),o.document.addEventListener("keydown",this._onKeyDown,!1),o.document.addEventListener("mouseup",this._onMouseUp,!1),n.disableDrag(),this._startPos=n.mousePos(this._el,t),this._active=!0)},s.prototype._onMouseMove=function(t){var e=this._startPos,r=n.mousePos(this._el,t);this._box||(this._box=n.create("div","mapboxgl-boxzoom",this._container),this._container.classList.add("mapboxgl-crosshair"),this._fireEvent("boxzoomstart",t));var i=Math.min(e.x,r.x),a=Math.max(e.x,r.x),o=Math.min(e.y,r.y),s=Math.max(e.y,r.y);n.setTransform(this._box,"translate("+i+"px,"+o+"px)"),this._box.style.width=a-i+"px",this._box.style.height=s-o+"px"},s.prototype._onMouseUp=function(t){if(0===t.button){var e=this._startPos,r=n.mousePos(this._el,t),a=(new i).extend(this._map.unproject(e)).extend(this._map.unproject(r));this._finish(),e.x===r.x&&e.y===r.y?this._fireEvent("boxzoomcancel",t):this._map.fitBounds(a,{linear:!0}).fire("boxzoomend",{originalEvent:t,boxZoomBounds:a})}},s.prototype._onKeyDown=function(t){27===t.keyCode&&(this._finish(),this._fireEvent("boxzoomcancel",t))},s.prototype._finish=function(){this._active=!1,o.document.removeEventListener("mousemove",this._onMouseMove,!1),o.document.removeEventListener("keydown",this._onKeyDown,!1),o.document.removeEventListener("mouseup",this._onMouseUp,!1),this._container.classList.remove("mapboxgl-crosshair"),this._box&&(n.remove(this._box),this._box=null),n.enableDrag()},s.prototype._fireEvent=function(t,e){return this._map.fire(t,{originalEvent:e})},e.exports=s},{"../../geo/lng_lat_bounds":63,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],240:[function(t,e,r){var n=t("../../util/util"),i=function(t){this._map=t,n.bindAll(["_onDblClick","_onZoomEnd"],this)};i.prototype.isEnabled=function(){return!!this._enabled},i.prototype.isActive=function(){return!!this._active},i.prototype.enable=function(){this.isEnabled()||(this._map.on("dblclick",this._onDblClick),this._enabled=!0)},i.prototype.disable=function(){this.isEnabled()&&(this._map.off("dblclick",this._onDblClick),this._enabled=!1)},i.prototype._onDblClick=function(t){this._active=!0,this._map.on("zoomend",this._onZoomEnd),this._map.zoomTo(this._map.getZoom()+(t.originalEvent.shiftKey?-1:1),{around:t.lngLat},t)},i.prototype._onZoomEnd=function(){this._active=!1,this._map.off("zoomend",this._onZoomEnd)},e.exports=i},{"../../util/util":275}],241:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.3,1),l=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onDown","_onMove","_onUp","_onTouchEnd","_onMouseUp","_onDragFrame","_onDragFinished"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.isActive=function(){return!!this._active},l.prototype.enable=function(){this.isEnabled()||(this._el.classList.add("mapboxgl-touch-drag-pan"),this._el.addEventListener("mousedown",this._onDown),this._el.addEventListener("touchstart",this._onDown),this._enabled=!0)},l.prototype.disable=function(){this.isEnabled()&&(this._el.classList.remove("mapboxgl-touch-drag-pan"),this._el.removeEventListener("mousedown",this._onDown),this._el.removeEventListener("touchstart",this._onDown),this._enabled=!1)},l.prototype._onDown=function(t){this._ignoreEvent(t)||this.isActive()||(t.touches?(a.document.addEventListener("touchmove",this._onMove),a.document.addEventListener("touchend",this._onTouchEnd)):(a.document.addEventListener("mousemove",this._onMove),a.document.addEventListener("mouseup",this._onMouseUp)),a.addEventListener("blur",this._onMouseUp),this._active=!1,this._previousPos=n.mousePos(this._el,t),this._inertia=[[o.now(),this._previousPos]])},l.prototype._onMove=function(t){if(!this._ignoreEvent(t)){this._lastMoveEvent=t,t.preventDefault();var e=n.mousePos(this._el,t);if(this._drainInertiaBuffer(),this._inertia.push([o.now(),e]),!this._previousPos)return void(this._previousPos=e);this._pos=e,this.isActive()||(this._active=!0,this._map.moving=!0,this._fireEvent("dragstart",t),this._fireEvent("movestart",t),this._map._startAnimation(this._onDragFrame,this._onDragFinished)),this._map._update()}},l.prototype._onDragFrame=function(t){var e=this._lastMoveEvent;e&&(t.setLocationAtPoint(t.pointLocation(this._previousPos),this._pos),this._fireEvent("drag",e),this._fireEvent("move",e),this._previousPos=this._pos,delete this._lastMoveEvent)},l.prototype._onDragFinished=function(t){var e=this;if(this.isActive()){this._active=!1,delete this._lastMoveEvent,delete this._previousPos,delete this._pos,this._fireEvent("dragend",t),this._drainInertiaBuffer();var r=function(){e._map.moving=!1,e._fireEvent("moveend",t)},n=this._inertia;if(n.length<2)return void r();var i=n[n.length-1],a=n[0],o=i[1].sub(a[1]),l=(i[0]-a[0])/1e3;if(0===l||i[1].equals(a[1]))return void r();var c=o.mult(.3/l),u=c.mag();u>1400&&(u=1400,c._unit()._mult(u));var f=u/750,h=c.mult(-f/2);this._map.panBy(h,{duration:1e3*f,easing:s,noMoveStart:!0},{originalEvent:t})}},l.prototype._onUp=function(t){this._onDragFinished(t)},l.prototype._onMouseUp=function(t){this._ignoreEvent(t)||(this._onUp(t),a.document.removeEventListener("mousemove",this._onMove),a.document.removeEventListener("mouseup",this._onMouseUp),a.removeEventListener("blur",this._onMouseUp))},l.prototype._onTouchEnd=function(t){this._ignoreEvent(t)||(this._onUp(t),a.document.removeEventListener("touchmove",this._onMove),a.document.removeEventListener("touchend",this._onTouchEnd))},l.prototype._fireEvent=function(t,e){return this._map.fire(t,e?{originalEvent:e}:{})},l.prototype._ignoreEvent=function(t){var e=this._map;return!(!e.boxZoom||!e.boxZoom.isActive())||!(!e.dragRotate||!e.dragRotate.isActive())||(t.touches?t.touches.length>1:!!t.ctrlKey||"mousemove"!==t.type&&t.button&&0!==t.button)},l.prototype._drainInertiaBuffer=function(){for(var t=this._inertia,e=o.now();t.length>0&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],242:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.25,1),l=function(t,e){this._map=t,this._el=e.element||t.getCanvasContainer(),this._button=e.button||"right",this._bearingSnap=e.bearingSnap||0,this._pitchWithRotate=!1!==e.pitchWithRotate,i.bindAll(["_onDown","_onMove","_onUp","_onDragFrame","_onDragFinished"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.isActive=function(){return!!this._active},l.prototype.enable=function(){this.isEnabled()||(this._el.addEventListener("mousedown",this._onDown),this._enabled=!0)},l.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("mousedown",this._onDown),this._enabled=!1)},l.prototype._onDown=function(t){if(!(this._map.boxZoom&&this._map.boxZoom.isActive()||this._map.dragPan&&this._map.dragPan.isActive()||this.isActive())){if("right"===this._button){var e=t.ctrlKey?0:2,r=t.button;if(void 0!==a.InstallTrigger&&2===t.button&&t.ctrlKey&&a.navigator.platform.toUpperCase().indexOf("MAC")>=0&&(r=0),r!==e)return}else if(t.ctrlKey||0!==t.button)return;n.disableDrag(),a.document.addEventListener("mousemove",this._onMove,{capture:!0}),a.document.addEventListener("mouseup",this._onUp),a.addEventListener("blur",this._onUp),this._active=!1,this._inertia=[[o.now(),this._map.getBearing()]],this._previousPos=n.mousePos(this._el,t),this._center=this._map.transform.centerPoint,t.preventDefault()}},l.prototype._onMove=function(t){this._lastMoveEvent=t;var e=n.mousePos(this._el,t);this._previousPos?(this._pos=e,this.isActive()||(this._active=!0,this._map.moving=!0,this._fireEvent("rotatestart",t),this._fireEvent("movestart",t),this._pitchWithRotate&&this._fireEvent("pitchstart",t),this._map._startAnimation(this._onDragFrame,this._onDragFinished)),this._map._update()):this._previousPos=e},l.prototype._onUp=function(t){a.document.removeEventListener("mousemove",this._onMove,{capture:!0}),a.document.removeEventListener("mouseup",this._onUp),a.removeEventListener("blur",this._onUp),n.enableDrag(),this._onDragFinished(t)},l.prototype._onDragFrame=function(t){var e=this._lastMoveEvent;if(e){var r=this._previousPos,n=this._pos,i=.8*(r.x-n.x),a=-.5*(r.y-n.y),s=t.bearing-i,l=t.pitch-a,c=this._inertia,u=c[c.length-1];this._drainInertiaBuffer(),c.push([o.now(),this._map._normalizeBearing(s,u[1])]),t.bearing=s,this._pitchWithRotate&&(this._fireEvent("pitch",e),t.pitch=l),this._fireEvent("rotate",e),this._fireEvent("move",e),delete this._lastMoveEvent,this._previousPos=this._pos}},l.prototype._onDragFinished=function(t){var e=this;if(this.isActive()){this._active=!1,delete this._lastMoveEvent,delete this._previousPos,this._fireEvent("rotateend",t),this._drainInertiaBuffer();var r=this._map,n=r.getBearing(),i=this._inertia,a=function(){Math.abs(n)180&&(d=180);var g=d/180;u+=h*d*(g/2),Math.abs(r._normalizeBearing(u,0))0&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],243:[function(t,e,r){function n(t){return t*(2-t)}var i=t("../../util/util"),a=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onKeyDown"],this)};a.prototype.isEnabled=function(){return!!this._enabled},a.prototype.enable=function(){this.isEnabled()||(this._el.addEventListener("keydown",this._onKeyDown,!1),this._enabled=!0)},a.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("keydown",this._onKeyDown),this._enabled=!1)},a.prototype._onKeyDown=function(t){if(!(t.altKey||t.ctrlKey||t.metaKey)){var e=0,r=0,i=0,a=0,o=0;switch(t.keyCode){case 61:case 107:case 171:case 187:e=1;break;case 189:case 109:case 173:e=-1;break;case 37:t.shiftKey?r=-1:(t.preventDefault(),a=-1);break;case 39:t.shiftKey?r=1:(t.preventDefault(),a=1);break;case 38:t.shiftKey?i=1:(t.preventDefault(),o=-1);break;case 40:t.shiftKey?i=-1:(o=1,t.preventDefault());break;default:return}var s=this._map,l=s.getZoom(),c={duration:300,delayEndEvents:500,easing:n,zoom:e?Math.round(l)+e*(t.shiftKey?2:1):l,bearing:s.getBearing()+15*r,pitch:s.getPitch()+10*i,offset:[100*-a,100*-o],center:s.getCenter()};s.easeTo(c,{originalEvent:t})}},e.exports=a},{"../../util/util":275}],244:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/browser"),o=t("../../util/window"),s=t("../../style-spec/util/interpolate").number,l=t("../../geo/lng_lat"),c=o.navigator.userAgent.toLowerCase(),u=-1!==c.indexOf("firefox"),f=-1!==c.indexOf("safari")&&-1===c.indexOf("chrom"),h=function(t){this._map=t,this._el=t.getCanvasContainer(),this._delta=0,i.bindAll(["_onWheel","_onTimeout","_onScrollFrame","_onScrollFinished"],this)};h.prototype.isEnabled=function(){return!!this._enabled},h.prototype.isActive=function(){return!!this._active},h.prototype.enable=function(t){this.isEnabled()||(this._el.addEventListener("wheel",this._onWheel,!1),this._el.addEventListener("mousewheel",this._onWheel,!1),this._enabled=!0,this._aroundCenter=t&&"center"===t.around)},h.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("wheel",this._onWheel),this._el.removeEventListener("mousewheel",this._onWheel),this._enabled=!1)},h.prototype._onWheel=function(t){var e=0;"wheel"===t.type?(e=t.deltaY,u&&t.deltaMode===o.WheelEvent.DOM_DELTA_PIXEL&&(e/=a.devicePixelRatio),t.deltaMode===o.WheelEvent.DOM_DELTA_LINE&&(e*=40)):"mousewheel"===t.type&&(e=-t.wheelDeltaY,f&&(e/=3));var r=a.now(),n=r-(this._lastWheelEventTime||0);this._lastWheelEventTime=r,0!==e&&e%4.000244140625==0?this._type="wheel":0!==e&&Math.abs(e)<4?this._type="trackpad":n>400?(this._type=null,this._lastValue=e,this._timeout=setTimeout(this._onTimeout,40,t)):this._type||(this._type=Math.abs(n*e)<200?"trackpad":"wheel",this._timeout&&(clearTimeout(this._timeout),this._timeout=null,e+=this._lastValue)),t.shiftKey&&e&&(e/=4),this._type&&(this._lastWheelEvent=t,this._delta-=e,this.isActive()||this._start(t)),t.preventDefault()},h.prototype._onTimeout=function(t){this._type="wheel",this._delta-=this._lastValue,this.isActive()||this._start(t)},h.prototype._start=function(t){if(this._delta){this._active=!0,this._map.moving=!0,this._map.zooming=!0,this._map.fire("movestart",{originalEvent:t}),this._map.fire("zoomstart",{originalEvent:t}),clearTimeout(this._finishTimeout);var e=n.mousePos(this._el,t);this._around=l.convert(this._aroundCenter?this._map.getCenter():this._map.unproject(e)),this._aroundPoint=this._map.transform.locationPoint(this._around),this._map._startAnimation(this._onScrollFrame,this._onScrollFinished)}},h.prototype._onScrollFrame=function(t){if(this.isActive()){if(0!==this._delta){var e="wheel"===this._type&&Math.abs(this._delta)>4.000244140625?1/450:.01,r=2/(1+Math.exp(-Math.abs(this._delta*e)));this._delta<0&&0!==r&&(r=1/r);var n="number"==typeof this._targetZoom?t.zoomScale(this._targetZoom):t.scale;this._targetZoom=Math.min(t.maxZoom,Math.max(t.minZoom,t.scaleZoom(n*r))),"wheel"===this._type&&(this._startZoom=t.zoom,this._easing=this._smoothOutEasing(200)),this._delta=0}if("wheel"===this._type){var i=Math.min((a.now()-this._lastWheelEventTime)/200,1),o=this._easing(i);t.zoom=s(this._startZoom,this._targetZoom,o),1===i&&this._map.stop()}else t.zoom=this._targetZoom,this._map.stop();t.setLocationAtPoint(this._around,this._aroundPoint),this._map.fire("move",{originalEvent:this._lastWheelEvent}),this._map.fire("zoom",{originalEvent:this._lastWheelEvent})}},h.prototype._onScrollFinished=function(){var t=this;this.isActive()&&(this._active=!1,this._finishTimeout=setTimeout(function(){t._map.moving=!1,t._map.zooming=!1,t._map.fire("zoomend"),t._map.fire("moveend"),delete t._targetZoom},200))},h.prototype._smoothOutEasing=function(t){var e=i.ease;if(this._prevEase){var r=this._prevEase,n=(a.now()-r.start)/r.duration,o=r.easing(n+.01)-r.easing(n),s=.27/Math.sqrt(o*o+1e-4)*.01,l=Math.sqrt(.0729-s*s);e=i.bezier(s,l,.25,1)}return this._prevEase={start:a.now(),duration:t,easing:e},e},e.exports=h},{"../../geo/lng_lat":62,"../../style-spec/util/interpolate":158,"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],245:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.15,1),l=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onStart","_onMove","_onEnd"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.enable=function(t){this.isEnabled()||(this._el.classList.add("mapboxgl-touch-zoom-rotate"),this._el.addEventListener("touchstart",this._onStart,!1),this._enabled=!0,this._aroundCenter=t&&"center"===t.around)},l.prototype.disable=function(){this.isEnabled()&&(this._el.classList.remove("mapboxgl-touch-zoom-rotate"),this._el.removeEventListener("touchstart",this._onStart),this._enabled=!1)},l.prototype.disableRotation=function(){this._rotationDisabled=!0},l.prototype.enableRotation=function(){this._rotationDisabled=!1},l.prototype._onStart=function(t){if(2===t.touches.length){var e=n.mousePos(this._el,t.touches[0]),r=n.mousePos(this._el,t.touches[1]);this._startVec=e.sub(r),this._startScale=this._map.transform.scale,this._startBearing=this._map.transform.bearing,this._gestureIntent=void 0,this._inertia=[],a.document.addEventListener("touchmove",this._onMove,!1),a.document.addEventListener("touchend",this._onEnd,!1)}},l.prototype._onMove=function(t){if(2===t.touches.length){var e=n.mousePos(this._el,t.touches[0]),r=n.mousePos(this._el,t.touches[1]),i=e.add(r).div(2),a=e.sub(r),s=a.mag()/this._startVec.mag(),l=this._rotationDisabled?0:180*a.angleWith(this._startVec)/Math.PI,c=this._map;if(this._gestureIntent){var u={duration:0,around:c.unproject(i)};"rotate"===this._gestureIntent&&(u.bearing=this._startBearing+l),"zoom"!==this._gestureIntent&&"rotate"!==this._gestureIntent||(u.zoom=c.transform.scaleZoom(this._startScale*s)),c.stop(),this._drainInertiaBuffer(),this._inertia.push([o.now(),s,i]),c.easeTo(u,{originalEvent:t})}else{var f=Math.abs(1-s)>.15;Math.abs(l)>10?this._gestureIntent="rotate":f&&(this._gestureIntent="zoom"),this._gestureIntent&&(this._startVec=a,this._startScale=c.transform.scale,this._startBearing=c.transform.bearing)}t.preventDefault()}},l.prototype._onEnd=function(t){a.document.removeEventListener("touchmove",this._onMove),a.document.removeEventListener("touchend",this._onEnd),this._drainInertiaBuffer();var e=this._inertia,r=this._map;if(e.length<2)r.snapToNorth({},{originalEvent:t});else{var n=e[e.length-1],i=e[0],o=r.transform.scaleZoom(this._startScale*n[1]),l=r.transform.scaleZoom(this._startScale*i[1]),c=o-l,u=(n[0]-i[0])/1e3,f=n[2];if(0!==u&&o!==l){var h=.15*c/u;Math.abs(h)>2.5&&(h=h>0?2.5:-2.5);var p=1e3*Math.abs(h/(12*.15)),d=o+h*p/2e3;d<0&&(d=0),r.easeTo({zoom:d,duration:p,easing:s,around:this._aroundCenter?r.getCenter():r.unproject(f)},{originalEvent:t})}else r.snapToNorth({},{originalEvent:t})}},l.prototype._drainInertiaBuffer=function(){for(var t=this._inertia,e=o.now();t.length>2&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],246:[function(t,e,r){var n=t("../util/util"),i=t("../util/window"),a=t("../util/throttle"),o=function(){n.bindAll(["_onHashChange","_updateHash"],this),this._updateHash=a(this._updateHashUnthrottled.bind(this),300)};o.prototype.addTo=function(t){return this._map=t,i.addEventListener("hashchange",this._onHashChange,!1),this._map.on("moveend",this._updateHash),this},o.prototype.remove=function(){return i.removeEventListener("hashchange",this._onHashChange,!1),this._map.off("moveend",this._updateHash),delete this._map,this},o.prototype.getHashString=function(t){var e=this._map.getCenter(),r=Math.round(100*this._map.getZoom())/100,n=Math.ceil((r*Math.LN2+Math.log(512/360/.5))/Math.LN10),i=Math.pow(10,n),a=Math.round(e.lng*i)/i,o=Math.round(e.lat*i)/i,s=this._map.getBearing(),l=this._map.getPitch(),c="";return c+=t?"#/"+a+"/"+o+"/"+r:"#"+r+"/"+o+"/"+a,(s||l)&&(c+="/"+Math.round(10*s)/10),l&&(c+="/"+Math.round(l)),c},o.prototype._onHashChange=function(){var t=i.location.hash.replace("#","").split("/");return t.length>=3&&(this._map.jumpTo({center:[+t[2],+t[1]],zoom:+t[0],bearing:+(t[3]||0),pitch:+(t[4]||0)}),!0)},o.prototype._updateHashUnthrottled=function(){var t=this.getHashString();i.history.replaceState("","",t)},e.exports=o},{"../util/throttle":272,"../util/util":275,"../util/window":254}],247:[function(t,e,r){function n(t){t.parentNode&&t.parentNode.removeChild(t)}var i=t("../util/util"),a=t("../util/browser"),o=t("../util/window"),s=t("../util/window"),l=s.HTMLImageElement,c=s.HTMLElement,u=t("../util/dom"),f=t("../util/ajax"),h=t("../style/style"),p=t("../style/evaluation_parameters"),d=t("../render/painter"),g=t("../geo/transform"),m=t("./hash"),v=t("./bind_handlers"),y=t("./camera"),x=t("../geo/lng_lat"),b=t("../geo/lng_lat_bounds"),_=t("@mapbox/point-geometry"),w=t("./control/attribution_control"),k=t("./control/logo_control"),M=t("@mapbox/mapbox-gl-supported"),A=t("../util/image").RGBAImage;t("./events");var T={center:[0,0],zoom:0,bearing:0,pitch:0,minZoom:0,maxZoom:22,interactive:!0,scrollZoom:!0,boxZoom:!0,dragRotate:!0,dragPan:!0,keyboard:!0,doubleClickZoom:!0,touchZoomRotate:!0,bearingSnap:7,hash:!1,attributionControl:!0,failIfMajorPerformanceCaveat:!1,preserveDrawingBuffer:!1,trackResize:!0,renderWorldCopies:!0,refreshExpiredTiles:!0,maxTileCacheSize:null,transformRequest:null,fadeDuration:300},S=function(t){function e(e){if(null!=(e=i.extend({},T,e)).minZoom&&null!=e.maxZoom&&e.minZoom>e.maxZoom)throw new Error("maxZoom must be greater than minZoom");var r=new g(e.minZoom,e.maxZoom,e.renderWorldCopies);t.call(this,r,e),this._interactive=e.interactive,this._maxTileCacheSize=e.maxTileCacheSize,this._failIfMajorPerformanceCaveat=e.failIfMajorPerformanceCaveat,this._preserveDrawingBuffer=e.preserveDrawingBuffer,this._trackResize=e.trackResize,this._bearingSnap=e.bearingSnap,this._refreshExpiredTiles=e.refreshExpiredTiles,this._fadeDuration=e.fadeDuration,this._crossFadingFactor=1,this._collectResourceTiming=e.collectResourceTiming;var n=e.transformRequest;if(this._transformRequest=n?function(t,e){return n(t,e)||{url:t}}:function(t){return{url:t}},"string"==typeof e.container){var a=o.document.getElementById(e.container);if(!a)throw new Error("Container '"+e.container+"' not found.");this._container=a}else{if(!(e.container instanceof c))throw new Error("Invalid type: 'container' must be a String or HTMLElement.");this._container=e.container}e.maxBounds&&this.setMaxBounds(e.maxBounds),i.bindAll(["_onWindowOnline","_onWindowResize","_contextLost","_contextRestored","_update","_render","_onData","_onDataLoading"],this),this._setupContainer(),this._setupPainter(),this.on("move",this._update.bind(this,!1)),this.on("zoom",this._update.bind(this,!0)),void 0!==o&&(o.addEventListener("online",this._onWindowOnline,!1),o.addEventListener("resize",this._onWindowResize,!1)),v(this,e),this._hash=e.hash&&(new m).addTo(this),this._hash&&this._hash._onHashChange()||this.jumpTo({center:e.center,zoom:e.zoom,bearing:e.bearing,pitch:e.pitch}),this.resize(),e.style&&this.setStyle(e.style,{localIdeographFontFamily:e.localIdeographFontFamily}),e.attributionControl&&this.addControl(new w),this.addControl(new k,e.logoPosition),this.on("style.load",function(){this.transform.unmodified&&this.jumpTo(this.style.stylesheet)}),this.on("data",this._onData),this.on("dataloading",this._onDataLoading)}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={showTileBoundaries:{},showCollisionBoxes:{},showOverdrawInspector:{},repaint:{},vertices:{}};return e.prototype.addControl=function(t,e){void 0===e&&t.getDefaultPosition&&(e=t.getDefaultPosition()),void 0===e&&(e="top-right");var r=t.onAdd(this),n=this._controlPositions[e];return-1!==e.indexOf("bottom")?n.insertBefore(r,n.firstChild):n.appendChild(r),this},e.prototype.removeControl=function(t){return t.onRemove(this),this},e.prototype.resize=function(){var t=this._containerDimensions(),e=t[0],r=t[1];return this._resizeCanvas(e,r),this.transform.resize(e,r),this.painter.resize(e,r),this.fire("movestart").fire("move").fire("resize").fire("moveend")},e.prototype.getBounds=function(){var t=new b(this.transform.pointLocation(new _(0,this.transform.height)),this.transform.pointLocation(new _(this.transform.width,0)));return(this.transform.angle||this.transform.pitch)&&(t.extend(this.transform.pointLocation(new _(this.transform.size.x,0))),t.extend(this.transform.pointLocation(new _(0,this.transform.size.y)))),t},e.prototype.getMaxBounds=function(){return this.transform.latRange&&2===this.transform.latRange.length&&this.transform.lngRange&&2===this.transform.lngRange.length?new b([this.transform.lngRange[0],this.transform.latRange[0]],[this.transform.lngRange[1],this.transform.latRange[1]]):null},e.prototype.setMaxBounds=function(t){if(t){var e=b.convert(t);this.transform.lngRange=[e.getWest(),e.getEast()],this.transform.latRange=[e.getSouth(),e.getNorth()],this.transform._constrain(),this._update()}else null!==t&&void 0!==t||(this.transform.lngRange=null,this.transform.latRange=null,this._update());return this},e.prototype.setMinZoom=function(t){if((t=null===t||void 0===t?0:t)>=0&&t<=this.transform.maxZoom)return this.transform.minZoom=t,this._update(),this.getZoom()=this.transform.minZoom)return this.transform.maxZoom=t,this._update(),this.getZoom()>t&&this.setZoom(t),this;throw new Error("maxZoom must be greater than the current minZoom")},e.prototype.getMaxZoom=function(){return this.transform.maxZoom},e.prototype.project=function(t){return this.transform.locationPoint(x.convert(t))},e.prototype.unproject=function(t){return this.transform.pointLocation(_.convert(t))},e.prototype.on=function(e,r,n){var a=this;if(void 0===n)return t.prototype.on.call(this,e,r);var o=function(){if("mouseenter"===e||"mouseover"===e){var t=!1;return{layer:r,listener:n,delegates:{mousemove:function(o){var s=a.getLayer(r)?a.queryRenderedFeatures(o.point,{layers:[r]}):[];s.length?t||(t=!0,n.call(a,i.extend({features:s},o,{type:e}))):t=!1},mouseout:function(){t=!1}}}}if("mouseleave"===e||"mouseout"===e){var o=!1;return{layer:r,listener:n,delegates:{mousemove:function(t){(a.getLayer(r)?a.queryRenderedFeatures(t.point,{layers:[r]}):[]).length?o=!0:o&&(o=!1,n.call(a,i.extend({},t,{type:e})))},mouseout:function(t){o&&(o=!1,n.call(a,i.extend({},t,{type:e})))}}}}var s;return{layer:r,listener:n,delegates:(s={},s[e]=function(t){var e=a.getLayer(r)?a.queryRenderedFeatures(t.point,{layers:[r]}):[];e.length&&n.call(a,i.extend({features:e},t))},s)}}();for(var s in this._delegatedListeners=this._delegatedListeners||{},this._delegatedListeners[e]=this._delegatedListeners[e]||[],this._delegatedListeners[e].push(o),o.delegates)a.on(s,o.delegates[s]);return this},e.prototype.off=function(e,r,n){if(void 0===n)return t.prototype.off.call(this,e,r);if(this._delegatedListeners&&this._delegatedListeners[e])for(var i=this._delegatedListeners[e],a=0;athis._map.transform.height-i?["bottom"]:[],t.xthis._map.transform.width-n/2&&e.push("right"),e=0===e.length?"bottom":e.join("-")}var o=t.add(r[e]).round(),l={top:"translate(-50%,0)","top-left":"translate(0,0)","top-right":"translate(-100%,0)",bottom:"translate(-50%,-100%)","bottom-left":"translate(0,-100%)","bottom-right":"translate(-100%,-100%)",left:"translate(0,-50%)",right:"translate(-100%,-50%)"},u=this._container.classList;for(var f in l)u.remove("mapboxgl-popup-anchor-"+f);u.add("mapboxgl-popup-anchor-"+e),a.setTransform(this._container,l[e]+" translate("+o.x+"px,"+o.y+"px)")}},e.prototype._onClickClose=function(){this.remove()},e}(i);e.exports=f},{"../geo/lng_lat":62,"../util/dom":259,"../util/evented":260,"../util/smart_wrap":270,"../util/util":275,"../util/window":254,"@mapbox/point-geometry":4}],250:[function(t,e,r){var n=t("./util"),i=t("./web_worker_transfer"),a=i.serialize,o=i.deserialize,s=function(t,e,r){this.target=t,this.parent=e,this.mapId=r,this.callbacks={},this.callbackID=0,n.bindAll(["receive"],this),this.target.addEventListener("message",this.receive,!1)};s.prototype.send=function(t,e,r,n){var i=r?this.mapId+":"+this.callbackID++:null;r&&(this.callbacks[i]=r);var o=[];this.target.postMessage({targetMapId:n,sourceMapId:this.mapId,type:t,id:String(i),data:a(e,o)},o)},s.prototype.receive=function(t){var e,r=this,n=t.data,i=n.id;if(!n.targetMapId||this.mapId===n.targetMapId){var s=function(t,e){var n=[];r.target.postMessage({sourceMapId:r.mapId,type:"",id:String(i),error:t?String(t):null,data:a(e,n)},n)};if(""===n.type)e=this.callbacks[n.id],delete this.callbacks[n.id],e&&n.error?e(new Error(n.error)):e&&e(null,o(n.data));else if(void 0!==n.id&&this.parent[n.type])this.parent[n.type](n.sourceMapId,o(n.data),s);else if(void 0!==n.id&&this.parent.getWorkerSource){var l=n.type.split(".");this.parent.getWorkerSource(n.sourceMapId,l[0])[l[1]](o(n.data),s)}else this.parent[n.type](o(n.data))}},s.prototype.remove=function(){this.target.removeEventListener("message",this.receive,!1)},e.exports=s},{"./util":275,"./web_worker_transfer":278}],251:[function(t,e,r){function n(t){var e=new a.XMLHttpRequest;for(var r in e.open("GET",t.url,!0),t.headers)e.setRequestHeader(r,t.headers[r]);return e.withCredentials="include"===t.credentials,e}function i(t){var e=a.document.createElement("a");return e.href=t,e.protocol===a.document.location.protocol&&e.host===a.document.location.host}var a=t("./window"),o={Unknown:"Unknown",Style:"Style",Source:"Source",Tile:"Tile",Glyphs:"Glyphs",SpriteImage:"SpriteImage",SpriteJSON:"SpriteJSON",Image:"Image"};r.ResourceType=o,"function"==typeof Object.freeze&&Object.freeze(o);var s=function(t){function e(e,r){t.call(this,e),this.status=r}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(Error);r.getJSON=function(t,e){var r=n(t);return r.setRequestHeader("Accept","application/json"),r.onerror=function(){e(new Error(r.statusText))},r.onload=function(){if(r.status>=200&&r.status<300&&r.response){var t;try{t=JSON.parse(r.response)}catch(t){return e(t)}e(null,t)}else e(new s(r.statusText,r.status))},r.send(),r},r.getArrayBuffer=function(t,e){var r=n(t);return r.responseType="arraybuffer",r.onerror=function(){e(new Error(r.statusText))},r.onload=function(){var t=r.response;if(0===t.byteLength&&200===r.status)return e(new Error("http status 200 returned without content."));r.status>=200&&r.status<300&&r.response?e(null,{data:t,cacheControl:r.getResponseHeader("Cache-Control"),expires:r.getResponseHeader("Expires")}):e(new s(r.statusText,r.status))},r.send(),r};r.getImage=function(t,e){return r.getArrayBuffer(t,function(t,r){if(t)e(t);else if(r){var n=new a.Image,i=a.URL||a.webkitURL;n.onload=function(){e(null,n),i.revokeObjectURL(n.src)};var o=new a.Blob([new Uint8Array(r.data)],{type:"image/png"});n.cacheControl=r.cacheControl,n.expires=r.expires,n.src=r.data.byteLength?i.createObjectURL(o):"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII="}})},r.getVideo=function(t,e){var r=a.document.createElement("video");r.onloadstart=function(){e(null,r)};for(var n=0;n1)for(var f=0;f0||this._oneTimeListeners&&this._oneTimeListeners[t]&&this._oneTimeListeners[t].length>0||this._eventedParent&&this._eventedParent.listens(t)},o.prototype.setEventedParent=function(t,e){return this._eventedParent=t,this._eventedParentData=e,this},e.exports=o},{"./util":275}],261:[function(t,e,r){function n(t,e){return e.max-t.max}function i(t,e,r,n){this.p=new o(t,e),this.h=r,this.d=function(t,e){for(var r=!1,n=1/0,i=0;it.y!=f.y>t.y&&t.x<(f.x-u.x)*(t.y-u.y)/(f.y-u.y)+u.x&&(r=!r),n=Math.min(n,s(t,u,f))}return(r?1:-1)*Math.sqrt(n)}(this.p,n),this.max=this.d+this.h*Math.SQRT2}var a=t("tinyqueue"),o=t("@mapbox/point-geometry"),s=t("./intersection_tests").distToSegmentSquared;e.exports=function(t,e,r){void 0===e&&(e=1),void 0===r&&(r=!1);for(var s=1/0,l=1/0,c=-1/0,u=-1/0,f=t[0],h=0;hc)&&(c=p.x),(!h||p.y>u)&&(u=p.y)}var d=c-s,g=u-l,m=Math.min(d,g),v=m/2,y=new a(null,n);if(0===m)return new o(s,l);for(var x=s;x_.d||!_.d)&&(_=k,r&&console.log("found best %d after %d probes",Math.round(1e4*k.d)/1e4,w)),k.max-_.d<=e||(v=k.h/2,y.push(new i(k.p.x-v,k.p.y-v,v,t)),y.push(new i(k.p.x+v,k.p.y-v,v,t)),y.push(new i(k.p.x-v,k.p.y+v,v,t)),y.push(new i(k.p.x+v,k.p.y+v,v,t)),w+=4)}return r&&(console.log("num probes: "+w),console.log("best distance: "+_.d)),_.p}},{"./intersection_tests":264,"@mapbox/point-geometry":4,tinyqueue:33}],262:[function(t,e,r){var n,i=t("./worker_pool");e.exports=function(){return n||(n=new i),n}},{"./worker_pool":279}],263:[function(t,e,r){function n(t,e,r,n){var i=e.width,a=e.height;if(n){if(n.length!==i*a*r)throw new RangeError("mismatched image size")}else n=new Uint8Array(i*a*r);return t.width=i,t.height=a,t.data=n,t}function i(t,e,r){var i=e.width,o=e.height;if(i!==t.width||o!==t.height){var s=n({},{width:i,height:o},r);a(t,s,{x:0,y:0},{x:0,y:0},{width:Math.min(t.width,i),height:Math.min(t.height,o)},r),t.width=i,t.height=o,t.data=s.data}}function a(t,e,r,n,i,a){if(0===i.width||0===i.height)return e;if(i.width>t.width||i.height>t.height||r.x>t.width-i.width||r.y>t.height-i.height)throw new RangeError("out of range source coordinates for image copy");if(i.width>e.width||i.height>e.height||n.x>e.width-i.width||n.y>e.height-i.height)throw new RangeError("out of range destination coordinates for image copy");for(var o=t.data,s=e.data,l=0;l1){if(i(t,e))return!0;for(var n=0;n1?t.distSqr(r):t.distSqr(r.sub(e)._mult(i)._add(e))}function l(t,e){for(var r,n,i,a=!1,o=0;oe.y!=i.y>e.y&&e.x<(i.x-n.x)*(e.y-n.y)/(i.y-n.y)+n.x&&(a=!a);return a}function c(t,e){for(var r=!1,n=0,i=t.length-1;ne.y!=o.y>e.y&&e.x<(o.x-a.x)*(e.y-a.y)/(o.y-a.y)+a.x&&(r=!r)}return r}var u=t("./util").isCounterClockwise;e.exports={multiPolygonIntersectsBufferedMultiPoint:function(t,e,r){for(var n=0;n=3)for(var l=0;l=128&&t<=255},Arabic:function(t){return t>=1536&&t<=1791},"Arabic Supplement":function(t){return t>=1872&&t<=1919},"Arabic Extended-A":function(t){return t>=2208&&t<=2303},"Hangul Jamo":function(t){return t>=4352&&t<=4607},"Unified Canadian Aboriginal Syllabics":function(t){return t>=5120&&t<=5759},"Unified Canadian Aboriginal Syllabics Extended":function(t){return t>=6320&&t<=6399},"General Punctuation":function(t){return t>=8192&&t<=8303},"Letterlike Symbols":function(t){return t>=8448&&t<=8527},"Number Forms":function(t){return t>=8528&&t<=8591},"Miscellaneous Technical":function(t){return t>=8960&&t<=9215},"Control Pictures":function(t){return t>=9216&&t<=9279},"Optical Character Recognition":function(t){return t>=9280&&t<=9311},"Enclosed Alphanumerics":function(t){return t>=9312&&t<=9471},"Geometric Shapes":function(t){return t>=9632&&t<=9727},"Miscellaneous Symbols":function(t){return t>=9728&&t<=9983},"Miscellaneous Symbols and Arrows":function(t){return t>=11008&&t<=11263},"CJK Radicals Supplement":function(t){return t>=11904&&t<=12031},"Kangxi Radicals":function(t){return t>=12032&&t<=12255},"Ideographic Description Characters":function(t){return t>=12272&&t<=12287},"CJK Symbols and Punctuation":function(t){return t>=12288&&t<=12351},Hiragana:function(t){return t>=12352&&t<=12447},Katakana:function(t){return t>=12448&&t<=12543},Bopomofo:function(t){return t>=12544&&t<=12591},"Hangul Compatibility Jamo":function(t){return t>=12592&&t<=12687},Kanbun:function(t){return t>=12688&&t<=12703},"Bopomofo Extended":function(t){return t>=12704&&t<=12735},"CJK Strokes":function(t){return t>=12736&&t<=12783},"Katakana Phonetic Extensions":function(t){return t>=12784&&t<=12799},"Enclosed CJK Letters and Months":function(t){return t>=12800&&t<=13055},"CJK Compatibility":function(t){return t>=13056&&t<=13311},"CJK Unified Ideographs Extension A":function(t){return t>=13312&&t<=19903},"Yijing Hexagram Symbols":function(t){return t>=19904&&t<=19967},"CJK Unified Ideographs":function(t){return t>=19968&&t<=40959},"Yi Syllables":function(t){return t>=40960&&t<=42127},"Yi Radicals":function(t){return t>=42128&&t<=42191},"Hangul Jamo Extended-A":function(t){return t>=43360&&t<=43391},"Hangul Syllables":function(t){return t>=44032&&t<=55215},"Hangul Jamo Extended-B":function(t){return t>=55216&&t<=55295},"Private Use Area":function(t){return t>=57344&&t<=63743},"CJK Compatibility Ideographs":function(t){return t>=63744&&t<=64255},"Arabic Presentation Forms-A":function(t){return t>=64336&&t<=65023},"Vertical Forms":function(t){return t>=65040&&t<=65055},"CJK Compatibility Forms":function(t){return t>=65072&&t<=65103},"Small Form Variants":function(t){return t>=65104&&t<=65135},"Arabic Presentation Forms-B":function(t){return t>=65136&&t<=65279},"Halfwidth and Fullwidth Forms":function(t){return t>=65280&&t<=65519}}},{}],266:[function(t,e,r){var n=function(t,e){this.max=t,this.onRemove=e,this.reset()};n.prototype.reset=function(){var t=this;for(var e in t.data)t.onRemove(t.data[e]);return this.data={},this.order=[],this},n.prototype.add=function(t,e){if(this.has(t))this.order.splice(this.order.indexOf(t),1),this.data[t]=e,this.order.push(t);else if(this.data[t]=e,this.order.push(t),this.order.length>this.max){var r=this.getAndRemove(this.order[0]);r&&this.onRemove(r)}return this},n.prototype.has=function(t){return t in this.data},n.prototype.keys=function(){return this.order},n.prototype.getAndRemove=function(t){if(!this.has(t))return null;var e=this.data[t];return delete this.data[t],this.order.splice(this.order.indexOf(t),1),e},n.prototype.get=function(t){return this.has(t)?this.data[t]:null},n.prototype.remove=function(t){if(!this.has(t))return this;var e=this.data[t];return delete this.data[t],this.onRemove(e),this.order.splice(this.order.indexOf(t),1),this},n.prototype.setMaxSize=function(t){var e=this;for(this.max=t;this.order.length>this.max;){var r=e.getAndRemove(e.order[0]);r&&e.onRemove(r)}return this},e.exports=n},{}],267:[function(t,e,r){function n(t,e){var r=a(s.API_URL);if(t.protocol=r.protocol,t.authority=r.authority,"/"!==r.path&&(t.path=""+r.path+t.path),!s.REQUIRE_ACCESS_TOKEN)return o(t);if(!(e=e||s.ACCESS_TOKEN))throw new Error("An API access token is required to use Mapbox GL. "+c);if("s"===e[0])throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). "+c);return t.params.push("access_token="+e),o(t)}function i(t){return 0===t.indexOf("mapbox:")}function a(t){var e=t.match(f);if(!e)throw new Error("Unable to parse URL object");return{protocol:e[1],authority:e[2],path:e[3]||"/",params:e[4]?e[4].split("&"):[]}}function o(t){var e=t.params.length?"?"+t.params.join("&"):"";return t.protocol+"://"+t.authority+t.path+e}var s=t("./config"),l=t("./browser"),c="See https://www.mapbox.com/api-documentation/#access-tokens";r.isMapboxURL=i,r.normalizeStyleURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/styles/v1"+r.path,n(r,e)},r.normalizeGlyphsURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/fonts/v1"+r.path,n(r,e)},r.normalizeSourceURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/v4/"+r.authority+".json",r.params.push("secure"),n(r,e)},r.normalizeSpriteURL=function(t,e,r,s){var l=a(t);return i(t)?(l.path="/styles/v1"+l.path+"/sprite"+e+r,n(l,s)):(l.path+=""+e+r,o(l))};var u=/(\.(png|jpg)\d*)(?=$)/;r.normalizeTileURL=function(t,e,r){if(!e||!i(e))return t;var n=a(t),c=l.devicePixelRatio>=2||512===r?"@2x":"",f=l.supportsWebp?".webp":"$1";return n.path=n.path.replace(u,""+c+f),function(t){for(var e=0;e=65097&&t<=65103)||n["CJK Compatibility Ideographs"](t)||n["CJK Compatibility"](t)||n["CJK Radicals Supplement"](t)||n["CJK Strokes"](t)||!(!n["CJK Symbols and Punctuation"](t)||t>=12296&&t<=12305||t>=12308&&t<=12319||12336===t)||n["CJK Unified Ideographs Extension A"](t)||n["CJK Unified Ideographs"](t)||n["Enclosed CJK Letters and Months"](t)||n["Hangul Compatibility Jamo"](t)||n["Hangul Jamo Extended-A"](t)||n["Hangul Jamo Extended-B"](t)||n["Hangul Jamo"](t)||n["Hangul Syllables"](t)||n.Hiragana(t)||n["Ideographic Description Characters"](t)||n.Kanbun(t)||n["Kangxi Radicals"](t)||n["Katakana Phonetic Extensions"](t)||n.Katakana(t)&&12540!==t||!(!n["Halfwidth and Fullwidth Forms"](t)||65288===t||65289===t||65293===t||t>=65306&&t<=65310||65339===t||65341===t||65343===t||t>=65371&&t<=65503||65507===t||t>=65512&&t<=65519)||!(!n["Small Form Variants"](t)||t>=65112&&t<=65118||t>=65123&&t<=65126)||n["Unified Canadian Aboriginal Syllabics"](t)||n["Unified Canadian Aboriginal Syllabics Extended"](t)||n["Vertical Forms"](t)||n["Yijing Hexagram Symbols"](t)||n["Yi Syllables"](t)||n["Yi Radicals"](t)))},r.charHasNeutralVerticalOrientation=function(t){return!!(n["Latin-1 Supplement"](t)&&(167===t||169===t||174===t||177===t||188===t||189===t||190===t||215===t||247===t)||n["General Punctuation"](t)&&(8214===t||8224===t||8225===t||8240===t||8241===t||8251===t||8252===t||8258===t||8263===t||8264===t||8265===t||8273===t)||n["Letterlike Symbols"](t)||n["Number Forms"](t)||n["Miscellaneous Technical"](t)&&(t>=8960&&t<=8967||t>=8972&&t<=8991||t>=8996&&t<=9e3||9003===t||t>=9085&&t<=9114||t>=9150&&t<=9165||9167===t||t>=9169&&t<=9179||t>=9186&&t<=9215)||n["Control Pictures"](t)&&9251!==t||n["Optical Character Recognition"](t)||n["Enclosed Alphanumerics"](t)||n["Geometric Shapes"](t)||n["Miscellaneous Symbols"](t)&&!(t>=9754&&t<=9759)||n["Miscellaneous Symbols and Arrows"](t)&&(t>=11026&&t<=11055||t>=11088&&t<=11097||t>=11192&&t<=11243)||n["CJK Symbols and Punctuation"](t)||n.Katakana(t)||n["Private Use Area"](t)||n["CJK Compatibility Forms"](t)||n["Small Form Variants"](t)||n["Halfwidth and Fullwidth Forms"](t)||8734===t||8756===t||8757===t||t>=9984&&t<=10087||t>=10102&&t<=10131||65532===t||65533===t)},r.charHasRotatedVerticalOrientation=function(t){return!(r.charHasUprightVerticalOrientation(t)||r.charHasNeutralVerticalOrientation(t))}},{"./is_char_in_unicode_block":265}],270:[function(t,e,r){var n=t("../geo/lng_lat");e.exports=function(t,e,r){if(t=new n(t.lng,t.lat),e){var i=new n(t.lng-360,t.lat),a=new n(t.lng+360,t.lat),o=r.locationPoint(t).distSqr(e);r.locationPoint(i).distSqr(e)180;){var s=r.locationPoint(t);if(s.x>=0&&s.y>=0&&s.x<=r.width&&s.y<=r.height)break;t.lng>r.center.lng?t.lng-=360:t.lng+=360}return t}},{"../geo/lng_lat":62}],271:[function(t,e,r){function n(t,e){return Math.ceil(t/e)*e}var i={Int8:Int8Array,Uint8:Uint8Array,Int16:Int16Array,Uint16:Uint16Array,Int32:Int32Array,Uint32:Uint32Array,Float32:Float32Array},a=function(){this.isTransferred=!1,this.capacity=-1,this.resize(0)};a.serialize=function(t,e){return t._trim(),e&&(t.isTransferred=!0,e.push(t.arrayBuffer)),{length:t.length,arrayBuffer:t.arrayBuffer}},a.deserialize=function(t){var e=Object.create(this.prototype);return e.arrayBuffer=t.arrayBuffer,e.length=t.length,e.capacity=t.arrayBuffer.byteLength/e.bytesPerElement,e._refreshViews(),e},a.prototype._trim=function(){this.length!==this.capacity&&(this.capacity=this.length,this.arrayBuffer=this.arrayBuffer.slice(0,this.length*this.bytesPerElement),this._refreshViews())},a.prototype.clear=function(){this.length=0},a.prototype.resize=function(t){this.reserve(t),this.length=t},a.prototype.reserve=function(t){if(t>this.capacity){this.capacity=Math.max(t,Math.floor(5*this.capacity),128),this.arrayBuffer=new ArrayBuffer(this.capacity*this.bytesPerElement);var e=this.uint8;this._refreshViews(),e&&this.uint8.set(e)}},a.prototype._refreshViews=function(){throw new Error("_refreshViews() must be implemented by each concrete StructArray layout")},e.exports.StructArray=a,e.exports.Struct=function(t,e){this._structArray=t,this._pos1=e*this.size,this._pos2=this._pos1/2,this._pos4=this._pos1/4,this._pos8=this._pos1/8},e.exports.viewTypes=i,e.exports.createLayout=function(t,e){void 0===e&&(e=1);var r=0,a=0;return{members:t.map(function(t){var o=function(t){return i[t].BYTES_PER_ELEMENT}(t.type),s=r=n(r,Math.max(e,o)),l=t.components||1;return a=Math.max(a,o),r+=o*l,{name:t.name,type:t.type,components:l,offset:s}}),size:n(r,Math.max(a,e)),alignment:e}}},{}],272:[function(t,e,r){e.exports=function(t,e){var r=!1,n=0,i=function(){n=0,r&&(t(),n=setTimeout(i,e),r=!1)};return function(){return r=!0,n||i(),n}}},{}],273:[function(t,e,r){function n(t,e){if(t.row>e.row){var r=t;t=e,e=r}return{x0:t.column,y0:t.row,x1:e.column,y1:e.row,dx:e.column-t.column,dy:e.row-t.row}}function i(t,e,r,n,i){var a=Math.max(r,Math.floor(e.y0)),o=Math.min(n,Math.ceil(e.y1));if(t.x0===e.x0&&t.y0===e.y0?t.x0+e.dy/t.dy*t.dx0,f=e.dx<0,h=a;hu.dy&&(l=c,c=u,u=l),c.dy>f.dy&&(l=c,c=f,f=l),u.dy>f.dy&&(l=u,u=f,f=l),c.dy&&i(f,c,a,o,s),u.dy&&i(f,u,a,o,s)}t("../geo/coordinate");var o=t("../source/tile_id").OverscaledTileID;e.exports=function(t,e,r,n){function i(e,i,a){var c,u,f;if(a>=0&&a<=s)for(c=e;c=1)return 1;var e=t*t,r=e*t;return 4*(t<.5?r:3*(t-e)+r-.75)},r.bezier=function(t,e,r,i){var a=new n(t,e,r,i);return function(t){return a.solve(t)}},r.ease=r.bezier(.25,.1,.25,1),r.clamp=function(t,e,r){return Math.min(r,Math.max(e,t))},r.wrap=function(t,e,r){var n=r-e,i=((t-e)%n+n)%n+e;return i===e?r:i},r.asyncAll=function(t,e,r){if(!t.length)return r(null,[]);var n=t.length,i=new Array(t.length),a=null;t.forEach(function(t,o){e(t,function(t,e){t&&(a=t),i[o]=e,0==--n&&r(a,i)})})},r.values=function(t){var e=[];for(var r in t)e.push(t[r]);return e},r.keysDifference=function(t,e){var r=[];for(var n in t)n in e||r.push(n);return r},r.extend=function(t){for(var e=arguments,r=[],n=arguments.length-1;n-- >0;)r[n]=e[n+1];for(var i=0,a=r;i=0)return!0;return!1};var o={};r.warnOnce=function(t){o[t]||("undefined"!=typeof console&&console.warn(t),o[t]=!0)},r.isCounterClockwise=function(t,e,r){return(r.y-t.y)*(e.x-t.x)>(e.y-t.y)*(r.x-t.x)},r.calculateSignedArea=function(t){for(var e=0,r=0,n=t.length,i=n-1,a=void 0,o=void 0;r0||Math.abs(e.y-n.y)>0)&&Math.abs(r.calculateSignedArea(t))>.01},r.sphericalToCartesian=function(t){var e=t[0],r=t[1],n=t[2];return r+=90,r*=Math.PI/180,n*=Math.PI/180,{x:e*Math.cos(r)*Math.sin(n),y:e*Math.sin(r)*Math.sin(n),z:e*Math.cos(n)}},r.parseCacheControl=function(t){var e={};if(t.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g,function(t,r,n,i){var a=n||i;return e[r]=!a||a.toLowerCase(),""}),e["max-age"]){var r=parseInt(e["max-age"],10);isNaN(r)?delete e["max-age"]:e["max-age"]=r}return e}},{"../geo/coordinate":61,"../style-spec/util/deep_equal":155,"@mapbox/point-geometry":4,"@mapbox/unitbezier":7}],276:[function(t,e,r){var n=function(t,e,r,n){this.type="Feature",this._vectorTileFeature=t,t._z=e,t._x=r,t._y=n,this.properties=t.properties,null!=t.id&&(this.id=t.id)},i={geometry:{}};i.geometry.get=function(){return void 0===this._geometry&&(this._geometry=this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x,this._vectorTileFeature._y,this._vectorTileFeature._z).geometry),this._geometry},i.geometry.set=function(t){this._geometry=t},n.prototype.toJSON=function(){var t={geometry:this.geometry};for(var e in this)"_geometry"!==e&&"_vectorTileFeature"!==e&&(t[e]=this[e]);return t},Object.defineProperties(n.prototype,i),e.exports=n},{}],277:[function(t,e,r){var n=t("./script_detection");e.exports=function(t){for(var r="",i=0;i":"\ufe40","?":"\ufe16","@":"\uff20","[":"\ufe47","\\":"\uff3c","]":"\ufe48","^":"\uff3e",_:"\ufe33","`":"\uff40","{":"\ufe37","|":"\u2015","}":"\ufe38","~":"\uff5e","\xa2":"\uffe0","\xa3":"\uffe1","\xa5":"\uffe5","\xa6":"\uffe4","\xac":"\uffe2","\xaf":"\uffe3","\u2013":"\ufe32","\u2014":"\ufe31","\u2018":"\ufe43","\u2019":"\ufe44","\u201c":"\ufe41","\u201d":"\ufe42","\u2026":"\ufe19","\u2027":"\u30fb","\u20a9":"\uffe6","\u3001":"\ufe11","\u3002":"\ufe12","\u3008":"\ufe3f","\u3009":"\ufe40","\u300a":"\ufe3d","\u300b":"\ufe3e","\u300c":"\ufe41","\u300d":"\ufe42","\u300e":"\ufe43","\u300f":"\ufe44","\u3010":"\ufe3b","\u3011":"\ufe3c","\u3014":"\ufe39","\u3015":"\ufe3a","\u3016":"\ufe17","\u3017":"\ufe18","\uff01":"\ufe15","\uff08":"\ufe35","\uff09":"\ufe36","\uff0c":"\ufe10","\uff0d":"\ufe32","\uff0e":"\u30fb","\uff1a":"\ufe13","\uff1b":"\ufe14","\uff1c":"\ufe3f","\uff1e":"\ufe40","\uff1f":"\ufe16","\uff3b":"\ufe47","\uff3d":"\ufe48","\uff3f":"\ufe33","\uff5b":"\ufe37","\uff5c":"\u2015","\uff5d":"\ufe38","\uff5f":"\ufe35","\uff60":"\ufe36","\uff61":"\ufe12","\uff62":"\ufe41","\uff63":"\ufe42"}},{"./script_detection":269}],278:[function(t,e,r){function n(t,e,r){void 0===r&&(r={}),Object.defineProperty(e,"_classRegistryKey",{value:t,writeable:!1}),g[t]={klass:e,omit:r.omit||[],shallow:r.shallow||[]}}var i=t("grid-index"),a=t("../style-spec/util/color"),o=t("../style-spec/expression"),s=o.StylePropertyFunction,l=o.StyleExpression,c=o.StyleExpressionWithErrorHandling,u=o.ZoomDependentExpression,f=o.ZoomConstantExpression,h=t("../style-spec/expression/compound_expression").CompoundExpression,p=t("../style-spec/expression/definitions"),d=t("./window").ImageData,g={};for(var m in n("Object",Object),i.serialize=function(t,e){var r=t.toArrayBuffer();return e&&e.push(r),r},i.deserialize=function(t){return new i(t)},n("Grid",i),n("Color",a),n("StylePropertyFunction",s),n("StyleExpression",l,{omit:["_evaluator"]}),n("StyleExpressionWithErrorHandling",c,{omit:["_evaluator"]}),n("ZoomDependentExpression",u),n("ZoomConstantExpression",f),n("CompoundExpression",h,{omit:["_evaluate"]}),p)p[m]._classRegistryKey||n("Expression_"+m,p[m]);e.exports={register:n,serialize:function t(e,r){if(null===e||void 0===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||e instanceof Boolean||e instanceof Number||e instanceof String||e instanceof Date||e instanceof RegExp)return e;if(e instanceof ArrayBuffer)return r&&r.push(e),e;if(ArrayBuffer.isView(e)){var n=e;return r&&r.push(n.buffer),n}if(e instanceof d)return r&&r.push(e.data.buffer),e;if(Array.isArray(e)){for(var i=[],a=0,o=e;a=0)){var h=e[f];u[f]=g[c].shallow.indexOf(f)>=0?h:t(h,r)}return{name:c,properties:u}}throw new Error("can't serialize object of type "+typeof e)},deserialize:function t(e){if(null===e||void 0===e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||e instanceof Boolean||e instanceof Number||e instanceof String||e instanceof Date||e instanceof RegExp||e instanceof ArrayBuffer||ArrayBuffer.isView(e)||e instanceof d)return e;if(Array.isArray(e))return e.map(function(e){return t(e)});if("object"==typeof e){var r=e,n=r.name,i=r.properties;if(!n)throw new Error("can't deserialize object of anonymous class");var a=g[n].klass;if(!a)throw new Error("can't deserialize unregistered class "+n);if(a.deserialize)return a.deserialize(i._serialized);for(var o=Object.create(a.prototype),s=0,l=Object.keys(i);s=0?i[c]:t(i[c])}return o}throw new Error("can't deserialize object of type "+typeof e)}}},{"../style-spec/expression":139,"../style-spec/expression/compound_expression":123,"../style-spec/expression/definitions":131,"../style-spec/util/color":153,"./window":254,"grid-index":24}],279:[function(t,e,r){var n=t("./web_worker"),i=function(){this.active={}};i.prototype.acquire=function(e){if(!this.workers){var r=t("../").workerCount;for(this.workers=[];this.workers.lengthp[1][2]&&(v[0]=-v[0]),p[0][2]>p[2][0]&&(v[1]=-v[1]),p[1][0]>p[0][1]&&(v[2]=-v[2]),!0}},{"./normalize":372,"gl-mat4/clone":229,"gl-mat4/create":230,"gl-mat4/determinant":231,"gl-mat4/invert":235,"gl-mat4/transpose":245,"gl-vec3/cross":290,"gl-vec3/dot":293,"gl-vec3/length":298,"gl-vec3/normalize":304}],372:[function(t,e,r){e.exports=function(t,e){var r=e[15];if(0===r)return!1;for(var n=1/r,i=0;i<16;i++)t[i]=e[i]*n;return!0}},{}],373:[function(t,e,r){var n=t("gl-vec3/lerp"),i=t("mat4-recompose"),a=t("mat4-decompose"),o=t("gl-mat4/determinant"),s=t("quat-slerp"),l=f(),c=f(),u=f();function f(){return{translate:h(),scale:h(1),skew:h(),perspective:[0,0,0,1],quaternion:[0,0,0,1]}}function h(t){return[t||0,t||0,t||0]}e.exports=function(t,e,r,f){if(0===o(e)||0===o(r))return!1;var h=a(e,l.translate,l.scale,l.skew,l.perspective,l.quaternion),p=a(r,c.translate,c.scale,c.skew,c.perspective,c.quaternion);return!(!h||!p||(n(u.translate,l.translate,c.translate,f),n(u.skew,l.skew,c.skew,f),n(u.scale,l.scale,c.scale,f),n(u.perspective,l.perspective,c.perspective,f),s(u.quaternion,l.quaternion,c.quaternion,f),i(t,u.translate,u.scale,u.skew,u.perspective,u.quaternion),0))}},{"gl-mat4/determinant":231,"gl-vec3/lerp":299,"mat4-decompose":371,"mat4-recompose":374,"quat-slerp":425}],374:[function(t,e,r){var n={identity:t("gl-mat4/identity"),translate:t("gl-mat4/translate"),multiply:t("gl-mat4/multiply"),create:t("gl-mat4/create"),scale:t("gl-mat4/scale"),fromRotationTranslation:t("gl-mat4/fromRotationTranslation")},i=(n.create(),n.create());e.exports=function(t,e,r,a,o,s){return n.identity(t),n.fromRotationTranslation(t,s,e),t[3]=o[0],t[7]=o[1],t[11]=o[2],t[15]=o[3],n.identity(i),0!==a[2]&&(i[9]=a[2],n.multiply(t,t,i)),0!==a[1]&&(i[9]=0,i[8]=a[1],n.multiply(t,t,i)),0!==a[0]&&(i[8]=0,i[4]=a[0],n.multiply(t,t,i)),n.scale(t,t,r),t}},{"gl-mat4/create":230,"gl-mat4/fromRotationTranslation":233,"gl-mat4/identity":234,"gl-mat4/multiply":237,"gl-mat4/scale":243,"gl-mat4/translate":244}],375:[function(t,e,r){"use strict";e.exports=Math.log2||function(t){return Math.log(t)*Math.LOG2E}},{}],376:[function(t,e,r){"use strict";var n=t("binary-search-bounds"),i=t("mat4-interpolate"),a=t("gl-mat4/invert"),o=t("gl-mat4/rotateX"),s=t("gl-mat4/rotateY"),l=t("gl-mat4/rotateZ"),c=t("gl-mat4/lookAt"),u=t("gl-mat4/translate"),f=(t("gl-mat4/scale"),t("gl-vec3/normalize")),h=[0,0,0];function p(t){this._components=t.slice(),this._time=[0],this.prevMatrix=t.slice(),this.nextMatrix=t.slice(),this.computedMatrix=t.slice(),this.computedInverse=t.slice(),this.computedEye=[0,0,0],this.computedUp=[0,0,0],this.computedCenter=[0,0,0],this.computedRadius=[0],this._limits=[-1/0,1/0]}e.exports=function(t){return new p((t=t||{}).matrix||[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1])};var d=p.prototype;d.recalcMatrix=function(t){var e=this._time,r=n.le(e,t),o=this.computedMatrix;if(!(r<0)){var s=this._components;if(r===e.length-1)for(var l=16*r,c=0;c<16;++c)o[c]=s[l++];else{var u=e[r+1]-e[r],h=(l=16*r,this.prevMatrix),p=!0;for(c=0;c<16;++c)h[c]=s[l++];var d=this.nextMatrix;for(c=0;c<16;++c)d[c]=s[l++],p=p&&h[c]===d[c];if(u<1e-6||p)for(c=0;c<16;++c)o[c]=h[c];else i(o,h,d,(t-e[r])/u)}var g=this.computedUp;g[0]=o[1],g[1]=o[5],g[2]=o[9],f(g,g);var m=this.computedInverse;a(m,o);var v=this.computedEye,y=m[15];v[0]=m[12]/y,v[1]=m[13]/y,v[2]=m[14]/y;var x=this.computedCenter,b=Math.exp(this.computedRadius[0]);for(c=0;c<3;++c)x[c]=v[c]-o[2+4*c]*b}},d.idle=function(t){if(!(t1&&n(t[o[u-2]],t[o[u-1]],c)<=0;)u-=1,o.pop();for(o.push(l),u=s.length;u>1&&n(t[s[u-2]],t[s[u-1]],c)>=0;)u-=1,s.pop();s.push(l)}for(var r=new Array(s.length+o.length-2),f=0,i=0,h=o.length;i0;--p)r[f++]=s[p];return r};var n=t("robust-orientation")[3]},{"robust-orientation":446}],378:[function(t,e,r){"use strict";e.exports=function(t,e){e||(e=t,t=window);var r=0,i=0,a=0,o={shift:!1,alt:!1,control:!1,meta:!1},s=!1;function l(t){var e=!1;return"altKey"in t&&(e=e||t.altKey!==o.alt,o.alt=!!t.altKey),"shiftKey"in t&&(e=e||t.shiftKey!==o.shift,o.shift=!!t.shiftKey),"ctrlKey"in t&&(e=e||t.ctrlKey!==o.control,o.control=!!t.ctrlKey),"metaKey"in t&&(e=e||t.metaKey!==o.meta,o.meta=!!t.metaKey),e}function c(t,s){var c=n.x(s),u=n.y(s);"buttons"in s&&(t=0|s.buttons),(t!==r||c!==i||u!==a||l(s))&&(r=0|t,i=c||0,a=u||0,e&&e(r,i,a,o))}function u(t){c(0,t)}function f(){(r||i||a||o.shift||o.alt||o.meta||o.control)&&(i=a=0,r=0,o.shift=o.alt=o.control=o.meta=!1,e&&e(0,0,0,o))}function h(t){l(t)&&e&&e(r,i,a,o)}function p(t){0===n.buttons(t)?c(0,t):c(r,t)}function d(t){c(r|n.buttons(t),t)}function g(t){c(r&~n.buttons(t),t)}function m(){s||(s=!0,t.addEventListener("mousemove",p),t.addEventListener("mousedown",d),t.addEventListener("mouseup",g),t.addEventListener("mouseleave",u),t.addEventListener("mouseenter",u),t.addEventListener("mouseout",u),t.addEventListener("mouseover",u),t.addEventListener("blur",f),t.addEventListener("keyup",h),t.addEventListener("keydown",h),t.addEventListener("keypress",h),t!==window&&(window.addEventListener("blur",f),window.addEventListener("keyup",h),window.addEventListener("keydown",h),window.addEventListener("keypress",h)))}m();var v={element:t};return Object.defineProperties(v,{enabled:{get:function(){return s},set:function(e){e?m():s&&(s=!1,t.removeEventListener("mousemove",p),t.removeEventListener("mousedown",d),t.removeEventListener("mouseup",g),t.removeEventListener("mouseleave",u),t.removeEventListener("mouseenter",u),t.removeEventListener("mouseout",u),t.removeEventListener("mouseover",u),t.removeEventListener("blur",f),t.removeEventListener("keyup",h),t.removeEventListener("keydown",h),t.removeEventListener("keypress",h),t!==window&&(window.removeEventListener("blur",f),window.removeEventListener("keyup",h),window.removeEventListener("keydown",h),window.removeEventListener("keypress",h)))},enumerable:!0},buttons:{get:function(){return r},enumerable:!0},x:{get:function(){return i},enumerable:!0},y:{get:function(){return a},enumerable:!0},mods:{get:function(){return o},enumerable:!0}}),v};var n=t("mouse-event")},{"mouse-event":380}],379:[function(t,e,r){var n={left:0,top:0};e.exports=function(t,e,r){e=e||t.currentTarget||t.srcElement,Array.isArray(r)||(r=[0,0]);var i=t.clientX||0,a=t.clientY||0,o=(s=e,s===window||s===document||s===document.body?n:s.getBoundingClientRect());var s;return r[0]=i-o.left,r[1]=a-o.top,r}},{}],380:[function(t,e,r){"use strict";function n(t){return t.target||t.srcElement||window}r.buttons=function(t){if("object"==typeof t){if("buttons"in t)return t.buttons;if("which"in t){if(2===(e=t.which))return 4;if(3===e)return 2;if(e>0)return 1<=0)return 1< 0");"function"!=typeof t.vertex&&e("Must specify vertex creation function");"function"!=typeof t.cell&&e("Must specify cell creation function");"function"!=typeof t.phase&&e("Must specify phase function");for(var C=t.getters||[],E=new Array(T),L=0;L=0?E[L]=!0:E[L]=!1;return function(t,e,r,T,S,C){var E=C.length,L=S.length;if(L<2)throw new Error("ndarray-extract-contour: Dimension must be at least 2");for(var z="extractContour"+S.join("_"),P=[],D=[],O=[],I=0;I0&&N.push(l(I,S[R-1])+"*"+s(S[R-1])),D.push(d(I,S[R])+"=("+N.join("-")+")|0")}for(var I=0;I=0;--I)j.push(s(S[I]));D.push(w+"=("+j.join("*")+")|0",b+"=mallocUint32("+w+")",x+"=mallocUint32("+w+")",k+"=0"),D.push(g(0)+"=0");for(var R=1;R<1<0;M=M-1&d)w.push(x+"["+k+"+"+v(M)+"]");w.push(y(0));for(var M=0;M=0;--e)G(e,0);for(var r=[],e=0;e0){",p(S[e]),"=1;");t(e-1,r|1<=0?s.push("0"):e.indexOf(-(l+1))>=0?s.push("s["+l+"]-1"):(s.push("-1"),a.push("1"),o.push("s["+l+"]-2"));var c=".lo("+a.join()+").hi("+o.join()+")";if(0===a.length&&(c=""),i>0){n.push("if(1");for(var l=0;l=0||e.indexOf(-(l+1))>=0||n.push("&&s[",l,"]>2");n.push("){grad",i,"(src.pick(",s.join(),")",c);for(var l=0;l=0||e.indexOf(-(l+1))>=0||n.push(",dst.pick(",s.join(),",",l,")",c);n.push(");")}for(var l=0;l1){dst.set(",s.join(),",",u,",0.5*(src.get(",h.join(),")-src.get(",p.join(),")))}else{dst.set(",s.join(),",",u,",0)};"):n.push("if(s[",u,"]>1){diff(",f,",src.pick(",h.join(),")",c,",src.pick(",p.join(),")",c,");}else{zero(",f,");};");break;case"mirror":0===i?n.push("dst.set(",s.join(),",",u,",0);"):n.push("zero(",f,");");break;case"wrap":var d=s.slice(),g=s.slice();e[l]<0?(d[u]="s["+u+"]-2",g[u]="0"):(d[u]="s["+u+"]-1",g[u]="1"),0===i?n.push("if(s[",u,"]>2){dst.set(",s.join(),",",u,",0.5*(src.get(",d.join(),")-src.get(",g.join(),")))}else{dst.set(",s.join(),",",u,",0)};"):n.push("if(s[",u,"]>2){diff(",f,",src.pick(",d.join(),")",c,",src.pick(",g.join(),")",c,");}else{zero(",f,");};");break;default:throw new Error("ndarray-gradient: Invalid boundary condition")}}i>0&&n.push("};")}for(var s=0;s<1<>",rrshift:">>>"};!function(){for(var t in s){var e=s[t];r[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),r[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a"+e+"=b"},rvalue:!0,funcName:t+"eq"}),r[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),r[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a"+e+"=s"},rvalue:!0,funcName:t+"seq"})}}();var l={not:"!",bnot:"~",neg:"-",recip:"1.0/"};!function(){for(var t in l){var e=l[t];r[t]=o({args:["array","array"],body:{args:["a","b"],body:"a="+e+"b"},funcName:t}),r[t+"eq"]=o({args:["array"],body:{args:["a"],body:"a="+e+"a"},rvalue:!0,count:2,funcName:t+"eq"})}}();var c={and:"&&",or:"||",eq:"===",neq:"!==",lt:"<",gt:">",leq:"<=",geq:">="};!function(){for(var t in c){var e=c[t];r[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),r[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),r[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a=a"+e+"b"},rvalue:!0,count:2,funcName:t+"eq"}),r[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a=a"+e+"s"},rvalue:!0,count:2,funcName:t+"seq"})}}();var u=["abs","acos","asin","atan","ceil","cos","exp","floor","log","round","sin","sqrt","tan"];!function(){for(var t=0;tthis_s){this_s=-a}else if(a>this_s){this_s=a}",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norminf"}),r.norm1=n({args:["array"],pre:{args:[],localVars:[],thisVars:["this_s"],body:"this_s=0"},body:{args:[{name:"a",lvalue:!1,rvalue:!0,count:3}],body:"this_s+=a<0?-a:a",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norm1"}),r.sup=n({args:["array"],pre:{body:"this_h=-Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_>this_h)this_h=_inline_1_arg0_",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_h"],localVars:[]},post:{body:"return this_h",args:[],thisVars:["this_h"],localVars:[]}}),r.inf=n({args:["array"],pre:{body:"this_h=Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_this_v){this_v=_inline_1_arg1_;for(var _inline_1_k=0;_inline_1_k<_inline_1_arg0_.length;++_inline_1_k){this_i[_inline_1_k]=_inline_1_arg0_[_inline_1_k]}}}",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_i","this_v"],localVars:["_inline_1_k"]},post:{body:"{return this_i}",args:[],thisVars:["this_i"],localVars:[]}}),r.random=o({args:["array"],pre:{args:[],body:"this_f=Math.random",thisVars:["this_f"]},body:{args:["a"],body:"a=this_f()",thisVars:["this_f"]},funcName:"random"}),r.assign=o({args:["array","array"],body:{args:["a","b"],body:"a=b"},funcName:"assign"}),r.assigns=o({args:["array","scalar"],body:{args:["a","b"],body:"a=b"},funcName:"assigns"}),r.equals=n({args:["array","array"],pre:i,body:{args:[{name:"x",lvalue:!1,rvalue:!0,count:1},{name:"y",lvalue:!1,rvalue:!0,count:1}],body:"if(x!==y){return false}",localVars:[],thisVars:[]},post:{args:[],localVars:[],thisVars:[],body:"return true"},funcName:"equals"})},{"cwise-compiler":117}],388:[function(t,e,r){"use strict";var n=t("ndarray"),i=t("./doConvert.js");e.exports=function(t,e){for(var r=[],a=t,o=1;Array.isArray(a);)r.push(a.length),o*=a.length,a=a[0];return 0===r.length?n():(e||(e=n(new Float64Array(o),r)),i(e,t),e)}},{"./doConvert.js":389,ndarray:393}],389:[function(t,e,r){e.exports=t("cwise-compiler")({args:["array","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\nvar _inline_1_v=_inline_1_arg1_,_inline_1_i\nfor(_inline_1_i=0;_inline_1_i<_inline_1_arg2_.length-1;++_inline_1_i) {\n_inline_1_v=_inline_1_v[_inline_1_arg2_[_inline_1_i]]\n}\n_inline_1_arg0_=_inline_1_v[_inline_1_arg2_[_inline_1_arg2_.length-1]]\n}",args:[{name:"_inline_1_arg0_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:4}],thisVars:[],localVars:["_inline_1_i","_inline_1_v"]},post:{body:"{}",args:[],thisVars:[],localVars:[]},funcName:"convert",blockSize:64})},{"cwise-compiler":117}],390:[function(t,e,r){"use strict";var n=t("typedarray-pool"),i=32;function a(t){switch(t){case"uint8":return[n.mallocUint8,n.freeUint8];case"uint16":return[n.mallocUint16,n.freeUint16];case"uint32":return[n.mallocUint32,n.freeUint32];case"int8":return[n.mallocInt8,n.freeInt8];case"int16":return[n.mallocInt16,n.freeInt16];case"int32":return[n.mallocInt32,n.freeInt32];case"float32":return[n.mallocFloat,n.freeFloat];case"float64":return[n.mallocDouble,n.freeDouble];default:return null}}function o(t){for(var e=[],r=0;r0?s.push(["d",d,"=s",d,"-d",f,"*n",f].join("")):s.push(["d",d,"=s",d].join("")),f=d),0!=(p=t.length-1-l)&&(h>0?s.push(["e",p,"=s",p,"-e",h,"*n",h,",f",p,"=",c[p],"-f",h,"*n",h].join("")):s.push(["e",p,"=s",p,",f",p,"=",c[p]].join("")),h=p)}r.push("var "+s.join(","));var g=["0","n0-1","data","offset"].concat(o(t.length));r.push(["if(n0<=",i,"){","insertionSort(",g.join(","),")}else{","quickSort(",g.join(","),")}"].join("")),r.push("}return "+n);var m=new Function("insertionSort","quickSort",r.join("\n")),v=function(t,e){var r=["'use strict'"],n=["ndarrayInsertionSort",t.join("d"),e].join(""),i=["left","right","data","offset"].concat(o(t.length)),s=a(e),l=["i,j,cptr,ptr=left*s0+offset"];if(t.length>1){for(var c=[],u=1;u1){for(r.push("dptr=0;sptr=ptr"),u=t.length-1;u>=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"b){break __l}"].join("")),u=t.length-1;u>=1;--u)r.push("sptr+=e"+u,"dptr+=f"+u,"}");for(r.push("dptr=cptr;sptr=cptr-s0"),u=t.length-1;u>=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"scratch)){",h("cptr",f("cptr-s0")),"cptr-=s0","}",h("cptr","scratch"));return r.push("}"),t.length>1&&s&&r.push("free(scratch)"),r.push("} return "+n),s?new Function("malloc","free",r.join("\n"))(s[0],s[1]):new Function(r.join("\n"))()}(t,e);return m(v,function(t,e,r){var n=["'use strict'"],s=["ndarrayQuickSort",t.join("d"),e].join(""),l=["left","right","data","offset"].concat(o(t.length)),c=a(e),u=0;n.push(["function ",s,"(",l.join(","),"){"].join(""));var f=["sixth=((right-left+1)/6)|0","index1=left+sixth","index5=right-sixth","index3=(left+right)>>1","index2=index3-sixth","index4=index3+sixth","el1=index1","el2=index2","el3=index3","el4=index4","el5=index5","less=left+1","great=right-1","pivots_are_equal=true","tmp","tmp0","x","y","z","k","ptr0","ptr1","ptr2","comp_pivot1=0","comp_pivot2=0","comp=0"];if(t.length>1){for(var h=[],p=1;p=0;--a)0!==(o=t[a])&&n.push(["for(i",o,"=0;i",o,"1)for(a=0;a1?n.push("ptr_shift+=d"+o):n.push("ptr0+=d"+o),n.push("}"))}}function y(e,r,i,a){if(1===r.length)n.push("ptr0="+d(r[0]));else{for(var o=0;o1)for(o=0;o=1;--o)i&&n.push("pivot_ptr+=f"+o),r.length>1?n.push("ptr_shift+=e"+o):n.push("ptr0+=e"+o),n.push("}")}function x(){t.length>1&&c&&n.push("free(pivot1)","free(pivot2)")}function b(e,r){var i="el"+e,a="el"+r;if(t.length>1){var o="__l"+ ++u;y(o,[i,a],!1,["comp=",g("ptr0"),"-",g("ptr1"),"\n","if(comp>0){tmp0=",i,";",i,"=",a,";",a,"=tmp0;break ",o,"}\n","if(comp<0){break ",o,"}"].join(""))}else n.push(["if(",g(d(i)),">",g(d(a)),"){tmp0=",i,";",i,"=",a,";",a,"=tmp0}"].join(""))}function _(e,r){t.length>1?v([e,r],!1,m("ptr0",g("ptr1"))):n.push(m(d(e),g(d(r))))}function w(e,r,i){if(t.length>1){var a="__l"+ ++u;y(a,[r],!0,[e,"=",g("ptr0"),"-pivot",i,"[pivot_ptr]\n","if(",e,"!==0){break ",a,"}"].join(""))}else n.push([e,"=",g(d(r)),"-pivot",i].join(""))}function k(e,r){t.length>1?v([e,r],!1,["tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1","tmp")].join("")):n.push(["ptr0=",d(e),"\n","ptr1=",d(r),"\n","tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1","tmp")].join(""))}function M(e,r,i){t.length>1?(v([e,r,i],!1,["tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1",g("ptr2")),"\n",m("ptr2","tmp")].join("")),n.push("++"+r,"--"+i)):n.push(["ptr0=",d(e),"\n","ptr1=",d(r),"\n","ptr2=",d(i),"\n","++",r,"\n","--",i,"\n","tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1",g("ptr2")),"\n",m("ptr2","tmp")].join(""))}function A(t,e){k(t,e),n.push("--"+e)}function T(e,r,i){t.length>1?v([e,r],!0,[m("ptr0",g("ptr1")),"\n",m("ptr1",["pivot",i,"[pivot_ptr]"].join(""))].join("")):n.push(m(d(e),g(d(r))),m(d(r),"pivot"+i))}function S(e,r){n.push(["if((",r,"-",e,")<=",i,"){\n","insertionSort(",e,",",r,",data,offset,",o(t.length).join(","),")\n","}else{\n",s,"(",e,",",r,",data,offset,",o(t.length).join(","),")\n","}"].join(""))}function C(e,r,i){t.length>1?(n.push(["__l",++u,":while(true){"].join("")),v([e],!0,["if(",g("ptr0"),"!==pivot",r,"[pivot_ptr]){break __l",u,"}"].join("")),n.push(i,"}")):n.push(["while(",g(d(e)),"===pivot",r,"){",i,"}"].join(""))}return n.push("var "+f.join(",")),b(1,2),b(4,5),b(1,3),b(2,3),b(1,4),b(3,4),b(2,5),b(2,3),b(4,5),t.length>1?v(["el1","el2","el3","el4","el5","index1","index3","index5"],!0,["pivot1[pivot_ptr]=",g("ptr1"),"\n","pivot2[pivot_ptr]=",g("ptr3"),"\n","pivots_are_equal=pivots_are_equal&&(pivot1[pivot_ptr]===pivot2[pivot_ptr])\n","x=",g("ptr0"),"\n","y=",g("ptr2"),"\n","z=",g("ptr4"),"\n",m("ptr5","x"),"\n",m("ptr6","y"),"\n",m("ptr7","z")].join("")):n.push(["pivot1=",g(d("el2")),"\n","pivot2=",g(d("el4")),"\n","pivots_are_equal=pivot1===pivot2\n","x=",g(d("el1")),"\n","y=",g(d("el3")),"\n","z=",g(d("el5")),"\n",m(d("index1"),"x"),"\n",m(d("index3"),"y"),"\n",m(d("index5"),"z")].join("")),_("index2","left"),_("index4","right"),n.push("if(pivots_are_equal){"),n.push("for(k=less;k<=great;++k){"),w("comp","k",1),n.push("if(comp===0){continue}"),n.push("if(comp<0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),n.push("while(true){"),w("comp","great",1),n.push("if(comp>0){"),n.push("great--"),n.push("}else if(comp<0){"),M("k","less","great"),n.push("break"),n.push("}else{"),A("k","great"),n.push("break"),n.push("}"),n.push("}"),n.push("}"),n.push("}"),n.push("}else{"),n.push("for(k=less;k<=great;++k){"),w("comp_pivot1","k",1),n.push("if(comp_pivot1<0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),w("comp_pivot2","k",2),n.push("if(comp_pivot2>0){"),n.push("while(true){"),w("comp","great",2),n.push("if(comp>0){"),n.push("if(--greatindex5){"),C("less",1,"++less"),C("great",2,"--great"),n.push("for(k=less;k<=great;++k){"),w("comp_pivot1","k",1),n.push("if(comp_pivot1===0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),w("comp_pivot2","k",2),n.push("if(comp_pivot2===0){"),n.push("while(true){"),w("comp","great",2),n.push("if(comp===0){"),n.push("if(--great1&&c?new Function("insertionSort","malloc","free",n.join("\n"))(r,c[0],c[1]):new Function("insertionSort",n.join("\n"))(r)}(t,e,v))}},{"typedarray-pool":481}],391:[function(t,e,r){"use strict";var n=t("./lib/compile_sort.js"),i={};e.exports=function(t){var e=t.order,r=t.dtype,a=[e,r].join(":"),o=i[a];return o||(i[a]=o=n(e,r)),o(t),t}},{"./lib/compile_sort.js":390}],392:[function(t,e,r){"use strict";var n=t("ndarray-linear-interpolate"),i=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=new Array(_inline_3_arg4_)}",args:[{name:"_inline_3_arg0_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg1_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg2_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg3_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_4_arg2_(this_warped,_inline_4_arg0_),_inline_4_arg1_=_inline_4_arg3_.apply(void 0,this_warped)}",args:[{name:"_inline_4_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_4_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg4_",lvalue:!1,rvalue:!1,count:0}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warpND",blockSize:64}),a=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_7_arg2_(this_warped,_inline_7_arg0_),_inline_7_arg1_=_inline_7_arg3_(_inline_7_arg4_,this_warped[0])}",args:[{name:"_inline_7_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_7_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp1D",blockSize:64}),o=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0,0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_10_arg2_(this_warped,_inline_10_arg0_),_inline_10_arg1_=_inline_10_arg3_(_inline_10_arg4_,this_warped[0],this_warped[1])}",args:[{name:"_inline_10_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_10_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp2D",blockSize:64}),s=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0,0,0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_13_arg2_(this_warped,_inline_13_arg0_),_inline_13_arg1_=_inline_13_arg3_(_inline_13_arg4_,this_warped[0],this_warped[1],this_warped[2])}",args:[{name:"_inline_13_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_13_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp3D",blockSize:64});e.exports=function(t,e,r){switch(e.shape.length){case 1:a(t,r,n.d1,e);break;case 2:o(t,r,n.d2,e);break;case 3:s(t,r,n.d3,e);break;default:i(t,r,n.bind(void 0,e),e.shape.length)}return t}},{"cwise/lib/wrapper":120,"ndarray-linear-interpolate":386}],393:[function(t,e,r){var n=t("iota-array"),i=t("is-buffer"),a="undefined"!=typeof Float64Array;function o(t,e){return t[0]-e[0]}function s(){var t,e=this.stride,r=new Array(e.length);for(t=0;tMath.abs(this.stride[1]))?[1,0]:[0,1]}})"):3===e&&a.push("var s0=Math.abs(this.stride[0]),s1=Math.abs(this.stride[1]),s2=Math.abs(this.stride[2]);if(s0>s1){if(s1>s2){return [2,1,0];}else if(s0>s2){return [1,2,0];}else{return [1,0,2];}}else if(s0>s2){return [2,0,1];}else if(s2>s1){return [0,1,2];}else{return [0,2,1];}}})")):a.push("ORDER})")),a.push("proto.set=function "+r+"_set("+l.join(",")+",v){"),i?a.push("return this.data.set("+u+",v)}"):a.push("return this.data["+u+"]=v}"),a.push("proto.get=function "+r+"_get("+l.join(",")+"){"),i?a.push("return this.data.get("+u+")}"):a.push("return this.data["+u+"]}"),a.push("proto.index=function "+r+"_index(",l.join(),"){return "+u+"}"),a.push("proto.hi=function "+r+"_hi("+l.join(",")+"){return new "+r+"(this.data,"+o.map(function(t){return["(typeof i",t,"!=='number'||i",t,"<0)?this.shape[",t,"]:i",t,"|0"].join("")}).join(",")+","+o.map(function(t){return"this.stride["+t+"]"}).join(",")+",this.offset)}");var p=o.map(function(t){return"a"+t+"=this.shape["+t+"]"}),d=o.map(function(t){return"c"+t+"=this.stride["+t+"]"});a.push("proto.lo=function "+r+"_lo("+l.join(",")+"){var b=this.offset,d=0,"+p.join(",")+","+d.join(","));for(var g=0;g=0){d=i"+g+"|0;b+=c"+g+"*d;a"+g+"-=d}");a.push("return new "+r+"(this.data,"+o.map(function(t){return"a"+t}).join(",")+","+o.map(function(t){return"c"+t}).join(",")+",b)}"),a.push("proto.step=function "+r+"_step("+l.join(",")+"){var "+o.map(function(t){return"a"+t+"=this.shape["+t+"]"}).join(",")+","+o.map(function(t){return"b"+t+"=this.stride["+t+"]"}).join(",")+",c=this.offset,d=0,ceil=Math.ceil");for(g=0;g=0){c=(c+this.stride["+g+"]*i"+g+")|0}else{a.push(this.shape["+g+"]);b.push(this.stride["+g+"])}");return a.push("var ctor=CTOR_LIST[a.length+1];return ctor(this.data,a,b,c)}"),a.push("return function construct_"+r+"(data,shape,stride,offset){return new "+r+"(data,"+o.map(function(t){return"shape["+t+"]"}).join(",")+","+o.map(function(t){return"stride["+t+"]"}).join(",")+",offset)}"),new Function("CTOR_LIST","ORDER",a.join("\n"))(c[t],s)}var c={float32:[],float64:[],int8:[],int16:[],int32:[],uint8:[],uint16:[],uint32:[],array:[],uint8_clamped:[],buffer:[],generic:[]};e.exports=function(t,e,r,n){if(void 0===t)return(0,c.array[0])([]);"number"==typeof t&&(t=[t]),void 0===e&&(e=[t.length]);var o=e.length;if(void 0===r){r=new Array(o);for(var s=o-1,u=1;s>=0;--s)r[s]=u,u*=e[s]}if(void 0===n)for(n=0,s=0;s>>0;e.exports=function(t,e){if(isNaN(t)||isNaN(e))return NaN;if(t===e)return t;if(0===t)return e<0?-i:i;var r=n.hi(t),o=n.lo(t);e>t==t>0?o===a?(r+=1,o=0):o+=1:0===o?(o=a,r-=1):o-=1;return n.pack(o,r)}},{"double-bits":134}],395:[function(t,e,r){var n=Math.PI,i=c(120);function a(t,e,r,n){return["C",t,e,r,n,r,n]}function o(t,e,r,n,i,a){return["C",t/3+2/3*r,e/3+2/3*n,i/3+2/3*r,a/3+2/3*n,i,a]}function s(t,e,r,a,o,c,u,f,h,p){if(p)k=p[0],M=p[1],_=p[2],w=p[3];else{var d=l(t,e,-o);t=d.x,e=d.y;var g=(t-(f=(d=l(f,h,-o)).x))/2,m=(e-(h=d.y))/2,v=g*g/(r*r)+m*m/(a*a);v>1&&(r*=v=Math.sqrt(v),a*=v);var y=r*r,x=a*a,b=(c==u?-1:1)*Math.sqrt(Math.abs((y*x-y*m*m-x*g*g)/(y*m*m+x*g*g)));b==1/0&&(b=1);var _=b*r*m/a+(t+f)/2,w=b*-a*g/r+(e+h)/2,k=Math.asin(((e-w)/a).toFixed(9)),M=Math.asin(((h-w)/a).toFixed(9));k=t<_?n-k:k,M=f<_?n-M:M,k<0&&(k=2*n+k),M<0&&(M=2*n+M),u&&k>M&&(k-=2*n),!u&&M>k&&(M-=2*n)}if(Math.abs(M-k)>i){var A=M,T=f,S=h;M=k+i*(u&&M>k?1:-1);var C=s(f=_+r*Math.cos(M),h=w+a*Math.sin(M),r,a,o,0,u,T,S,[M,A,_,w])}var E=Math.tan((M-k)/4),L=4/3*r*E,z=4/3*a*E,P=[2*t-(t+L*Math.sin(k)),2*e-(e-z*Math.cos(k)),f+L*Math.sin(M),h-z*Math.cos(M),f,h];if(p)return P;C&&(P=P.concat(C));for(var D=0;D7&&(r.push(v.splice(0,7)),v.unshift("C"));break;case"S":var x=p,b=d;"C"!=e&&"S"!=e||(x+=x-n,b+=b-i),v=["C",x,b,v[1],v[2],v[3],v[4]];break;case"T":"Q"==e||"T"==e?(f=2*p-f,h=2*d-h):(f=p,h=d),v=o(p,d,f,h,v[1],v[2]);break;case"Q":f=v[1],h=v[2],v=o(p,d,v[1],v[2],v[3],v[4]);break;case"L":v=a(p,d,v[1],v[2]);break;case"H":v=a(p,d,v[1],d);break;case"V":v=a(p,d,p,v[1]);break;case"Z":v=a(p,d,l,u)}e=y,p=v[v.length-2],d=v[v.length-1],v.length>4?(n=v[v.length-4],i=v[v.length-3]):(n=p,i=d),r.push(v)}return r}},{}],396:[function(t,e,r){r.vertexNormals=function(t,e,r){for(var n=e.length,i=new Array(n),a=void 0===r?1e-6:r,o=0;oa){var b=i[c],_=1/Math.sqrt(m*y);for(x=0;x<3;++x){var w=(x+1)%3,k=(x+2)%3;b[x]+=_*(v[w]*g[k]-v[k]*g[w])}}}for(o=0;oa)for(_=1/Math.sqrt(M),x=0;x<3;++x)b[x]*=_;else for(x=0;x<3;++x)b[x]=0}return i},r.faceNormals=function(t,e,r){for(var n=t.length,i=new Array(n),a=void 0===r?1e-6:r,o=0;oa?1/Math.sqrt(p):0;for(c=0;c<3;++c)h[c]*=p;i[o]=h}return i}},{}],397:[function(t,e,r){"use strict";var n=Object.getOwnPropertySymbols,i=Object.prototype.hasOwnProperty,a=Object.prototype.propertyIsEnumerable;e.exports=function(){try{if(!Object.assign)return!1;var t=new String("abc");if(t[5]="de","5"===Object.getOwnPropertyNames(t)[0])return!1;for(var e={},r=0;r<10;r++)e["_"+String.fromCharCode(r)]=r;if("0123456789"!==Object.getOwnPropertyNames(e).map(function(t){return e[t]}).join(""))return!1;var n={};return"abcdefghijklmnopqrst".split("").forEach(function(t){n[t]=t}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},n)).join("")}catch(t){return!1}}()?Object.assign:function(t,e){for(var r,o,s=function(t){if(null===t||void 0===t)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(t)}(t),l=1;l0){var f=Math.sqrt(u+1);t[0]=.5*(o-l)/f,t[1]=.5*(s-n)/f,t[2]=.5*(r-a)/f,t[3]=.5*f}else{var h=Math.max(e,a,c),f=Math.sqrt(2*h-u+1);e>=h?(t[0]=.5*f,t[1]=.5*(i+r)/f,t[2]=.5*(s+n)/f,t[3]=.5*(o-l)/f):a>=h?(t[0]=.5*(r+i)/f,t[1]=.5*f,t[2]=.5*(l+o)/f,t[3]=.5*(s-n)/f):(t[0]=.5*(n+s)/f,t[1]=.5*(o+l)/f,t[2]=.5*f,t[3]=.5*(r-i)/f)}return t}},{}],399:[function(t,e,r){"use strict";e.exports=function(t){var e=(t=t||{}).center||[0,0,0],r=t.rotation||[0,0,0,1],n=t.radius||1;e=[].slice.call(e,0,3),u(r=[].slice.call(r,0,4),r);var i=new f(r,e,Math.log(n));i.setDistanceLimits(t.zoomMin,t.zoomMax),("eye"in t||"up"in t)&&i.lookAt(0,t.eye,t.center,t.up);return i};var n=t("filtered-vector"),i=t("gl-mat4/lookAt"),a=t("gl-mat4/fromQuat"),o=t("gl-mat4/invert"),s=t("./lib/quatFromFrame");function l(t,e,r){return Math.sqrt(Math.pow(t,2)+Math.pow(e,2)+Math.pow(r,2))}function c(t,e,r,n){return Math.sqrt(Math.pow(t,2)+Math.pow(e,2)+Math.pow(r,2)+Math.pow(n,2))}function u(t,e){var r=e[0],n=e[1],i=e[2],a=e[3],o=c(r,n,i,a);o>1e-6?(t[0]=r/o,t[1]=n/o,t[2]=i/o,t[3]=a/o):(t[0]=t[1]=t[2]=0,t[3]=1)}function f(t,e,r){this.radius=n([r]),this.center=n(e),this.rotation=n(t),this.computedRadius=this.radius.curve(0),this.computedCenter=this.center.curve(0),this.computedRotation=this.rotation.curve(0),this.computedUp=[.1,0,0],this.computedEye=[.1,0,0],this.computedMatrix=[.1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],this.recalcMatrix(0)}var h=f.prototype;h.lastT=function(){return Math.max(this.radius.lastT(),this.center.lastT(),this.rotation.lastT())},h.recalcMatrix=function(t){this.radius.curve(t),this.center.curve(t),this.rotation.curve(t);var e=this.computedRotation;u(e,e);var r=this.computedMatrix;a(r,e);var n=this.computedCenter,i=this.computedEye,o=this.computedUp,s=Math.exp(this.computedRadius[0]);i[0]=n[0]+s*r[2],i[1]=n[1]+s*r[6],i[2]=n[2]+s*r[10],o[0]=r[1],o[1]=r[5],o[2]=r[9];for(var l=0;l<3;++l){for(var c=0,f=0;f<3;++f)c+=r[l+4*f]*i[f];r[12+l]=-c}},h.getMatrix=function(t,e){this.recalcMatrix(t);var r=this.computedMatrix;if(e){for(var n=0;n<16;++n)e[n]=r[n];return e}return r},h.idle=function(t){this.center.idle(t),this.radius.idle(t),this.rotation.idle(t)},h.flush=function(t){this.center.flush(t),this.radius.flush(t),this.rotation.flush(t)},h.pan=function(t,e,r,n){e=e||0,r=r||0,n=n||0,this.recalcMatrix(t);var i=this.computedMatrix,a=i[1],o=i[5],s=i[9],c=l(a,o,s);a/=c,o/=c,s/=c;var u=i[0],f=i[4],h=i[8],p=u*a+f*o+h*s,d=l(u-=a*p,f-=o*p,h-=s*p);u/=d,f/=d,h/=d;var g=i[2],m=i[6],v=i[10],y=g*a+m*o+v*s,x=g*u+m*f+v*h,b=l(g-=y*a+x*u,m-=y*o+x*f,v-=y*s+x*h);g/=b,m/=b,v/=b;var _=u*e+a*r,w=f*e+o*r,k=h*e+s*r;this.center.move(t,_,w,k);var M=Math.exp(this.computedRadius[0]);M=Math.max(1e-4,M+n),this.radius.set(t,Math.log(M))},h.rotate=function(t,e,r,n){this.recalcMatrix(t),e=e||0,r=r||0;var i=this.computedMatrix,a=i[0],o=i[4],s=i[8],u=i[1],f=i[5],h=i[9],p=i[2],d=i[6],g=i[10],m=e*a+r*u,v=e*o+r*f,y=e*s+r*h,x=-(d*y-g*v),b=-(g*m-p*y),_=-(p*v-d*m),w=Math.sqrt(Math.max(0,1-Math.pow(x,2)-Math.pow(b,2)-Math.pow(_,2))),k=c(x,b,_,w);k>1e-6?(x/=k,b/=k,_/=k,w/=k):(x=b=_=0,w=1);var M=this.computedRotation,A=M[0],T=M[1],S=M[2],C=M[3],E=A*w+C*x+T*_-S*b,L=T*w+C*b+S*x-A*_,z=S*w+C*_+A*b-T*x,P=C*w-A*x-T*b-S*_;if(n){x=p,b=d,_=g;var D=Math.sin(n)/l(x,b,_);x*=D,b*=D,_*=D,P=P*(w=Math.cos(e))-(E=E*w+P*x+L*_-z*b)*x-(L=L*w+P*b+z*x-E*_)*b-(z=z*w+P*_+E*b-L*x)*_}var O=c(E,L,z,P);O>1e-6?(E/=O,L/=O,z/=O,P/=O):(E=L=z=0,P=1),this.rotation.set(t,E,L,z,P)},h.lookAt=function(t,e,r,n){this.recalcMatrix(t),r=r||this.computedCenter,e=e||this.computedEye,n=n||this.computedUp;var a=this.computedMatrix;i(a,e,r,n);var o=this.computedRotation;s(o,a[0],a[1],a[2],a[4],a[5],a[6],a[8],a[9],a[10]),u(o,o),this.rotation.set(t,o[0],o[1],o[2],o[3]);for(var l=0,c=0;c<3;++c)l+=Math.pow(r[c]-e[c],2);this.radius.set(t,.5*Math.log(Math.max(l,1e-6))),this.center.set(t,r[0],r[1],r[2])},h.translate=function(t,e,r,n){this.center.move(t,e||0,r||0,n||0)},h.setMatrix=function(t,e){var r=this.computedRotation;s(r,e[0],e[1],e[2],e[4],e[5],e[6],e[8],e[9],e[10]),u(r,r),this.rotation.set(t,r[0],r[1],r[2],r[3]);var n=this.computedMatrix;o(n,e);var i=n[15];if(Math.abs(i)>1e-6){var a=n[12]/i,l=n[13]/i,c=n[14]/i;this.recalcMatrix(t);var f=Math.exp(this.computedRadius[0]);this.center.set(t,a-n[2]*f,l-n[6]*f,c-n[10]*f),this.radius.idle(t)}else this.center.idle(t),this.radius.idle(t)},h.setDistance=function(t,e){e>0&&this.radius.set(t,Math.log(e))},h.setDistanceLimits=function(t,e){t=t>0?Math.log(t):-1/0,e=e>0?Math.log(e):1/0,e=Math.max(e,t),this.radius.bounds[0][0]=t,this.radius.bounds[1][0]=e},h.getDistanceLimits=function(t){var e=this.radius.bounds;return t?(t[0]=Math.exp(e[0][0]),t[1]=Math.exp(e[1][0]),t):[Math.exp(e[0][0]),Math.exp(e[1][0])]},h.toJSON=function(){return this.recalcMatrix(this.lastT()),{center:this.computedCenter.slice(),rotation:this.computedRotation.slice(),distance:Math.log(this.computedRadius[0]),zoomMin:this.radius.bounds[0][0],zoomMax:this.radius.bounds[1][0]}},h.fromJSON=function(t){var e=this.lastT(),r=t.center;r&&this.center.set(e,r[0],r[1],r[2]);var n=t.rotation;n&&this.rotation.set(e,n[0],n[1],n[2],n[3]);var i=t.distance;i&&i>0&&this.radius.set(e,Math.log(i)),this.setDistanceLimits(t.zoomMin,t.zoomMax)}},{"./lib/quatFromFrame":398,"filtered-vector":198,"gl-mat4/fromQuat":232,"gl-mat4/invert":235,"gl-mat4/lookAt":236}],400:[function(t,e,r){"use strict";var n=t("repeat-string");e.exports=function(t,e,r){return n(r=void 0!==r?r+"":" ",e)+t}},{"repeat-string":439}],401:[function(t,e,r){"use strict";var n=t("pick-by-alias");e.exports=function(t){var e;arguments.length>1&&(t=arguments);"string"==typeof t?t=t.split(/\s/).map(parseFloat):"number"==typeof t&&(t=[t]);t.length&&"number"==typeof t[0]?e=1===t.length?{width:t[0],height:t[0],x:0,y:0}:2===t.length?{width:t[0],height:t[1],x:0,y:0}:{x:t[0],y:t[1],width:t[2]-t[0]||0,height:t[3]-t[1]||0}:t&&(t=n(t,{left:"x l left Left",top:"y t top Top",width:"w width W Width",height:"h height W Width",bottom:"b bottom Bottom",right:"r right Right"}),e={x:t.left||0,y:t.top||0},null==t.width?t.right?e.width=t.right-e.x:e.width=0:e.width=t.width,null==t.height?t.bottom?e.height=t.bottom-e.y:e.height=0:e.height=t.height);return e}},{"pick-by-alias":407}],402:[function(t,e,r){e.exports=function(t){var e=[];return t.replace(i,function(t,r,i){var o=r.toLowerCase();for(i=function(t){var e=t.match(a);return e?e.map(Number):[]}(i),"m"==o&&i.length>2&&(e.push([r].concat(i.splice(0,2))),o="l",r="m"==r?"l":"L");;){if(i.length==n[o])return i.unshift(r),e.push(i);if(i.length0;--o)a=l[o],r=s[o],s[o]=s[a],s[a]=r,l[o]=l[r],l[r]=a,c=(c+r)*o;return n.freeUint32(l),n.freeUint32(s),c},r.unrank=function(t,e,r){switch(t){case 0:return r||[];case 1:return r?(r[0]=0,r):[0];case 2:return r?(e?(r[0]=0,r[1]=1):(r[0]=1,r[1]=0),r):e?[0,1]:[1,0]}var n,i,a,o=1;for((r=r||new Array(t))[0]=0,a=1;a0;--a)e=e-(n=e/o|0)*o|0,o=o/a|0,i=0|r[a],r[a]=0|r[n],r[n]=0|i;return r}},{"invert-permutation":359,"typedarray-pool":481}],407:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n,a,o={};if("string"==typeof e&&(e=i(e)),Array.isArray(e)){var s={};for(a=0;a0){o=a[u][r][0],l=u;break}s=o[1^l];for(var f=0;f<2;++f)for(var h=a[f][r],p=0;p0&&(o=d,s=g,l=f)}return i?s:(o&&c(o,l),s)}function f(t,r){var i=a[r][t][0],o=[t];c(i,r);for(var s=i[1^r];;){for(;s!==t;)o.push(s),s=u(o[o.length-2],s,!1);if(a[0][t].length+a[1][t].length===0)break;var l=o[o.length-1],f=t,h=o[1],p=u(l,f,!0);if(n(e[l],e[f],e[h],e[p])<0)break;o.push(t),s=u(l,f)}return o}function h(t,e){return e[1]===e[e.length-1]}for(var o=0;o0;){a[0][o].length;var g=f(o,p);h(d,g)?d.push.apply(d,g):(d.length>0&&l.push(d),d=g)}d.length>0&&l.push(d)}return l};var n=t("compare-angle")},{"compare-angle":108}],409:[function(t,e,r){"use strict";e.exports=function(t,e){for(var r=n(t,e.length),i=new Array(e.length),a=new Array(e.length),o=[],s=0;s0;){var c=o.pop();i[c]=!1;for(var u=r[c],s=0;s0})).length,m=new Array(g),v=new Array(g),p=0;p0;){var N=B.pop(),j=E[N];l(j,function(t,e){return t-e});var V,U=j.length,q=F[N];if(0===q){var k=d[N];V=[k]}for(var p=0;p=0)&&(F[H]=1^q,B.push(H),0===q)){var k=d[H];R(k)||(k.reverse(),V.push(k))}}0===q&&r.push(V)}return r};var n=t("edges-to-adjacency-list"),i=t("planar-dual"),a=t("point-in-big-polygon"),o=t("two-product"),s=t("robust-sum"),l=t("uniq"),c=t("./lib/trim-leaves");function u(t,e){for(var r=new Array(t),n=0;n>>1;e.dtype||(e.dtype="array"),"string"==typeof e.dtype?d=new(f(e.dtype))(m):e.dtype&&(d=e.dtype,Array.isArray(d)&&(d.length=m));for(var v=0;vr){for(var h=0;hl||A>c||T=E||o===s)){var u=y[a];void 0===s&&(s=u.length);for(var f=o;f=g&&p<=v&&d>=m&&d<=w&&z.push(h)}var b=x[a],_=b[4*o+0],k=b[4*o+1],C=b[4*o+2],L=b[4*o+3],P=function(t,e){for(var r=null,n=0;null===r;)if(r=t[4*e+n],++n>t.length)return null;return r}(b,o+1),D=.5*i,O=a+1;e(r,n,D,O,_,k||C||L||P),e(r,n+D,D,O,k,C||L||P),e(r+D,n,D,O,C,L||P),e(r+D,n+D,D,O,L,P)}}}(0,0,1,0,0,1),z},d;function C(t,e,r){for(var n=1,i=.5,a=.5,o=.5,s=0;s0&&e[i]===r[0]))return 1;a=t[i-1]}for(var s=1;a;){var l=a.key,c=n(r,l[0],l[1]);if(l[0][0]0))return 0;s=-1,a=a.right}else if(c>0)a=a.left;else{if(!(c<0))return 0;s=1,a=a.right}}return s}}(v.slabs,v.coordinates);return 0===a.length?y:function(t,e){return function(r){return t(r[0],r[1])?0:e(r)}}(l(a),y)};var n=t("robust-orientation")[3],i=t("slab-decomposition"),a=t("interval-tree-1d"),o=t("binary-search-bounds");function s(){return!0}function l(t){for(var e={},r=0;r=-t},pointBetween:function(e,r,n){var i=e[1]-r[1],a=n[0]-r[0],o=e[0]-r[0],s=n[1]-r[1],l=o*a+i*s;return!(l-t)},pointsSameX:function(e,r){return Math.abs(e[0]-r[0])t!=o-i>t&&(a-c)*(i-u)/(o-u)+c-n>t&&(s=!s),a=c,o=u}return s}};return e}},{}],418:[function(t,e,r){var n={toPolygon:function(t,e){function r(e){if(e.length<=0)return t.segments({inverted:!1,regions:[]});function r(e){var r=e.slice(0,e.length-1);return t.segments({inverted:!1,regions:[r]})}for(var n=r(e[0]),i=1;i0})}function u(t,n){var i=t.seg,a=n.seg,o=i.start,s=i.end,c=a.start,u=a.end;r&&r.checkIntersection(i,a);var f=e.linesIntersect(o,s,c,u);if(!1===f){if(!e.pointsCollinear(o,s,c))return!1;if(e.pointsSame(o,u)||e.pointsSame(s,c))return!1;var h=e.pointsSame(o,c),p=e.pointsSame(s,u);if(h&&p)return n;var d=!h&&e.pointBetween(o,c,u),g=!p&&e.pointBetween(s,c,u);if(h)return g?l(n,s):l(t,u),n;d&&(p||(g?l(n,s):l(t,u)),l(n,o))}else 0===f.alongA&&(-1===f.alongB?l(t,c):0===f.alongB?l(t,f.pt):1===f.alongB&&l(t,u)),0===f.alongB&&(-1===f.alongA?l(n,o):0===f.alongA?l(n,f.pt):1===f.alongA&&l(n,s));return!1}for(var f=[];!a.isEmpty();){var h=a.getHead();if(r&&r.vert(h.pt[0]),h.isStart){r&&r.segmentNew(h.seg,h.primary);var p=c(h),d=p.before?p.before.ev:null,g=p.after?p.after.ev:null;function m(){if(d){var t=u(h,d);if(t)return t}return!!g&&u(h,g)}r&&r.tempStatus(h.seg,!!d&&d.seg,!!g&&g.seg);var v,y,x=m();if(x)t?(y=null===h.seg.myFill.below||h.seg.myFill.above!==h.seg.myFill.below)&&(x.seg.myFill.above=!x.seg.myFill.above):x.seg.otherFill=h.seg.myFill,r&&r.segmentUpdate(x.seg),h.other.remove(),h.remove();if(a.getHead()!==h){r&&r.rewind(h.seg);continue}t?(y=null===h.seg.myFill.below||h.seg.myFill.above!==h.seg.myFill.below,h.seg.myFill.below=g?g.seg.myFill.above:i,h.seg.myFill.above=y?!h.seg.myFill.below:h.seg.myFill.below):null===h.seg.otherFill&&(v=g?h.primary===g.primary?g.seg.otherFill.above:g.seg.myFill.above:h.primary?o:i,h.seg.otherFill={above:v,below:v}),r&&r.status(h.seg,!!d&&d.seg,!!g&&g.seg),h.other.status=p.insert(n.node({ev:h}))}else{var b=h.status;if(null===b)throw new Error("PolyBool: Zero-length segment detected; your epsilon is probably too small or too large");if(s.exists(b.prev)&&s.exists(b.next)&&u(b.prev.ev,b.next.ev),r&&r.statusRemove(b.ev.seg),b.remove(),!h.primary){var _=h.seg.myFill;h.seg.myFill=h.seg.otherFill,h.seg.otherFill=_}f.push(h.seg)}a.getHead().remove()}return r&&r.done(),f}return t?{addRegion:function(t){for(var n,i,a,o=t[t.length-1],l=0;l=c?(M=1,y=c+2*h+d):y=h*(M=-h/c)+d):(M=0,p>=0?(A=0,y=d):-p>=f?(A=1,y=f+2*p+d):y=p*(A=-p/f)+d);else if(A<0)A=0,h>=0?(M=0,y=d):-h>=c?(M=1,y=c+2*h+d):y=h*(M=-h/c)+d;else{var T=1/k;y=(M*=T)*(c*M+u*(A*=T)+2*h)+A*(u*M+f*A+2*p)+d}else M<0?(b=f+p)>(x=u+h)?(_=b-x)>=(w=c-2*u+f)?(M=1,A=0,y=c+2*h+d):y=(M=_/w)*(c*M+u*(A=1-M)+2*h)+A*(u*M+f*A+2*p)+d:(M=0,b<=0?(A=1,y=f+2*p+d):p>=0?(A=0,y=d):y=p*(A=-p/f)+d):A<0?(b=c+h)>(x=u+p)?(_=b-x)>=(w=c-2*u+f)?(A=1,M=0,y=f+2*p+d):y=(M=1-(A=_/w))*(c*M+u*A+2*h)+A*(u*M+f*A+2*p)+d:(A=0,b<=0?(M=1,y=c+2*h+d):h>=0?(M=0,y=d):y=h*(M=-h/c)+d):(_=f+p-u-h)<=0?(M=0,A=1,y=f+2*p+d):_>=(w=c-2*u+f)?(M=1,A=0,y=c+2*h+d):y=(M=_/w)*(c*M+u*(A=1-M)+2*h)+A*(u*M+f*A+2*p)+d;var S=1-M-A;for(l=0;l1)for(var r=1;r0){var c=t[r-1];if(0===n(s,c)&&a(c)!==l){r-=1;continue}}t[r++]=s}}return t.length=r,t}},{"cell-orientation":93,"compare-cell":109,"compare-oriented-cell":110}],432:[function(t,e,r){"use strict";var n=t("array-bounds"),i=t("color-normalize"),a=t("update-diff"),o=t("pick-by-alias"),s=t("object-assign"),l=t("flatten-vertex-data"),c=t("to-float32"),u=c.float32,f=c.fract32;e.exports=function(t,e){"function"==typeof t?(e||(e={}),e.regl=t):e=t;e.length&&(e.positions=e);if(!(t=e.regl).hasExtension("ANGLE_instanced_arrays"))throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");var r,c,p,d,g,m,v=t._gl,y={color:"black",capSize:5,lineWidth:1,opacity:1,viewport:null,range:null,offset:0,count:0,bounds:null,positions:[],errors:[]},x=[];return d=t.buffer({usage:"dynamic",type:"uint8",data:new Uint8Array(0)}),c=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),p=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),g=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),m=t.buffer({usage:"static",type:"float",data:h}),k(e),r=t({vert:"\n\t\tprecision highp float;\n\n\t\tattribute vec2 position, positionFract;\n\t\tattribute vec4 error;\n\t\tattribute vec4 color;\n\n\t\tattribute vec2 direction, lineOffset, capOffset;\n\n\t\tuniform vec4 viewport;\n\t\tuniform float lineWidth, capSize;\n\t\tuniform vec2 scale, scaleFract, translate, translateFract;\n\n\t\tvarying vec4 fragColor;\n\n\t\tvoid main() {\n\t\t\tfragColor = color / 255.;\n\n\t\t\tvec2 pixelOffset = lineWidth * lineOffset + (capSize + lineWidth) * capOffset;\n\n\t\t\tvec2 dxy = -step(.5, direction.xy) * error.xz + step(direction.xy, vec2(-.5)) * error.yw;\n\n\t\t\tvec2 position = position + dxy;\n\n\t\t\tvec2 pos = (position + translate) * scale\n\t\t\t\t+ (positionFract + translateFract) * scale\n\t\t\t\t+ (position + translate) * scaleFract\n\t\t\t\t+ (positionFract + translateFract) * scaleFract;\n\n\t\t\tpos += pixelOffset / viewport.zw;\n\n\t\t\tgl_Position = vec4(pos * 2. - 1., 0, 1);\n\t\t}\n\t\t",frag:"\n\t\tprecision mediump float;\n\n\t\tvarying vec4 fragColor;\n\n\t\tuniform float opacity;\n\n\t\tvoid main() {\n\t\t\tgl_FragColor = fragColor;\n\t\t\tgl_FragColor.a *= opacity;\n\t\t}\n\t\t",uniforms:{range:t.prop("range"),lineWidth:t.prop("lineWidth"),capSize:t.prop("capSize"),opacity:t.prop("opacity"),scale:t.prop("scale"),translate:t.prop("translate"),scaleFract:t.prop("scaleFract"),translateFract:t.prop("translateFract"),viewport:function(t,e){return[e.viewport.x,e.viewport.y,t.viewportWidth,t.viewportHeight]}},attributes:{color:{buffer:d,offset:function(t,e){return 4*e.offset},divisor:1},position:{buffer:c,offset:function(t,e){return 8*e.offset},divisor:1},positionFract:{buffer:p,offset:function(t,e){return 8*e.offset},divisor:1},error:{buffer:g,offset:function(t,e){return 16*e.offset},divisor:1},direction:{buffer:m,stride:24,offset:0},lineOffset:{buffer:m,stride:24,offset:8},capOffset:{buffer:m,stride:24,offset:16}},primitive:"triangles",blend:{enable:!0,color:[0,0,0,0],equation:{rgb:"add",alpha:"add"},func:{srcRGB:"src alpha",dstRGB:"one minus src alpha",srcAlpha:"one minus dst alpha",dstAlpha:"one"}},depth:{enable:!1},scissor:{enable:!0,box:t.prop("viewport")},viewport:t.prop("viewport"),stencil:!1,instances:t.prop("count"),count:h.length}),s(b,{update:k,draw:_,destroy:M,regl:t,gl:v,canvas:v.canvas,groups:x}),b;function b(t){t?k(t):null===t&&M(),_()}function _(e){if("number"==typeof e)return w(e);e&&!Array.isArray(e)&&(e=[e]),t._refresh(),x.forEach(function(t,r){t&&(e&&(e[r]?t.draw=!0:t.draw=!1),t.draw?w(r):t.draw=!0)})}function w(t){"number"==typeof t&&(t=x[t]),null!=t&&t&&t.count&&t.color&&t.opacity&&t.positions&&t.positions.length>1&&(t.scaleRatio=[t.scale[0]*t.viewport.width,t.scale[1]*t.viewport.height],r(t),t.after&&t.after(t))}function k(t){if(t){null!=t.length?"number"==typeof t[0]&&(t=[{positions:t}]):Array.isArray(t)||(t=[t]);var e=0,r=0;if(b.groups=x=t.map(function(t,c){var u=x[c];return t?("function"==typeof t?t={after:t}:"number"==typeof t[0]&&(t={positions:t}),t=o(t,{color:"color colors fill",capSize:"capSize cap capsize cap-size",lineWidth:"lineWidth line-width width line thickness",opacity:"opacity alpha",range:"range dataBox",viewport:"viewport viewBox",errors:"errors error",positions:"positions position data points"}),u||(x[c]=u={id:c,scale:null,translate:null,scaleFract:null,translateFract:null,draw:!0},t=s({},y,t)),a(u,t,[{lineWidth:function(t){return.5*+t},capSize:function(t){return.5*+t},opacity:parseFloat,errors:function(t){return t=l(t),r+=t.length,t},positions:function(t,r){return t=l(t,"float64"),r.count=Math.floor(t.length/2),r.bounds=n(t,2),r.offset=e,e+=r.count,t}},{color:function(t,e){var r=e.count;if(t||(t="transparent"),!Array.isArray(t)||"number"==typeof t[0]){var n=t;t=Array(r);for(var a=0;a 0. && baClipping < length(normalWidth * endBotJoin)) {\n\t\t//handle miter clipping\n\t\tbTopCoord -= normalWidth * endTopJoin;\n\t\tbTopCoord += normalize(endTopJoin * normalWidth) * baClipping;\n\t}\n\n\tif (nextReverse) {\n\t\t//make join rectangular\n\t\tvec2 miterShift = normalWidth * endJoinDirection * miterLimit * .5;\n\t\tfloat normalAdjust = 1. - min(miterLimit / endMiterRatio, 1.);\n\t\tbBotCoord = bCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;\n\t\tbTopCoord = bCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;\n\t}\n\telse if (!prevReverse && abClipping > 0. && abClipping < length(normalWidth * startBotJoin)) {\n\t\t//handle miter clipping\n\t\taBotCoord -= normalWidth * startBotJoin;\n\t\taBotCoord += normalize(startBotJoin * normalWidth) * abClipping;\n\t}\n\n\tvec2 aTopPosition = (aTopCoord) * scale + translate;\n\tvec2 aBotPosition = (aBotCoord) * scale + translate;\n\n\tvec2 bTopPosition = (bTopCoord) * scale + translate;\n\tvec2 bBotPosition = (bBotCoord) * scale + translate;\n\n\t//position is normalized 0..1 coord on the screen\n\tvec2 position = (aTopPosition * lineTop + aBotPosition * lineBot) * lineStart + (bTopPosition * lineTop + bBotPosition * lineBot) * lineEnd;\n\n\tstartCoord = aCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n\tendCoord = bCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n\n\tgl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n\tenableStartMiter = step(dot(currTangent, prevTangent), .5);\n\tenableEndMiter = step(dot(currTangent, nextTangent), .5);\n\n\t//bevel miter cutoffs\n\tif (miterMode == 1.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tvec2 startMiterWidth = vec2(startJoinDirection) * thickness * miterLimit * .5;\n\t\t\tstartCutoff = vec4(aCoord, aCoord);\n\t\t\tstartCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n\t\t\tstartCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tstartCutoff += viewport.xyxy;\n\t\t\tstartCutoff += startMiterWidth.xyxy;\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tvec2 endMiterWidth = vec2(endJoinDirection) * thickness * miterLimit * .5;\n\t\t\tendCutoff = vec4(bCoord, bCoord);\n\t\t\tendCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x) / scaleRatio;\n\t\t\tendCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tendCutoff += viewport.xyxy;\n\t\t\tendCutoff += endMiterWidth.xyxy;\n\t\t}\n\t}\n\n\t//round miter cutoffs\n\telse if (miterMode == 2.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tvec2 startMiterWidth = vec2(startJoinDirection) * thickness * abs(dot(startJoinDirection, currNormal)) * .5;\n\t\t\tstartCutoff = vec4(aCoord, aCoord);\n\t\t\tstartCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n\t\t\tstartCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tstartCutoff += viewport.xyxy;\n\t\t\tstartCutoff += startMiterWidth.xyxy;\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tvec2 endMiterWidth = vec2(endJoinDirection) * thickness * abs(dot(endJoinDirection, currNormal)) * .5;\n\t\t\tendCutoff = vec4(bCoord, bCoord);\n\t\t\tendCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x) / scaleRatio;\n\t\t\tendCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tendCutoff += viewport.xyxy;\n\t\t\tendCutoff += endMiterWidth.xyxy;\n\t\t}\n\t}\n}\n"]),frag:o(["precision highp float;\n#define GLSLIFY 1\n\nuniform sampler2D dashPattern;\nuniform float dashSize, pixelRatio, thickness, opacity, id, miterMode;\n\nvarying vec4 fragColor;\nvarying vec2 tangent;\nvarying vec4 startCutoff, endCutoff;\nvarying vec2 startCoord, endCoord;\nvarying float enableStartMiter, enableEndMiter;\n\nfloat distToLine(vec2 p, vec2 a, vec2 b) {\n\tvec2 diff = b - a;\n\tvec2 perp = normalize(vec2(-diff.y, diff.x));\n\treturn dot(p - a, perp);\n}\n\nvoid main() {\n\tfloat alpha = 1., distToStart, distToEnd;\n\tfloat cutoff = thickness * .5;\n\n\t//bevel miter\n\tif (miterMode == 1.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tdistToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n\t\t\tif (distToStart < -1.) {\n\t\t\t\tdiscard;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\talpha *= min(max(distToStart + 1., 0.), 1.);\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tdistToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n\t\t\tif (distToEnd < -1.) {\n\t\t\t\tdiscard;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\talpha *= min(max(distToEnd + 1., 0.), 1.);\n\t\t}\n\t}\n\n\t// round miter\n\telse if (miterMode == 2.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tdistToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n\t\t\tif (distToStart < 0.) {\n\t\t\t\tfloat radius = length(gl_FragCoord.xy - startCoord);\n\n\t\t\t\tif(radius > cutoff + .5) {\n\t\t\t\t\tdiscard;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\talpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n\t\t\t}\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tdistToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n\t\t\tif (distToEnd < 0.) {\n\t\t\t\tfloat radius = length(gl_FragCoord.xy - endCoord);\n\n\t\t\t\tif(radius > cutoff + .5) {\n\t\t\t\t\tdiscard;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\talpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n\t\t\t}\n\t\t}\n\t}\n\n\tfloat t = fract(dot(tangent, gl_FragCoord.xy) / dashSize) * .5 + .25;\n\tfloat dash = texture2D(dashPattern, vec2(t, .5)).r;\n\n\tgl_FragColor = fragColor;\n\tgl_FragColor.a *= alpha * opacity * dash;\n}\n"]),attributes:{lineEnd:{buffer:r,divisor:0,stride:8,offset:0},lineTop:{buffer:r,divisor:0,stride:8,offset:4},aColor:{buffer:t.prop("colorBuffer"),stride:4,offset:0,divisor:1},bColor:{buffer:t.prop("colorBuffer"),stride:4,offset:4,divisor:1},prevCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:0,divisor:1},aCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:8,divisor:1},bCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:16,divisor:1},nextCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:24,divisor:1}}},n))}catch(t){e=i}return{fill:t({primitive:"triangle",elements:function(t,e){return e.triangles},offset:0,vert:o(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec2 position, positionFract;\n\nuniform vec4 color;\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float pixelRatio, id;\nuniform vec4 viewport;\nuniform float opacity;\n\nvarying vec4 fragColor;\n\nconst float MAX_LINES = 256.;\n\nvoid main() {\n\tfloat depth = (MAX_LINES - 4. - id) / (MAX_LINES);\n\n\tvec2 position = position * scale + translate\n + positionFract * scale + translateFract\n + position * scaleFract\n + positionFract * scaleFract;\n\n\tgl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n\tfragColor = color / 255.;\n\tfragColor.a *= opacity;\n}\n"]),frag:o(["precision highp float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor;\n\nvoid main() {\n\tgl_FragColor = fragColor;\n}\n"]),uniforms:{scale:t.prop("scale"),color:t.prop("fill"),scaleFract:t.prop("scaleFract"),translateFract:t.prop("translateFract"),translate:t.prop("translate"),opacity:t.prop("opacity"),pixelRatio:t.context("pixelRatio"),id:t.prop("id"),viewport:function(t,e){return[e.viewport.x,e.viewport.y,t.viewportWidth,t.viewportHeight]}},attributes:{position:{buffer:t.prop("positionBuffer"),stride:8,offset:8},positionFract:{buffer:t.prop("positionFractBuffer"),stride:8,offset:8}},blend:n.blend,depth:{enable:!1},scissor:n.scissor,stencil:n.stencil,viewport:n.viewport}),rect:i,miter:e}},m.defaults={dashes:null,join:"miter",miterLimit:1,thickness:10,cap:"square",color:"black",opacity:1,overlay:!1,viewport:null,range:null,close:!1,fill:null},m.prototype.render=function(){for(var t,e=[],r=arguments.length;r--;)e[r]=arguments[r];e.length&&(t=this).update.apply(t,e),this.draw()},m.prototype.draw=function(){for(var t=this,e=[],r=arguments.length;r--;)e[r]=arguments[r];return(e.length?e:this.passes).forEach(function(e,r){if(e&&Array.isArray(e))return(n=t).draw.apply(n,e);var n;("number"==typeof e&&(e=t.passes[e]),e&&e.count>1&&e.opacity)&&(t.regl._refresh(),e.fill&&e.triangles&&e.triangles.length>2&&t.shaders.fill(e),e.thickness&&(e.scale[0]*e.viewport.width>m.precisionThreshold||e.scale[1]*e.viewport.height>m.precisionThreshold?t.shaders.rect(e):"rect"===e.join||!e.join&&(e.thickness<=2||e.count>=m.maxPoints)?t.shaders.rect(e):t.shaders.miter(e)))}),this},m.prototype.update=function(t){var e=this;if(t){null!=t.length?"number"==typeof t[0]&&(t=[{positions:t}]):Array.isArray(t)||(t=[t]);var r=this.regl,o=this.gl;if(t.forEach(function(t,f){var d=e.passes[f];if(void 0!==t)if(null!==t){if("number"==typeof t[0]&&(t={positions:t}),t=s(t,{positions:"positions points data coords",thickness:"thickness lineWidth lineWidths line-width linewidth width stroke-width strokewidth strokeWidth",join:"lineJoin linejoin join type mode",miterLimit:"miterlimit miterLimit",dashes:"dash dashes dasharray dash-array dashArray",color:"color colour stroke colors colours stroke-color strokeColor",fill:"fill fill-color fillColor",opacity:"alpha opacity",overlay:"overlay crease overlap intersect",close:"closed close closed-path closePath",range:"range dataBox",viewport:"viewport viewBox",hole:"holes hole hollow"}),d||(e.passes[f]=d={id:f,scale:null,scaleFract:null,translate:null,translateFract:null,count:0,hole:[],depth:0,dashLength:1,dashTexture:r.texture({channels:1,data:new Uint8Array([255]),width:1,height:1,mag:"linear",min:"linear"}),colorBuffer:r.buffer({usage:"dynamic",type:"uint8",data:new Uint8Array}),positionBuffer:r.buffer({usage:"dynamic",type:"float",data:new Uint8Array}),positionFractBuffer:r.buffer({usage:"dynamic",type:"float",data:new Uint8Array})},t=a({},m.defaults,t)),null!=t.thickness&&(d.thickness=parseFloat(t.thickness)),null!=t.opacity&&(d.opacity=parseFloat(t.opacity)),null!=t.miterLimit&&(d.miterLimit=parseFloat(t.miterLimit)),null!=t.overlay&&(d.overlay=!!t.overlay,f 1.0 + delta) {\n\t\tdiscard;\n\t}\n\n\talpha -= smoothstep(1.0 - delta, 1.0 + delta, radius);\n\n\tfloat borderRadius = fragBorderRadius;\n\tfloat ratio = smoothstep(borderRadius - delta, borderRadius + delta, radius);\n\tvec4 color = mix(fragColor, fragBorderColor, ratio);\n\tcolor.a *= alpha * opacity;\n\tgl_FragColor = color;\n}\n"]),u.vert=l(["precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float pixelRatio;\nuniform sampler2D palette;\nuniform vec2 paletteSize;\n\nconst float maxSize = 100.;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nvec2 paletteCoord(float id) {\n return vec2(\n (mod(id, paletteSize.x) + .5) / paletteSize.x,\n (floor(id / paletteSize.x) + .5) / paletteSize.y\n );\n}\nvec2 paletteCoord(vec2 id) {\n return vec2(\n (id.x + .5) / paletteSize.x,\n (id.y + .5) / paletteSize.y\n );\n}\n\nvec4 getColor(vec4 id) {\n // zero-palette means we deal with direct buffer\n if (paletteSize.x == 0.) return id / 255.;\n return texture2D(palette, paletteCoord(id.xy));\n}\n\nvoid main() {\n // ignore inactive points\n if (isActive == 0.) return;\n\n vec2 position = vec2(x, y);\n vec2 positionFract = vec2(xFract, yFract);\n\n vec4 color = getColor(colorId);\n vec4 borderColor = getColor(borderColorId);\n\n float size = size * maxSize / 255.;\n float borderSize = borderSize * maxSize / 255.;\n\n gl_PointSize = (size + borderSize) * pixelRatio;\n\n vec2 pos = (position + translate) * scale\n + (positionFract + translateFract) * scale\n + (position + translate) * scaleFract\n + (positionFract + translateFract) * scaleFract;\n\n gl_Position = vec4(pos * 2. - 1., 0, 1);\n\n fragBorderRadius = 1. - 2. * borderSize / (size + borderSize);\n fragColor = color;\n fragBorderColor = borderColor.a == 0. || borderSize == 0. ? vec4(color.rgb, 0.) : borderColor;\n fragWidth = 1. / gl_PointSize;\n}\n"]),h&&(u.frag=u.frag.replace("smoothstep","smoothStep")),this.drawCircle=t(u)}e.exports=v,v.defaults={color:"black",borderColor:"transparent",borderSize:0,size:12,opacity:1,marker:void 0,viewport:null,range:null,pixelSize:null,count:0,offset:0,bounds:null,positions:[],snap:1e4},v.prototype.render=function(){for(var t,e=[],r=arguments.length;r--;)e[r]=arguments[r];return e.length&&(t=this).update.apply(t,e),this.draw(),this},v.prototype.draw=function(){for(var t=this,e=[],r=arguments.length;r--;)e[r]=arguments[r];var n=this.groups;if(1===e.length&&Array.isArray(e[0])&&(null===e[0][0]||Array.isArray(e[0][0]))&&(e=e[0]),this.regl._refresh(),e.length)for(var i=0;in)?e.tree=o(t,{bounds:h}):n&&n.length&&(e.tree=n),e.tree){var p={primitive:"points",usage:"static",data:e.tree,type:"uint32"};e.elements?e.elements(p):e.elements=l.elements(p)}return a({data:d(t),usage:"dynamic"}),s({data:g(t),usage:"dynamic"}),c({data:new Uint8Array(u),type:"uint8",usage:"stream"}),t}},{marker:function(e,r,n){var i=r.activation;if(i.forEach(function(t){return t&&t.destroy&&t.destroy()}),i.length=0,e&&"number"!=typeof e[0]){for(var a=[],o=0,s=Math.min(e.length,r.count);o=0)return a;if(t instanceof Uint8Array||t instanceof Uint8ClampedArray)e=t;else{e=new Uint8Array(t.length);for(var o=0,s=t.length;oi*i*4&&(this.tooManyColors=!0),this.updatePalette(r),1===o.length?o[0]:o},v.prototype.updatePalette=function(t){if(!this.tooManyColors){var e=this.maxColors,r=this.paletteTexture,n=Math.ceil(.25*t.length/e);if(n>1)for(var i=.25*(t=t.slice()).length%e;i2?(s[0],s[2],n=s[1],i=s[3]):s.length?(n=s[0],i=s[1]):(s.x,n=s.y,s.x+s.width,i=s.y+s.height),l.length>2?(a=l[0],o=l[2],l[1],l[3]):l.length?(a=l[0],o=l[1]):(a=l.x,l.y,o=l.x+l.width,l.y+l.height),[a,n,o,i]}function p(t){if("number"==typeof t)return[t,t,t,t];if(2===t.length)return[t[0],t[1],t[0],t[1]];var e=l(t);return[e.x,e.y,e.x+e.width,e.y+e.height]}e.exports=u,u.prototype.render=function(){for(var t,e=this,r=[],n=arguments.length;n--;)r[n]=arguments[n];return r.length&&(t=this).update.apply(t,r),this.regl.attributes.preserveDrawingBuffer?this.draw():(this.dirty?null==this.planned&&(this.planned=o(function(){e.draw(),e.dirty=!0,e.planned=null})):(this.draw(),this.dirty=!0,o(function(){e.dirty=!1})),this)},u.prototype.update=function(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];if(t.length){for(var r=0;rM))&&(s.lower||!(k>>=e))<<3,(e|=r=(15<(t>>>=r))<<2)|(r=(3<(t>>>=r))<<1)|t>>>r>>1}function l(t){t:{for(var e=16;268435456>=e;e*=16)if(t<=e){t=e;break t}t=0}return 0<(e=Y[s(t)>>2]).length?e.pop():new ArrayBuffer(t)}function c(t){Y[s(t.byteLength)>>2].push(t)}function u(t,e,r,n,i,a){for(var o=0;o(i=l)&&(i=n.buffer.byteLength,5123===f?i>>=1:5125===f&&(i>>=2)),n.vertCount=i,i=s,0>s&&(i=4,1===(s=n.buffer.dimension)&&(i=0),2===s&&(i=1),3===s&&(i=4)),n.primType=i}function s(t){n.elementsCount--,delete l[t.id],t.buffer.destroy(),t.buffer=null}var l={},c=0,u={uint8:5121,uint16:5123};e.oes_element_index_uint&&(u.uint32=5125),i.prototype.bind=function(){this.buffer.bind()};var f=[];return{create:function(t,e){function l(t){if(t)if("number"==typeof t)c(t),f.primType=4,f.vertCount=0|t,f.type=5121;else{var e=null,r=35044,n=-1,i=-1,s=0,h=0;Array.isArray(t)||G(t)||a(t)?e=t:("data"in t&&(e=t.data),"usage"in t&&(r=Q[t.usage]),"primitive"in t&&(n=rt[t.primitive]),"count"in t&&(i=0|t.count),"type"in t&&(h=u[t.type]),"length"in t?s=0|t.length:(s=i,5123===h||5122===h?s*=2:5125!==h&&5124!==h||(s*=4))),o(f,e,r,n,i,s,h)}else c(),f.primType=4,f.vertCount=0,f.type=5121;return l}var c=r.create(null,34963,!0),f=new i(c._buffer);return n.elementsCount++,l(t),l._reglType="elements",l._elements=f,l.subdata=function(t,e){return c.subdata(t,e),l},l.destroy=function(){s(f)},l},createStream:function(t){var e=f.pop();return e||(e=new i(r.create(null,34963,!0,!1)._buffer)),o(e,t,35040,-1,-1,0,0),e},destroyStream:function(t){f.push(t)},getElements:function(t){return"function"==typeof t&&t._elements instanceof i?t._elements:null},clear:function(){W(l).forEach(s)}}}function m(t){for(var e=X.allocType(5123,t.length),r=0;r>>31<<15,i=(a<<1>>>24)-127,a=a>>13&1023;e[r]=-24>i?n:-14>i?n+(a+1024>>-14-i):15>=i,r.height>>=i,p(r,n[i]),t.mipmask|=1<e;++e)t.images[e]=null;return t}function E(t){for(var e=t.images,r=0;re){for(var r=0;r=--this.refCount&&R(this)}}),s.profile&&(o.getTotalTextureSize=function(){var t=0;return Object.keys(ft).forEach(function(e){t+=ft[e].stats.size}),t}),{create2D:function(e,r){function n(t,e){var r=i.texInfo;L.call(r);var a=C();return"number"==typeof t?A(a,0|t,"number"==typeof e?0|e:0|t):t?(z(r,t),T(a,t)):A(a,1,1),r.genMipmaps&&(a.mipmask=(a.width<<1)-1),i.mipmask=a.mipmask,c(i,a),i.internalformat=a.internalformat,n.width=a.width,n.height=a.height,O(i),S(a,3553),P(r,3553),I(),E(a),s.profile&&(i.stats.size=k(i.internalformat,i.type,a.width,a.height,r.genMipmaps,!1)),n.format=$[i.internalformat],n.type=tt[i.type],n.mag=et[r.magFilter],n.min=rt[r.minFilter],n.wrapS=nt[r.wrapS],n.wrapT=nt[r.wrapT],n}var i=new D(3553);return ft[i.id]=i,o.textureCount++,n(e,r),n.subimage=function(t,e,r,a){e|=0,r|=0,a|=0;var o=g();return c(o,i),o.width=0,o.height=0,p(o,t),o.width=o.width||(i.width>>a)-e,o.height=o.height||(i.height>>a)-r,O(i),d(o,3553,e,r,a),I(),M(o),n},n.resize=function(e,r){var a=0|e,o=0|r||a;if(a===i.width&&o===i.height)return n;n.width=i.width=a,n.height=i.height=o,O(i);for(var l=0;i.mipmask>>l;++l)t.texImage2D(3553,l,i.format,a>>l,o>>l,0,i.format,i.type,null);return I(),s.profile&&(i.stats.size=k(i.internalformat,i.type,a,o,!1,!1)),n},n._reglType="texture2d",n._texture=i,s.profile&&(n.stats=i.stats),n.destroy=function(){i.decRef()},n},createCube:function(e,r,n,i,a,l){function f(t,e,r,n,i,a){var o,l=h.texInfo;for(L.call(l),o=0;6>o;++o)m[o]=C();if("number"!=typeof t&&t){if("object"==typeof t)if(e)T(m[0],t),T(m[1],e),T(m[2],r),T(m[3],n),T(m[4],i),T(m[5],a);else if(z(l,t),u(h,t),"faces"in t)for(t=t.faces,o=0;6>o;++o)c(m[o],h),T(m[o],t[o]);else for(o=0;6>o;++o)T(m[o],t)}else for(t=0|t||1,o=0;6>o;++o)A(m[o],t,t);for(c(h,m[0]),h.mipmask=l.genMipmaps?(m[0].width<<1)-1:m[0].mipmask,h.internalformat=m[0].internalformat,f.width=m[0].width,f.height=m[0].height,O(h),o=0;6>o;++o)S(m[o],34069+o);for(P(l,34067),I(),s.profile&&(h.stats.size=k(h.internalformat,h.type,f.width,f.height,l.genMipmaps,!0)),f.format=$[h.internalformat],f.type=tt[h.type],f.mag=et[l.magFilter],f.min=rt[l.minFilter],f.wrapS=nt[l.wrapS],f.wrapT=nt[l.wrapT],o=0;6>o;++o)E(m[o]);return f}var h=new D(34067);ft[h.id]=h,o.cubeCount++;var m=Array(6);return f(e,r,n,i,a,l),f.subimage=function(t,e,r,n,i){r|=0,n|=0,i|=0;var a=g();return c(a,h),a.width=0,a.height=0,p(a,e),a.width=a.width||(h.width>>i)-r,a.height=a.height||(h.height>>i)-n,O(h),d(a,34069+t,r,n,i),I(),M(a),f},f.resize=function(e){if((e|=0)!==h.width){f.width=h.width=e,f.height=h.height=e,O(h);for(var r=0;6>r;++r)for(var n=0;h.mipmask>>n;++n)t.texImage2D(34069+r,n,h.format,e>>n,e>>n,0,h.format,h.type,null);return I(),s.profile&&(h.stats.size=k(h.internalformat,h.type,f.width,f.height,!1,!0)),f}},f._reglType="textureCube",f._texture=h,s.profile&&(f.stats=h.stats),f.destroy=function(){h.decRef()},f},clear:function(){for(var e=0;er;++r)if(0!=(e.mipmask&1<>r,e.height>>r,0,e.internalformat,e.type,null);else for(var n=0;6>n;++n)t.texImage2D(34069+n,r,e.internalformat,e.width>>r,e.height>>r,0,e.internalformat,e.type,null);P(e.texInfo,e.target)})}}}function A(t,e,r,n,i,a){function o(t,e,r){this.target=t,this.texture=e,this.renderbuffer=r;var n=t=0;e?(t=e.width,n=e.height):r&&(t=r.width,n=r.height),this.width=t,this.height=n}function s(t){t&&(t.texture&&t.texture._texture.decRef(),t.renderbuffer&&t.renderbuffer._renderbuffer.decRef())}function l(t,e,r){t&&(t.texture?t.texture._texture.refCount+=1:t.renderbuffer._renderbuffer.refCount+=1)}function c(e,r){r&&(r.texture?t.framebufferTexture2D(36160,e,r.target,r.texture._texture.texture,0):t.framebufferRenderbuffer(36160,e,36161,r.renderbuffer._renderbuffer.renderbuffer))}function u(t){var e=3553,r=null,n=null,i=t;return"object"==typeof t&&(i=t.data,"target"in t&&(e=0|t.target)),"texture2d"===(t=i._reglType)?r=i:"textureCube"===t?r=i:"renderbuffer"===t&&(n=i,e=36161),new o(e,r,n)}function f(t,e,r,a,s){return r?((t=n.create2D({width:t,height:e,format:a,type:s}))._texture.refCount=0,new o(3553,t,null)):((t=i.create({width:t,height:e,format:a}))._renderbuffer.refCount=0,new o(36161,null,t))}function h(t){return t&&(t.texture||t.renderbuffer)}function p(t,e,r){t&&(t.texture?t.texture.resize(e,r):t.renderbuffer&&t.renderbuffer.resize(e,r))}function d(){this.id=k++,M[this.id]=this,this.framebuffer=t.createFramebuffer(),this.height=this.width=0,this.colorAttachments=[],this.depthStencilAttachment=this.stencilAttachment=this.depthAttachment=null}function g(t){t.colorAttachments.forEach(s),s(t.depthAttachment),s(t.stencilAttachment),s(t.depthStencilAttachment)}function m(e){t.deleteFramebuffer(e.framebuffer),e.framebuffer=null,a.framebufferCount--,delete M[e.id]}function v(e){var n;t.bindFramebuffer(36160,e.framebuffer);var i=e.colorAttachments;for(n=0;ni;++i){for(c=0;ct;++t)r[t].resize(n);return e.width=e.height=n,e},_reglType:"framebufferCube",destroy:function(){r.forEach(function(t){t.destroy()})}})},clear:function(){W(M).forEach(m)},restore:function(){W(M).forEach(function(e){e.framebuffer=t.createFramebuffer(),v(e)})}})}function T(){this.w=this.z=this.y=this.x=this.state=0,this.buffer=null,this.size=0,this.normalized=!1,this.type=5126,this.divisor=this.stride=this.offset=0}function S(t,e,r,n){function i(t,e,r,n){this.name=t,this.id=e,this.location=r,this.info=n}function a(t,e){for(var r=0;rt&&(t=e.stats.uniformsCount)}),t},r.getMaxAttributesCount=function(){var t=0;return h.forEach(function(e){e.stats.attributesCount>t&&(t=e.stats.attributesCount)}),t}),{clear:function(){var e=t.deleteShader.bind(t);W(c).forEach(e),c={},W(u).forEach(e),u={},h.forEach(function(e){t.deleteProgram(e.program)}),h.length=0,f={},r.shaderCount=0},program:function(t,e,n){var i=f[e];i||(i=f[e]={});var a=i[t];return a||(a=new s(e,t),r.shaderCount++,l(a),i[t]=a,h.push(a)),a},restore:function(){c={},u={};for(var t=0;t="+e+"?"+i+".constant["+e+"]:0;"}).join(""),"}}else{","if(",o,"(",i,".buffer)){",u,"=",s,".createStream(",34962,",",i,".buffer);","}else{",u,"=",s,".getBuffer(",i,".buffer);","}",f,'="type" in ',i,"?",a.glTypes,"[",i,".type]:",u,".dtype;",l.normalized,"=!!",i,".normalized;"),n("size"),n("offset"),n("stride"),n("divisor"),r("}}"),r.exit("if(",l.isStream,"){",s,".destroyStream(",u,");","}"),l})}),o}function A(t,e,r,n,i){var a=_(t),s=function(t,e,r){function n(t){if(t in i){var r=i[t];t=!0;var n,o,s=0|r.x,l=0|r.y;return"width"in r?n=0|r.width:t=!1,"height"in r?o=0|r.height:t=!1,new O(!t&&e&&e.thisDep,!t&&e&&e.contextDep,!t&&e&&e.propDep,function(t,e){var i=t.shared.context,a=n;"width"in r||(a=e.def(i,".","framebufferWidth","-",s));var c=o;return"height"in r||(c=e.def(i,".","framebufferHeight","-",l)),[s,l,a,c]})}if(t in a){var c=a[t];return t=B(c,function(t,e){var r=t.invoke(e,c),n=t.shared.context,i=e.def(r,".x|0"),a=e.def(r,".y|0");return[i,a,e.def('"width" in ',r,"?",r,".width|0:","(",n,".","framebufferWidth","-",i,")"),r=e.def('"height" in ',r,"?",r,".height|0:","(",n,".","framebufferHeight","-",a,")")]}),e&&(t.thisDep=t.thisDep||e.thisDep,t.contextDep=t.contextDep||e.contextDep,t.propDep=t.propDep||e.propDep),t}return e?new O(e.thisDep,e.contextDep,e.propDep,function(t,e){var r=t.shared.context;return[0,0,e.def(r,".","framebufferWidth"),e.def(r,".","framebufferHeight")]}):null}var i=t.static,a=t.dynamic;if(t=n("viewport")){var o=t;t=new O(t.thisDep,t.contextDep,t.propDep,function(t,e){var r=o.append(t,e),n=t.shared.context;return e.set(n,".viewportWidth",r[2]),e.set(n,".viewportHeight",r[3]),r})}return{viewport:t,scissor_box:n("scissor.box")}}(t,a),l=k(t),c=function(t,e){var r=t.static,n=t.dynamic,i={};return nt.forEach(function(t){function e(e,o){if(t in r){var s=e(r[t]);i[a]=R(function(){return s})}else if(t in n){var l=n[t];i[a]=B(l,function(t,e){return o(t,e,t.invoke(e,l))})}}var a=m(t);switch(t){case"cull.enable":case"blend.enable":case"dither":case"stencil.enable":case"depth.enable":case"scissor.enable":case"polygonOffset.enable":case"sample.alpha":case"sample.enable":case"depth.mask":return e(function(t){return t},function(t,e,r){return r});case"depth.func":return e(function(t){return yt[t]},function(t,e,r){return e.def(t.constants.compareFuncs,"[",r,"]")});case"depth.range":return e(function(t){return t},function(t,e,r){return[e.def("+",r,"[0]"),e=e.def("+",r,"[1]")]});case"blend.func":return e(function(t){return[vt["srcRGB"in t?t.srcRGB:t.src],vt["dstRGB"in t?t.dstRGB:t.dst],vt["srcAlpha"in t?t.srcAlpha:t.src],vt["dstAlpha"in t?t.dstAlpha:t.dst]]},function(t,e,r){function n(t,n){return e.def('"',t,n,'" in ',r,"?",r,".",t,n,":",r,".",t)}t=t.constants.blendFuncs;var i=n("src","RGB"),a=n("dst","RGB"),o=(i=e.def(t,"[",i,"]"),e.def(t,"[",n("src","Alpha"),"]"));return[i,a=e.def(t,"[",a,"]"),o,t=e.def(t,"[",n("dst","Alpha"),"]")]});case"blend.equation":return e(function(t){return"string"==typeof t?[J[t],J[t]]:"object"==typeof t?[J[t.rgb],J[t.alpha]]:void 0},function(t,e,r){var n=t.constants.blendEquations,i=e.def(),a=e.def();return(t=t.cond("typeof ",r,'==="string"')).then(i,"=",a,"=",n,"[",r,"];"),t.else(i,"=",n,"[",r,".rgb];",a,"=",n,"[",r,".alpha];"),e(t),[i,a]});case"blend.color":return e(function(t){return o(4,function(e){return+t[e]})},function(t,e,r){return o(4,function(t){return e.def("+",r,"[",t,"]")})});case"stencil.mask":return e(function(t){return 0|t},function(t,e,r){return e.def(r,"|0")});case"stencil.func":return e(function(t){return[yt[t.cmp||"keep"],t.ref||0,"mask"in t?t.mask:-1]},function(t,e,r){return[t=e.def('"cmp" in ',r,"?",t.constants.compareFuncs,"[",r,".cmp]",":",7680),e.def(r,".ref|0"),e=e.def('"mask" in ',r,"?",r,".mask|0:-1")]});case"stencil.opFront":case"stencil.opBack":return e(function(e){return["stencil.opBack"===t?1029:1028,xt[e.fail||"keep"],xt[e.zfail||"keep"],xt[e.zpass||"keep"]]},function(e,r,n){function i(t){return r.def('"',t,'" in ',n,"?",a,"[",n,".",t,"]:",7680)}var a=e.constants.stencilOps;return["stencil.opBack"===t?1029:1028,i("fail"),i("zfail"),i("zpass")]});case"polygonOffset.offset":return e(function(t){return[0|t.factor,0|t.units]},function(t,e,r){return[e.def(r,".factor|0"),e=e.def(r,".units|0")]});case"cull.face":return e(function(t){var e=0;return"front"===t?e=1028:"back"===t&&(e=1029),e},function(t,e,r){return e.def(r,'==="front"?',1028,":",1029)});case"lineWidth":return e(function(t){return t},function(t,e,r){return r});case"frontFace":return e(function(t){return bt[t]},function(t,e,r){return e.def(r+'==="cw"?2304:2305')});case"colorMask":return e(function(t){return t.map(function(t){return!!t})},function(t,e,r){return o(4,function(t){return"!!"+r+"["+t+"]"})});case"sample.coverage":return e(function(t){return["value"in t?t.value:1,!!t.invert]},function(t,e,r){return[e.def('"value" in ',r,"?+",r,".value:1"),e=e.def("!!",r,".invert")]})}}),i}(t),u=w(t),f=s.viewport;return f&&(c.viewport=f),(s=s[f=m("scissor.box")])&&(c[f]=s),(a={framebuffer:a,draw:l,shader:u,state:c,dirty:s=0>1)",s],");")}function e(){r(l,".drawArraysInstancedANGLE(",[d,g,m,s],");")}p?y?t():(r("if(",p,"){"),t(),r("}else{"),e(),r("}")):e()}function o(){function t(){r(u+".drawElements("+[d,m,v,g+"<<(("+v+"-5121)>>1)"]+");")}function e(){r(u+".drawArrays("+[d,g,m]+");")}p?y?t():(r("if(",p,"){"),t(),r("}else{"),e(),r("}")):e()}var s,l,c=t.shared,u=c.gl,f=c.draw,h=n.draw,p=function(){var i=h.elements,a=e;return i?((i.contextDep&&n.contextDynamic||i.propDep)&&(a=r),i=i.append(t,a)):i=a.def(f,".","elements"),i&&a("if("+i+")"+u+".bindBuffer(34963,"+i+".buffer.buffer);"),i}(),d=i("primitive"),g=i("offset"),m=function(){var i=h.count,a=e;return i?((i.contextDep&&n.contextDynamic||i.propDep)&&(a=r),i=i.append(t,a)):i=a.def(f,".","count"),i}();if("number"==typeof m){if(0===m)return}else r("if(",m,"){"),r.exit("}");Q&&(s=i("instances"),l=t.instancing);var v=p+".type",y=h.elements&&I(h.elements);Q&&("number"!=typeof s||0<=s)?"string"==typeof s?(r("if(",s,">0){"),a(),r("}else if(",s,"<0){"),o(),r("}")):a():o()}function q(t,e,r,n,i){return i=(e=b()).proc("body",i),Q&&(e.instancing=i.def(e.shared.extensions,".angle_instanced_arrays")),t(e,i,r,n),e.compile().body}function H(t,e,r,n){L(t,e),N(t,e,r,n.attributes,function(){return!0}),j(t,e,r,n.uniforms,function(){return!0}),V(t,e,e,r)}function G(t,e,r,n){function i(){return!0}t.batchId="a1",L(t,e),N(t,e,r,n.attributes,i),j(t,e,r,n.uniforms,i),V(t,e,e,r)}function W(t,e,r,n){function i(t){return t.contextDep&&o||t.propDep}function a(t){return!i(t)}L(t,e);var o=r.contextDep,s=e.def(),l=e.def();t.shared.props=l,t.batchId=s;var c=t.scope(),u=t.scope();e(c.entry,"for(",s,"=0;",s,"<","a1",";++",s,"){",l,"=","a0","[",s,"];",u,"}",c.exit),r.needsContext&&T(t,u,r.context),r.needsFramebuffer&&S(t,u,r.framebuffer),E(t,u,r.state,i),r.profile&&i(r.profile)&&F(t,u,r,!1,!0),n?(N(t,c,r,n.attributes,a),N(t,u,r,n.attributes,i),j(t,c,r,n.uniforms,a),j(t,u,r,n.uniforms,i),V(t,c,u,r)):(e=t.global.def("{}"),n=r.shader.progVar.append(t,u),l=u.def(n,".id"),c=u.def(e,"[",l,"]"),u(t.shared.gl,".useProgram(",n,".program);","if(!",c,"){",c,"=",e,"[",l,"]=",t.link(function(e){return q(G,t,r,e,2)}),"(",n,");}",c,".call(this,a0[",s,"],",s,");"))}function Y(t,r){function n(e){var n=r.shader[e];n&&i.set(a.shader,"."+e,n.append(t,i))}var i=t.proc("scope",3);t.batchId="a2";var a=t.shared,o=a.current;T(t,i,r.context),r.framebuffer&&r.framebuffer.append(t,i),D(Object.keys(r.state)).forEach(function(e){var n=r.state[e].append(t,i);v(n)?n.forEach(function(r,n){i.set(t.next[e],"["+n+"]",r)}):i.set(a.next,"."+e,n)}),F(t,i,r,!0,!0),["elements","offset","count","instances","primitive"].forEach(function(e){var n=r.draw[e];n&&i.set(a.draw,"."+e,""+n.append(t,i))}),Object.keys(r.uniforms).forEach(function(n){i.set(a.uniforms,"["+e.id(n)+"]",r.uniforms[n].append(t,i))}),Object.keys(r.attributes).forEach(function(e){var n=r.attributes[e].append(t,i),a=t.scopeAttrib(e);Object.keys(new Z).forEach(function(t){i.set(a,"."+t,n[t])})}),n("vert"),n("frag"),0=--this.refCount&&o(this)},i.profile&&(n.getTotalRenderbufferSize=function(){var t=0;return Object.keys(u).forEach(function(e){t+=u[e].stats.size}),t}),{create:function(e,r){function o(e,r){var n=0,a=0,u=32854;if("object"==typeof e&&e?("shape"in e?(n=0|(a=e.shape)[0],a=0|a[1]):("radius"in e&&(n=a=0|e.radius),"width"in e&&(n=0|e.width),"height"in e&&(a=0|e.height)),"format"in e&&(u=s[e.format])):"number"==typeof e?(n=0|e,a="number"==typeof r?0|r:n):e||(n=a=1),n!==c.width||a!==c.height||u!==c.format)return o.width=c.width=n,o.height=c.height=a,c.format=u,t.bindRenderbuffer(36161,c.renderbuffer),t.renderbufferStorage(36161,u,n,a),i.profile&&(c.stats.size=ft[c.format]*c.width*c.height),o.format=l[c.format],o}var c=new a(t.createRenderbuffer());return u[c.id]=c,n.renderbufferCount++,o(e,r),o.resize=function(e,r){var n=0|e,a=0|r||n;return n===c.width&&a===c.height?o:(o.width=c.width=n,o.height=c.height=a,t.bindRenderbuffer(36161,c.renderbuffer),t.renderbufferStorage(36161,c.format,n,a),i.profile&&(c.stats.size=ft[c.format]*c.width*c.height),o)},o._reglType="renderbuffer",o._renderbuffer=c,i.profile&&(o.stats=c.stats),o.destroy=function(){c.decRef()},o},clear:function(){W(u).forEach(o)},restore:function(){W(u).forEach(function(e){e.renderbuffer=t.createRenderbuffer(),t.bindRenderbuffer(36161,e.renderbuffer),t.renderbufferStorage(36161,e.format,e.width,e.height)}),t.bindRenderbuffer(36161,null)}}},pt=[];pt[6408]=4;var dt=[];dt[5121]=1,dt[5126]=4,dt[36193]=2;var gt=["x","y","z","w"],mt="blend.func blend.equation stencil.func stencil.opFront stencil.opBack sample.coverage viewport scissor.box polygonOffset.offset".split(" "),vt={0:0,1:1,zero:0,one:1,"src color":768,"one minus src color":769,"src alpha":770,"one minus src alpha":771,"dst color":774,"one minus dst color":775,"dst alpha":772,"one minus dst alpha":773,"constant color":32769,"one minus constant color":32770,"constant alpha":32771,"one minus constant alpha":32772,"src alpha saturate":776},yt={never:512,less:513,"<":513,equal:514,"=":514,"==":514,"===":514,lequal:515,"<=":515,greater:516,">":516,notequal:517,"!=":517,"!==":517,gequal:518,">=":518,always:519},xt={0:0,zero:0,keep:7680,replace:7681,increment:7682,decrement:7683,"increment wrap":34055,"decrement wrap":34056,invert:5386},bt={cw:2304,ccw:2305},_t=new O(!1,!1,!1,function(){});return function(t){function e(){if(0===X.length)w&&w.update(),Q=null;else{Q=q.next(e),f();for(var t=X.length-1;0<=t;--t){var r=X[t];r&&r(z,null,0)}m.flush(),w&&w.update()}}function r(){!Q&&0=X.length&&n()}}}}function u(){var t=W.viewport,e=W.scissor_box;t[0]=t[1]=e[0]=e[1]=0,z.viewportWidth=z.framebufferWidth=z.drawingBufferWidth=t[2]=e[2]=m.drawingBufferWidth,z.viewportHeight=z.framebufferHeight=z.drawingBufferHeight=t[3]=e[3]=m.drawingBufferHeight}function f(){z.tick+=1,z.time=p(),u(),G.procs.poll()}function h(){u(),G.procs.refresh(),w&&w.update()}function p(){return(H()-k)/1e3}if(!(t=i(t)))return null;var m=t.gl,v=m.getContextAttributes();m.isContextLost();var y=function(t,e){function r(e){var r;e=e.toLowerCase();try{r=n[e]=t.getExtension(e)}catch(t){}return!!r}for(var n={},i=0;ie;++e)$(j({framebuffer:t.framebuffer.faces[e]},t),l);else $(t,l);else l(0,t)},prop:U.define.bind(null,1),context:U.define.bind(null,2),this:U.define.bind(null,3),draw:s({}),buffer:function(t){return D.create(t,34962,!1,!1)},elements:function(t){return O.create(t,!1)},texture:R.create2D,cube:R.createCube,renderbuffer:B.create,framebuffer:V.create,framebufferCube:V.createCube,attributes:v,frame:c,on:function(t,e){var r;switch(t){case"frame":return c(e);case"lost":r=Z;break;case"restore":r=J;break;case"destroy":r=K}return r.push(e),{cancel:function(){for(var t=0;t=r)return i.substr(0,r);for(;r>i.length&&e>1;)1&e&&(i+=t),e>>=1,t+=t;return i=(i+=t).substr(0,r)}},{}],440:[function(t,e,r){(function(t){e.exports=t.performance&&t.performance.now?function(){return performance.now()}:Date.now||function(){return+new Date}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],441:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.length,r=t[t.length-1],n=e,i=e-2;i>=0;--i){var a=r,o=t[i],s=(r=a+o)-a,l=o-s;l&&(t[--n]=r,r=l)}for(var c=0,i=n;i>1;return["sum(",t(e.slice(0,r)),",",t(e.slice(r)),")"].join("")}(e);var n}function u(t){return new Function("sum","scale","prod","compress",["function robustDeterminant",t,"(m){return compress(",c(function(t){for(var e=new Array(t),r=0;r>1;return["sum(",c(t.slice(0,e)),",",c(t.slice(e)),")"].join("")}function u(t,e){if("m"===t.charAt(0)){if("w"===e.charAt(0)){var r=t.split("[");return["w",e.substr(1),"m",r[0].substr(1)].join("")}return["prod(",t,",",e,")"].join("")}return u(e,t)}function f(t){if(2===t.length)return[["diff(",u(t[0][0],t[1][1]),",",u(t[1][0],t[0][1]),")"].join("")];for(var e=[],r=0;r0&&r.push(","),r.push("[");for(var o=0;o0&&r.push(","),o===i?r.push("+b[",a,"]"):r.push("+A[",a,"][",o,"]");r.push("]")}r.push("]),")}r.push("det(A)]}return ",e);var s=new Function("det",r.join(""));return s(t<6?n[t]:n)}var o=[function(){return[0]},function(t,e){return[[e[0]],[t[0][0]]]}];!function(){for(;o.length>1;return["sum(",c(t.slice(0,e)),",",c(t.slice(e)),")"].join("")}function u(t){if(2===t.length)return[["sum(prod(",t[0][0],",",t[1][1],"),prod(-",t[0][1],",",t[1][0],"))"].join("")];for(var e=[],r=0;r0){if(a<=0)return o;n=i+a}else{if(!(i<0))return o;if(a>=0)return o;n=-(i+a)}var s=3.3306690738754716e-16*n;return o>=s||o<=-s?o:h(t,e,r)},function(t,e,r,n){var i=t[0]-n[0],a=e[0]-n[0],o=r[0]-n[0],s=t[1]-n[1],l=e[1]-n[1],c=r[1]-n[1],u=t[2]-n[2],f=e[2]-n[2],h=r[2]-n[2],d=a*c,g=o*l,m=o*s,v=i*c,y=i*l,x=a*s,b=u*(d-g)+f*(m-v)+h*(y-x),_=7.771561172376103e-16*((Math.abs(d)+Math.abs(g))*Math.abs(u)+(Math.abs(m)+Math.abs(v))*Math.abs(f)+(Math.abs(y)+Math.abs(x))*Math.abs(h));return b>_||-b>_?b:p(t,e,r,n)}];!function(){for(;d.length<=s;)d.push(f(d.length));for(var t=[],r=["slow"],n=0;n<=s;++n)t.push("a"+n),r.push("o"+n);var i=["function getOrientation(",t.join(),"){switch(arguments.length){case 0:case 1:return 0;"];for(n=2;n<=s;++n)i.push("case ",n,":return o",n,"(",t.slice(0,n).join(),");");i.push("}var s=new Array(arguments.length);for(var i=0;i0&&o>0||a<0&&o<0)return!1;var s=n(r,t,e),l=n(i,t,e);if(s>0&&l>0||s<0&&l<0)return!1;if(0===a&&0===o&&0===s&&0===l)return function(t,e,r,n){for(var i=0;i<2;++i){var a=t[i],o=e[i],s=Math.min(a,o),l=Math.max(a,o),c=r[i],u=n[i],f=Math.min(c,u),h=Math.max(c,u);if(h=n?(i=f,(l+=1)=n?(i=f,(l+=1)0?1:0}},{}],453:[function(t,e,r){"use strict";e.exports=function(t){return i(n(t))};var n=t("boundary-cells"),i=t("reduce-simplicial-complex")},{"boundary-cells":77,"reduce-simplicial-complex":431}],454:[function(t,e,r){"use strict";e.exports=function(t,e,r,s){r=r||0,void 0===s&&(s=function(t){for(var e=t.length,r=0,n=0;n>1,v=E[2*m+1];","if(v===b){return m}","if(b0&&l.push(","),l.push("[");for(var n=0;n0&&l.push(","),l.push("B(C,E,c[",i[0],"],c[",i[1],"])")}l.push("]")}l.push(");")}}for(var a=t+1;a>1;--a){a>1,s=a(t[o],e);s<=0?(0===s&&(i=o),r=o+1):s>0&&(n=o-1)}return i}function u(t,e){for(var r=new Array(t.length),i=0,o=r.length;i=t.length||0!==a(t[m],s)););}return r}function f(t,e){if(e<0)return[];for(var r=[],i=(1<>>u&1&&c.push(i[u]);e.push(c)}return s(e)},r.skeleton=f,r.boundary=function(t){for(var e=[],r=0,n=t.length;r>1:(t>>1)-1}function x(t){for(var e=v(t);;){var r=e,n=2*t+1,i=2*(t+1),a=t;if(n0;){var r=y(t);if(r>=0){var n=v(r);if(e0){var t=M[0];return m(0,S-1),S-=1,x(0),t}return-1}function w(t,e){var r=M[t];return c[r]===e?t:(c[r]=-1/0,b(t),_(),c[r]=e,b((S+=1)-1))}function k(t){if(!u[t]){u[t]=!0;var e=s[t],r=l[t];s[r]>=0&&(s[r]=e),l[e]>=0&&(l[e]=r),A[e]>=0&&w(A[e],g(e)),A[r]>=0&&w(A[r],g(r))}}for(var M=[],A=new Array(a),f=0;f>1;f>=0;--f)x(f);for(;;){var C=_();if(C<0||c[C]>r)break;k(C)}for(var E=[],f=0;f=0&&r>=0&&e!==r){var n=A[e],i=A[r];n!==i&&z.push([n,i])}}),i.unique(i.normalize(z)),{positions:E,edges:z}};var n=t("robust-orientation"),i=t("simplicial-complex")},{"robust-orientation":446,"simplicial-complex":458}],461:[function(t,e,r){"use strict";e.exports=function(t,e){var r,a,o,s;if(e[0][0]e[1][0]))return i(e,t);r=e[1],a=e[0]}if(t[0][0]t[1][0]))return-i(t,e);o=t[1],s=t[0]}var l=n(r,a,s),c=n(r,a,o);if(l<0){if(c<=0)return l}else if(l>0){if(c>=0)return l}else if(c)return c;if(l=n(s,o,a),c=n(s,o,r),l<0){if(c<=0)return l}else if(l>0){if(c>=0)return l}else if(c)return c;return a[0]-s[0]};var n=t("robust-orientation");function i(t,e){var r,i,a,o;if(e[0][0]e[1][0])){var s=Math.min(t[0][1],t[1][1]),l=Math.max(t[0][1],t[1][1]),c=Math.min(e[0][1],e[1][1]),u=Math.max(e[0][1],e[1][1]);return lu?s-u:l-u}r=e[1],i=e[0]}t[0][1]0)if(e[0]!==o[1][0])r=t,t=t.right;else{if(l=c(t.right,e))return l;t=t.left}else{if(e[0]!==o[1][0])return t;var l;if(l=c(t.right,e))return l;t=t.left}}return r}function u(t,e,r,n){this.y=t,this.index=e,this.start=r,this.closed=n}function f(t,e,r,n){this.x=t,this.segment=e,this.create=r,this.index=n}s.prototype.castUp=function(t){var e=n.le(this.coordinates,t[0]);if(e<0)return-1;this.slabs[e];var r=c(this.slabs[e],t),i=-1;if(r&&(i=r.value),this.coordinates[e]===t[0]){var s=null;if(r&&(s=r.key),e>0){var u=c(this.slabs[e-1],t);u&&(s?o(u.key,s)>0&&(s=u.key,i=u.value):(i=u.value,s=u.key))}var f=this.horizontal[e];if(f.length>0){var h=n.ge(f,t[1],l);if(h=f.length)return i;p=f[h]}}if(p.start)if(s){var d=a(s[0],s[1],[t[0],p.y]);s[0][0]>s[1][0]&&(d=-d),d>0&&(i=p.index)}else i=p.index;else p.y!==t[1]&&(i=p.index)}}}return i}},{"./lib/order-segments":461,"binary-search-bounds":73,"functional-red-black-tree":200,"robust-orientation":446}],463:[function(t,e,r){"use strict";var n=t("robust-dot-product"),i=t("robust-sum");function a(t,e){var r=i(n(t,e),[e[e.length-1]]);return r[r.length-1]}function o(t,e,r,n){var i=-e/(n-e);i<0?i=0:i>1&&(i=1);for(var a=1-i,o=t.length,s=new Array(o),l=0;l0||i>0&&u<0){var f=o(s,u,l,i);r.push(f),n.push(f.slice())}u<0?n.push(l.slice()):u>0?r.push(l.slice()):(r.push(l.slice()),n.push(l.slice())),i=u}return{positive:r,negative:n}},e.exports.positive=function(t,e){for(var r=[],n=a(t[t.length-1],e),i=t[t.length-1],s=t[0],l=0;l0||n>0&&c<0)&&r.push(o(i,c,s,n)),c>=0&&r.push(s.slice()),n=c}return r},e.exports.negative=function(t,e){for(var r=[],n=a(t[t.length-1],e),i=t[t.length-1],s=t[0],l=0;l0||n>0&&c<0)&&r.push(o(i,c,s,n)),c<=0&&r.push(s.slice()),n=c}return r}},{"robust-dot-product":443,"robust-sum":451}],464:[function(t,e,r){!function(){"use strict";var t={not_string:/[^s]/,not_bool:/[^t]/,not_type:/[^T]/,not_primitive:/[^v]/,number:/[diefg]/,numeric_arg:/[bcdiefguxX]/,json:/[j]/,not_json:/[^j]/,text:/^[^\x25]+/,modulo:/^\x25{2}/,placeholder:/^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,key:/^([a-z_][a-z_\d]*)/i,key_access:/^\.([a-z_][a-z_\d]*)/i,index_access:/^\[(\d+)\]/,sign:/^[\+\-]/};function e(r){return function(r,n){var i,a,o,s,l,c,u,f,h,p=1,d=r.length,g="";for(a=0;a=0),s[8]){case"b":i=parseInt(i,10).toString(2);break;case"c":i=String.fromCharCode(parseInt(i,10));break;case"d":case"i":i=parseInt(i,10);break;case"j":i=JSON.stringify(i,null,s[6]?parseInt(s[6]):0);break;case"e":i=s[7]?parseFloat(i).toExponential(s[7]):parseFloat(i).toExponential();break;case"f":i=s[7]?parseFloat(i).toFixed(s[7]):parseFloat(i);break;case"g":i=s[7]?String(Number(i.toPrecision(s[7]))):parseFloat(i);break;case"o":i=(parseInt(i,10)>>>0).toString(8);break;case"s":i=String(i),i=s[7]?i.substring(0,s[7]):i;break;case"t":i=String(!!i),i=s[7]?i.substring(0,s[7]):i;break;case"T":i=Object.prototype.toString.call(i).slice(8,-1).toLowerCase(),i=s[7]?i.substring(0,s[7]):i;break;case"u":i=parseInt(i,10)>>>0;break;case"v":i=i.valueOf(),i=s[7]?i.substring(0,s[7]):i;break;case"x":i=(parseInt(i,10)>>>0).toString(16);break;case"X":i=(parseInt(i,10)>>>0).toString(16).toUpperCase()}t.json.test(s[8])?g+=i:(!t.number.test(s[8])||f&&!s[3]?h="":(h=f?"+":"-",i=i.toString().replace(t.sign,"")),c=s[4]?"0"===s[4]?"0":s[4].charAt(1):" ",u=s[6]-(h+i).length,l=s[6]&&u>0?c.repeat(u):"",g+=s[5]?h+i+l:"0"===c?h+l+i:l+h+i)}return g}(function(e){if(i[e])return i[e];var r,n=e,a=[],o=0;for(;n;){if(null!==(r=t.text.exec(n)))a.push(r[0]);else if(null!==(r=t.modulo.exec(n)))a.push("%");else{if(null===(r=t.placeholder.exec(n)))throw new SyntaxError("[sprintf] unexpected placeholder");if(r[2]){o|=1;var s=[],l=r[2],c=[];if(null===(c=t.key.exec(l)))throw new SyntaxError("[sprintf] failed to parse named argument key");for(s.push(c[1]);""!==(l=l.substring(c[0].length));)if(null!==(c=t.key_access.exec(l)))s.push(c[1]);else{if(null===(c=t.index_access.exec(l)))throw new SyntaxError("[sprintf] failed to parse named argument key");s.push(c[1])}r[2]=s}else o|=2;if(3===o)throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");a.push(r)}n=n.substring(r[0].length)}return i[e]=a}(r),arguments)}function n(t,r){return e.apply(null,[t].concat(r||[]))}var i=Object.create(null);void 0!==r&&(r.sprintf=e,r.vsprintf=n),"undefined"!=typeof window&&(window.sprintf=e,window.vsprintf=n)}()},{}],465:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.length,r=new Array(e),n=new Array(e),i=new Array(e),a=new Array(e),o=new Array(e),s=new Array(e),l=0;l0;){e=c[c.length-1];var p=t[e];if(a[e]=0&&s[e].push(o[g])}a[e]=d}else{if(n[e]===r[e]){for(var m=[],v=[],y=0,d=l.length-1;d>=0;--d){var x=l[d];if(i[x]=!1,m.push(x),v.push(s[x]),y+=s[x].length,o[x]=f.length,x===e){l.length=d;break}}f.push(m);for(var b=new Array(y),d=0;d c)|0 },"),"generic"===e&&a.push("getters:[0],");for(var s=[],l=[],c=0;c>>7){");for(var c=0;c<1<<(1<128&&c%128==0){f.length>0&&h.push("}}");var p="vExtra"+f.length;a.push("case ",c>>>7,":",p,"(m&0x7f,",l.join(),");break;"),h=["function ",p,"(m,",l.join(),"){switch(m){"],f.push(h)}h.push("case ",127&c,":");for(var d=new Array(r),g=new Array(r),m=new Array(r),v=new Array(r),y=0,x=0;xx)&&!(c&1<<_)!=!(c&1<0&&(A="+"+m[b]+"*c");var T=d[b].length/y*.5,S=.5+v[b]/y*.5;M.push("d"+b+"-"+S+"-"+T+"*("+d[b].join("+")+A+")/("+g[b].join("+")+")")}h.push("a.push([",M.join(),"]);","break;")}a.push("}},"),f.length>0&&h.push("}}");for(var C=[],c=0;c<1<1&&(a=1),a<-1&&(a=-1),i*Math.acos(a)};r.default=function(t){var e=t.px,r=t.py,l=t.cx,c=t.cy,u=t.rx,f=t.ry,h=t.xAxisRotation,p=void 0===h?0:h,d=t.largeArcFlag,g=void 0===d?0:d,m=t.sweepFlag,v=void 0===m?0:m,y=[];if(0===u||0===f)return[];var x=Math.sin(p*i/360),b=Math.cos(p*i/360),_=b*(e-l)/2+x*(r-c)/2,w=-x*(e-l)/2+b*(r-c)/2;if(0===_&&0===w)return[];u=Math.abs(u),f=Math.abs(f);var k=Math.pow(_,2)/Math.pow(u,2)+Math.pow(w,2)/Math.pow(f,2);k>1&&(u*=Math.sqrt(k),f*=Math.sqrt(k));var M=function(t,e,r,n,a,o,l,c,u,f,h,p){var d=Math.pow(a,2),g=Math.pow(o,2),m=Math.pow(h,2),v=Math.pow(p,2),y=d*g-d*v-g*m;y<0&&(y=0),y/=d*v+g*m;var x=(y=Math.sqrt(y)*(l===c?-1:1))*a/o*p,b=y*-o/a*h,_=f*x-u*b+(t+r)/2,w=u*x+f*b+(e+n)/2,k=(h-x)/a,M=(p-b)/o,A=(-h-x)/a,T=(-p-b)/o,S=s(1,0,k,M),C=s(k,M,A,T);return 0===c&&C>0&&(C-=i),1===c&&C<0&&(C+=i),[_,w,S,C]}(e,r,l,c,u,f,g,v,x,b,_,w),A=n(M,4),T=A[0],S=A[1],C=A[2],E=A[3],L=Math.max(Math.ceil(Math.abs(E)/(i/4)),1);E/=L;for(var z=0;ze[2]&&(e[2]=c[u+0]),c[u+1]>e[3]&&(e[3]=c[u+1]);return e}},{"abs-svg-path":45,assert:53,"is-svg-path":367,"normalize-svg-path":470,"parse-svg-path":402}],470:[function(t,e,r){"use strict";e.exports=function(t){for(var e,r=[],o=0,s=0,l=0,c=0,u=null,f=null,h=0,p=0,d=0,g=t.length;d4?(o=m[m.length-4],s=m[m.length-3]):(o=h,s=p),r.push(m)}return r};var n=t("svg-arc-to-cubic-bezier");function i(t,e,r,n){return["C",t,e,r,n,r,n]}function a(t,e,r,n,i,a){return["C",t/3+2/3*r,e/3+2/3*n,i/3+2/3*r,a/3+2/3*n,i,a]}},{"svg-arc-to-cubic-bezier":468}],471:[function(t,e,r){(function(r){"use strict";var n=t("svg-path-bounds"),i=t("parse-svg-path"),a=t("draw-svg-path"),o=t("is-svg-path"),s=t("bitmap-sdf"),l=document.createElement("canvas"),c=l.getContext("2d");e.exports=function(t,e){if(!o(t))throw Error("Argument should be valid svg path string");e||(e={});var u,f;e.shape?(u=e.shape[0],f=e.shape[1]):(u=l.width=e.w||e.width||200,f=l.height=e.h||e.height||200);var h=Math.min(u,f),p=e.stroke||0,d=e.viewbox||e.viewBox||n(t),g=[u/(d[2]-d[0]),f/(d[3]-d[1])],m=Math.min(g[0]||0,g[1]||0)/2;c.fillStyle="black",c.fillRect(0,0,u,f),c.fillStyle="white",p&&("number"!=typeof p&&(p=1),c.strokeStyle=p>0?"white":"black",c.lineWidth=Math.abs(p));if(c.translate(.5*u,.5*f),c.scale(m,m),r.Path2D){var v=new Path2D(t);c.fill(v),p&&c.stroke(v)}else{var y=i(t);a(c,y),c.fill(),p&&c.stroke()}return c.setTransform(1,0,0,1,0,0),s(c,{cutoff:null!=e.cutoff?e.cutoff:.5,radius:null!=e.radius?e.radius:.5*h})}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"bitmap-sdf":75,"draw-svg-path":135,"is-svg-path":367,"parse-svg-path":402,"svg-path-bounds":469}],472:[function(t,e,r){(function(r){"use strict";e.exports=function t(e,r,i){var i=i||{};var o=a[e];o||(o=a[e]={" ":{data:new Float32Array(0),shape:.2}});var s=o[r];if(!s)if(r.length<=1||!/\d/.test(r))s=o[r]=function(t){for(var e=t.cells,r=t.positions,n=new Float32Array(6*e.length),i=0,a=0,o=0;o0&&(f+=.02);for(var p=new Float32Array(u),d=0,g=-.5*f,h=0;h1&&(r-=1),r<1/6?t+6*(e-t)*r:r<.5?e:r<2/3?t+(e-t)*(2/3-r)*6:t}if(t=L(t,360),e=L(e,100),r=L(r,100),0===e)n=i=a=r;else{var s=r<.5?r*(1+e):r+e-r*e,l=2*r-s;n=o(l,s,t+1/3),i=o(l,s,t),a=o(l,s,t-1/3)}return{r:255*n,g:255*i,b:255*a}}(e.h,l,u),f=!0,h="hsl"),e.hasOwnProperty("a")&&(a=e.a));var p,d,g;return a=E(a),{ok:f,format:e.format||h,r:o(255,s(i.r,0)),g:o(255,s(i.g,0)),b:o(255,s(i.b,0)),a:a}}(e);this._originalInput=e,this._r=u.r,this._g=u.g,this._b=u.b,this._a=u.a,this._roundA=a(100*this._a)/100,this._format=l.format||u.format,this._gradientType=l.gradientType,this._r<1&&(this._r=a(this._r)),this._g<1&&(this._g=a(this._g)),this._b<1&&(this._b=a(this._b)),this._ok=u.ok,this._tc_id=i++}function u(t,e,r){t=L(t,255),e=L(e,255),r=L(r,255);var n,i,a=s(t,e,r),l=o(t,e,r),c=(a+l)/2;if(a==l)n=i=0;else{var u=a-l;switch(i=c>.5?u/(2-a-l):u/(a+l),a){case t:n=(e-r)/u+(e>1)+720)%360;--e;)n.h=(n.h+i)%360,a.push(c(n));return a}function T(t,e){e=e||6;for(var r=c(t).toHsv(),n=r.h,i=r.s,a=r.v,o=[],s=1/e;e--;)o.push(c({h:n,s:i,v:a})),a=(a+s)%1;return o}c.prototype={isDark:function(){return this.getBrightness()<128},isLight:function(){return!this.isDark()},isValid:function(){return this._ok},getOriginalInput:function(){return this._originalInput},getFormat:function(){return this._format},getAlpha:function(){return this._a},getBrightness:function(){var t=this.toRgb();return(299*t.r+587*t.g+114*t.b)/1e3},getLuminance:function(){var e,r,n,i=this.toRgb();return e=i.r/255,r=i.g/255,n=i.b/255,.2126*(e<=.03928?e/12.92:t.pow((e+.055)/1.055,2.4))+.7152*(r<=.03928?r/12.92:t.pow((r+.055)/1.055,2.4))+.0722*(n<=.03928?n/12.92:t.pow((n+.055)/1.055,2.4))},setAlpha:function(t){return this._a=E(t),this._roundA=a(100*this._a)/100,this},toHsv:function(){var t=f(this._r,this._g,this._b);return{h:360*t.h,s:t.s,v:t.v,a:this._a}},toHsvString:function(){var t=f(this._r,this._g,this._b),e=a(360*t.h),r=a(100*t.s),n=a(100*t.v);return 1==this._a?"hsv("+e+", "+r+"%, "+n+"%)":"hsva("+e+", "+r+"%, "+n+"%, "+this._roundA+")"},toHsl:function(){var t=u(this._r,this._g,this._b);return{h:360*t.h,s:t.s,l:t.l,a:this._a}},toHslString:function(){var t=u(this._r,this._g,this._b),e=a(360*t.h),r=a(100*t.s),n=a(100*t.l);return 1==this._a?"hsl("+e+", "+r+"%, "+n+"%)":"hsla("+e+", "+r+"%, "+n+"%, "+this._roundA+")"},toHex:function(t){return h(this._r,this._g,this._b,t)},toHexString:function(t){return"#"+this.toHex(t)},toHex8:function(t){return function(t,e,r,n,i){var o=[D(a(t).toString(16)),D(a(e).toString(16)),D(a(r).toString(16)),D(I(n))];if(i&&o[0].charAt(0)==o[0].charAt(1)&&o[1].charAt(0)==o[1].charAt(1)&&o[2].charAt(0)==o[2].charAt(1)&&o[3].charAt(0)==o[3].charAt(1))return o[0].charAt(0)+o[1].charAt(0)+o[2].charAt(0)+o[3].charAt(0);return o.join("")}(this._r,this._g,this._b,this._a,t)},toHex8String:function(t){return"#"+this.toHex8(t)},toRgb:function(){return{r:a(this._r),g:a(this._g),b:a(this._b),a:this._a}},toRgbString:function(){return 1==this._a?"rgb("+a(this._r)+", "+a(this._g)+", "+a(this._b)+")":"rgba("+a(this._r)+", "+a(this._g)+", "+a(this._b)+", "+this._roundA+")"},toPercentageRgb:function(){return{r:a(100*L(this._r,255))+"%",g:a(100*L(this._g,255))+"%",b:a(100*L(this._b,255))+"%",a:this._a}},toPercentageRgbString:function(){return 1==this._a?"rgb("+a(100*L(this._r,255))+"%, "+a(100*L(this._g,255))+"%, "+a(100*L(this._b,255))+"%)":"rgba("+a(100*L(this._r,255))+"%, "+a(100*L(this._g,255))+"%, "+a(100*L(this._b,255))+"%, "+this._roundA+")"},toName:function(){return 0===this._a?"transparent":!(this._a<1)&&(C[h(this._r,this._g,this._b,!0)]||!1)},toFilter:function(t){var e="#"+p(this._r,this._g,this._b,this._a),r=e,n=this._gradientType?"GradientType = 1, ":"";if(t){var i=c(t);r="#"+p(i._r,i._g,i._b,i._a)}return"progid:DXImageTransform.Microsoft.gradient("+n+"startColorstr="+e+",endColorstr="+r+")"},toString:function(t){var e=!!t;t=t||this._format;var r=!1,n=this._a<1&&this._a>=0;return e||!n||"hex"!==t&&"hex6"!==t&&"hex3"!==t&&"hex4"!==t&&"hex8"!==t&&"name"!==t?("rgb"===t&&(r=this.toRgbString()),"prgb"===t&&(r=this.toPercentageRgbString()),"hex"!==t&&"hex6"!==t||(r=this.toHexString()),"hex3"===t&&(r=this.toHexString(!0)),"hex4"===t&&(r=this.toHex8String(!0)),"hex8"===t&&(r=this.toHex8String()),"name"===t&&(r=this.toName()),"hsl"===t&&(r=this.toHslString()),"hsv"===t&&(r=this.toHsvString()),r||this.toHexString()):"name"===t&&0===this._a?this.toName():this.toRgbString()},clone:function(){return c(this.toString())},_applyModification:function(t,e){var r=t.apply(null,[this].concat([].slice.call(e)));return this._r=r._r,this._g=r._g,this._b=r._b,this.setAlpha(r._a),this},lighten:function(){return this._applyModification(v,arguments)},brighten:function(){return this._applyModification(y,arguments)},darken:function(){return this._applyModification(x,arguments)},desaturate:function(){return this._applyModification(d,arguments)},saturate:function(){return this._applyModification(g,arguments)},greyscale:function(){return this._applyModification(m,arguments)},spin:function(){return this._applyModification(b,arguments)},_applyCombination:function(t,e){return t.apply(null,[this].concat([].slice.call(e)))},analogous:function(){return this._applyCombination(A,arguments)},complement:function(){return this._applyCombination(_,arguments)},monochromatic:function(){return this._applyCombination(T,arguments)},splitcomplement:function(){return this._applyCombination(M,arguments)},triad:function(){return this._applyCombination(w,arguments)},tetrad:function(){return this._applyCombination(k,arguments)}},c.fromRatio=function(t,e){if("object"==typeof t){var r={};for(var n in t)t.hasOwnProperty(n)&&(r[n]="a"===n?t[n]:O(t[n]));t=r}return c(t,e)},c.equals=function(t,e){return!(!t||!e)&&c(t).toRgbString()==c(e).toRgbString()},c.random=function(){return c.fromRatio({r:l(),g:l(),b:l()})},c.mix=function(t,e,r){r=0===r?0:r||50;var n=c(t).toRgb(),i=c(e).toRgb(),a=r/100;return c({r:(i.r-n.r)*a+n.r,g:(i.g-n.g)*a+n.g,b:(i.b-n.b)*a+n.b,a:(i.a-n.a)*a+n.a})},c.readability=function(e,r){var n=c(e),i=c(r);return(t.max(n.getLuminance(),i.getLuminance())+.05)/(t.min(n.getLuminance(),i.getLuminance())+.05)},c.isReadable=function(t,e,r){var n,i,a=c.readability(t,e);switch(i=!1,(n=function(t){var e,r;e=((t=t||{level:"AA",size:"small"}).level||"AA").toUpperCase(),r=(t.size||"small").toLowerCase(),"AA"!==e&&"AAA"!==e&&(e="AA");"small"!==r&&"large"!==r&&(r="small");return{level:e,size:r}}(r)).level+n.size){case"AAsmall":case"AAAlarge":i=a>=4.5;break;case"AAlarge":i=a>=3;break;case"AAAsmall":i=a>=7}return i},c.mostReadable=function(t,e,r){var n,i,a,o,s=null,l=0;i=(r=r||{}).includeFallbackColors,a=r.level,o=r.size;for(var u=0;ul&&(l=n,s=c(e[u]));return c.isReadable(t,s,{level:a,size:o})||!i?s:(r.includeFallbackColors=!1,c.mostReadable(t,["#fff","#000"],r))};var S=c.names={aliceblue:"f0f8ff",antiquewhite:"faebd7",aqua:"0ff",aquamarine:"7fffd4",azure:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"000",blanchedalmond:"ffebcd",blue:"00f",blueviolet:"8a2be2",brown:"a52a2a",burlywood:"deb887",burntsienna:"ea7e5d",cadetblue:"5f9ea0",chartreuse:"7fff00",chocolate:"d2691e",coral:"ff7f50",cornflowerblue:"6495ed",cornsilk:"fff8dc",crimson:"dc143c",cyan:"0ff",darkblue:"00008b",darkcyan:"008b8b",darkgoldenrod:"b8860b",darkgray:"a9a9a9",darkgreen:"006400",darkgrey:"a9a9a9",darkkhaki:"bdb76b",darkmagenta:"8b008b",darkolivegreen:"556b2f",darkorange:"ff8c00",darkorchid:"9932cc",darkred:"8b0000",darksalmon:"e9967a",darkseagreen:"8fbc8f",darkslateblue:"483d8b",darkslategray:"2f4f4f",darkslategrey:"2f4f4f",darkturquoise:"00ced1",darkviolet:"9400d3",deeppink:"ff1493",deepskyblue:"00bfff",dimgray:"696969",dimgrey:"696969",dodgerblue:"1e90ff",firebrick:"b22222",floralwhite:"fffaf0",forestgreen:"228b22",fuchsia:"f0f",gainsboro:"dcdcdc",ghostwhite:"f8f8ff",gold:"ffd700",goldenrod:"daa520",gray:"808080",green:"008000",greenyellow:"adff2f",grey:"808080",honeydew:"f0fff0",hotpink:"ff69b4",indianred:"cd5c5c",indigo:"4b0082",ivory:"fffff0",khaki:"f0e68c",lavender:"e6e6fa",lavenderblush:"fff0f5",lawngreen:"7cfc00",lemonchiffon:"fffacd",lightblue:"add8e6",lightcoral:"f08080",lightcyan:"e0ffff",lightgoldenrodyellow:"fafad2",lightgray:"d3d3d3",lightgreen:"90ee90",lightgrey:"d3d3d3",lightpink:"ffb6c1",lightsalmon:"ffa07a",lightseagreen:"20b2aa",lightskyblue:"87cefa",lightslategray:"789",lightslategrey:"789",lightsteelblue:"b0c4de",lightyellow:"ffffe0",lime:"0f0",limegreen:"32cd32",linen:"faf0e6",magenta:"f0f",maroon:"800000",mediumaquamarine:"66cdaa",mediumblue:"0000cd",mediumorchid:"ba55d3",mediumpurple:"9370db",mediumseagreen:"3cb371",mediumslateblue:"7b68ee",mediumspringgreen:"00fa9a",mediumturquoise:"48d1cc",mediumvioletred:"c71585",midnightblue:"191970",mintcream:"f5fffa",mistyrose:"ffe4e1",moccasin:"ffe4b5",navajowhite:"ffdead",navy:"000080",oldlace:"fdf5e6",olive:"808000",olivedrab:"6b8e23",orange:"ffa500",orangered:"ff4500",orchid:"da70d6",palegoldenrod:"eee8aa",palegreen:"98fb98",paleturquoise:"afeeee",palevioletred:"db7093",papayawhip:"ffefd5",peachpuff:"ffdab9",peru:"cd853f",pink:"ffc0cb",plum:"dda0dd",powderblue:"b0e0e6",purple:"800080",rebeccapurple:"663399",red:"f00",rosybrown:"bc8f8f",royalblue:"4169e1",saddlebrown:"8b4513",salmon:"fa8072",sandybrown:"f4a460",seagreen:"2e8b57",seashell:"fff5ee",sienna:"a0522d",silver:"c0c0c0",skyblue:"87ceeb",slateblue:"6a5acd",slategray:"708090",slategrey:"708090",snow:"fffafa",springgreen:"00ff7f",steelblue:"4682b4",tan:"d2b48c",teal:"008080",thistle:"d8bfd8",tomato:"ff6347",turquoise:"40e0d0",violet:"ee82ee",wheat:"f5deb3",white:"fff",whitesmoke:"f5f5f5",yellow:"ff0",yellowgreen:"9acd32"},C=c.hexNames=function(t){var e={};for(var r in t)t.hasOwnProperty(r)&&(e[t[r]]=r);return e}(S);function E(t){return t=parseFloat(t),(isNaN(t)||t<0||t>1)&&(t=1),t}function L(e,r){(function(t){return"string"==typeof t&&-1!=t.indexOf(".")&&1===parseFloat(t)})(e)&&(e="100%");var n=function(t){return"string"==typeof t&&-1!=t.indexOf("%")}(e);return e=o(r,s(0,parseFloat(e))),n&&(e=parseInt(e*r,10)/100),t.abs(e-r)<1e-6?1:e%r/parseFloat(r)}function z(t){return o(1,s(0,t))}function P(t){return parseInt(t,16)}function D(t){return 1==t.length?"0"+t:""+t}function O(t){return t<=1&&(t=100*t+"%"),t}function I(e){return t.round(255*parseFloat(e)).toString(16)}function R(t){return P(t)/255}var B,F,N,j=(F="[\\s|\\(]+("+(B="(?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?)")+")[,|\\s]+("+B+")[,|\\s]+("+B+")\\s*\\)?",N="[\\s|\\(]+("+B+")[,|\\s]+("+B+")[,|\\s]+("+B+")[,|\\s]+("+B+")\\s*\\)?",{CSS_UNIT:new RegExp(B),rgb:new RegExp("rgb"+F),rgba:new RegExp("rgba"+N),hsl:new RegExp("hsl"+F),hsla:new RegExp("hsla"+N),hsv:new RegExp("hsv"+F),hsva:new RegExp("hsva"+N),hex3:/^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,hex4:/^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex8:/^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/});function V(t){return!!j.CSS_UNIT.exec(t)}void 0!==e&&e.exports?e.exports=c:window.tinycolor=c}(Math)},{}],474:[function(t,e,r){"use strict";function n(t){if(t instanceof Float32Array)return t;if("number"==typeof t)return new Float32Array([t])[0];var e=new Float32Array(t);return e.set(t),e}e.exports=n,e.exports.float32=e.exports.float=n,e.exports.fract32=e.exports.fract=function(t){if("number"==typeof t)return n(t-n(t));for(var e=n(t),r=0,i=e.length;rf&&(f=l[0]),l[1]h&&(h=l[1])}function i(t){switch(t.type){case"GeometryCollection":t.geometries.forEach(i);break;case"Point":n(t.coordinates);break;case"MultiPoint":t.coordinates.forEach(n)}}if(!e){var a,o,s=r(t),l=new Array(2),c=1/0,u=c,f=-c,h=-c;for(o in t.arcs.forEach(function(t){for(var e=-1,r=t.length;++ef&&(f=l[0]),l[1]h&&(h=l[1])}),t.objects)i(t.objects[o]);e=t.bbox=[c,u,f,h]}return e},i=function(t,e){for(var r,n=t.length,i=n-e;i<--n;)r=t[i],t[i++]=t[n],t[n]=r};function a(t,e){var r=e.id,n=e.bbox,i=null==e.properties?{}:e.properties,a=o(t,e);return null==r&&null==n?{type:"Feature",properties:i,geometry:a}:null==n?{type:"Feature",id:r,properties:i,geometry:a}:{type:"Feature",id:r,bbox:n,properties:i,geometry:a}}function o(t,e){var n=r(t),a=t.arcs;function o(t,e){e.length&&e.pop();for(var r=a[t<0?~t:t],o=0,s=r.length;o1)n=function(t,e,r){var n,i=[],a=[];function o(t){var e=t<0?~t:t;(a[e]||(a[e]=[])).push({i:t,g:n})}function s(t){t.forEach(o)}function l(t){t.forEach(s)}return function t(e){switch(n=e,e.type){case"GeometryCollection":e.geometries.forEach(t);break;case"LineString":s(e.arcs);break;case"MultiLineString":case"Polygon":l(e.arcs);break;case"MultiPolygon":e.arcs.forEach(l)}}(e),a.forEach(null==r?function(t){i.push(t[0].i)}:function(t){r(t[0].g,t[t.length-1].g)&&i.push(t[0].i)}),i}(0,e,r);else for(i=0,n=new Array(a=t.arcs.length);i1)for(var a,o,c=1,u=l(i[0]);cu&&(o=i[0],i[0]=i[c],i[c]=o,u=a);return i})}}var u=function(t,e){for(var r=0,n=t.length;r>>1;t[i]=2))throw new Error("n must be \u22652");if(t.transform)throw new Error("already quantized");var r,i=n(t),a=i[0],o=(i[2]-a)/(e-1)||1,s=i[1],l=(i[3]-s)/(e-1)||1;function c(t){t[0]=Math.round((t[0]-a)/o),t[1]=Math.round((t[1]-s)/l)}function u(t){switch(t.type){case"GeometryCollection":t.geometries.forEach(u);break;case"Point":c(t.coordinates);break;case"MultiPoint":t.coordinates.forEach(c)}}for(r in t.arcs.forEach(function(t){for(var e,r,n,i=1,c=1,u=t.length,f=t[0],h=f[0]=Math.round((f[0]-a)/o),p=f[1]=Math.round((f[1]-s)/l);iMath.max(r,n)?i[2]=1:r>Math.max(e,n)?i[0]=1:i[1]=1;for(var a=0,o=0,l=0;l<3;++l)a+=t[l]*t[l],o+=i[l]*t[l];for(l=0;l<3;++l)i[l]-=o/a*t[l];return s(i,i),i}function h(t,e,r,i,a,o,s,l){this.center=n(r),this.up=n(i),this.right=n(a),this.radius=n([o]),this.angle=n([s,l]),this.angle.bounds=[[-1/0,-Math.PI/2],[1/0,Math.PI/2]],this.setDistanceLimits(t,e),this.computedCenter=this.center.curve(0),this.computedUp=this.up.curve(0),this.computedRight=this.right.curve(0),this.computedRadius=this.radius.curve(0),this.computedAngle=this.angle.curve(0),this.computedToward=[0,0,0],this.computedEye=[0,0,0],this.computedMatrix=new Array(16);for(var c=0;c<16;++c)this.computedMatrix[c]=.5;this.recalcMatrix(0)}var p=h.prototype;p.setDistanceLimits=function(t,e){t=t>0?Math.log(t):-1/0,e=e>0?Math.log(e):1/0,e=Math.max(e,t),this.radius.bounds[0][0]=t,this.radius.bounds[1][0]=e},p.getDistanceLimits=function(t){var e=this.radius.bounds[0];return t?(t[0]=Math.exp(e[0][0]),t[1]=Math.exp(e[1][0]),t):[Math.exp(e[0][0]),Math.exp(e[1][0])]},p.recalcMatrix=function(t){this.center.curve(t),this.up.curve(t),this.right.curve(t),this.radius.curve(t),this.angle.curve(t);for(var e=this.computedUp,r=this.computedRight,n=0,i=0,a=0;a<3;++a)i+=e[a]*r[a],n+=e[a]*e[a];var l=Math.sqrt(n),u=0;for(a=0;a<3;++a)r[a]-=e[a]*i/n,u+=r[a]*r[a],e[a]/=l;var f=Math.sqrt(u);for(a=0;a<3;++a)r[a]/=f;var h=this.computedToward;o(h,e,r),s(h,h);var p=Math.exp(this.computedRadius[0]),d=this.computedAngle[0],g=this.computedAngle[1],m=Math.cos(d),v=Math.sin(d),y=Math.cos(g),x=Math.sin(g),b=this.computedCenter,_=m*y,w=v*y,k=x,M=-m*x,A=-v*x,T=y,S=this.computedEye,C=this.computedMatrix;for(a=0;a<3;++a){var E=_*r[a]+w*h[a]+k*e[a];C[4*a+1]=M*r[a]+A*h[a]+T*e[a],C[4*a+2]=E,C[4*a+3]=0}var L=C[1],z=C[5],P=C[9],D=C[2],O=C[6],I=C[10],R=z*I-P*O,B=P*D-L*I,F=L*O-z*D,N=c(R,B,F);R/=N,B/=N,F/=N,C[0]=R,C[4]=B,C[8]=F;for(a=0;a<3;++a)S[a]=b[a]+C[2+4*a]*p;for(a=0;a<3;++a){u=0;for(var j=0;j<3;++j)u+=C[a+4*j]*S[j];C[12+a]=-u}C[15]=1},p.getMatrix=function(t,e){this.recalcMatrix(t);var r=this.computedMatrix;if(e){for(var n=0;n<16;++n)e[n]=r[n];return e}return r};var d=[0,0,0];p.rotate=function(t,e,r,n){if(this.angle.move(t,e,r),n){this.recalcMatrix(t);var i=this.computedMatrix;d[0]=i[2],d[1]=i[6],d[2]=i[10];for(var o=this.computedUp,s=this.computedRight,l=this.computedToward,c=0;c<3;++c)i[4*c]=o[c],i[4*c+1]=s[c],i[4*c+2]=l[c];a(i,i,n,d);for(c=0;c<3;++c)o[c]=i[4*c],s[c]=i[4*c+1];this.up.set(t,o[0],o[1],o[2]),this.right.set(t,s[0],s[1],s[2])}},p.pan=function(t,e,r,n){e=e||0,r=r||0,n=n||0,this.recalcMatrix(t);var i=this.computedMatrix,a=(Math.exp(this.computedRadius[0]),i[1]),o=i[5],s=i[9],l=c(a,o,s);a/=l,o/=l,s/=l;var u=i[0],f=i[4],h=i[8],p=u*a+f*o+h*s,d=c(u-=a*p,f-=o*p,h-=s*p),g=(u/=d)*e+a*r,m=(f/=d)*e+o*r,v=(h/=d)*e+s*r;this.center.move(t,g,m,v);var y=Math.exp(this.computedRadius[0]);y=Math.max(1e-4,y+n),this.radius.set(t,Math.log(y))},p.translate=function(t,e,r,n){this.center.move(t,e||0,r||0,n||0)},p.setMatrix=function(t,e,r,n){var a=1;"number"==typeof r&&(a=0|r),(a<0||a>3)&&(a=1);var o=(a+2)%3;e||(this.recalcMatrix(t),e=this.computedMatrix);var s=e[a],l=e[a+4],f=e[a+8];if(n){var h=Math.abs(s),p=Math.abs(l),d=Math.abs(f),g=Math.max(h,p,d);h===g?(s=s<0?-1:1,l=f=0):d===g?(f=f<0?-1:1,s=l=0):(l=l<0?-1:1,s=f=0)}else{var m=c(s,l,f);s/=m,l/=m,f/=m}var v,y,x=e[o],b=e[o+4],_=e[o+8],w=x*s+b*l+_*f,k=c(x-=s*w,b-=l*w,_-=f*w),M=l*(_/=k)-f*(b/=k),A=f*(x/=k)-s*_,T=s*b-l*x,S=c(M,A,T);if(M/=S,A/=S,T/=S,this.center.jump(t,H,G,W),this.radius.idle(t),this.up.jump(t,s,l,f),this.right.jump(t,x,b,_),2===a){var C=e[1],E=e[5],L=e[9],z=C*x+E*b+L*_,P=C*M+E*A+L*T;v=R<0?-Math.PI/2:Math.PI/2,y=Math.atan2(P,z)}else{var D=e[2],O=e[6],I=e[10],R=D*s+O*l+I*f,B=D*x+O*b+I*_,F=D*M+O*A+I*T;v=Math.asin(u(R)),y=Math.atan2(F,B)}this.angle.jump(t,y,v),this.recalcMatrix(t);var N=e[2],j=e[6],V=e[10],U=this.computedMatrix;i(U,e);var q=U[15],H=U[12]/q,G=U[13]/q,W=U[14]/q,Y=Math.exp(this.computedRadius[0]);this.center.jump(t,H-N*Y,G-j*Y,W-V*Y)},p.lastT=function(){return Math.max(this.center.lastT(),this.up.lastT(),this.right.lastT(),this.radius.lastT(),this.angle.lastT())},p.idle=function(t){this.center.idle(t),this.up.idle(t),this.right.idle(t),this.radius.idle(t),this.angle.idle(t)},p.flush=function(t){this.center.flush(t),this.up.flush(t),this.right.flush(t),this.radius.flush(t),this.angle.flush(t)},p.setDistance=function(t,e){e>0&&this.radius.set(t,Math.log(e))},p.lookAt=function(t,e,r,n){this.recalcMatrix(t),e=e||this.computedEye,r=r||this.computedCenter;var i=(n=n||this.computedUp)[0],a=n[1],o=n[2],s=c(i,a,o);if(!(s<1e-6)){i/=s,a/=s,o/=s;var l=e[0]-r[0],f=e[1]-r[1],h=e[2]-r[2],p=c(l,f,h);if(!(p<1e-6)){l/=p,f/=p,h/=p;var d=this.computedRight,g=d[0],m=d[1],v=d[2],y=i*g+a*m+o*v,x=c(g-=y*i,m-=y*a,v-=y*o);if(!(x<.01&&(x=c(g=a*h-o*f,m=o*l-i*h,v=i*f-a*l))<1e-6)){g/=x,m/=x,v/=x,this.up.set(t,i,a,o),this.right.set(t,g,m,v),this.center.set(t,r[0],r[1],r[2]),this.radius.set(t,Math.log(p));var b=a*v-o*m,_=o*g-i*v,w=i*m-a*g,k=c(b,_,w),M=i*l+a*f+o*h,A=g*l+m*f+v*h,T=(b/=k)*l+(_/=k)*f+(w/=k)*h,S=Math.asin(u(M)),C=Math.atan2(T,A),E=this.angle._state,L=E[E.length-1],z=E[E.length-2];L%=2*Math.PI;var P=Math.abs(L+2*Math.PI-C),D=Math.abs(L-C),O=Math.abs(L-2*Math.PI-C);P0?r.pop():new ArrayBuffer(t)}function h(t){return new Uint8Array(f(t),0,t)}function p(t){return new Uint16Array(f(2*t),0,t)}function d(t){return new Uint32Array(f(4*t),0,t)}function g(t){return new Int8Array(f(t),0,t)}function m(t){return new Int16Array(f(2*t),0,t)}function v(t){return new Int32Array(f(4*t),0,t)}function y(t){return new Float32Array(f(4*t),0,t)}function x(t){return new Float64Array(f(8*t),0,t)}function b(t){return o?new Uint8ClampedArray(f(t),0,t):h(t)}function _(t){return new DataView(f(t),0,t)}function w(t){t=i.nextPow2(t);var e=i.log2(t),r=c[e];return r.length>0?r.pop():new n(t)}r.free=function(t){if(n.isBuffer(t))c[i.log2(t.length)].push(t);else{if("[object ArrayBuffer]"!==Object.prototype.toString.call(t)&&(t=t.buffer),!t)return;var e=t.length||t.byteLength,r=0|i.log2(e);l[r].push(t)}},r.freeUint8=r.freeUint16=r.freeUint32=r.freeInt8=r.freeInt16=r.freeInt32=r.freeFloat32=r.freeFloat=r.freeFloat64=r.freeDouble=r.freeUint8Clamped=r.freeDataView=function(t){u(t.buffer)},r.freeArrayBuffer=u,r.freeBuffer=function(t){c[i.log2(t.length)].push(t)},r.malloc=function(t,e){if(void 0===e||"arraybuffer"===e)return f(t);switch(e){case"uint8":return h(t);case"uint16":return p(t);case"uint32":return d(t);case"int8":return g(t);case"int16":return m(t);case"int32":return v(t);case"float":case"float32":return y(t);case"double":case"float64":return x(t);case"uint8_clamped":return b(t);case"buffer":return w(t);case"data":case"dataview":return _(t);default:return null}return null},r.mallocArrayBuffer=f,r.mallocUint8=h,r.mallocUint16=p,r.mallocUint32=d,r.mallocInt8=g,r.mallocInt16=m,r.mallocInt32=v,r.mallocFloat32=r.mallocFloat=y,r.mallocFloat64=r.mallocDouble=x,r.mallocUint8Clamped=b,r.mallocDataView=_,r.mallocBuffer=w,r.clearCache=function(){for(var t=0;t<32;++t)s.UINT8[t].length=0,s.UINT16[t].length=0,s.UINT32[t].length=0,s.INT8[t].length=0,s.INT16[t].length=0,s.INT32[t].length=0,s.FLOAT[t].length=0,s.DOUBLE[t].length=0,s.UINT8C[t].length=0,l[t].length=0,c[t].length=0}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},t("buffer").Buffer)},{"bit-twiddle":74,buffer:86,dup:137}],482:[function(t,e,r){"use strict";"use restrict";function n(t){this.roots=new Array(t),this.ranks=new Array(t);for(var e=0;e=a)return t;switch(t){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return JSON.stringify(n[r++])}catch(t){return"[Circular]"}default:return t}}),l=n[r];r=3&&(n.depth=arguments[2]),arguments.length>=4&&(n.colors=arguments[3]),d(e)?n.showHidden=e:e&&r._extend(n,e),y(n.showHidden)&&(n.showHidden=!1),y(n.depth)&&(n.depth=2),y(n.colors)&&(n.colors=!1),y(n.customInspect)&&(n.customInspect=!0),n.colors&&(n.stylize=l),u(n,t,n.depth)}function l(t,e){var r=s.styles[e];return r?"\x1b["+s.colors[r][0]+"m"+t+"\x1b["+s.colors[r][1]+"m":t}function c(t,e){return t}function u(t,e,n){if(t.customInspect&&e&&k(e.inspect)&&e.inspect!==r.inspect&&(!e.constructor||e.constructor.prototype!==e)){var i=e.inspect(n,t);return v(i)||(i=u(t,i,n)),i}var a=function(t,e){if(y(e))return t.stylize("undefined","undefined");if(v(e)){var r="'"+JSON.stringify(e).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return t.stylize(r,"string")}if(m(e))return t.stylize(""+e,"number");if(d(e))return t.stylize(""+e,"boolean");if(g(e))return t.stylize("null","null")}(t,e);if(a)return a;var o=Object.keys(e),s=function(t){var e={};return t.forEach(function(t,r){e[t]=!0}),e}(o);if(t.showHidden&&(o=Object.getOwnPropertyNames(e)),w(e)&&(o.indexOf("message")>=0||o.indexOf("description")>=0))return f(e);if(0===o.length){if(k(e)){var l=e.name?": "+e.name:"";return t.stylize("[Function"+l+"]","special")}if(x(e))return t.stylize(RegExp.prototype.toString.call(e),"regexp");if(_(e))return t.stylize(Date.prototype.toString.call(e),"date");if(w(e))return f(e)}var c,b="",M=!1,A=["{","}"];(p(e)&&(M=!0,A=["[","]"]),k(e))&&(b=" [Function"+(e.name?": "+e.name:"")+"]");return x(e)&&(b=" "+RegExp.prototype.toString.call(e)),_(e)&&(b=" "+Date.prototype.toUTCString.call(e)),w(e)&&(b=" "+f(e)),0!==o.length||M&&0!=e.length?n<0?x(e)?t.stylize(RegExp.prototype.toString.call(e),"regexp"):t.stylize("[Object]","special"):(t.seen.push(e),c=M?function(t,e,r,n,i){for(var a=[],o=0,s=e.length;o=0&&0,t+e.replace(/\u001b\[\d\d?m/g,"").length+1},0)>60)return r[0]+(""===e?"":e+"\n ")+" "+t.join(",\n ")+" "+r[1];return r[0]+e+" "+t.join(", ")+" "+r[1]}(c,b,A)):A[0]+b+A[1]}function f(t){return"["+Error.prototype.toString.call(t)+"]"}function h(t,e,r,n,i,a){var o,s,l;if((l=Object.getOwnPropertyDescriptor(e,i)||{value:e[i]}).get?s=l.set?t.stylize("[Getter/Setter]","special"):t.stylize("[Getter]","special"):l.set&&(s=t.stylize("[Setter]","special")),S(n,i)||(o="["+i+"]"),s||(t.seen.indexOf(l.value)<0?(s=g(r)?u(t,l.value,null):u(t,l.value,r-1)).indexOf("\n")>-1&&(s=a?s.split("\n").map(function(t){return" "+t}).join("\n").substr(2):"\n"+s.split("\n").map(function(t){return" "+t}).join("\n")):s=t.stylize("[Circular]","special")),y(o)){if(a&&i.match(/^\d+$/))return s;(o=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(o=o.substr(1,o.length-2),o=t.stylize(o,"name")):(o=o.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),o=t.stylize(o,"string"))}return o+": "+s}function p(t){return Array.isArray(t)}function d(t){return"boolean"==typeof t}function g(t){return null===t}function m(t){return"number"==typeof t}function v(t){return"string"==typeof t}function y(t){return void 0===t}function x(t){return b(t)&&"[object RegExp]"===M(t)}function b(t){return"object"==typeof t&&null!==t}function _(t){return b(t)&&"[object Date]"===M(t)}function w(t){return b(t)&&("[object Error]"===M(t)||t instanceof Error)}function k(t){return"function"==typeof t}function M(t){return Object.prototype.toString.call(t)}function A(t){return t<10?"0"+t.toString(10):t.toString(10)}r.debuglog=function(t){if(y(a)&&(a=e.env.NODE_DEBUG||""),t=t.toUpperCase(),!o[t])if(new RegExp("\\b"+t+"\\b","i").test(a)){var n=e.pid;o[t]=function(){var e=r.format.apply(r,arguments);console.error("%s %d: %s",t,n,e)}}else o[t]=function(){};return o[t]},r.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},r.isArray=p,r.isBoolean=d,r.isNull=g,r.isNullOrUndefined=function(t){return null==t},r.isNumber=m,r.isString=v,r.isSymbol=function(t){return"symbol"==typeof t},r.isUndefined=y,r.isRegExp=x,r.isObject=b,r.isDate=_,r.isError=w,r.isFunction=k,r.isPrimitive=function(t){return null===t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||"symbol"==typeof t||void 0===t},r.isBuffer=t("./support/isBuffer");var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function S(t,e){return Object.prototype.hasOwnProperty.call(t,e)}r.log=function(){var t,e;console.log("%s - %s",(t=new Date,e=[A(t.getHours()),A(t.getMinutes()),A(t.getSeconds())].join(":"),[t.getDate(),T[t.getMonth()],e].join(" ")),r.format.apply(r,arguments))},r.inherits=t("inherits"),r._extend=function(t,e){if(!e||!b(e))return t;for(var r=Object.keys(e),n=r.length;n--;)t[r[n]]=e[r[n]];return t}}).call(this,t("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":486,_process:424,inherits:485}],488:[function(t,e,r){"use strict";e.exports=function(t,e){"object"==typeof e&&null!==e||(e={});return n(t,e.canvas||i,e.context||a,e)};var n=t("./lib/vtext"),i=null,a=null;"undefined"!=typeof document&&((i=document.createElement("canvas")).width=8192,i.height=1024,a=i.getContext("2d"))},{"./lib/vtext":489}],489:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var a=n.size||64,o=n.font||"normal";return r.font=a+"px "+o,r.textAlign="start",r.textBaseline="alphabetic",r.direction="ltr",f(function(t,e,r,n){var a=0|Math.ceil(e.measureText(r).width+2*n);if(a>8192)throw new Error("vectorize-text: String too long (sorry, this will get fixed later)");var o=3*n;t.height=0?e[a]:i})},has___:{value:x(function(e){var n=y(e);return n?r in n:t.indexOf(e)>=0})},set___:{value:x(function(n,i){var a,o=y(n);return o?o[r]=i:(a=t.indexOf(n))>=0?e[a]=i:(a=t.length,e[a]=i,t[a]=n),this})},delete___:{value:x(function(n){var i,a,o=y(n);return o?r in o&&delete o[r]:!((i=t.indexOf(n))<0||(a=t.length-1,t[i]=void 0,e[i]=e[a],t[i]=t[a],t.length=a,e.length=a,0))})}})};g.prototype=Object.create(Object.prototype,{get:{value:function(t,e){return this.get___(t,e)},writable:!0,configurable:!0},has:{value:function(t){return this.has___(t)},writable:!0,configurable:!0},set:{value:function(t,e){return this.set___(t,e)},writable:!0,configurable:!0},delete:{value:function(t){return this.delete___(t)},writable:!0,configurable:!0}}),"function"==typeof r?function(){function n(){this instanceof g||b();var e,n=new r,i=void 0,a=!1;return e=t?function(t,e){return n.set(t,e),n.has(t)||(i||(i=new g),i.set(t,e)),this}:function(t,e){if(a)try{n.set(t,e)}catch(r){i||(i=new g),i.set___(t,e)}else n.set(t,e);return this},Object.create(g.prototype,{get___:{value:x(function(t,e){return i?n.has(t)?n.get(t):i.get___(t,e):n.get(t,e)})},has___:{value:x(function(t){return n.has(t)||!!i&&i.has___(t)})},set___:{value:x(e)},delete___:{value:x(function(t){var e=!!n.delete(t);return i&&i.delete___(t)||e})},permitHostObjects___:{value:x(function(t){if(t!==m)throw new Error("bogus call to permitHostObjects___");a=!0})}})}t&&"undefined"!=typeof Proxy&&(Proxy=void 0),n.prototype=g.prototype,e.exports=n,Object.defineProperty(WeakMap.prototype,"constructor",{value:WeakMap,enumerable:!1,configurable:!0,writable:!0})}():("undefined"!=typeof Proxy&&(Proxy=void 0),e.exports=g)}function m(t){t.permitHostObjects___&&t.permitHostObjects___(m)}function v(t){return!(t.substr(0,l.length)==l&&"___"===t.substr(t.length-3))}function y(t){if(t!==Object(t))throw new TypeError("Not an object: "+t);var e=t[c];if(e&&e.key===t)return e;if(s(t)){e={key:t};try{return o(t,c,{value:e,writable:!1,enumerable:!1,configurable:!1}),e}catch(t){return}}}function x(t){return t.prototype=null,Object.freeze(t)}function b(){p||"undefined"==typeof console||(p=!0,console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future."))}}()},{}],491:[function(t,e,r){var n=t("./hidden-store.js");e.exports=function(){var t={};return function(e){if(("object"!=typeof e||null===e)&&"function"!=typeof e)throw new Error("Weakmap-shim: Key must be object");var r=e.valueOf(t);return r&&r.identity===t?r:n(e,t)}}},{"./hidden-store.js":492}],492:[function(t,e,r){e.exports=function(t,e){var r={identity:e},n=t.valueOf;return Object.defineProperty(t,"valueOf",{value:function(t){return t!==e?n.apply(this,arguments):r},writable:!0}),r}},{}],493:[function(t,e,r){var n=t("./create-store.js");e.exports=function(){var t=n();return{get:function(e,r){var n=t(e);return n.hasOwnProperty("value")?n.value:r},set:function(e,r){return t(e).value=r,this},has:function(e){return"value"in t(e)},delete:function(e){return delete t(e).value}}}},{"./create-store.js":491}],494:[function(t,e,r){var n=t("get-canvas-context");e.exports=function(t){return n("webgl",t)}},{"get-canvas-context":202}],495:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Chinese",jdEpoch:1721425.5,hasYearZero:!1,minMonth:0,firstMonth:0,minDay:1,regionalOptions:{"":{name:"Chinese",epochs:["BEC","EC"],monthNumbers:function(t,e){if("string"==typeof t){var r=t.match(l);return r?r[0]:""}var n=this._validateYear(t),i=t.month(),a=""+this.toChineseMonth(n,i);return e&&a.length<2&&(a="0"+a),this.isIntercalaryMonth(n,i)&&(a+="i"),a},monthNames:function(t){if("string"==typeof t){var e=t.match(c);return e?e[0]:""}var r=this._validateYear(t),n=t.month(),i=["\u4e00\u6708","\u4e8c\u6708","\u4e09\u6708","\u56db\u6708","\u4e94\u6708","\u516d\u6708","\u4e03\u6708","\u516b\u6708","\u4e5d\u6708","\u5341\u6708","\u5341\u4e00\u6708","\u5341\u4e8c\u6708"][this.toChineseMonth(r,n)-1];return this.isIntercalaryMonth(r,n)&&(i="\u95f0"+i),i},monthNamesShort:function(t){if("string"==typeof t){var e=t.match(u);return e?e[0]:""}var r=this._validateYear(t),n=t.month(),i=["\u4e00","\u4e8c","\u4e09","\u56db","\u4e94","\u516d","\u4e03","\u516b","\u4e5d","\u5341","\u5341\u4e00","\u5341\u4e8c"][this.toChineseMonth(r,n)-1];return this.isIntercalaryMonth(r,n)&&(i="\u95f0"+i),i},parseMonth:function(t,e){t=this._validateYear(t);var r,n=parseInt(e);if(isNaN(n))"\u95f0"===e[0]&&(r=!0,e=e.substring(1)),"\u6708"===e[e.length-1]&&(e=e.substring(0,e.length-1)),n=1+["\u4e00","\u4e8c","\u4e09","\u56db","\u4e94","\u516d","\u4e03","\u516b","\u4e5d","\u5341","\u5341\u4e00","\u5341\u4e8c"].indexOf(e);else{var i=e[e.length-1];r="i"===i||"I"===i}return this.toMonthIndex(t,n,r)},dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:1,isRTL:!1}},_validateYear:function(t,e){if(t.year&&(t=t.year()),"number"!=typeof t||t<1888||t>2111)throw e.replace(/\{0\}/,this.local.name);return t},toMonthIndex:function(t,e,r){var i=this.intercalaryMonth(t);if(r&&e!==i||e<1||e>12)throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return i?!r&&e<=i?e-1:e:e-1},toChineseMonth:function(t,e){t.year&&(e=(t=t.year()).month());var r=this.intercalaryMonth(t);if(e<0||e>(r?12:11))throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return r?e>13},isIntercalaryMonth:function(t,e){t.year&&(e=(t=t.year()).month());var r=this.intercalaryMonth(t);return!!r&&r===e},leapYear:function(t){return 0!==this.intercalaryMonth(t)},weekOfYear:function(t,e,r){var i,o=this._validateYear(t,n.local.invalidyear),s=h[o-h[0]],l=s>>9&4095,c=s>>5&15,u=31&s;(i=a.newDate(l,c,u)).add(4-(i.dayOfWeek()||7),"d");var f=this.toJD(t,e,r)-i.toJD();return 1+Math.floor(f/7)},monthsInYear:function(t){return this.leapYear(t)?13:12},daysInMonth:function(t,e){t.year&&(e=t.month(),t=t.year()),t=this._validateYear(t);var r=f[t-f[0]];if(e>(r>>13?12:11))throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return r&1<<12-e?30:29},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,s,r,n.local.invalidDate);t=this._validateYear(i.year()),e=i.month(),r=i.day();var o=this.isIntercalaryMonth(t,e),s=this.toChineseMonth(t,e),l=function(t,e,r,n,i){var a,o,s;if("object"==typeof t)o=t,a=e||{};else{var l="number"==typeof t&&t>=1888&&t<=2111;if(!l)throw new Error("Lunar year outside range 1888-2111");var c="number"==typeof e&&e>=1&&e<=12;if(!c)throw new Error("Lunar month outside range 1 - 12");var u,p="number"==typeof r&&r>=1&&r<=30;if(!p)throw new Error("Lunar day outside range 1 - 30");"object"==typeof n?(u=!1,a=n):(u=!!n,a=i||{}),o={year:t,month:e,day:r,isIntercalary:u}}s=o.day-1;var d,g=f[o.year-f[0]],m=g>>13;d=m?o.month>m?o.month:o.isIntercalary?o.month:o.month-1:o.month-1;for(var v=0;v>9&4095,(x>>5&15)-1,(31&x)+s);return a.year=b.getFullYear(),a.month=1+b.getMonth(),a.day=b.getDate(),a}(t,s,r,o);return a.toJD(l.year,l.month,l.day)},fromJD:function(t){var e=a.fromJD(t),r=function(t,e,r,n){var i,a;if("object"==typeof t)i=t,a=e||{};else{var o="number"==typeof t&&t>=1888&&t<=2111;if(!o)throw new Error("Solar year outside range 1888-2111");var s="number"==typeof e&&e>=1&&e<=12;if(!s)throw new Error("Solar month outside range 1 - 12");var l="number"==typeof r&&r>=1&&r<=31;if(!l)throw new Error("Solar day outside range 1 - 31");i={year:t,month:e,day:r},a=n||{}}var c=h[i.year-h[0]],u=i.year<<9|i.month<<5|i.day;a.year=u>=c?i.year:i.year-1,c=h[a.year-h[0]];var p,d=new Date(c>>9&4095,(c>>5&15)-1,31&c),g=new Date(i.year,i.month-1,i.day);p=Math.round((g-d)/864e5);var m,v=f[a.year-f[0]];for(m=0;m<13;m++){var y=v&1<<12-m?30:29;if(p>13;!x||m=2&&n<=6},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return{century:o[Math.floor((i.year()-1)/100)+1]||""}},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year()+(i.year()<0?1:0),e=i.month(),(r=i.day())+(e>1?16:0)+(e>2?32*(e-2):0)+400*(t-1)+this.jdEpoch-1},fromJD:function(t){t=Math.floor(t+.5)-Math.floor(this.jdEpoch)-1;var e=Math.floor(t/400)+1;t-=400*(e-1),t+=t>15?16:0;var r=Math.floor(t/32)+1,n=t-32*(r-1)+1;return this.newDate(e<=0?e-1:e,r,n)}});var o={20:"Fruitbat",21:"Anchovy"};n.calendars.discworld=a},{"../main":509,"object-assign":397}],498:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Ethiopian",jdEpoch:1724220.5,daysPerMonth:[30,30,30,30,30,30,30,30,30,30,30,30,5],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Ethiopian",epochs:["BEE","EE"],monthNames:["Meskerem","Tikemet","Hidar","Tahesas","Tir","Yekatit","Megabit","Miazia","Genbot","Sene","Hamle","Nehase","Pagume"],monthNamesShort:["Mes","Tik","Hid","Tah","Tir","Yek","Meg","Mia","Gen","Sen","Ham","Neh","Pag"],dayNames:["Ehud","Segno","Maksegno","Irob","Hamus","Arb","Kidame"],dayNamesShort:["Ehu","Seg","Mak","Iro","Ham","Arb","Kid"],dayNamesMin:["Eh","Se","Ma","Ir","Ha","Ar","Ki"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return(t=e.year()+(e.year()<0?1:0))%4==3||t%4==-1},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear||n.regionalOptions[""].invalidYear),13},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(13===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return(t=i.year())<0&&t++,i.day()+30*(i.month()-1)+365*(t-1)+Math.floor(t/4)+this.jdEpoch-1},fromJD:function(t){var e=Math.floor(t)+.5-this.jdEpoch,r=Math.floor((e-Math.floor((e+366)/1461))/365)+1;r<=0&&r--,e=Math.floor(t)+.5-this.newDate(r,1,1).toJD();var n=Math.floor(e/30)+1,i=e-30*(n-1)+1;return this.newDate(r,n,i)}}),n.calendars.ethiopian=a},{"../main":509,"object-assign":397}],499:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}function o(t,e){return t-e*Math.floor(t/e)}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Hebrew",jdEpoch:347995.5,daysPerMonth:[30,29,30,29,30,29,30,29,30,29,30,29,29],hasYearZero:!1,minMonth:1,firstMonth:7,minDay:1,regionalOptions:{"":{name:"Hebrew",epochs:["BAM","AM"],monthNames:["Nisan","Iyar","Sivan","Tammuz","Av","Elul","Tishrei","Cheshvan","Kislev","Tevet","Shevat","Adar","Adar II"],monthNamesShort:["Nis","Iya","Siv","Tam","Av","Elu","Tis","Che","Kis","Tev","She","Ada","Ad2"],dayNames:["Yom Rishon","Yom Sheni","Yom Shlishi","Yom Revi'i","Yom Chamishi","Yom Shishi","Yom Shabbat"],dayNamesShort:["Ris","She","Shl","Rev","Cha","Shi","Sha"],dayNamesMin:["Ri","She","Shl","Re","Ch","Shi","Sha"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return this._leapYear(e.year())},_leapYear:function(t){return o(7*(t=t<0?t+1:t)+1,19)<7},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),this._leapYear(t.year?t.year():t)?13:12},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){return t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year(),this.toJD(-1===t?1:t+1,7,1)-this.toJD(t,7,1)},daysInMonth:function(t,e){return t.year&&(e=t.month(),t=t.year()),this._validate(t,e,this.minDay,n.local.invalidMonth),12===e&&this.leapYear(t)?30:8===e&&5===o(this.daysInYear(t),10)?30:9===e&&3===o(this.daysInYear(t),10)?29:this.daysPerMonth[e-1]},weekDay:function(t,e,r){return 6!==this.dayOfWeek(t,e,r)},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return{yearType:(this.leapYear(i)?"embolismic":"common")+" "+["deficient","regular","complete"][this.daysInYear(i)%10-3]}},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=t<=0?t+1:t,o=this.jdEpoch+this._delay1(a)+this._delay2(a)+r+1;if(e<7){for(var s=7;s<=this.monthsInYear(t);s++)o+=this.daysInMonth(t,s);for(s=1;s=this.toJD(-1===e?1:e+1,7,1);)e++;for(var r=tthis.toJD(e,r,this.daysInMonth(e,r));)r++;var n=t-this.toJD(e,r,1)+1;return this.newDate(e,r,n)}}),n.calendars.hebrew=a},{"../main":509,"object-assign":397}],500:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Islamic",jdEpoch:1948439.5,daysPerMonth:[30,29,30,29,30,29,30,29,30,29,30,29],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Islamic",epochs:["BH","AH"],monthNames:["Muharram","Safar","Rabi' al-awwal","Rabi' al-thani","Jumada al-awwal","Jumada al-thani","Rajab","Sha'aban","Ramadan","Shawwal","Dhu al-Qi'dah","Dhu al-Hijjah"],monthNamesShort:["Muh","Saf","Rab1","Rab2","Jum1","Jum2","Raj","Sha'","Ram","Shaw","DhuQ","DhuH"],dayNames:["Yawm al-ahad","Yawm al-ithnayn","Yawm ath-thulaathaa'","Yawm al-arbi'aa'","Yawm al-kham\u012bs","Yawm al-jum'a","Yawm as-sabt"],dayNamesShort:["Aha","Ith","Thu","Arb","Kha","Jum","Sab"],dayNamesMin:["Ah","It","Th","Ar","Kh","Ju","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:6,isRTL:!1}},leapYear:function(t){return(11*this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year()+14)%30<11},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){return this.leapYear(t)?355:354},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year(),e=i.month(),r=i.day(),t=t<=0?t+1:t,r+Math.ceil(29.5*(e-1))+354*(t-1)+Math.floor((3+11*t)/30)+this.jdEpoch-1},fromJD:function(t){t=Math.floor(t)+.5;var e=Math.floor((30*(t-this.jdEpoch)+10646)/10631);e=e<=0?e-1:e;var r=Math.min(12,Math.ceil((t-29-this.toJD(e,1,1))/29.5)+1),n=t-this.toJD(e,r,1)+1;return this.newDate(e,r,n)}}),n.calendars.islamic=a},{"../main":509,"object-assign":397}],501:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Julian",jdEpoch:1721423.5,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Julian",epochs:["BC","AD"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"mm/dd/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return(t=e.year()<0?e.year()+1:e.year())%4==0},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(4-(n.dayOfWeek()||7),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year(),e=i.month(),r=i.day(),t<0&&t++,e<=2&&(t--,e+=12),Math.floor(365.25*(t+4716))+Math.floor(30.6001*(e+1))+r-1524.5},fromJD:function(t){var e=Math.floor(t+.5)+1524,r=Math.floor((e-122.1)/365.25),n=Math.floor(365.25*r),i=Math.floor((e-n)/30.6001),a=i-Math.floor(i<14?1:13),o=r-Math.floor(a>2?4716:4715),s=e-n-Math.floor(30.6001*i);return o<=0&&o--,this.newDate(o,a,s)}}),n.calendars.julian=a},{"../main":509,"object-assign":397}],502:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}function o(t,e){return t-e*Math.floor(t/e)}function s(t,e){return o(t-1,e)+1}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Mayan",jdEpoch:584282.5,hasYearZero:!0,minMonth:0,firstMonth:0,minDay:0,regionalOptions:{"":{name:"Mayan",epochs:["",""],monthNames:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17"],monthNamesShort:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17"],dayNames:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],dayNamesShort:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],dayNamesMin:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],digits:null,dateFormat:"YYYY.m.d",firstDay:0,isRTL:!1,haabMonths:["Pop","Uo","Zip","Zotz","Tzec","Xul","Yaxkin","Mol","Chen","Yax","Zac","Ceh","Mac","Kankin","Muan","Pax","Kayab","Cumku","Uayeb"],tzolkinMonths:["Imix","Ik","Akbal","Kan","Chicchan","Cimi","Manik","Lamat","Muluc","Oc","Chuen","Eb","Ben","Ix","Men","Cib","Caban","Etznab","Cauac","Ahau"]}},leapYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),!1},formatYear:function(t){t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year();var e=Math.floor(t/400);return t%=400,t+=t<0?400:0,e+"."+Math.floor(t/20)+"."+t%20},forYear:function(t){if((t=t.split(".")).length<3)throw"Invalid Mayan year";for(var e=0,r=0;r19||r>0&&n<0)throw"Invalid Mayan year";e=20*e+n}return e},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),18},weekOfYear:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate),0},daysInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),360},daysInMonth:function(t,e){return this._validate(t,e,this.minDay,n.local.invalidMonth),20},daysInWeek:function(){return 5},dayOfWeek:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate).day()},weekDay:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate),!0},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate).toJD(),a=this._toHaab(i),o=this._toTzolkin(i);return{haabMonthName:this.local.haabMonths[a[0]-1],haabMonth:a[0],haabDay:a[1],tzolkinDayName:this.local.tzolkinMonths[o[0]-1],tzolkinDay:o[0],tzolkinTrecena:o[1]}},_toHaab:function(t){var e=o((t-=this.jdEpoch)+8+340,365);return[Math.floor(e/20)+1,o(e,20)]},_toTzolkin:function(t){return[s((t-=this.jdEpoch)+20,20),s(t+4,13)]},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return i.day()+20*i.month()+360*i.year()+this.jdEpoch},fromJD:function(t){t=Math.floor(t)+.5-this.jdEpoch;var e=Math.floor(t/360);t%=360,t+=t<0?360:0;var r=Math.floor(t/20),n=t%20;return this.newDate(e,r,n)}}),n.calendars.mayan=a},{"../main":509,"object-assign":397}],503:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar;var o=n.instance("gregorian");i(a.prototype,{name:"Nanakshahi",jdEpoch:2257673.5,daysPerMonth:[31,31,31,31,31,30,30,30,30,30,30,30],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Nanakshahi",epochs:["BN","AN"],monthNames:["Chet","Vaisakh","Jeth","Harh","Sawan","Bhadon","Assu","Katak","Maghar","Poh","Magh","Phagun"],monthNamesShort:["Che","Vai","Jet","Har","Saw","Bha","Ass","Kat","Mgr","Poh","Mgh","Pha"],dayNames:["Somvaar","Mangalvar","Budhvaar","Veervaar","Shukarvaar","Sanicharvaar","Etvaar"],dayNamesShort:["Som","Mangal","Budh","Veer","Shukar","Sanichar","Et"],dayNamesMin:["So","Ma","Bu","Ve","Sh","Sa","Et"],digits:null,dateFormat:"dd-mm-yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear||n.regionalOptions[""].invalidYear);return o.leapYear(e.year()+(e.year()<1?1:0)+1469)},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(1-(n.dayOfWeek()||7),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidMonth);(t=i.year())<0&&t++;for(var a=i.day(),s=1;s=this.toJD(e+1,1,1);)e++;for(var r=t-Math.floor(this.toJD(e,1,1)+.5)+1,n=1;r>this.daysInMonth(e,n);)r-=this.daysInMonth(e,n),n++;return this.newDate(e,n,r)}}),n.calendars.nanakshahi=a},{"../main":509,"object-assign":397}],504:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Nepali",jdEpoch:1700709.5,daysPerMonth:[31,31,32,32,31,30,30,29,30,29,30,30],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,daysPerYear:365,regionalOptions:{"":{name:"Nepali",epochs:["BBS","ABS"],monthNames:["Baisakh","Jestha","Ashadh","Shrawan","Bhadra","Ashwin","Kartik","Mangsir","Paush","Mangh","Falgun","Chaitra"],monthNamesShort:["Bai","Je","As","Shra","Bha","Ash","Kar","Mang","Pau","Ma","Fal","Chai"],dayNames:["Aaitabaar","Sombaar","Manglbaar","Budhabaar","Bihibaar","Shukrabaar","Shanibaar"],dayNamesShort:["Aaita","Som","Mangl","Budha","Bihi","Shukra","Shani"],dayNamesMin:["Aai","So","Man","Bu","Bi","Shu","Sha"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:1,isRTL:!1}},leapYear:function(t){return this.daysInYear(t)!==this.daysPerYear},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){if(t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year(),void 0===this.NEPALI_CALENDAR_DATA[t])return this.daysPerYear;for(var e=0,r=this.minMonth;r<=12;r++)e+=this.NEPALI_CALENDAR_DATA[t][r];return e},daysInMonth:function(t,e){return t.year&&(e=t.month(),t=t.year()),this._validate(t,e,this.minDay,n.local.invalidMonth),void 0===this.NEPALI_CALENDAR_DATA[t]?this.daysPerMonth[e-1]:this.NEPALI_CALENDAR_DATA[t][e]},weekDay:function(t,e,r){return 6!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=n.instance(),o=0,s=e,l=t;this._createMissingCalendarData(t);var c=t-(s>9||9===s&&r>=this.NEPALI_CALENDAR_DATA[l][0]?56:57);for(9!==e&&(o=r,s--);9!==s;)s<=0&&(s=12,l--),o+=this.NEPALI_CALENDAR_DATA[l][s],s--;return 9===e?(o+=r-this.NEPALI_CALENDAR_DATA[l][0])<0&&(o+=a.daysInYear(c)):o+=this.NEPALI_CALENDAR_DATA[l][9]-this.NEPALI_CALENDAR_DATA[l][0],a.newDate(c,1,1).add(o,"d").toJD()},fromJD:function(t){var e=n.instance().fromJD(t),r=e.year(),i=e.dayOfYear(),a=r+56;this._createMissingCalendarData(a);for(var o=9,s=this.NEPALI_CALENDAR_DATA[a][0],l=this.NEPALI_CALENDAR_DATA[a][o]-s+1;i>l;)++o>12&&(o=1,a++),l+=this.NEPALI_CALENDAR_DATA[a][o];var c=this.NEPALI_CALENDAR_DATA[a][o]-(l-i);return this.newDate(a,o,c)},_createMissingCalendarData:function(t){var e=this.daysPerMonth.slice(0);e.unshift(17);for(var r=t-1;r0?474:473))%2820+474+38)%2816<682},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-(n.dayOfWeek()+1)%7,"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=t-(t>=0?474:473),s=474+o(a,2820);return r+(e<=7?31*(e-1):30*(e-1)+6)+Math.floor((682*s-110)/2816)+365*(s-1)+1029983*Math.floor(a/2820)+this.jdEpoch-1},fromJD:function(t){var e=(t=Math.floor(t)+.5)-this.toJD(475,1,1),r=Math.floor(e/1029983),n=o(e,1029983),i=2820;if(1029982!==n){var a=Math.floor(n/366),s=o(n,366);i=Math.floor((2134*a+2816*s+2815)/1028522)+a+1}var l=i+2820*r+474;l=l<=0?l-1:l;var c=t-this.toJD(l,1,1)+1,u=c<=186?Math.ceil(c/31):Math.ceil((c-6)/30),f=t-this.toJD(l,u,1)+1;return this.newDate(l,u,f)}}),n.calendars.persian=a,n.calendars.jalali=a},{"../main":509,"object-assign":397}],506:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Taiwan",jdEpoch:2419402.5,yearsOffset:1911,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Taiwan",epochs:["BROC","ROC"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:1,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(e.year());return a.leapYear(t)},weekOfYear:function(t,e,r){var i=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(i.year());return a.weekOfYear(t,i.month(),i.day())},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=this._t2gYear(i.year());return a.toJD(t,i.month(),i.day())},fromJD:function(t){var e=a.fromJD(t),r=this._g2tYear(e.year());return this.newDate(r,e.month(),e.day())},_t2gYear:function(t){return t+this.yearsOffset+(t>=-this.yearsOffset&&t<=-1?1:0)},_g2tYear:function(t){return t-this.yearsOffset-(t>=1&&t<=this.yearsOffset?1:0)}}),n.calendars.taiwan=o},{"../main":509,"object-assign":397}],507:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Thai",jdEpoch:1523098.5,yearsOffset:543,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Thai",epochs:["BBE","BE"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(e.year());return a.leapYear(t)},weekOfYear:function(t,e,r){var i=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(i.year());return a.weekOfYear(t,i.month(),i.day())},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=this._t2gYear(i.year());return a.toJD(t,i.month(),i.day())},fromJD:function(t){var e=a.fromJD(t),r=this._g2tYear(e.year());return this.newDate(r,e.month(),e.day())},_t2gYear:function(t){return t-this.yearsOffset-(t>=1&&t<=this.yearsOffset?1:0)},_g2tYear:function(t){return t+this.yearsOffset+(t>=-this.yearsOffset&&t<=-1?1:0)}}),n.calendars.thai=o},{"../main":509,"object-assign":397}],508:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"UmmAlQura",hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Umm al-Qura",epochs:["BH","AH"],monthNames:["Al-Muharram","Safar","Rabi' al-awwal","Rabi' Al-Thani","Jumada Al-Awwal","Jumada Al-Thani","Rajab","Sha'aban","Ramadan","Shawwal","Dhu al-Qi'dah","Dhu al-Hijjah"],monthNamesShort:["Muh","Saf","Rab1","Rab2","Jum1","Jum2","Raj","Sha'","Ram","Shaw","DhuQ","DhuH"],dayNames:["Yawm al-Ahad","Yawm al-Ithnain","Yawm al-Thal\u0101th\u0101\u2019","Yawm al-Arba\u2018\u0101\u2019","Yawm al-Kham\u012bs","Yawm al-Jum\u2018a","Yawm al-Sabt"],dayNamesMin:["Ah","Ith","Th","Ar","Kh","Ju","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:6,isRTL:!0}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return 355===this.daysInYear(e.year())},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){for(var e=0,r=1;r<=12;r++)e+=this.daysInMonth(t,r);return e},daysInMonth:function(t,e){for(var r=this._validate(t,e,this.minDay,n.local.invalidMonth).toJD()-24e5+.5,i=0,a=0;ar)return o[i]-o[i-1];i++}return 30},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate),a=12*(i.year()-1)+i.month()-15292;return i.day()+o[a-1]-1+24e5-.5},fromJD:function(t){for(var e=t-24e5+.5,r=0,n=0;ne);n++)r++;var i=r+15292,a=Math.floor((i-1)/12),s=a+1,l=i-12*a,c=e-o[r-1]+1;return this.newDate(s,l,c)},isValid:function(t,e,r){var i=n.baseCalendar.prototype.isValid.apply(this,arguments);return i&&(i=(t=null!=t.year?t.year:t)>=1276&&t<=1500),i},_validate:function(t,e,r,i){var a=n.baseCalendar.prototype._validate.apply(this,arguments);if(a.year<1276||a.year>1500)throw i.replace(/\{0\}/,this.local.name);return a}}),n.calendars.ummalqura=a;var o=[20,50,79,109,138,168,197,227,256,286,315,345,374,404,433,463,492,522,551,581,611,641,670,700,729,759,788,818,847,877,906,936,965,995,1024,1054,1083,1113,1142,1172,1201,1231,1260,1290,1320,1350,1379,1409,1438,1468,1497,1527,1556,1586,1615,1645,1674,1704,1733,1763,1792,1822,1851,1881,1910,1940,1969,1999,2028,2058,2087,2117,2146,2176,2205,2235,2264,2294,2323,2353,2383,2413,2442,2472,2501,2531,2560,2590,2619,2649,2678,2708,2737,2767,2796,2826,2855,2885,2914,2944,2973,3003,3032,3062,3091,3121,3150,3180,3209,3239,3268,3298,3327,3357,3386,3416,3446,3476,3505,3535,3564,3594,3623,3653,3682,3712,3741,3771,3800,3830,3859,3889,3918,3948,3977,4007,4036,4066,4095,4125,4155,4185,4214,4244,4273,4303,4332,4362,4391,4421,4450,4480,4509,4539,4568,4598,4627,4657,4686,4716,4745,4775,4804,4834,4863,4893,4922,4952,4981,5011,5040,5070,5099,5129,5158,5188,5218,5248,5277,5307,5336,5366,5395,5425,5454,5484,5513,5543,5572,5602,5631,5661,5690,5720,5749,5779,5808,5838,5867,5897,5926,5956,5985,6015,6044,6074,6103,6133,6162,6192,6221,6251,6281,6311,6340,6370,6399,6429,6458,6488,6517,6547,6576,6606,6635,6665,6694,6724,6753,6783,6812,6842,6871,6901,6930,6960,6989,7019,7048,7078,7107,7137,7166,7196,7225,7255,7284,7314,7344,7374,7403,7433,7462,7492,7521,7551,7580,7610,7639,7669,7698,7728,7757,7787,7816,7846,7875,7905,7934,7964,7993,8023,8053,8083,8112,8142,8171,8201,8230,8260,8289,8319,8348,8378,8407,8437,8466,8496,8525,8555,8584,8614,8643,8673,8702,8732,8761,8791,8821,8850,8880,8909,8938,8968,8997,9027,9056,9086,9115,9145,9175,9205,9234,9264,9293,9322,9352,9381,9410,9440,9470,9499,9529,9559,9589,9618,9648,9677,9706,9736,9765,9794,9824,9853,9883,9913,9943,9972,10002,10032,10061,10090,10120,10149,10178,10208,10237,10267,10297,10326,10356,10386,10415,10445,10474,10504,10533,10562,10592,10621,10651,10680,10710,10740,10770,10799,10829,10858,10888,10917,10947,10976,11005,11035,11064,11094,11124,11153,11183,11213,11242,11272,11301,11331,11360,11389,11419,11448,11478,11507,11537,11567,11596,11626,11655,11685,11715,11744,11774,11803,11832,11862,11891,11921,11950,11980,12010,12039,12069,12099,12128,12158,12187,12216,12246,12275,12304,12334,12364,12393,12423,12453,12483,12512,12542,12571,12600,12630,12659,12688,12718,12747,12777,12807,12837,12866,12896,12926,12955,12984,13014,13043,13072,13102,13131,13161,13191,13220,13250,13280,13310,13339,13368,13398,13427,13456,13486,13515,13545,13574,13604,13634,13664,13693,13723,13752,13782,13811,13840,13870,13899,13929,13958,13988,14018,14047,14077,14107,14136,14166,14195,14224,14254,14283,14313,14342,14372,14401,14431,14461,14490,14520,14550,14579,14609,14638,14667,14697,14726,14756,14785,14815,14844,14874,14904,14933,14963,14993,15021,15051,15081,15110,15140,15169,15199,15228,15258,15287,15317,15347,15377,15406,15436,15465,15494,15524,15553,15582,15612,15641,15671,15701,15731,15760,15790,15820,15849,15878,15908,15937,15966,15996,16025,16055,16085,16114,16144,16174,16204,16233,16262,16292,16321,16350,16380,16409,16439,16468,16498,16528,16558,16587,16617,16646,16676,16705,16734,16764,16793,16823,16852,16882,16912,16941,16971,17001,17030,17060,17089,17118,17148,17177,17207,17236,17266,17295,17325,17355,17384,17414,17444,17473,17502,17532,17561,17591,17620,17650,17679,17709,17738,17768,17798,17827,17857,17886,17916,17945,17975,18004,18034,18063,18093,18122,18152,18181,18211,18241,18270,18300,18330,18359,18388,18418,18447,18476,18506,18535,18565,18595,18625,18654,18684,18714,18743,18772,18802,18831,18860,18890,18919,18949,18979,19008,19038,19068,19098,19127,19156,19186,19215,19244,19274,19303,19333,19362,19392,19422,19452,19481,19511,19540,19570,19599,19628,19658,19687,19717,19746,19776,19806,19836,19865,19895,19924,19954,19983,20012,20042,20071,20101,20130,20160,20190,20219,20249,20279,20308,20338,20367,20396,20426,20455,20485,20514,20544,20573,20603,20633,20662,20692,20721,20751,20780,20810,20839,20869,20898,20928,20957,20987,21016,21046,21076,21105,21135,21164,21194,21223,21253,21282,21312,21341,21371,21400,21430,21459,21489,21519,21548,21578,21607,21637,21666,21696,21725,21754,21784,21813,21843,21873,21902,21932,21962,21991,22021,22050,22080,22109,22138,22168,22197,22227,22256,22286,22316,22346,22375,22405,22434,22464,22493,22522,22552,22581,22611,22640,22670,22700,22730,22759,22789,22818,22848,22877,22906,22936,22965,22994,23024,23054,23083,23113,23143,23173,23202,23232,23261,23290,23320,23349,23379,23408,23438,23467,23497,23527,23556,23586,23616,23645,23674,23704,23733,23763,23792,23822,23851,23881,23910,23940,23970,23999,24029,24058,24088,24117,24147,24176,24206,24235,24265,24294,24324,24353,24383,24413,24442,24472,24501,24531,24560,24590,24619,24648,24678,24707,24737,24767,24796,24826,24856,24885,24915,24944,24974,25003,25032,25062,25091,25121,25150,25180,25210,25240,25269,25299,25328,25358,25387,25416,25446,25475,25505,25534,25564,25594,25624,25653,25683,25712,25742,25771,25800,25830,25859,25888,25918,25948,25977,26007,26037,26067,26096,26126,26155,26184,26214,26243,26272,26302,26332,26361,26391,26421,26451,26480,26510,26539,26568,26598,26627,26656,26686,26715,26745,26775,26805,26834,26864,26893,26923,26952,26982,27011,27041,27070,27099,27129,27159,27188,27218,27248,27277,27307,27336,27366,27395,27425,27454,27484,27513,27542,27572,27602,27631,27661,27691,27720,27750,27779,27809,27838,27868,27897,27926,27956,27985,28015,28045,28074,28104,28134,28163,28193,28222,28252,28281,28310,28340,28369,28399,28428,28458,28488,28517,28547,28577,28607,28636,28665,28695,28724,28754,28783,28813,28843,28872,28901,28931,28960,28990,29019,29049,29078,29108,29137,29167,29196,29226,29255,29285,29315,29345,29375,29404,29434,29463,29492,29522,29551,29580,29610,29640,29669,29699,29729,29759,29788,29818,29847,29876,29906,29935,29964,29994,30023,30053,30082,30112,30141,30171,30200,30230,30259,30289,30318,30348,30378,30408,30437,30467,30496,30526,30555,30585,30614,30644,30673,30703,30732,30762,30791,30821,30850,30880,30909,30939,30968,30998,31027,31057,31086,31116,31145,31175,31204,31234,31263,31293,31322,31352,31381,31411,31441,31471,31500,31530,31559,31589,31618,31648,31676,31706,31736,31766,31795,31825,31854,31884,31913,31943,31972,32002,32031,32061,32090,32120,32150,32180,32209,32239,32268,32298,32327,32357,32386,32416,32445,32475,32504,32534,32563,32593,32622,32652,32681,32711,32740,32770,32799,32829,32858,32888,32917,32947,32976,33006,33035,33065,33094,33124,33153,33183,33213,33243,33272,33302,33331,33361,33390,33420,33450,33479,33509,33539,33568,33598,33627,33657,33686,33716,33745,33775,33804,33834,33863,33893,33922,33952,33981,34011,34040,34069,34099,34128,34158,34187,34217,34247,34277,34306,34336,34365,34395,34424,34454,34483,34512,34542,34571,34601,34631,34660,34690,34719,34749,34778,34808,34837,34867,34896,34926,34955,34985,35015,35044,35074,35103,35133,35162,35192,35222,35251,35280,35310,35340,35370,35399,35429,35458,35488,35517,35547,35576,35605,35635,35665,35694,35723,35753,35782,35811,35841,35871,35901,35930,35960,35989,36019,36048,36078,36107,36136,36166,36195,36225,36254,36284,36314,36343,36373,36403,36433,36462,36492,36521,36551,36580,36610,36639,36669,36698,36728,36757,36786,36816,36845,36875,36904,36934,36963,36993,37022,37052,37081,37111,37141,37170,37200,37229,37259,37288,37318,37347,37377,37406,37436,37465,37495,37524,37554,37584,37613,37643,37672,37701,37731,37760,37790,37819,37849,37878,37908,37938,37967,37997,38027,38056,38085,38115,38144,38174,38203,38233,38262,38292,38322,38351,38381,38410,38440,38469,38499,38528,38558,38587,38617,38646,38676,38705,38735,38764,38794,38823,38853,38882,38912,38941,38971,39001,39030,39059,39089,39118,39148,39178,39208,39237,39267,39297,39326,39355,39385,39414,39444,39473,39503,39532,39562,39592,39621,39650,39680,39709,39739,39768,39798,39827,39857,39886,39916,39946,39975,40005,40035,40064,40094,40123,40153,40182,40212,40241,40271,40300,40330,40359,40389,40418,40448,40477,40507,40536,40566,40595,40625,40655,40685,40714,40744,40773,40803,40832,40862,40892,40921,40951,40980,41009,41039,41068,41098,41127,41157,41186,41216,41245,41275,41304,41334,41364,41393,41422,41452,41481,41511,41540,41570,41599,41629,41658,41688,41718,41748,41777,41807,41836,41865,41894,41924,41953,41983,42012,42042,42072,42102,42131,42161,42190,42220,42249,42279,42308,42337,42367,42397,42426,42456,42485,42515,42545,42574,42604,42633,42662,42692,42721,42751,42780,42810,42839,42869,42899,42929,42958,42988,43017,43046,43076,43105,43135,43164,43194,43223,43253,43283,43312,43342,43371,43401,43430,43460,43489,43519,43548,43578,43607,43637,43666,43696,43726,43755,43785,43814,43844,43873,43903,43932,43962,43991,44021,44050,44080,44109,44139,44169,44198,44228,44258,44287,44317,44346,44375,44405,44434,44464,44493,44523,44553,44582,44612,44641,44671,44700,44730,44759,44788,44818,44847,44877,44906,44936,44966,44996,45025,45055,45084,45114,45143,45172,45202,45231,45261,45290,45320,45350,45380,45409,45439,45468,45498,45527,45556,45586,45615,45644,45674,45704,45733,45763,45793,45823,45852,45882,45911,45940,45970,45999,46028,46058,46088,46117,46147,46177,46206,46236,46265,46295,46324,46354,46383,46413,46442,46472,46501,46531,46560,46590,46620,46649,46679,46708,46738,46767,46797,46826,46856,46885,46915,46944,46974,47003,47033,47063,47092,47122,47151,47181,47210,47240,47269,47298,47328,47357,47387,47417,47446,47476,47506,47535,47565,47594,47624,47653,47682,47712,47741,47771,47800,47830,47860,47890,47919,47949,47978,48008,48037,48066,48096,48125,48155,48184,48214,48244,48273,48303,48333,48362,48392,48421,48450,48480,48509,48538,48568,48598,48627,48657,48687,48717,48746,48776,48805,48834,48864,48893,48922,48952,48982,49011,49041,49071,49100,49130,49160,49189,49218,49248,49277,49306,49336,49365,49395,49425,49455,49484,49514,49543,49573,49602,49632,49661,49690,49720,49749,49779,49809,49838,49868,49898,49927,49957,49986,50016,50045,50075,50104,50133,50163,50192,50222,50252,50281,50311,50340,50370,50400,50429,50459,50488,50518,50547,50576,50606,50635,50665,50694,50724,50754,50784,50813,50843,50872,50902,50931,50960,50990,51019,51049,51078,51108,51138,51167,51197,51227,51256,51286,51315,51345,51374,51403,51433,51462,51492,51522,51552,51582,51611,51641,51670,51699,51729,51758,51787,51816,51846,51876,51906,51936,51965,51995,52025,52054,52083,52113,52142,52171,52200,52230,52260,52290,52319,52349,52379,52408,52438,52467,52497,52526,52555,52585,52614,52644,52673,52703,52733,52762,52792,52822,52851,52881,52910,52939,52969,52998,53028,53057,53087,53116,53146,53176,53205,53235,53264,53294,53324,53353,53383,53412,53441,53471,53500,53530,53559,53589,53619,53648,53678,53708,53737,53767,53796,53825,53855,53884,53913,53943,53973,54003,54032,54062,54092,54121,54151,54180,54209,54239,54268,54297,54327,54357,54387,54416,54446,54476,54505,54535,54564,54593,54623,54652,54681,54711,54741,54770,54800,54830,54859,54889,54919,54948,54977,55007,55036,55066,55095,55125,55154,55184,55213,55243,55273,55302,55332,55361,55391,55420,55450,55479,55508,55538,55567,55597,55627,55657,55686,55716,55745,55775,55804,55834,55863,55892,55922,55951,55981,56011,56040,56070,56100,56129,56159,56188,56218,56247,56276,56306,56335,56365,56394,56424,56454,56483,56513,56543,56572,56601,56631,56660,56690,56719,56749,56778,56808,56837,56867,56897,56926,56956,56985,57015,57044,57074,57103,57133,57162,57192,57221,57251,57280,57310,57340,57369,57399,57429,57458,57487,57517,57546,57576,57605,57634,57664,57694,57723,57753,57783,57813,57842,57871,57901,57930,57959,57989,58018,58048,58077,58107,58137,58167,58196,58226,58255,58285,58314,58343,58373,58402,58432,58461,58491,58521,58551,58580,58610,58639,58669,58698,58727,58757,58786,58816,58845,58875,58905,58934,58964,58994,59023,59053,59082,59111,59141,59170,59200,59229,59259,59288,59318,59348,59377,59407,59436,59466,59495,59525,59554,59584,59613,59643,59672,59702,59731,59761,59791,59820,59850,59879,59909,59939,59968,59997,60027,60056,60086,60115,60145,60174,60204,60234,60264,60293,60323,60352,60381,60411,60440,60469,60499,60528,60558,60588,60618,60648,60677,60707,60736,60765,60795,60824,60853,60883,60912,60942,60972,61002,61031,61061,61090,61120,61149,61179,61208,61237,61267,61296,61326,61356,61385,61415,61445,61474,61504,61533,61563,61592,61621,61651,61680,61710,61739,61769,61799,61828,61858,61888,61917,61947,61976,62006,62035,62064,62094,62123,62153,62182,62212,62242,62271,62301,62331,62360,62390,62419,62448,62478,62507,62537,62566,62596,62625,62655,62685,62715,62744,62774,62803,62832,62862,62891,62921,62950,62980,63009,63039,63069,63099,63128,63157,63187,63216,63246,63275,63305,63334,63363,63393,63423,63453,63482,63512,63541,63571,63600,63630,63659,63689,63718,63747,63777,63807,63836,63866,63895,63925,63955,63984,64014,64043,64073,64102,64131,64161,64190,64220,64249,64279,64309,64339,64368,64398,64427,64457,64486,64515,64545,64574,64603,64633,64663,64692,64722,64752,64782,64811,64841,64870,64899,64929,64958,64987,65017,65047,65076,65106,65136,65166,65195,65225,65254,65283,65313,65342,65371,65401,65431,65460,65490,65520,65549,65579,65608,65638,65667,65697,65726,65755,65785,65815,65844,65874,65903,65933,65963,65992,66022,66051,66081,66110,66140,66169,66199,66228,66258,66287,66317,66346,66376,66405,66435,66465,66494,66524,66553,66583,66612,66641,66671,66700,66730,66760,66789,66819,66849,66878,66908,66937,66967,66996,67025,67055,67084,67114,67143,67173,67203,67233,67262,67292,67321,67351,67380,67409,67439,67468,67497,67527,67557,67587,67617,67646,67676,67705,67735,67764,67793,67823,67852,67882,67911,67941,67971,68e3,68030,68060,68089,68119,68148,68177,68207,68236,68266,68295,68325,68354,68384,68414,68443,68473,68502,68532,68561,68591,68620,68650,68679,68708,68738,68768,68797,68827,68857,68886,68916,68946,68975,69004,69034,69063,69092,69122,69152,69181,69211,69240,69270,69300,69330,69359,69388,69418,69447,69476,69506,69535,69565,69595,69624,69654,69684,69713,69743,69772,69802,69831,69861,69890,69919,69949,69978,70008,70038,70067,70097,70126,70156,70186,70215,70245,70274,70303,70333,70362,70392,70421,70451,70481,70510,70540,70570,70599,70629,70658,70687,70717,70746,70776,70805,70835,70864,70894,70924,70954,70983,71013,71042,71071,71101,71130,71159,71189,71218,71248,71278,71308,71337,71367,71397,71426,71455,71485,71514,71543,71573,71602,71632,71662,71691,71721,71751,71781,71810,71839,71869,71898,71927,71957,71986,72016,72046,72075,72105,72135,72164,72194,72223,72253,72282,72311,72341,72370,72400,72429,72459,72489,72518,72548,72577,72607,72637,72666,72695,72725,72754,72784,72813,72843,72872,72902,72931,72961,72991,73020,73050,73080,73109,73139,73168,73197,73227,73256,73286,73315,73345,73375,73404,73434,73464,73493,73523,73552,73581,73611,73640,73669,73699,73729,73758,73788,73818,73848,73877,73907,73936,73965,73995,74024,74053,74083,74113,74142,74172,74202,74231,74261,74291,74320,74349,74379,74408,74437,74467,74497,74526,74556,74586,74615,74645,74675,74704,74733,74763,74792,74822,74851,74881,74910,74940,74969,74999,75029,75058,75088,75117,75147,75176,75206,75235,75264,75294,75323,75353,75383,75412,75442,75472,75501,75531,75560,75590,75619,75648,75678,75707,75737,75766,75796,75826,75856,75885,75915,75944,75974,76003,76032,76062,76091,76121,76150,76180,76210,76239,76269,76299,76328,76358,76387,76416,76446,76475,76505,76534,76564,76593,76623,76653,76682,76712,76741,76771,76801,76830,76859,76889,76918,76948,76977,77007,77036,77066,77096,77125,77155,77185,77214,77243,77273,77302,77332,77361,77390,77420,77450,77479,77509,77539,77569,77598,77627,77657,77686,77715,77745,77774,77804,77833,77863,77893,77923,77952,77982,78011,78041,78070,78099,78129,78158,78188,78217,78247,78277,78307,78336,78366,78395,78425,78454,78483,78513,78542,78572,78601,78631,78661,78690,78720,78750,78779,78808,78838,78867,78897,78926,78956,78985,79015,79044,79074,79104,79133,79163,79192,79222,79251,79281,79310,79340,79369,79399,79428,79458,79487,79517,79546,79576,79606,79635,79665,79695,79724,79753,79783,79812,79841,79871,79900,79930,79960,79990]},{"../main":509,"object-assign":397}],509:[function(t,e,r){var n=t("object-assign");function i(){this.regionalOptions=[],this.regionalOptions[""]={invalidCalendar:"Calendar {0} not found",invalidDate:"Invalid {0} date",invalidMonth:"Invalid {0} month",invalidYear:"Invalid {0} year",differentCalendars:"Cannot mix {0} and {1} dates"},this.local=this.regionalOptions[""],this.calendars={},this._localCals={}}function a(t,e,r,n){if(this._calendar=t,this._year=e,this._month=r,this._day=n,0===this._calendar._validateLevel&&!this._calendar.isValid(this._year,this._month,this._day))throw(c.local.invalidDate||c.regionalOptions[""].invalidDate).replace(/\{0\}/,this._calendar.local.name)}function o(t,e){return"000000".substring(0,e-(t=""+t).length)+t}function s(){this.shortYearCutoff="+10"}function l(t){this.local=this.regionalOptions[t]||this.regionalOptions[""]}n(i.prototype,{instance:function(t,e){t=(t||"gregorian").toLowerCase(),e=e||"";var r=this._localCals[t+"-"+e];if(!r&&this.calendars[t]&&(r=new this.calendars[t](e),this._localCals[t+"-"+e]=r),!r)throw(this.local.invalidCalendar||this.regionalOptions[""].invalidCalendar).replace(/\{0\}/,t);return r},newDate:function(t,e,r,n,i){return(n=(null!=t&&t.year?t.calendar():"string"==typeof n?this.instance(n,i):n)||this.instance()).newDate(t,e,r)},substituteDigits:function(t){return function(e){return(e+"").replace(/[0-9]/g,function(e){return t[e]})}},substituteChineseDigits:function(t,e){return function(r){for(var n="",i=0;r>0;){var a=r%10;n=(0===a?"":t[a]+e[i])+n,i++,r=Math.floor(r/10)}return 0===n.indexOf(t[1]+e[1])&&(n=n.substr(1)),n||t[0]}}}),n(a.prototype,{newDate:function(t,e,r){return this._calendar.newDate(null==t?this:t,e,r)},year:function(t){return 0===arguments.length?this._year:this.set(t,"y")},month:function(t){return 0===arguments.length?this._month:this.set(t,"m")},day:function(t){return 0===arguments.length?this._day:this.set(t,"d")},date:function(t,e,r){if(!this._calendar.isValid(t,e,r))throw(c.local.invalidDate||c.regionalOptions[""].invalidDate).replace(/\{0\}/,this._calendar.local.name);return this._year=t,this._month=e,this._day=r,this},leapYear:function(){return this._calendar.leapYear(this)},epoch:function(){return this._calendar.epoch(this)},formatYear:function(){return this._calendar.formatYear(this)},monthOfYear:function(){return this._calendar.monthOfYear(this)},weekOfYear:function(){return this._calendar.weekOfYear(this)},daysInYear:function(){return this._calendar.daysInYear(this)},dayOfYear:function(){return this._calendar.dayOfYear(this)},daysInMonth:function(){return this._calendar.daysInMonth(this)},dayOfWeek:function(){return this._calendar.dayOfWeek(this)},weekDay:function(){return this._calendar.weekDay(this)},extraInfo:function(){return this._calendar.extraInfo(this)},add:function(t,e){return this._calendar.add(this,t,e)},set:function(t,e){return this._calendar.set(this,t,e)},compareTo:function(t){if(this._calendar.name!==t._calendar.name)throw(c.local.differentCalendars||c.regionalOptions[""].differentCalendars).replace(/\{0\}/,this._calendar.local.name).replace(/\{1\}/,t._calendar.local.name);var e=this._year!==t._year?this._year-t._year:this._month!==t._month?this.monthOfYear()-t.monthOfYear():this._day-t._day;return 0===e?0:e<0?-1:1},calendar:function(){return this._calendar},toJD:function(){return this._calendar.toJD(this)},fromJD:function(t){return this._calendar.fromJD(t)},toJSDate:function(){return this._calendar.toJSDate(this)},fromJSDate:function(t){return this._calendar.fromJSDate(t)},toString:function(){return(this.year()<0?"-":"")+o(Math.abs(this.year()),4)+"-"+o(this.month(),2)+"-"+o(this.day(),2)}}),n(s.prototype,{_validateLevel:0,newDate:function(t,e,r){return null==t?this.today():(t.year&&(this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),r=t.day(),e=t.month(),t=t.year()),new a(this,t,e,r))},today:function(){return this.fromJSDate(new Date)},epoch:function(t){return this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear).year()<0?this.local.epochs[0]:this.local.epochs[1]},formatYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear);return(e.year()<0?"-":"")+o(Math.abs(e.year()),4)},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear),12},monthOfYear:function(t,e){var r=this._validate(t,e,this.minDay,c.local.invalidMonth||c.regionalOptions[""].invalidMonth);return(r.month()+this.monthsInYear(r)-this.firstMonth)%this.monthsInYear(r)+this.minMonth},fromMonthOfYear:function(t,e){var r=(e+this.firstMonth-2*this.minMonth)%this.monthsInYear(t)+this.minMonth;return this._validate(t,r,this.minDay,c.local.invalidMonth||c.regionalOptions[""].invalidMonth),r},daysInYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear);return this.leapYear(e)?366:365},dayOfYear:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate);return n.toJD()-this.newDate(n.year(),this.fromMonthOfYear(n.year(),this.minMonth),this.minDay).toJD()+1},daysInWeek:function(){return 7},dayOfWeek:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate);return(Math.floor(this.toJD(n))+2)%this.daysInWeek()},extraInfo:function(t,e,r){return this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),{}},add:function(t,e,r){return this._validate(t,this.minMonth,this.minDay,c.local.invalidDate||c.regionalOptions[""].invalidDate),this._correctAdd(t,this._add(t,e,r),e,r)},_add:function(t,e,r){if(this._validateLevel++,"d"===r||"w"===r){var n=t.toJD()+e*("w"===r?this.daysInWeek():1),i=t.calendar().fromJD(n);return this._validateLevel--,[i.year(),i.month(),i.day()]}try{var a=t.year()+("y"===r?e:0),o=t.monthOfYear()+("m"===r?e:0);i=t.day();"y"===r?(t.month()!==this.fromMonthOfYear(a,o)&&(o=this.newDate(a,t.month(),this.minDay).monthOfYear()),o=Math.min(o,this.monthsInYear(a)),i=Math.min(i,this.daysInMonth(a,this.fromMonthOfYear(a,o)))):"m"===r&&(!function(t){for(;oe-1+t.minMonth;)a++,o-=e,e=t.monthsInYear(a)}(this),i=Math.min(i,this.daysInMonth(a,this.fromMonthOfYear(a,o))));var s=[a,this.fromMonthOfYear(a,o),i];return this._validateLevel--,s}catch(t){throw this._validateLevel--,t}},_correctAdd:function(t,e,r,n){if(!(this.hasYearZero||"y"!==n&&"m"!==n||0!==e[0]&&t.year()>0==e[0]>0)){var i={y:[1,1,"y"],m:[1,this.monthsInYear(-1),"m"],w:[this.daysInWeek(),this.daysInYear(-1),"d"],d:[1,this.daysInYear(-1),"d"]}[n],a=r<0?-1:1;e=this._add(t,r*i[0]+a*i[1],i[2])}return t.date(e[0],e[1],e[2])},set:function(t,e,r){this._validate(t,this.minMonth,this.minDay,c.local.invalidDate||c.regionalOptions[""].invalidDate);var n="y"===r?e:t.year(),i="m"===r?e:t.month(),a="d"===r?e:t.day();return"y"!==r&&"m"!==r||(a=Math.min(a,this.daysInMonth(n,i))),t.date(n,i,a)},isValid:function(t,e,r){this._validateLevel++;var n=this.hasYearZero||0!==t;if(n){var i=this.newDate(t,e,this.minDay);n=e>=this.minMonth&&e-this.minMonth=this.minDay&&r-this.minDay13.5?13:1),c=i-(l>2.5?4716:4715);return c<=0&&c--,this.newDate(c,l,s)},toJSDate:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),i=new Date(n.year(),n.month()-1,n.day());return i.setHours(0),i.setMinutes(0),i.setSeconds(0),i.setMilliseconds(0),i.setHours(i.getHours()>12?i.getHours()+2:0),i},fromJSDate:function(t){return this.newDate(t.getFullYear(),t.getMonth()+1,t.getDate())}});var c=e.exports=new i;c.cdate=a,c.baseCalendar=s,c.calendars.gregorian=l},{"object-assign":397}],510:[function(t,e,r){var n=t("object-assign"),i=t("./main");n(i.regionalOptions[""],{invalidArguments:"Invalid arguments",invalidFormat:"Cannot format a date from another calendar",missingNumberAt:"Missing number at position {0}",unknownNameAt:"Unknown name at position {0}",unexpectedLiteralAt:"Unexpected literal at position {0}",unexpectedText:"Additional text found at end"}),i.local=i.regionalOptions[""],n(i.cdate.prototype,{formatDate:function(t,e){return"string"!=typeof t&&(e=t,t=""),this._calendar.formatDate(t||"",this,e)}}),n(i.baseCalendar.prototype,{UNIX_EPOCH:i.instance().newDate(1970,1,1).toJD(),SECS_PER_DAY:86400,TICKS_EPOCH:i.instance().jdEpoch,TICKS_PER_DAY:864e9,ATOM:"yyyy-mm-dd",COOKIE:"D, dd M yyyy",FULL:"DD, MM d, yyyy",ISO_8601:"yyyy-mm-dd",JULIAN:"J",RFC_822:"D, d M yy",RFC_850:"DD, dd-M-yy",RFC_1036:"D, d M yy",RFC_1123:"D, d M yyyy",RFC_2822:"D, d M yyyy",RSS:"D, d M yy",TICKS:"!",TIMESTAMP:"@",W3C:"yyyy-mm-dd",formatDate:function(t,e,r){if("string"!=typeof t&&(r=e,e=t,t=""),!e)return"";if(e.calendar()!==this)throw i.local.invalidFormat||i.regionalOptions[""].invalidFormat;t=t||this.local.dateFormat;for(var n,a,o,s,l=(r=r||{}).dayNamesShort||this.local.dayNamesShort,c=r.dayNames||this.local.dayNames,u=r.monthNumbers||this.local.monthNumbers,f=r.monthNamesShort||this.local.monthNamesShort,h=r.monthNames||this.local.monthNames,p=(r.calculateWeek||this.local.calculateWeek,function(e,r){for(var n=1;w+n1}),d=function(t,e,r,n){var i=""+e;if(p(t,n))for(;i.length1},x=function(t,r){var n=y(t,r),a=[2,3,n?4:2,n?4:2,10,11,20]["oyYJ@!".indexOf(t)+1],o=new RegExp("^-?\\d{1,"+a+"}"),s=e.substring(A).match(o);if(!s)throw(i.local.missingNumberAt||i.regionalOptions[""].missingNumberAt).replace(/\{0\}/,A);return A+=s[0].length,parseInt(s[0],10)},b=this,_=function(){if("function"==typeof l){y("m");var t=l.call(b,e.substring(A));return A+=t.length,t}return x("m")},w=function(t,r,n,a){for(var o=y(t,a)?n:r,s=0;s-1){p=1,d=g;for(var C=this.daysInMonth(h,p);d>C;C=this.daysInMonth(h,p))p++,d-=C}return f>-1?this.fromJD(f):this.newDate(h,p,d)},determineDate:function(t,e,r,n,i){r&&"object"!=typeof r&&(i=n,n=r,r=null),"string"!=typeof n&&(i=n,n="");var a=this;return e=e?e.newDate():null,t=null==t?e:"string"==typeof t?function(t){try{return a.parseDate(n,t,i)}catch(t){}for(var e=((t=t.toLowerCase()).match(/^c/)&&r?r.newDate():null)||a.today(),o=/([+-]?[0-9]+)\s*(d|w|m|y)?/g,s=o.exec(t);s;)e.add(parseInt(s[1],10),s[2]||"d"),s=o.exec(t);return e}(t):"number"==typeof t?isNaN(t)||t===1/0||t===-1/0?e:a.today().add(t,"d"):a.newDate(t)}})},{"./main":509,"object-assign":397}],511:[function(t,e,r){e.exports=t("cwise-compiler")({args:["array",{offset:[1],array:0},"scalar","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\n var _inline_1_da = _inline_1_arg0_ - _inline_1_arg3_\n var _inline_1_db = _inline_1_arg1_ - _inline_1_arg3_\n if((_inline_1_da >= 0) !== (_inline_1_db >= 0)) {\n _inline_1_arg2_.push(_inline_1_arg4_[0] + 0.5 + 0.5 * (_inline_1_da + _inline_1_db) / (_inline_1_da - _inline_1_db))\n }\n }",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg3_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:[],localVars:["_inline_1_da","_inline_1_db"]},funcName:"zeroCrossings"})},{"cwise-compiler":117}],512:[function(t,e,r){"use strict";e.exports=function(t,e){var r=[];return e=+e||0,n(t.hi(t.shape[0]-1),r,e),r};var n=t("./lib/zc-core")},{"./lib/zc-core":511}],513:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/cartesian/axes"),a=t("./common_defaults"),o=t("./attributes");e.exports=function(t,e,r,s,l){function c(r,i){return n.coerce(t,e,o,r,i)}s=s||{};var u=c("visible",!(l=l||{}).itemIsNotPlainObject),f=c("clicktoshow");if(!u&&!f)return e;a(t,e,r,c);for(var h=e.showarrow,p=["x","y"],d=[-10,-30],g={_fullLayout:r},m=0;m<2;m++){var v=p[m],y=i.coerceRef(t,e,g,v,"","paper");if(i.coercePosition(e,g,c,y,v,.5),h){var x="a"+v,b=i.coerceRef(t,e,g,x,"pixel");"pixel"!==b&&b!==y&&(b=e[x]="pixel");var _="pixel"===b?d[m]:.4;i.coercePosition(e,g,c,b,x,_)}c(v+"anchor"),c(v+"shift")}if(n.noneOrAll(t,e,["x","y"]),h&&n.noneOrAll(t,e,["ax","ay"]),f){var w=c("xclick"),k=c("yclick");e._xclick=void 0===w?e.x:i.cleanPosition(w,g,e.xref),e._yclick=void 0===k?e.y:i.cleanPosition(k,g,e.yref)}return e}},{"../../lib":660,"../../plots/cartesian/axes":706,"./attributes":515,"./common_defaults":518}],514:[function(t,e,r){"use strict";e.exports=[{path:"",backoff:0},{path:"M-2.4,-3V3L0.6,0Z",backoff:.6},{path:"M-3.7,-2.5V2.5L1.3,0Z",backoff:1.3},{path:"M-4.45,-3L-1.65,-0.2V0.2L-4.45,3L1.55,0Z",backoff:1.55},{path:"M-2.2,-2.2L-0.2,-0.2V0.2L-2.2,2.2L-1.4,3L1.6,0L-1.4,-3Z",backoff:1.6},{path:"M-4.4,-2.1L-0.6,-0.2V0.2L-4.4,2.1L-4,3L2,0L-4,-3Z",backoff:2},{path:"M2,0A2,2 0 1,1 0,-2A2,2 0 0,1 2,0Z",backoff:0,noRotate:!0},{path:"M2,2V-2H-2V2Z",backoff:0,noRotate:!0}]},{}],515:[function(t,e,r){"use strict";var n=t("./arrow_paths"),i=t("../../plots/font_attributes"),a=t("../../plots/cartesian/constants");e.exports={_isLinkedToArray:"annotation",visible:{valType:"boolean",dflt:!0,editType:"calcIfAutorange+arraydraw"},text:{valType:"string",editType:"calcIfAutorange+arraydraw"},textangle:{valType:"angle",dflt:0,editType:"calcIfAutorange+arraydraw"},font:i({editType:"calcIfAutorange+arraydraw",colorEditType:"arraydraw"}),width:{valType:"number",min:1,dflt:null,editType:"calcIfAutorange+arraydraw"},height:{valType:"number",min:1,dflt:null,editType:"calcIfAutorange+arraydraw"},opacity:{valType:"number",min:0,max:1,dflt:1,editType:"arraydraw"},align:{valType:"enumerated",values:["left","center","right"],dflt:"center",editType:"arraydraw"},valign:{valType:"enumerated",values:["top","middle","bottom"],dflt:"middle",editType:"arraydraw"},bgcolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"arraydraw"},bordercolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"arraydraw"},borderpad:{valType:"number",min:0,dflt:1,editType:"calcIfAutorange+arraydraw"},borderwidth:{valType:"number",min:0,dflt:1,editType:"calcIfAutorange+arraydraw"},showarrow:{valType:"boolean",dflt:!0,editType:"calcIfAutorange+arraydraw"},arrowcolor:{valType:"color",editType:"arraydraw"},arrowhead:{valType:"integer",min:0,max:n.length,dflt:1,editType:"arraydraw"},startarrowhead:{valType:"integer",min:0,max:n.length,dflt:1,editType:"arraydraw"},arrowside:{valType:"flaglist",flags:["end","start"],extras:["none"],dflt:"end",editType:"arraydraw"},arrowsize:{valType:"number",min:.3,dflt:1,editType:"calcIfAutorange+arraydraw"},startarrowsize:{valType:"number",min:.3,dflt:1,editType:"calcIfAutorange+arraydraw"},arrowwidth:{valType:"number",min:.1,editType:"calcIfAutorange+arraydraw"},standoff:{valType:"number",min:0,dflt:0,editType:"calcIfAutorange+arraydraw"},startstandoff:{valType:"number",min:0,dflt:0,editType:"calcIfAutorange+arraydraw"},ax:{valType:"any",editType:"calcIfAutorange+arraydraw"},ay:{valType:"any",editType:"calcIfAutorange+arraydraw"},axref:{valType:"enumerated",dflt:"pixel",values:["pixel",a.idRegex.x.toString()],editType:"calc"},ayref:{valType:"enumerated",dflt:"pixel",values:["pixel",a.idRegex.y.toString()],editType:"calc"},xref:{valType:"enumerated",values:["paper",a.idRegex.x.toString()],editType:"calc"},x:{valType:"any",editType:"calcIfAutorange+arraydraw"},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"auto",editType:"calcIfAutorange+arraydraw"},xshift:{valType:"number",dflt:0,editType:"calcIfAutorange+arraydraw"},yref:{valType:"enumerated",values:["paper",a.idRegex.y.toString()],editType:"calc"},y:{valType:"any",editType:"calcIfAutorange+arraydraw"},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"auto",editType:"calcIfAutorange+arraydraw"},yshift:{valType:"number",dflt:0,editType:"calcIfAutorange+arraydraw"},clicktoshow:{valType:"enumerated",values:[!1,"onoff","onout"],dflt:!1,editType:"arraydraw"},xclick:{valType:"any",editType:"arraydraw"},yclick:{valType:"any",editType:"arraydraw"},hovertext:{valType:"string",editType:"arraydraw"},hoverlabel:{bgcolor:{valType:"color",editType:"arraydraw"},bordercolor:{valType:"color",editType:"arraydraw"},font:i({editType:"arraydraw"}),editType:"arraydraw"},captureevents:{valType:"boolean",editType:"arraydraw"},editType:"calc",_deprecated:{ref:{valType:"string",editType:"calc"}}}},{"../../plots/cartesian/constants":711,"../../plots/font_attributes":732,"./arrow_paths":514}],516:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/cartesian/axes"),a=t("./draw").draw;function o(t){var e=t._fullLayout;n.filterVisible(e.annotations).forEach(function(e){var r,n,a,o,s=i.getFromId(t,e.xref),l=i.getFromId(t,e.yref),c=3*e.arrowsize*e.arrowwidth||0,u=3*e.startarrowsize*e.arrowwidth||0;s&&s.autorange&&(r=c+e.xshift,n=c-e.xshift,a=u+e.xshift,o=u-e.xshift,e.axref===e.xref?(i.expand(s,[s.r2c(e.x)],{ppadplus:r,ppadminus:n}),i.expand(s,[s.r2c(e.ax)],{ppadplus:Math.max(e._xpadplus,a),ppadminus:Math.max(e._xpadminus,o)})):(a=e.ax?a+e.ax:a,o=e.ax?o-e.ax:o,i.expand(s,[s.r2c(e.x)],{ppadplus:Math.max(e._xpadplus,r,a),ppadminus:Math.max(e._xpadminus,n,o)}))),l&&l.autorange&&(r=c-e.yshift,n=c+e.yshift,a=u-e.yshift,o=u+e.yshift,e.ayref===e.yref?(i.expand(l,[l.r2c(e.y)],{ppadplus:r,ppadminus:n}),i.expand(l,[l.r2c(e.ay)],{ppadplus:Math.max(e._ypadplus,a),ppadminus:Math.max(e._ypadminus,o)})):(a=e.ay?a+e.ay:a,o=e.ay?o-e.ay:o,i.expand(l,[l.r2c(e.y)],{ppadplus:Math.max(e._ypadplus,r,a),ppadminus:Math.max(e._ypadminus,n,o)})))})}e.exports=function(t){var e=t._fullLayout,r=n.filterVisible(e.annotations);if(r.length&&t._fullData.length){var s={};for(var l in r.forEach(function(t){s[t.xref]=1,s[t.yref]=1}),s){var c=i.getFromId(t,l);if(c&&c.autorange)return n.syncOrAsync([a,o],t)}}}},{"../../lib":660,"../../plots/cartesian/axes":706,"./draw":521}],517:[function(t,e,r){"use strict";var n=t("../../registry");function i(t,e){var r,n,i,o,s,l,c,u=t._fullLayout.annotations,f=[],h=[],p=[],d=(e||[]).length;for(r=0;r0||r.explicitOff.length>0},onClick:function(t,e){var r,a=i(t,e),o=a.on,s=a.off.concat(a.explicitOff),l={};if(!o.length&&!s.length)return;for(r=0;r2/3?"right":"center"),{center:0,middle:0,left:.5,bottom:-.5,right:-.5,top:.5}[e]}e._w=I,e._h=B;for(var V=!1,U=["x","y"],q=0;q1)&&(K===J?((ot=Q.r2fraction(e["a"+Z]))<0||ot>1)&&(V=!0):V=!0,V))continue;H=Q._offset+Q.r2p(e[Z]),Y=.5}else"x"===Z?(W=e[Z],H=x.l+x.w*W):(W=1-e[Z],H=x.t+x.h*W),Y=e.showarrow?.5:W;if(e.showarrow){at.head=H;var st=e["a"+Z];X=tt*j(.5,e.xanchor)-et*j(.5,e.yanchor),K===J?(at.tail=Q._offset+Q.r2p(st),G=X):(at.tail=H+st,G=X+st),at.text=at.tail+X;var lt=y["x"===Z?"width":"height"];if("paper"===J&&(at.head=o.constrain(at.head,1,lt-1)),"pixel"===K){var ct=-Math.max(at.tail-3,at.text),ut=Math.min(at.tail+3,at.text)-lt;ct>0?(at.tail+=ct,at.text+=ct):ut>0&&(at.tail-=ut,at.text-=ut)}at.tail+=it,at.head+=it}else G=X=rt*j(Y,nt),at.text=H+X;at.text+=it,X+=it,G+=it,e["_"+Z+"padplus"]=rt/2+G,e["_"+Z+"padminus"]=rt/2-G,e["_"+Z+"size"]=rt,e["_"+Z+"shift"]=X}if(V)C.remove();else{var ft=0,ht=0;if("left"!==e.align&&(ft=(I-S)*("center"===e.align?.5:1)),"top"!==e.valign&&(ht=(B-L)*("middle"===e.valign?.5:1)),u)n.select("svg").attr({x:z+ft-1,y:z+ht}).call(c.setClipUrl,D?_:null);else{var pt=z+ht-m.top,dt=z+ft-m.left;R.call(f.positionText,dt,pt).call(c.setClipUrl,D?_:null)}O.select("rect").call(c.setRect,z,z,I,B),P.call(c.setRect,E/2,E/2,F-E,N-E),C.call(c.setTranslate,Math.round(w.x.text-F/2),Math.round(w.y.text-N/2)),A.attr({transform:"rotate("+k+","+w.x.text+","+w.y.text+")"});var gt,mt,vt=function(r,n){M.selectAll(".annotation-arrow-g").remove();var u=w.x.head,f=w.y.head,h=w.x.tail+r,m=w.y.tail+n,y=w.x.text+r,_=w.y.text+n,T=o.rotationXYMatrix(k,y,_),S=o.apply2DTransform(T),E=o.apply2DTransform2(T),L=+P.attr("width"),z=+P.attr("height"),D=y-.5*L,O=D+L,I=_-.5*z,R=I+z,B=[[D,I,D,R],[D,R,O,R],[O,R,O,I],[O,I,D,I]].map(E);if(!B.reduce(function(t,e){return t^!!o.segmentsIntersect(u,f,u+1e6,f+1e6,e[0],e[1],e[2],e[3])},!1)){B.forEach(function(t){var e=o.segmentsIntersect(h,m,u,f,t[0],t[1],t[2],t[3]);e&&(h=e.x,m=e.y)});var F=e.arrowwidth,N=e.arrowcolor,j=e.arrowside,V=M.append("g").style({opacity:l.opacity(N)}).classed("annotation-arrow-g",!0),U=V.append("path").attr("d","M"+h+","+m+"L"+u+","+f).style("stroke-width",F+"px").call(l.stroke,l.rgb(N));if(d(U,j,e),b.annotationPosition&&U.node().parentNode&&!a){var q=u,H=f;if(e.standoff){var G=Math.sqrt(Math.pow(u-h,2)+Math.pow(f-m,2));q+=e.standoff*(h-u)/G,H+=e.standoff*(m-f)/G}var W,Y,X,Z=V.append("path").classed("annotation-arrow",!0).classed("anndrag",!0).classed("cursor-move",!0).attr({d:"M3,3H-3V-3H3ZM0,0L"+(h-q)+","+(m-H),transform:"translate("+q+","+H+")"}).style("stroke-width",F+6+"px").call(l.stroke,"rgba(0,0,0,0)").call(l.fill,"rgba(0,0,0,0)");p.init({element:Z.node(),gd:t,prepFn:function(){var t=c.getTranslate(C);Y=t.x,X=t.y,W={},s&&s.autorange&&(W[s._name+".autorange"]=!0),g&&g.autorange&&(W[g._name+".autorange"]=!0)},moveFn:function(t,r){var n=S(Y,X),i=n[0]+t,a=n[1]+r;C.call(c.setTranslate,i,a),W[v+".x"]=s?s.p2r(s.r2p(e.x)+t):e.x+t/x.w,W[v+".y"]=g?g.p2r(g.r2p(e.y)+r):e.y-r/x.h,e.axref===e.xref&&(W[v+".ax"]=s.p2r(s.r2p(e.ax)+t)),e.ayref===e.yref&&(W[v+".ay"]=g.p2r(g.r2p(e.ay)+r)),V.attr("transform","translate("+t+","+r+")"),A.attr({transform:"rotate("+k+","+i+","+a+")"})},doneFn:function(){i.call("relayout",t,W);var e=document.querySelector(".js-notes-box-panel");e&&e.redraw(e.selectedObj)}})}}};if(e.showarrow&&vt(0,0),T)p.init({element:C.node(),gd:t,prepFn:function(){mt=A.attr("transform"),gt={}},moveFn:function(t,r){var n="pointer";if(e.showarrow)e.axref===e.xref?gt[v+".ax"]=s.p2r(s.r2p(e.ax)+t):gt[v+".ax"]=e.ax+t,e.ayref===e.yref?gt[v+".ay"]=g.p2r(g.r2p(e.ay)+r):gt[v+".ay"]=e.ay+r,vt(t,r);else{if(a)return;if(s)gt[v+".x"]=s.p2r(s.r2p(e.x)+t);else{var i=e._xsize/x.w,o=e.x+(e._xshift-e.xshift)/x.w-i/2;gt[v+".x"]=p.align(o+t/x.w,i,0,1,e.xanchor)}if(g)gt[v+".y"]=g.p2r(g.r2p(e.y)+r);else{var l=e._ysize/x.h,c=e.y-(e._yshift+e.yshift)/x.h-l/2;gt[v+".y"]=p.align(c-r/x.h,l,0,1,e.yanchor)}s&&g||(n=p.getCursor(s?.5:gt[v+".x"],g?.5:gt[v+".y"],e.xanchor,e.yanchor))}A.attr({transform:"translate("+t+","+r+")"+mt}),h(C,n)},doneFn:function(){h(C),i.call("relayout",t,gt);var e=document.querySelector(".js-notes-box-panel");e&&e.redraw(e.selectedObj)}})}}}e.exports={draw:function(t){var e=t._fullLayout;e._infolayer.selectAll(".annotation").remove();for(var r=0;r=0,m=e.indexOf("end")>=0,v=f.backoff*p+r.standoff,y=h.backoff*d+r.startstandoff;if("line"===u.nodeName){o={x:+t.attr("x1"),y:+t.attr("y1")},s={x:+t.attr("x2"),y:+t.attr("y2")};var x=o.x-s.x,b=o.y-s.y;if(c=(l=Math.atan2(b,x))+Math.PI,v&&y&&v+y>Math.sqrt(x*x+b*b))return void z();if(v){if(v*v>x*x+b*b)return void z();var _=v*Math.cos(l),w=v*Math.sin(l);s.x+=_,s.y+=w,t.attr({x2:s.x,y2:s.y})}if(y){if(y*y>x*x+b*b)return void z();var k=y*Math.cos(l),M=y*Math.sin(l);o.x-=k,o.y-=M,t.attr({x1:o.x,y1:o.y})}}else if("path"===u.nodeName){var A=u.getTotalLength(),T="";if(A1){c=!0;break}}c?t.fullLayout._infolayer.select(".annotation-"+t.id+'[data-index="'+s+'"]').remove():(l._pdata=i(t.glplot.cameraParams,[e.xaxis.r2l(l.x)*r[0],e.yaxis.r2l(l.y)*r[1],e.zaxis.r2l(l.z)*r[2]]),n(t.graphDiv,l,s,t.id,l._xa,l._ya))}}},{"../../plots/gl3d/project":757,"../annotations/draw":521}],528:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib");e.exports={moduleType:"component",name:"annotations3d",schema:{subplots:{scene:{annotations:t("./attributes")}}},layoutAttributes:t("./attributes"),handleDefaults:t("./defaults"),includeBasePlot:function(t,e){var r=n.subplotsRegistry.gl3d;if(!r)return;for(var a=r.attrRegex,o=Object.keys(t),s=0;s=0))return t;if(3===o)n[o]>1&&(n[o]=1);else if(n[o]>=1)return t}var s=Math.round(255*n[0])+", "+Math.round(255*n[1])+", "+Math.round(255*n[2]);return a?"rgba("+s+", "+n[3]+")":"rgb("+s+")"}a.tinyRGB=function(t){var e=t.toRgb();return"rgb("+Math.round(e.r)+", "+Math.round(e.g)+", "+Math.round(e.b)+")"},a.rgb=function(t){return a.tinyRGB(n(t))},a.opacity=function(t){return t?n(t).getAlpha():0},a.addOpacity=function(t,e){var r=n(t).toRgb();return"rgba("+Math.round(r.r)+", "+Math.round(r.g)+", "+Math.round(r.b)+", "+e+")"},a.combine=function(t,e){var r=n(t).toRgb();if(1===r.a)return n(t).toRgbString();var i=n(e||l).toRgb(),a=1===i.a?i:{r:255*(1-i.a)+i.r*i.a,g:255*(1-i.a)+i.g*i.a,b:255*(1-i.a)+i.b*i.a},o={r:a.r*(1-r.a)+r.r*r.a,g:a.g*(1-r.a)+r.g*r.a,b:a.b*(1-r.a)+r.b*r.a};return n(o).toRgbString()},a.contrast=function(t,e,r){var i=n(t);return 1!==i.getAlpha()&&(i=n(a.combine(t,l))),(i.isDark()?e?i.lighten(e):l:r?i.darken(r):s).toString()},a.stroke=function(t,e){var r=n(e);t.style({stroke:a.tinyRGB(r),"stroke-opacity":r.getAlpha()})},a.fill=function(t,e){var r=n(e);t.style({fill:a.tinyRGB(r),"fill-opacity":r.getAlpha()})},a.clean=function(t){if(t&&"object"==typeof t){var e,r,n,i,o=Object.keys(t);for(e=0;e0?A>=P:A<=P));T++)A>O&&A0?A>=P:A<=P));T++)A>S[0]&&A1){var nt=Math.pow(10,Math.floor(Math.log(rt)/Math.LN10));tt*=nt*c.roundUp(rt/nt,[2,5,10]),(Math.abs(r.levels.start)/r.levels.size+1e-6)%1<2e-6&&(Q.tick0=0)}Q.dtick=tt}Q.domain=[X+G,X+U-G],Q.setScale();var it=c.ensureSingle(b._infolayer,"g",e,function(t){t.classed(_.colorbar,!0).each(function(){var t=n.select(this);t.append("rect").classed(_.cbbg,!0),t.append("g").classed(_.cbfills,!0),t.append("g").classed(_.cblines,!0),t.append("g").classed(_.cbaxis,!0).classed(_.crisp,!0),t.append("g").classed(_.cbtitleunshift,!0).append("g").classed(_.cbtitle,!0),t.append("rect").classed(_.cboutline,!0),t.select(".cbtitle").datum(0)})});it.attr("transform","translate("+Math.round(M.l)+","+Math.round(M.t)+")");var at=it.select(".cbtitleunshift").attr("transform","translate(-"+Math.round(M.l)+",-"+Math.round(M.t)+")");Q._axislayer=it.select(".cbaxis");var ot=0;if(-1!==["top","bottom"].indexOf(r.titleside)){var st,lt=M.l+(r.x+q)*M.w,ct=Q.titlefont.size;st="top"===r.titleside?(1-(X+U-G))*M.h+M.t+3+.75*ct:(1-(X+G))*M.h+M.t-3-.25*ct,gt(Q._id+"title",{attributes:{x:lt,y:st,"text-anchor":"start"}})}var ut,ft,ht,pt=c.syncOrAsync([a.previousPromises,function(){if(-1!==["top","bottom"].indexOf(r.titleside)){var e=it.select(".cbtitle"),a=e.select("text"),o=[-r.outlinewidth/2,r.outlinewidth/2],l=e.select(".h"+Q._id+"title-math-group").node(),u=15.6;if(a.node()&&(u=parseInt(a.node().style.fontSize,10)*m),l?(ot=h.bBox(l).height)>u&&(o[1]-=(ot-u)/2):a.node()&&!a.classed(_.jsPlaceholder)&&(ot=h.bBox(a.node()).height),ot){if(ot+=5,"top"===r.titleside)Q.domain[1]-=ot/M.h,o[1]*=-1;else{Q.domain[0]+=ot/M.h;var f=g.lineCount(a);o[1]+=(1-f)*u}e.attr("transform","translate("+o+")"),Q.setScale()}}it.selectAll(".cbfills,.cblines").attr("transform","translate(0,"+Math.round(M.h*(1-Q.domain[1]))+")"),Q._axislayer.attr("transform","translate(0,"+Math.round(-M.t)+")");var p=it.select(".cbfills").selectAll("rect.cbfill").data(E);p.enter().append("rect").classed(_.cbfill,!0).style("stroke","none"),p.exit().remove(),p.each(function(t,e){var r=[0===e?S[0]:(E[e]+E[e-1])/2,e===E.length-1?S[1]:(E[e]+E[e+1])/2].map(Q.c2p).map(Math.round);e!==E.length-1&&(r[1]+=r[1]>r[0]?1:-1);var a=z(t).replace("e-",""),o=i(a).toHexString();n.select(this).attr({x:W,width:Math.max(N,2),y:n.min(r),height:Math.max(n.max(r)-n.min(r),2),fill:o})});var d=it.select(".cblines").selectAll("path.cbline").data(r.line.color&&r.line.width?C:[]);return d.enter().append("path").classed(_.cbline,!0),d.exit().remove(),d.each(function(t){n.select(this).attr("d","M"+W+","+(Math.round(Q.c2p(t))+r.line.width/2%1)+"h"+N).call(h.lineGroupStyle,r.line.width,L(t),r.line.dash)}),Q._axislayer.selectAll("g."+Q._id+"tick,path").remove(),Q._pos=W+N+(r.outlinewidth||0)/2-("outside"===r.ticks?1:0),Q.side="right",c.syncOrAsync([function(){return s.doTicksSingle(t,Q,!0)},function(){if(-1===["top","bottom"].indexOf(r.titleside)){var e=Q.titlefont.size,i=Q._offset+Q._length/2,a=M.l+(Q.position||0)*M.w+("right"===Q.side?10+e*(Q.showticklabels?1:.5):-10-e*(Q.showticklabels?.5:0));gt("h"+Q._id+"title",{avoid:{selection:n.select(t).selectAll("g."+Q._id+"tick"),side:r.titleside,offsetLeft:M.l,offsetTop:0,maxShift:b.width},attributes:{x:a,y:i,"text-anchor":"middle"},transform:{rotate:"-90",offset:0}})}}])},a.previousPromises,function(){var n=N+r.outlinewidth/2+h.bBox(Q._axislayer.node()).width;if((R=at.select("text")).node()&&!R.classed(_.jsPlaceholder)){var i,o=at.select(".h"+Q._id+"title-math-group").node();i=o&&-1!==["top","bottom"].indexOf(r.titleside)?h.bBox(o).width:h.bBox(at.node()).right-W-M.l,n=Math.max(n,i)}var s=2*r.xpad+n+r.borderwidth+r.outlinewidth/2,l=Z-J;it.select(".cbbg").attr({x:W-r.xpad-(r.borderwidth+r.outlinewidth)/2,y:J-H,width:Math.max(s,2),height:Math.max(l+2*H,2)}).call(p.fill,r.bgcolor).call(p.stroke,r.bordercolor).style({"stroke-width":r.borderwidth}),it.selectAll(".cboutline").attr({x:W,y:J+r.ypad+("top"===r.titleside?ot:0),width:Math.max(N,2),height:Math.max(l-2*r.ypad-ot,2)}).call(p.stroke,r.outlinecolor).style({fill:"None","stroke-width":r.outlinewidth});var c=({center:.5,right:1}[r.xanchor]||0)*s;it.attr("transform","translate("+(M.l-c)+","+M.t+")"),a.autoMargin(t,e,{x:r.x,y:r.y,l:s*({right:1,center:.5}[r.xanchor]||0),r:s*({left:1,center:.5}[r.xanchor]||0),t:l*({bottom:1,middle:.5}[r.yanchor]||0),b:l*({top:1,middle:.5}[r.yanchor]||0)})}],t);if(pt&&pt.then&&(t._promises||[]).push(pt),t._context.edits.colorbarPosition)l.init({element:it.node(),gd:t,prepFn:function(){ut=it.attr("transform"),f(it)},moveFn:function(t,e){it.attr("transform",ut+" translate("+t+","+e+")"),ft=l.align(Y+t/M.w,j,0,1,r.xanchor),ht=l.align(X-e/M.h,U,0,1,r.yanchor);var n=l.getCursor(ft,ht,r.xanchor,r.yanchor);f(it,n)},doneFn:function(){f(it),void 0!==ft&&void 0!==ht&&o.call("restyle",t,{"colorbar.x":ft,"colorbar.y":ht},k().index)}});return pt}function dt(t,e){return c.coerce(K,Q,x,t,e)}function gt(e,r){var n,i=k();n=o.traceIs(i,"markerColorscale")?"marker.colorbar.title":"colorbar.title";var a={propContainer:Q,propName:n,traceIndex:i.index,placeholder:b._dfltTitle.colorbar,containerGroup:it.select(".cbtitle")},s="h"===e.charAt(0)?e.substr(1):"h"+e;it.selectAll("."+s+",."+s+"-math-group").remove(),d.draw(t,e,u(a,r||{}))}b._infolayer.selectAll("g."+e).remove()}function k(){var r,n,i=e.substr(2);for(r=0;r=0?i.Reds:i.Blues,s.reversescale?a(y):y),l.autocolorscale||f("autocolorscale",!1))}},{"../../lib":660,"./flip_scale":544,"./scales":551}],540:[function(t,e,r){"use strict";var n=t("./attributes"),i=t("../../lib/extend").extendFlat;t("./scales.js");e.exports=function(t,e,r){return{color:{valType:"color",arrayOk:!0,editType:e||"style"},colorscale:i({},n.colorscale,{}),cauto:i({},n.zauto,{impliedEdits:{cmin:void 0,cmax:void 0}}),cmax:i({},n.zmax,{editType:e||n.zmax.editType,impliedEdits:{cauto:!1}}),cmin:i({},n.zmin,{editType:e||n.zmin.editType,impliedEdits:{cauto:!1}}),autocolorscale:i({},n.autocolorscale,{dflt:!1===r?r:n.autocolorscale.dflt}),reversescale:i({},n.reversescale,{})}}},{"../../lib/extend":649,"./attributes":538,"./scales.js":551}],541:[function(t,e,r){"use strict";var n=t("./scales");e.exports=n.RdBu},{"./scales":551}],542:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("../colorbar/has_colorbar"),o=t("../colorbar/defaults"),s=t("./is_valid_scale"),l=t("./flip_scale");e.exports=function(t,e,r,c,u){var f,h=u.prefix,p=u.cLetter,d=h.slice(0,h.length-1),g=h?i.nestedProperty(t,d).get()||{}:t,m=h?i.nestedProperty(e,d).get()||{}:e,v=g[p+"min"],y=g[p+"max"],x=g.colorscale;c(h+p+"auto",!(n(v)&&n(y)&&v=0;i--,a++)e=t[i],n[a]=[1-e[0],e[1]];return n}},{}],545:[function(t,e,r){"use strict";var n=t("./scales"),i=t("./default_scale"),a=t("./is_valid_scale_array");e.exports=function(t,e){if(e||(e=i),!t)return e;function r(){try{t=n[t]||JSON.parse(t)}catch(r){t=e}}return"string"==typeof t&&(r(),"string"==typeof t&&r()),a(t)?t:e}},{"./default_scale":541,"./is_valid_scale_array":549,"./scales":551}],546:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("./is_valid_scale");e.exports=function(t,e){var r=e?i.nestedProperty(t,e).get()||{}:t,o=r.color,s=!1;if(i.isArrayOrTypedArray(o))for(var l=0;l4/3-s?o:s}},{}],553:[function(t,e,r){"use strict";var n=t("../../lib"),i=[["sw-resize","s-resize","se-resize"],["w-resize","move","e-resize"],["nw-resize","n-resize","ne-resize"]];e.exports=function(t,e,r,a){return t="left"===r?0:"center"===r?1:"right"===r?2:n.constrain(Math.floor(3*t),0,2),e="bottom"===a?0:"middle"===a?1:"top"===a?2:n.constrain(Math.floor(3*e),0,2),i[e][t]}},{"../../lib":660}],554:[function(t,e,r){"use strict";var n=t("mouse-event-offset"),i=t("has-hover"),a=t("has-passive-events"),o=t("../../registry"),s=t("../../lib"),l=t("../../plots/cartesian/constants"),c=t("../../constants/interactions"),u=e.exports={};u.align=t("./align"),u.getCursor=t("./cursor");var f=t("./unhover");function h(){var t=document.createElement("div");t.className="dragcover";var e=t.style;return e.position="fixed",e.left=0,e.right=0,e.top=0,e.bottom=0,e.zIndex=999999999,e.background="none",document.body.appendChild(t),t}function p(t){return n(t.changedTouches?t.changedTouches[0]:t,document.body)}u.unhover=f.wrapped,u.unhoverRaw=f.raw,u.init=function(t){var e,r,n,f,d,g,m,v,y=t.gd,x=1,b=c.DBLCLICKDELAY,_=t.element;y._mouseDownTime||(y._mouseDownTime=0),_.style.pointerEvents="all",_.onmousedown=k,a?(_._ontouchstart&&_.removeEventListener("touchstart",_._ontouchstart),_._ontouchstart=k,_.addEventListener("touchstart",k,{passive:!1})):_.ontouchstart=k;var w=t.clampFn||function(t,e,r){return Math.abs(t)b&&(x=Math.max(x-1,1)),y._dragged)t.doneFn&&t.doneFn();else if(t.clickFn&&t.clickFn(x,g),!v){var r;try{r=new MouseEvent("click",e)}catch(t){var n=p(e);(r=document.createEvent("MouseEvents")).initMouseEvent("click",e.bubbles,e.cancelable,e.view,e.detail,e.screenX,e.screenY,n[0],n[1],e.ctrlKey,e.altKey,e.shiftKey,e.metaKey,e.button,e.relatedTarget)}m.dispatchEvent(r)}!function(t){t._dragging=!1,t._replotPending&&o.call("plot",t)}(y),y._dragged=!1}else y._dragged=!1}},u.coverSlip=h},{"../../constants/interactions":636,"../../lib":660,"../../plots/cartesian/constants":711,"../../registry":790,"./align":552,"./cursor":553,"./unhover":555,"has-hover":354,"has-passive-events":355,"mouse-event-offset":379}],555:[function(t,e,r){"use strict";var n=t("../../lib/events"),i=t("../../lib/throttle"),a=t("../../lib/get_graph_div"),o=t("../fx/constants"),s=e.exports={};s.wrapped=function(t,e,r){(t=a(t))._fullLayout&&i.clear(t._fullLayout._uid+o.HOVERID),s.raw(t,e,r)},s.raw=function(t,e){var r=t._fullLayout,i=t._hoverdata;e||(e={}),e.target&&!1===n.triggerHandler(t,"plotly_beforehover",e)||(r._hoverlayer.selectAll("g").remove(),r._hoverlayer.selectAll("line").remove(),r._hoverlayer.selectAll("circle").remove(),t._hoverdata=void 0,e.target&&i&&t.emit("plotly_unhover",{event:e,points:i}))}},{"../../lib/events":648,"../../lib/get_graph_div":655,"../../lib/throttle":685,"../fx/constants":569}],556:[function(t,e,r){"use strict";r.dash={valType:"string",values:["solid","dot","dash","longdash","dashdot","longdashdot"],dflt:"solid",editType:"style"}},{}],557:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("tinycolor2"),o=t("../../registry"),s=t("../color"),l=t("../colorscale"),c=t("../../lib"),u=t("../../lib/svg_text_utils"),f=t("../../constants/xmlns_namespaces"),h=t("../../constants/alignment").LINE_SPACING,p=t("../../constants/interactions").DESELECTDIM,d=t("../../traces/scatter/subtypes"),g=t("../../traces/scatter/make_bubble_size_func"),m=e.exports={};m.font=function(t,e,r,n){c.isPlainObject(e)&&(n=e.color,r=e.size,e=e.family),e&&t.style("font-family",e),r+1&&t.style("font-size",r+"px"),n&&t.call(s.fill,n)},m.setPosition=function(t,e,r){t.attr("x",e).attr("y",r)},m.setSize=function(t,e,r){t.attr("width",e).attr("height",r)},m.setRect=function(t,e,r,n,i){t.call(m.setPosition,e,r).call(m.setSize,n,i)},m.translatePoint=function(t,e,r,n){var a=r.c2p(t.x),o=n.c2p(t.y);return!!(i(a)&&i(o)&&e.node())&&("text"===e.node().nodeName?e.attr("x",a).attr("y",o):e.attr("transform","translate("+a+","+o+")"),!0)},m.translatePoints=function(t,e,r){t.each(function(t){var i=n.select(this);m.translatePoint(t,i,e,r)})},m.hideOutsideRangePoint=function(t,e,r,n,i,a){e.attr("display",r.isPtWithinRange(t,i)&&n.isPtWithinRange(t,a)?null:"none")},m.hideOutsideRangePoints=function(t,e){if(e._hasClipOnAxisFalse){var r=e.xaxis,i=e.yaxis;t.each(function(e){var a=e[0].trace,o=a.xcalendar,s=a.ycalendar,l="bar"===a.type?".bartext":".point,.textpoint";t.selectAll(l).each(function(t){m.hideOutsideRangePoint(t,n.select(this),r,i,o,s)})})}},m.crispRound=function(t,e,r){return e&&i(e)?t._context.staticPlot?e:e<1?1:Math.round(e):r||0},m.singleLineStyle=function(t,e,r,n,i){e.style("fill","none");var a=(((t||[])[0]||{}).trace||{}).line||{},o=r||a.width||0,l=i||a.dash||"";s.stroke(e,n||a.color),m.dashLine(e,l,o)},m.lineGroupStyle=function(t,e,r,i){t.style("fill","none").each(function(t){var a=(((t||[])[0]||{}).trace||{}).line||{},o=e||a.width||0,l=i||a.dash||"";n.select(this).call(s.stroke,r||a.color).call(m.dashLine,l,o)})},m.dashLine=function(t,e,r){r=+r||0,e=m.dashStyle(e,r),t.style({"stroke-dasharray":e,"stroke-width":r+"px"})},m.dashStyle=function(t,e){e=+e||1;var r=Math.max(e,3);return"solid"===t?t="":"dot"===t?t=r+"px,"+r+"px":"dash"===t?t=3*r+"px,"+3*r+"px":"longdash"===t?t=5*r+"px,"+5*r+"px":"dashdot"===t?t=3*r+"px,"+r+"px,"+r+"px,"+r+"px":"longdashdot"===t&&(t=5*r+"px,"+2*r+"px,"+r+"px,"+2*r+"px"),t},m.singleFillStyle=function(t){var e=(((n.select(t.node()).data()[0]||[])[0]||{}).trace||{}).fillcolor;e&&t.call(s.fill,e)},m.fillGroupStyle=function(t){t.style("stroke-width",0).each(function(e){var r=n.select(this);try{r.call(s.fill,e[0].trace.fillcolor)}catch(e){c.error(e,t),r.remove()}})};var v=t("./symbol_defs");m.symbolNames=[],m.symbolFuncs=[],m.symbolNeedLines={},m.symbolNoDot={},m.symbolNoFill={},m.symbolList=[],Object.keys(v).forEach(function(t){var e=v[t];m.symbolList=m.symbolList.concat([e.n,t,e.n+100,t+"-open"]),m.symbolNames[e.n]=t,m.symbolFuncs[e.n]=e.f,e.needLine&&(m.symbolNeedLines[e.n]=!0),e.noDot?m.symbolNoDot[e.n]=!0:m.symbolList=m.symbolList.concat([e.n+200,t+"-dot",e.n+300,t+"-open-dot"]),e.noFill&&(m.symbolNoFill[e.n]=!0)});var y=m.symbolNames.length,x="M0,0.5L0.5,0L0,-0.5L-0.5,0Z";function b(t,e){var r=t%100;return m.symbolFuncs[r](e)+(t>=200?x:"")}m.symbolNumber=function(t){if("string"==typeof t){var e=0;t.indexOf("-open")>0&&(e=100,t=t.replace("-open","")),t.indexOf("-dot")>0&&(e+=200,t=t.replace("-dot","")),(t=m.symbolNames.indexOf(t))>=0&&(t+=e)}return t%100>=y||t>=400?0:Math.floor(Math.max(t,0))};var _={x1:1,x2:0,y1:0,y2:0},w={x1:0,x2:0,y1:1,y2:0};m.gradient=function(t,e,r,i,o,l){var u=e._fullLayout._defs.select(".gradients").selectAll("#"+r).data([i+o+l],c.identity);u.exit().remove(),u.enter().append("radial"===i?"radialGradient":"linearGradient").each(function(){var t=n.select(this);"horizontal"===i?t.attr(_):"vertical"===i&&t.attr(w),t.attr("id",r);var e=a(o),c=a(l);t.append("stop").attr({offset:"0%","stop-color":s.tinyRGB(c),"stop-opacity":c.getAlpha()}),t.append("stop").attr({offset:"100%","stop-color":s.tinyRGB(e),"stop-opacity":e.getAlpha()})}),t.style({fill:"url(#"+r+")","fill-opacity":null})},m.initGradients=function(t){c.ensureSingle(t._fullLayout._defs,"g","gradients").selectAll("linearGradient,radialGradient").remove()},m.pointStyle=function(t,e,r){if(t.size()){var i=m.makePointStyleFns(e);t.each(function(t){m.singlePointStyle(t,n.select(this),e,i,r)})}},m.singlePointStyle=function(t,e,r,n,i){var a=r.marker,o=a.line;if(e.style("opacity",n.selectedOpacityFn?n.selectedOpacityFn(t):void 0===t.mo?a.opacity:t.mo),n.ms2mrc){var l;l="various"===t.ms||"various"===a.size?3:n.ms2mrc(t.ms),t.mrc=l,n.selectedSizeFn&&(l=t.mrc=n.selectedSizeFn(t));var u=m.symbolNumber(t.mx||a.symbol)||0;t.om=u%200>=100,e.attr("d",b(u,l))}var f,h,p,d=!1;if(t.so?(p=o.outlierwidth,h=o.outliercolor,f=a.outliercolor):(p=(t.mlw+1||o.width+1||(t.trace?t.trace.marker.line.width:0)+1)-1,h="mlc"in t?t.mlcc=n.lineScale(t.mlc):c.isArrayOrTypedArray(o.color)?s.defaultLine:o.color,c.isArrayOrTypedArray(a.color)&&(f=s.defaultLine,d=!0),f="mc"in t?t.mcc=n.markerScale(t.mc):a.color||"rgba(0,0,0,0)",n.selectedColorFn&&(f=n.selectedColorFn(t))),t.om)e.call(s.stroke,f).style({"stroke-width":(p||1)+"px",fill:"none"});else{e.style("stroke-width",p+"px");var g=a.gradient,v=t.mgt;if(v?d=!0:v=g&&g.type,v&&"none"!==v){var y=t.mgc;y?d=!0:y=g.color;var x="g"+i._fullLayout._uid+"-"+r.uid;d&&(x+="-"+t.i),e.call(m.gradient,i,x,v,f,y)}else e.call(s.fill,f);p&&e.call(s.stroke,h)}},m.makePointStyleFns=function(t){var e={},r=t.marker;return e.markerScale=m.tryColorscale(r,""),e.lineScale=m.tryColorscale(r,"line"),o.traceIs(t,"symbols")&&(e.ms2mrc=d.isBubble(t)?g(t):function(){return(r.size||6)/2}),t.selectedpoints&&c.extendFlat(e,m.makeSelectedPointStyleFns(t)),e},m.makeSelectedPointStyleFns=function(t){var e={},r=t.selected||{},n=t.unselected||{},i=t.marker||{},a=r.marker||{},s=n.marker||{},l=i.opacity,u=a.opacity,f=s.opacity,h=void 0!==u,d=void 0!==f;(c.isArrayOrTypedArray(l)||h||d)&&(e.selectedOpacityFn=function(t){var e=void 0===t.mo?i.opacity:t.mo;return t.selected?h?u:e:d?f:p*e});var g=i.color,m=a.color,v=s.color;(m||v)&&(e.selectedColorFn=function(t){var e=t.mcc||g;return t.selected?m||e:v||e});var y=i.size,x=a.size,b=s.size,_=void 0!==x,w=void 0!==b;return o.traceIs(t,"symbols")&&(_||w)&&(e.selectedSizeFn=function(t){var e=t.mrc||y/2;return t.selected?_?x/2:e:w?b/2:e}),e},m.makeSelectedTextStyleFns=function(t){var e={},r=t.selected||{},n=t.unselected||{},i=t.textfont||{},a=r.textfont||{},o=n.textfont||{},l=i.color,c=a.color,u=o.color;return e.selectedTextColorFn=function(t){var e=t.tc||l;return t.selected?c||e:u||(c?e:s.addOpacity(e,p))},e},m.selectedPointStyle=function(t,e){if(t.size()&&e.selectedpoints){var r=m.makeSelectedPointStyleFns(e),i=e.marker||{},a=[];r.selectedOpacityFn&&a.push(function(t,e){t.style("opacity",r.selectedOpacityFn(e))}),r.selectedColorFn&&a.push(function(t,e){s.fill(t,r.selectedColorFn(e))}),r.selectedSizeFn&&a.push(function(t,e){var n=e.mx||i.symbol||0,a=r.selectedSizeFn(e);t.attr("d",b(m.symbolNumber(n),a)),e.mrc2=a}),a.length&&t.each(function(t){for(var e=n.select(this),r=0;r0?r:0}m.textPointStyle=function(t,e,r){if(t.size()){var i;if(e.selectedpoints){var a=m.makeSelectedTextStyleFns(e);i=a.selectedTextColorFn}t.each(function(t){var a=n.select(this),o=c.extractOption(t,e,"tx","text");if(o){var s=t.tp||e.textposition,l=A(t,e),f=i?i(t):t.tc||e.textfont.color;a.call(m.font,t.tf||e.textfont.family,l,f).text(o).call(u.convertToTspans,r).call(M,s,l,t.mrc)}else a.remove()})}},m.selectedTextStyle=function(t,e){if(t.size()&&e.selectedpoints){var r=m.makeSelectedTextStyleFns(e);t.each(function(t){var i=n.select(this),a=r.selectedTextColorFn(t),o=t.tp||e.textposition,l=A(t,e);s.fill(i,a),M(i,o,l,t.mrc2||t.mrc)})}};var T=.5;function S(t,e,r,i){var a=t[0]-e[0],o=t[1]-e[1],s=r[0]-e[0],l=r[1]-e[1],c=Math.pow(a*a+o*o,T/2),u=Math.pow(s*s+l*l,T/2),f=(u*u*a-c*c*s)*i,h=(u*u*o-c*c*l)*i,p=3*u*(c+u),d=3*c*(c+u);return[[n.round(e[0]+(p&&f/p),2),n.round(e[1]+(p&&h/p),2)],[n.round(e[0]-(d&&f/d),2),n.round(e[1]-(d&&h/d),2)]]}m.smoothopen=function(t,e){if(t.length<3)return"M"+t.join("L");var r,n="M"+t[0],i=[];for(r=1;r=1e4&&(m.savedBBoxes={},L=0),r&&(m.savedBBoxes[r]=v),L++,c.extendFlat({},v)},m.setClipUrl=function(t,e){if(e){if(void 0===m.baseUrl){var r=n.select("base");r.size()&&r.attr("href")?m.baseUrl=window.location.href.split("#")[0]:m.baseUrl=""}t.attr("clip-path","url("+m.baseUrl+"#"+e+")")}else t.attr("clip-path",null)},m.getTranslate=function(t){var e=(t[t.attr?"attr":"getAttribute"]("transform")||"").replace(/.*\btranslate\((-?\d*\.?\d*)[^-\d]*(-?\d*\.?\d*)[^\d].*/,function(t,e,r){return[e,r].join(" ")}).split(" ");return{x:+e[0]||0,y:+e[1]||0}},m.setTranslate=function(t,e,r){var n=t.attr?"attr":"getAttribute",i=t.attr?"attr":"setAttribute",a=t[n]("transform")||"";return e=e||0,r=r||0,a=a.replace(/(\btranslate\(.*?\);?)/,"").trim(),a=(a+=" translate("+e+", "+r+")").trim(),t[i]("transform",a),a},m.getScale=function(t){var e=(t[t.attr?"attr":"getAttribute"]("transform")||"").replace(/.*\bscale\((\d*\.?\d*)[^\d]*(\d*\.?\d*)[^\d].*/,function(t,e,r){return[e,r].join(" ")}).split(" ");return{x:+e[0]||1,y:+e[1]||1}},m.setScale=function(t,e,r){var n=t.attr?"attr":"getAttribute",i=t.attr?"attr":"setAttribute",a=t[n]("transform")||"";return e=e||1,r=r||1,a=a.replace(/(\bscale\(.*?\);?)/,"").trim(),a=(a+=" scale("+e+", "+r+")").trim(),t[i]("transform",a),a};var P=/\s*sc.*/;m.setPointGroupScale=function(t,e,r){if(e=e||1,r=r||1,t){var n=1===e&&1===r?"":" scale("+e+","+r+")";t.each(function(){var t=(this.getAttribute("transform")||"").replace(P,"");t=(t+=n).trim(),this.setAttribute("transform",t)})}};var D=/translate\([^)]*\)\s*$/;m.setTextPointsScale=function(t,e,r){t&&t.each(function(){var t,i=n.select(this),a=i.select("text");if(a.node()){var o=parseFloat(a.attr("x")||0),s=parseFloat(a.attr("y")||0),l=(i.attr("transform")||"").match(D);t=1===e&&1===r?[]:["translate("+o+","+s+")","scale("+e+","+r+")","translate("+-o+","+-s+")"],l&&t.push(l),i.attr("transform",t.join(" "))}})}},{"../../constants/alignment":632,"../../constants/interactions":636,"../../constants/xmlns_namespaces":639,"../../lib":660,"../../lib/svg_text_utils":684,"../../registry":790,"../../traces/scatter/make_bubble_size_func":1007,"../../traces/scatter/subtypes":1012,"../color":532,"../colorscale":547,"./symbol_defs":558,d3:131,"fast-isnumeric":197,tinycolor2:473}],558:[function(t,e,r){"use strict";var n=t("d3");e.exports={circle:{n:0,f:function(t){var e=n.round(t,2);return"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"}},square:{n:1,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"}},diamond:{n:2,f:function(t){var e=n.round(1.3*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"Z"}},cross:{n:3,f:function(t){var e=n.round(.4*t,2),r=n.round(1.2*t,2);return"M"+r+","+e+"H"+e+"V"+r+"H-"+e+"V"+e+"H-"+r+"V-"+e+"H-"+e+"V-"+r+"H"+e+"V-"+e+"H"+r+"Z"}},x:{n:4,f:function(t){var e=n.round(.8*t/Math.sqrt(2),2),r="l"+e+","+e,i="l"+e+",-"+e,a="l-"+e+",-"+e,o="l-"+e+","+e;return"M0,"+e+r+i+a+i+a+o+a+o+r+o+r+"Z"}},"triangle-up":{n:5,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+e+","+n.round(t/2,2)+"H"+e+"L0,-"+n.round(t,2)+"Z"}},"triangle-down":{n:6,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+e+",-"+n.round(t/2,2)+"H"+e+"L0,"+n.round(t,2)+"Z"}},"triangle-left":{n:7,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M"+n.round(t/2,2)+",-"+e+"V"+e+"L-"+n.round(t,2)+",0Z"}},"triangle-right":{n:8,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+n.round(t/2,2)+",-"+e+"V"+e+"L"+n.round(t,2)+",0Z"}},"triangle-ne":{n:9,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M-"+r+",-"+e+"H"+e+"V"+r+"Z"}},"triangle-se":{n:10,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M"+e+",-"+r+"V"+e+"H-"+r+"Z"}},"triangle-sw":{n:11,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M"+r+","+e+"H-"+e+"V-"+r+"Z"}},"triangle-nw":{n:12,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M-"+e+","+r+"V-"+e+"H"+r+"Z"}},pentagon:{n:13,f:function(t){var e=n.round(.951*t,2),r=n.round(.588*t,2),i=n.round(-t,2),a=n.round(-.309*t,2);return"M"+e+","+a+"L"+r+","+n.round(.809*t,2)+"H-"+r+"L-"+e+","+a+"L0,"+i+"Z"}},hexagon:{n:14,f:function(t){var e=n.round(t,2),r=n.round(t/2,2),i=n.round(t*Math.sqrt(3)/2,2);return"M"+i+",-"+r+"V"+r+"L0,"+e+"L-"+i+","+r+"V-"+r+"L0,-"+e+"Z"}},hexagon2:{n:15,f:function(t){var e=n.round(t,2),r=n.round(t/2,2),i=n.round(t*Math.sqrt(3)/2,2);return"M-"+r+","+i+"H"+r+"L"+e+",0L"+r+",-"+i+"H-"+r+"L-"+e+",0Z"}},octagon:{n:16,f:function(t){var e=n.round(.924*t,2),r=n.round(.383*t,2);return"M-"+r+",-"+e+"H"+r+"L"+e+",-"+r+"V"+r+"L"+r+","+e+"H-"+r+"L-"+e+","+r+"V-"+r+"Z"}},star:{n:17,f:function(t){var e=1.4*t,r=n.round(.225*e,2),i=n.round(.951*e,2),a=n.round(.363*e,2),o=n.round(.588*e,2),s=n.round(-e,2),l=n.round(-.309*e,2),c=n.round(.118*e,2),u=n.round(.809*e,2);return"M"+r+","+l+"H"+i+"L"+a+","+c+"L"+o+","+u+"L0,"+n.round(.382*e,2)+"L-"+o+","+u+"L-"+a+","+c+"L-"+i+","+l+"H-"+r+"L0,"+s+"Z"}},hexagram:{n:18,f:function(t){var e=n.round(.66*t,2),r=n.round(.38*t,2),i=n.round(.76*t,2);return"M-"+i+",0l-"+r+",-"+e+"h"+i+"l"+r+",-"+e+"l"+r+","+e+"h"+i+"l-"+r+","+e+"l"+r+","+e+"h-"+i+"l-"+r+","+e+"l-"+r+",-"+e+"h-"+i+"Z"}},"star-triangle-up":{n:19,f:function(t){var e=n.round(t*Math.sqrt(3)*.8,2),r=n.round(.8*t,2),i=n.round(1.6*t,2),a=n.round(4*t,2),o="A "+a+","+a+" 0 0 1 ";return"M-"+e+","+r+o+e+","+r+o+"0,-"+i+o+"-"+e+","+r+"Z"}},"star-triangle-down":{n:20,f:function(t){var e=n.round(t*Math.sqrt(3)*.8,2),r=n.round(.8*t,2),i=n.round(1.6*t,2),a=n.round(4*t,2),o="A "+a+","+a+" 0 0 1 ";return"M"+e+",-"+r+o+"-"+e+",-"+r+o+"0,"+i+o+e+",-"+r+"Z"}},"star-square":{n:21,f:function(t){var e=n.round(1.1*t,2),r=n.round(2*t,2),i="A "+r+","+r+" 0 0 1 ";return"M-"+e+",-"+e+i+"-"+e+","+e+i+e+","+e+i+e+",-"+e+i+"-"+e+",-"+e+"Z"}},"star-diamond":{n:22,f:function(t){var e=n.round(1.4*t,2),r=n.round(1.9*t,2),i="A "+r+","+r+" 0 0 1 ";return"M-"+e+",0"+i+"0,"+e+i+e+",0"+i+"0,-"+e+i+"-"+e+",0Z"}},"diamond-tall":{n:23,f:function(t){var e=n.round(.7*t,2),r=n.round(1.4*t,2);return"M0,"+r+"L"+e+",0L0,-"+r+"L-"+e+",0Z"}},"diamond-wide":{n:24,f:function(t){var e=n.round(1.4*t,2),r=n.round(.7*t,2);return"M0,"+r+"L"+e+",0L0,-"+r+"L-"+e+",0Z"}},hourglass:{n:25,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"H-"+e+"L"+e+",-"+e+"H-"+e+"Z"},noDot:!0},bowtie:{n:26,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"V-"+e+"L-"+e+","+e+"V-"+e+"Z"},noDot:!0},"circle-cross":{n:27,f:function(t){var e=n.round(t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"},needLine:!0,noDot:!0},"circle-x":{n:28,f:function(t){var e=n.round(t,2),r=n.round(t/Math.sqrt(2),2);return"M"+r+","+r+"L-"+r+",-"+r+"M"+r+",-"+r+"L-"+r+","+r+"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"},needLine:!0,noDot:!0},"square-cross":{n:29,f:function(t){var e=n.round(t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"},needLine:!0,noDot:!0},"square-x":{n:30,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e+"M"+e+",-"+e+"L-"+e+","+e+"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"},needLine:!0,noDot:!0},"diamond-cross":{n:31,f:function(t){var e=n.round(1.3*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"ZM0,-"+e+"V"+e+"M-"+e+",0H"+e},needLine:!0,noDot:!0},"diamond-x":{n:32,f:function(t){var e=n.round(1.3*t,2),r=n.round(.65*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"ZM-"+r+",-"+r+"L"+r+","+r+"M-"+r+","+r+"L"+r+",-"+r},needLine:!0,noDot:!0},"cross-thin":{n:33,f:function(t){var e=n.round(1.4*t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e},needLine:!0,noDot:!0,noFill:!0},"x-thin":{n:34,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e+"M"+e+",-"+e+"L-"+e+","+e},needLine:!0,noDot:!0,noFill:!0},asterisk:{n:35,f:function(t){var e=n.round(1.2*t,2),r=n.round(.85*t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+r+","+r+"L-"+r+",-"+r+"M"+r+",-"+r+"L-"+r+","+r},needLine:!0,noDot:!0,noFill:!0},hash:{n:36,f:function(t){var e=n.round(t/2,2),r=n.round(t,2);return"M"+e+","+r+"V-"+r+"m-"+r+",0V"+r+"M"+r+","+e+"H-"+r+"m0,-"+r+"H"+r},needLine:!0,noFill:!0},"y-up":{n:37,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+e+","+i+"L0,0M"+e+","+i+"L0,0M0,-"+r+"L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-down":{n:38,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+e+",-"+i+"L0,0M"+e+",-"+i+"L0,0M0,"+r+"L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-left":{n:39,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M"+i+","+e+"L0,0M"+i+",-"+e+"L0,0M-"+r+",0L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-right":{n:40,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+i+","+e+"L0,0M-"+i+",-"+e+"L0,0M"+r+",0L0,0"},needLine:!0,noDot:!0,noFill:!0},"line-ew":{n:41,f:function(t){var e=n.round(1.4*t,2);return"M"+e+",0H-"+e},needLine:!0,noDot:!0,noFill:!0},"line-ns":{n:42,f:function(t){var e=n.round(1.4*t,2);return"M0,"+e+"V-"+e},needLine:!0,noDot:!0,noFill:!0},"line-ne":{n:43,f:function(t){var e=n.round(t,2);return"M"+e+",-"+e+"L-"+e+","+e},needLine:!0,noDot:!0,noFill:!0},"line-nw":{n:44,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e},needLine:!0,noDot:!0,noFill:!0}}},{d3:131}],559:[function(t,e,r){"use strict";e.exports={visible:{valType:"boolean",editType:"calc"},type:{valType:"enumerated",values:["percent","constant","sqrt","data"],editType:"calc"},symmetric:{valType:"boolean",editType:"calc"},array:{valType:"data_array",editType:"calc"},arrayminus:{valType:"data_array",editType:"calc"},value:{valType:"number",min:0,dflt:10,editType:"calc"},valueminus:{valType:"number",min:0,dflt:10,editType:"calc"},traceref:{valType:"integer",min:0,dflt:0,editType:"style"},tracerefminus:{valType:"integer",min:0,dflt:0,editType:"style"},copy_ystyle:{valType:"boolean",editType:"plot"},copy_zstyle:{valType:"boolean",editType:"style"},color:{valType:"color",editType:"style"},thickness:{valType:"number",min:0,dflt:2,editType:"style"},width:{valType:"number",min:0,editType:"plot"},editType:"calc",_deprecated:{opacity:{valType:"number",editType:"style"}}}},{}],560:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../registry"),a=t("../../plots/cartesian/axes"),o=t("./compute_error");function s(t,e,r,i){var s=e["error_"+i]||{},l=[];if(s.visible&&-1!==["linear","log"].indexOf(r.type)){for(var c=o(s),u=0;u0;t.each(function(t){var u,f=t[0].trace,h=f.error_x||{},p=f.error_y||{};f.ids&&(u=function(t){return t.id});var d=o.hasMarkers(f)&&f.marker.maxdisplayed>0;p.visible||h.visible||(t=[]);var g=n.select(this).selectAll("g.errorbar").data(t,u);if(g.exit().remove(),t.length){h.visible||g.selectAll("path.xerror").remove(),p.visible||g.selectAll("path.yerror").remove(),g.style("opacity",1);var m=g.enter().append("g").classed("errorbar",!0);c&&m.style("opacity",0).transition().duration(r.duration).style("opacity",1),a.setClipUrl(g,e.layerClipId),g.each(function(t){var e=n.select(this),a=function(t,e,r){var n={x:e.c2p(t.x),y:r.c2p(t.y)};void 0!==t.yh&&(n.yh=r.c2p(t.yh),n.ys=r.c2p(t.ys),i(n.ys)||(n.noYS=!0,n.ys=r.c2p(t.ys,!0)));void 0!==t.xh&&(n.xh=e.c2p(t.xh),n.xs=e.c2p(t.xs),i(n.xs)||(n.noXS=!0,n.xs=e.c2p(t.xs,!0)));return n}(t,s,l);if(!d||t.vis){var o,u=e.select("path.yerror");if(p.visible&&i(a.x)&&i(a.yh)&&i(a.ys)){var f=p.width;o="M"+(a.x-f)+","+a.yh+"h"+2*f+"m-"+f+",0V"+a.ys,a.noYS||(o+="m-"+f+",0h"+2*f),!u.size()?u=e.append("path").style("vector-effect","non-scaling-stroke").classed("yerror",!0):c&&(u=u.transition().duration(r.duration).ease(r.easing)),u.attr("d",o)}else u.remove();var g=e.select("path.xerror");if(h.visible&&i(a.y)&&i(a.xh)&&i(a.xs)){var m=(h.copy_ystyle?p:h).width;o="M"+a.xh+","+(a.y-m)+"v"+2*m+"m0,-"+m+"H"+a.xs,a.noXS||(o+="m0,-"+m+"v"+2*m),!g.size()?g=e.append("path").style("vector-effect","non-scaling-stroke").classed("xerror",!0):c&&(g=g.transition().duration(r.duration).ease(r.easing)),g.attr("d",o)}else g.remove()}})}})}},{"../../traces/scatter/subtypes":1012,"../drawing":557,d3:131,"fast-isnumeric":197}],565:[function(t,e,r){"use strict";var n=t("d3"),i=t("../color");e.exports=function(t){t.each(function(t){var e=t[0].trace,r=e.error_y||{},a=e.error_x||{},o=n.select(this);o.selectAll("path.yerror").style("stroke-width",r.thickness+"px").call(i.stroke,r.color),a.copy_ystyle&&(a=r),o.selectAll("path.xerror").style("stroke-width",a.thickness+"px").call(i.stroke,a.color)})}},{"../color":532,d3:131}],566:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes");e.exports={hoverlabel:{bgcolor:{valType:"color",arrayOk:!0,editType:"none"},bordercolor:{valType:"color",arrayOk:!0,editType:"none"},font:n({arrayOk:!0,editType:"none"}),namelength:{valType:"integer",min:-1,arrayOk:!0,editType:"none"},editType:"calc"}}},{"../../plots/font_attributes":732}],567:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry");function a(t,e,r,i){i=i||n.identity,Array.isArray(t)&&(e[0][r]=i(t))}e.exports=function(t){var e=t.calcdata,r=t._fullLayout;function o(t){return function(e){return n.coerceHoverinfo({hoverinfo:e},{_module:t._module},r)}}for(var s=0;s=0&&r.index-1&&o.length>y&&(o=y>3?o.substr(0,y-3)+"...":o.substr(0,y))}void 0!==t.zLabel?(void 0!==t.xLabel&&(c+="x: "+t.xLabel+"
"),void 0!==t.yLabel&&(c+="y: "+t.yLabel+"
"),c+=(c?"z: ":"")+t.zLabel):L&&t[i+"Label"]===M?c=t[("x"===i?"y":"x")+"Label"]||"":void 0===t.xLabel?void 0!==t.yLabel&&(c=t.yLabel):c=void 0===t.yLabel?t.xLabel:"("+t.xLabel+", "+t.yLabel+")",t.text&&!Array.isArray(t.text)&&(c+=(c?"
":"")+t.text),void 0!==t.extraText&&(c+=(c?"
":"")+t.extraText),""===c&&(""===o&&e.remove(),c=o);var x=e.select("text.nums").call(u.font,t.fontFamily||d,t.fontSize||g,t.fontColor||m).text(c).attr("data-notex",1).call(l.positionText,0,0).call(l.convertToTspans,r),b=e.select("text.name"),_=0;o&&o!==c?(b.call(u.font,t.fontFamily||d,t.fontSize||g,p).text(o).attr("data-notex",1).call(l.positionText,0,0).call(l.convertToTspans,r),_=b.node().getBoundingClientRect().width+2*k):(b.remove(),e.select("rect").remove()),e.select("path").style({fill:p,stroke:m});var A,T,z=x.node().getBoundingClientRect(),P=t.xa._offset+(t.x0+t.x1)/2,D=t.ya._offset+(t.y0+t.y1)/2,O=Math.abs(t.x1-t.x0),I=Math.abs(t.y1-t.y0),R=z.width+w+k+_;t.ty0=S-z.top,t.bx=z.width+2*k,t.by=z.height+2*k,t.anchor="start",t.txwidth=z.width,t.tx2width=_,t.offset=0,a?(t.pos=P,A=D+I/2+R<=E,T=D-I/2-R>=0,"top"!==t.idealAlign&&A||!T?A?(D+=I/2,t.anchor="start"):t.anchor="middle":(D-=I/2,t.anchor="end")):(t.pos=D,A=P+O/2+R<=C,T=P-O/2-R>=0,"left"!==t.idealAlign&&A||!T?A?(P+=O/2,t.anchor="start"):t.anchor="middle":(P-=O/2,t.anchor="end")),x.attr("text-anchor",t.anchor),_&&b.attr("text-anchor",t.anchor),e.attr("transform","translate("+P+","+D+")"+(a?"rotate("+v+")":""))}),R}function A(t,e){t.each(function(t){var r=n.select(this);if(t.del)r.remove();else{var i="end"===t.anchor?-1:1,a=r.select("text.nums"),o={start:1,end:-1,middle:0}[t.anchor],s=o*(w+k),c=s+o*(t.txwidth+k),f=0,h=t.offset;"middle"===t.anchor&&(s-=t.tx2width/2,c+=t.txwidth/2+k),e&&(h*=-_,f=t.offset*b),r.select("path").attr("d","middle"===t.anchor?"M-"+(t.bx/2+t.tx2width/2)+","+(h-t.by/2)+"h"+t.bx+"v"+t.by+"h-"+t.bx+"Z":"M0,0L"+(i*w+f)+","+(w+h)+"v"+(t.by/2-w)+"h"+i*t.bx+"v-"+t.by+"H"+(i*w+f)+"V"+(h-w)+"Z"),a.call(l.positionText,s+f,h+t.ty0-t.by/2+k),t.tx2width&&(r.select("text.name").call(l.positionText,c+o*k+f,h+t.ty0-t.by/2+k),r.select("rect").call(u.setRect,c+(o-1)*t.tx2width/2+f,h-t.by/2-1,t.tx2width,t.by+2))}})}function T(t,e){var r=t.index,n=t.trace||{},i=t.cd[0],a=t.cd[r]||{},s=Array.isArray(r)?function(t,e){return o.castOption(i,r,t)||o.extractOption({},n,"",e)}:function(t,e){return o.extractOption(a,n,t,e)};function l(e,r,n){var i=s(r,n);i&&(t[e]=i)}if(l("hoverinfo","hi","hoverinfo"),l("color","hbg","hoverlabel.bgcolor"),l("borderColor","hbc","hoverlabel.bordercolor"),l("fontFamily","htf","hoverlabel.font.family"),l("fontSize","hts","hoverlabel.font.size"),l("fontColor","htc","hoverlabel.font.color"),l("nameLength","hnl","hoverlabel.namelength"),t.posref="y"===e?t.xa._offset+(t.x0+t.x1)/2:t.ya._offset+(t.y0+t.y1)/2,t.x0=o.constrain(t.x0,0,t.xa._length),t.x1=o.constrain(t.x1,0,t.xa._length),t.y0=o.constrain(t.y0,0,t.ya._length),t.y1=o.constrain(t.y1,0,t.ya._length),void 0!==t.xLabelVal&&(t.xLabel="xLabel"in t?t.xLabel:p.hoverLabelText(t.xa,t.xLabelVal),t.xVal=t.xa.c2d(t.xLabelVal)),void 0!==t.yLabelVal&&(t.yLabel="yLabel"in t?t.yLabel:p.hoverLabelText(t.ya,t.yLabelVal),t.yVal=t.ya.c2d(t.yLabelVal)),void 0!==t.zLabelVal&&void 0===t.zLabel&&(t.zLabel=String(t.zLabelVal)),!(isNaN(t.xerr)||"log"===t.xa.type&&t.xerr<=0)){var c=p.tickText(t.xa,t.xa.c2l(t.xerr),"hover").text;void 0!==t.xerrneg?t.xLabel+=" +"+c+" / -"+p.tickText(t.xa,t.xa.c2l(t.xerrneg),"hover").text:t.xLabel+=" \xb1 "+c,"x"===e&&(t.distance+=1)}if(!(isNaN(t.yerr)||"log"===t.ya.type&&t.yerr<=0)){var u=p.tickText(t.ya,t.ya.c2l(t.yerr),"hover").text;void 0!==t.yerrneg?t.yLabel+=" +"+u+" / -"+p.tickText(t.ya,t.ya.c2l(t.yerrneg),"hover").text:t.yLabel+=" \xb1 "+u,"y"===e&&(t.distance+=1)}var f=t.hoverinfo||t.trace.hoverinfo;return"all"!==f&&(-1===(f=Array.isArray(f)?f:f.split("+")).indexOf("x")&&(t.xLabel=void 0),-1===f.indexOf("y")&&(t.yLabel=void 0),-1===f.indexOf("z")&&(t.zLabel=void 0),-1===f.indexOf("text")&&(t.text=void 0),-1===f.indexOf("name")&&(t.name=void 0)),t}function S(t,e){var r,n,i=e.container,o=e.fullLayout,s=e.event,l=!!t.hLinePoint,c=!!t.vLinePoint;if(i.selectAll(".spikeline").remove(),c||l){var h=f.combine(o.plot_bgcolor,o.paper_bgcolor);if(l){var p,d,g=t.hLinePoint;r=g&&g.xa,"cursor"===(n=g&&g.ya).spikesnap?(p=s.pointerX,d=s.pointerY):(p=r._offset+g.x,d=n._offset+g.y);var m,v,y=a.readability(g.color,h)<1.5?f.contrast(h):g.color,x=n.spikemode,b=n.spikethickness,_=n.spikecolor||y,w=n._boundingBox,k=(w.left+w.right)/2w[0]._length||tt<0||tt>k[0]._length)return h.unhoverRaw(t,e)}if(e.pointerX=$+w[0]._offset,e.pointerY=tt+k[0]._offset,I="xval"in e?g.flat(l,e.xval):g.p2c(w,$),R="yval"in e?g.flat(l,e.yval):g.p2c(k,tt),!i(I[0])||!i(R[0]))return o.warn("Fx.hover failed",e,t),h.unhoverRaw(t,e)}var nt=1/0;for(F=0;FY&&(J.splice(0,Y),nt=J[0].distance),y&&0!==Z&&0===J.length){W.distance=Z,W.index=!1;var lt=j._module.hoverPoints(W,H,G,"closest",u._hoverlayer);if(lt&&(lt=lt.filter(function(t){return t.spikeDistance<=Z})),lt&<.length){var ct,ut=lt.filter(function(t){return t.xa.showspikes});if(ut.length){var ft=ut[0];i(ft.x0)&&i(ft.y0)&&(ct=gt(ft),(!Q.vLinePoint||Q.vLinePoint.spikeDistance>ct.spikeDistance)&&(Q.vLinePoint=ct))}var ht=lt.filter(function(t){return t.ya.showspikes});if(ht.length){var pt=ht[0];i(pt.x0)&&i(pt.y0)&&(ct=gt(pt),(!Q.hLinePoint||Q.hLinePoint.spikeDistance>ct.spikeDistance)&&(Q.hLinePoint=ct))}}}}function dt(t,e){for(var r,n=null,i=1/0,a=0;a1,Ct=f.combine(u.plot_bgcolor||f.background,u.paper_bgcolor),Et={hovermode:O,rotateLabels:St,bgColor:Ct,container:u._hoverlayer,outerContainer:u._paperdiv,commonLabelOpts:u.hoverlabel,hoverdistance:u.hoverdistance},Lt=M(J,Et,t);if(function(t,e,r){var n,i,a,o,s,l,c,u=0,f=t.map(function(t,n){var i=t[e];return[{i:n,dp:0,pos:t.pos,posref:t.posref,size:t.by*("x"===i._id.charAt(0)?x:1)/2,pmin:0,pmax:"x"===i._id.charAt(0)?r.width:r.height}]}).sort(function(t,e){return t[0].posref-e[0].posref});function h(t){var e=t[0],r=t[t.length-1];if(i=e.pmin-e.pos-e.dp+e.size,a=r.pos+r.dp+r.size-e.pmax,i>.01){for(s=t.length-1;s>=0;s--)t[s].dp+=i;n=!1}if(!(a<.01)){if(i<-.01){for(s=t.length-1;s>=0;s--)t[s].dp-=a;n=!1}if(n){var c=0;for(o=0;oe.pmax&&c++;for(o=t.length-1;o>=0&&!(c<=0);o--)(l=t[o]).pos>e.pmax-1&&(l.del=!0,c--);for(o=0;o=0;s--)t[s].dp-=a;for(o=t.length-1;o>=0&&!(c<=0);o--)(l=t[o]).pos+l.dp+l.size>e.pmax&&(l.del=!0,c--)}}}for(;!n&&u<=t.length;){for(u++,n=!0,o=0;o.01&&g.pmin===m.pmin&&g.pmax===m.pmax){for(s=d.length-1;s>=0;s--)d[s].dp+=i;for(p.push.apply(p,d),f.splice(o+1,1),c=0,s=p.length-1;s>=0;s--)c+=p[s].dp;for(a=c/p.length,s=p.length-1;s>=0;s--)p[s].dp-=a;n=!1}else o++}f.forEach(h)}for(o=f.length-1;o>=0;o--){var v=f[o];for(s=v.length-1;s>=0;s--){var y=v[s],b=t[y.i];b.offset=y.dp,b.del=y.del}}}(J,St?"xa":"ya",u),A(Lt,St),e.target&&e.target.tagName){var zt=d.getComponentMethod("annotations","hasClickToShow")(t,At);c(n.select(e.target),zt?"pointer":"")}if(!e.target||a||!function(t,e,r){if(!r||r.length!==t._hoverdata.length)return!0;for(var n=r.length-1;n>=0;n--){var i=r[n],a=t._hoverdata[n];if(i.curveNumber!==a.curveNumber||String(i.pointNumber)!==String(a.pointNumber))return!0}return!1}(t,0,Mt))return;Mt&&t.emit("plotly_unhover",{event:e,points:Mt});t.emit("plotly_hover",{event:e,points:t._hoverdata,xaxes:w,yaxes:k,xvals:I,yvals:R})}(t,e,r,a)})},r.loneHover=function(t,e){var r={color:t.color||f.defaultLine,x0:t.x0||t.x||0,x1:t.x1||t.x||0,y0:t.y0||t.y||0,y1:t.y1||t.y||0,xLabel:t.xLabel,yLabel:t.yLabel,zLabel:t.zLabel,text:t.text,name:t.name,idealAlign:t.idealAlign,borderColor:t.borderColor,fontFamily:t.fontFamily,fontSize:t.fontSize,fontColor:t.fontColor,trace:{index:0,hoverinfo:""},xa:{_offset:0},ya:{_offset:0},index:0},i=n.select(e.container),a=e.outerContainer?n.select(e.outerContainer):i,o={hovermode:"closest",rotateLabels:!1,bgColor:e.bgColor||f.background,container:i,outerContainer:a},s=M([r],o,e.gd);return A(s,o.rotateLabels),s.node()}},{"../../lib":660,"../../lib/events":648,"../../lib/override_cursor":671,"../../lib/svg_text_utils":684,"../../plots/cartesian/axes":706,"../../registry":790,"../color":532,"../dragelement":554,"../drawing":557,"./constants":569,"./helpers":571,d3:131,"fast-isnumeric":197,tinycolor2:473}],573:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e,r,i){r("hoverlabel.bgcolor",(i=i||{}).bgcolor),r("hoverlabel.bordercolor",i.bordercolor),r("hoverlabel.namelength",i.namelength),n.coerceFont(r,"hoverlabel.font",i.font)}},{"../../lib":660}],574:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../dragelement"),o=t("./helpers"),s=t("./layout_attributes");e.exports={moduleType:"component",name:"fx",constants:t("./constants"),schema:{layout:s},attributes:t("./attributes"),layoutAttributes:s,supplyLayoutGlobalDefaults:t("./layout_global_defaults"),supplyDefaults:t("./defaults"),supplyLayoutDefaults:t("./layout_defaults"),calc:t("./calc"),getDistanceFunction:o.getDistanceFunction,getClosest:o.getClosest,inbox:o.inbox,quadrature:o.quadrature,appendArrayPointValue:o.appendArrayPointValue,castHoverOption:function(t,e,r){return i.castOption(t,e,"hoverlabel."+r)},castHoverinfo:function(t,e,r){return i.castOption(t,r,"hoverinfo",function(r){return i.coerceHoverinfo({hoverinfo:r},{_module:t._module},e)})},hover:t("./hover").hover,unhover:a.unhover,loneHover:t("./hover").loneHover,loneUnhover:function(t){var e=i.isD3Selection(t)?t:n.select(t);e.selectAll("g.hovertext").remove(),e.selectAll(".spikeline").remove()},click:t("./click")}},{"../../lib":660,"../dragelement":554,"./attributes":566,"./calc":567,"./click":568,"./constants":569,"./defaults":570,"./helpers":571,"./hover":572,"./layout_attributes":575,"./layout_defaults":576,"./layout_global_defaults":577,d3:131}],575:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../plots/font_attributes")({editType:"none"});i.family.dflt=n.HOVERFONT,i.size.dflt=n.HOVERFONTSIZE,e.exports={dragmode:{valType:"enumerated",values:["zoom","pan","select","lasso","orbit","turntable"],dflt:"zoom",editType:"modebar"},hovermode:{valType:"enumerated",values:["x","y","closest",!1],editType:"modebar"},hoverdistance:{valType:"integer",min:-1,dflt:20,editType:"none"},spikedistance:{valType:"integer",min:-1,dflt:20,editType:"none"},hoverlabel:{bgcolor:{valType:"color",editType:"none"},bordercolor:{valType:"color",editType:"none"},font:i,namelength:{valType:"integer",min:-1,dflt:15,editType:"none"},editType:"none"},selectdirection:{valType:"enumerated",values:["h","v","d","any"],dflt:"any",editType:"none"}}},{"../../plots/font_attributes":732,"./constants":569}],576:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./layout_attributes");e.exports=function(t,e,r){function a(r,a){return n.coerce(t,e,i,r,a)}var o;"select"===a("dragmode")&&a("selectdirection"),e._has("cartesian")?(e._isHoriz=function(t){for(var e=!0,r=0;r1){f||h||p||"independent"===k("pattern")&&(f=!0),g._hasSubplotGrid=f;var y,x,b="top to bottom"===k("roworder"),_=f?.2:.1,w=f?.3:.1;d&&e._splomGridDflt&&(y=e._splomGridDflt.xside,x=e._splomGridDflt.yside),g._domains={x:c("x",k,_,y,v),y:c("y",k,w,x,m,b)},e.grid=g}}function k(t,e){return n.coerce(r,g,s,t,e)}},contentDefaults:function(t,e){var r=e.grid;if(r&&r._domains){var n,i,a,o,s,c,f,h=t.grid||{},p=e._subplots,d=r._hasSubplotGrid,g=r.rows,m=r.columns,v="independent"===r.pattern,y=r._axisMap={};if(d){var x=h.subplots||[];c=r.subplots=new Array(g);var b=1;for(n=0;n=2/3},r.isCenterAnchor=function(t){return"center"===t.xanchor||"auto"===t.xanchor&&t.x>1/3&&t.x<2/3},r.isBottomAnchor=function(t){return"bottom"===t.yanchor||"auto"===t.yanchor&&t.y<=1/3},r.isMiddleAnchor=function(t){return"middle"===t.yanchor||"auto"===t.yanchor&&t.y>1/3&&t.y<2/3}},{}],585:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../color/attributes");e.exports={bgcolor:{valType:"color",editType:"legend"},bordercolor:{valType:"color",dflt:i.defaultLine,editType:"legend"},borderwidth:{valType:"number",min:0,dflt:0,editType:"legend"},font:n({editType:"legend"}),orientation:{valType:"enumerated",values:["v","h"],dflt:"v",editType:"legend"},traceorder:{valType:"flaglist",flags:["reversed","grouped"],extras:["normal"],editType:"legend"},tracegroupgap:{valType:"number",min:0,dflt:10,editType:"legend"},x:{valType:"number",min:-2,max:3,dflt:1.02,editType:"legend"},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"left",editType:"legend"},y:{valType:"number",min:-2,max:3,dflt:1,editType:"legend"},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"auto",editType:"legend"},editType:"legend"}},{"../../plots/font_attributes":732,"../color/attributes":531}],586:[function(t,e,r){"use strict";e.exports={scrollBarWidth:6,scrollBarMinHeight:20,scrollBarColor:"#808BA4",scrollBarMargin:4}},{}],587:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("./attributes"),o=t("../../plots/layout_attributes"),s=t("./helpers");e.exports=function(t,e,r){for(var l,c,u,f,h=t.legend||{},p={},d=0,g="normal",m=0;m1)){if(e.legend=p,y("bgcolor",e.paper_bgcolor),y("bordercolor"),y("borderwidth"),i.coerceFont(y,"font",e.font),y("orientation"),"h"===p.orientation){var x=t.xaxis;x&&x.rangeslider&&x.rangeslider.visible?(l=0,u="left",c=1.1,f="bottom"):(l=0,u="left",c=-.1,f="top")}y("traceorder",g),s.isGrouped(e.legend)&&y("tracegroupgap"),y("x",l),y("xanchor",u),y("y",c),y("yanchor",f),i.noneOrAll(h,p,["x","y"])}}},{"../../lib":660,"../../plots/layout_attributes":759,"../../registry":790,"./attributes":585,"./helpers":591}],588:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib/events"),l=t("../dragelement"),c=t("../drawing"),u=t("../color"),f=t("../../lib/svg_text_utils"),h=t("./handle_click"),p=t("./constants"),d=t("../../constants/interactions"),g=t("../../constants/alignment"),m=g.LINE_SPACING,v=g.FROM_TL,y=g.FROM_BR,x=t("./get_legend_data"),b=t("./style"),_=t("./helpers"),w=t("./anchor_utils"),k=d.DBLCLICKDELAY;function M(t,e,r,n,i){var a=r.data()[0][0].trace,o={event:i,node:r.node(),curveNumber:a.index,expandedIndex:a._expandedIndex,data:t.data,layout:t.layout,frames:t._transitionData._frames,config:t._context,fullData:t._fullData,fullLayout:t._fullLayout};if(a._group&&(o.group=a._group),"pie"===a.type&&(o.label=r.datum()[0].label),!1!==s.triggerHandler(t,"plotly_legendclick",o))if(1===n)e._clickTimeout=setTimeout(function(){h(r,t,n)},k);else if(2===n){e._clickTimeout&&clearTimeout(e._clickTimeout),t._legendMouseDownTime=0,!1!==s.triggerHandler(t,"plotly_legenddoubleclick",o)&&h(r,t,n)}}function A(t,e,r){var n=t.data()[0][0],a=e._fullLayout,s=n.trace,l=o.traceIs(s,"pie"),u=s.index,h=l?n.label:s.name,p=e._context.edits.legendText&&!l,d=i.ensureSingle(t,"text","legendtext");function g(r){f.convertToTspans(r,e,function(){!function(t,e){var r=t.data()[0][0];if(!r.trace.showlegend)return void t.remove();var n,i,a=t.select("g[class*=math-group]"),o=a.node(),s=e._fullLayout.legend.font.size*m;if(o){var l=c.bBox(o);n=l.height,i=l.width,c.setTranslate(a,0,n/4)}else{var u=t.select(".legendtext"),h=f.lineCount(u),p=u.node();n=s*h,i=p?c.bBox(p).width:0;var d=s*(.3+(1-h)/2);f.positionText(u,40,d)}n=Math.max(n,16)+3,r.height=n,r.width=i}(t,e)})}d.attr("text-anchor","start").classed("user-select-none",!0).call(c.font,a.legend.font).text(p?T(h,r):h),p?d.call(f.makeEditable,{gd:e,text:h}).call(g).on("edit",function(t){this.text(T(t,r)).call(g);var a=n.trace._fullInput||{},s={};if(o.hasTransform(a,"groupby")){var l=o.getTransformIndices(a,"groupby"),c=l[l.length-1],f=i.keyedContainer(a,"transforms["+c+"].styles","target","value.name");f.set(n.trace._group,t),s=f.constructUpdate()}else s.name=t;return o.call("restyle",e,s,u)}):g(d)}function T(t,e){var r=Math.max(4,e);if(t&&t.trim().length>=r/2)return t;for(var n=r-(t=t||"").length;n>0;n--)t+=" ";return t}function S(t,e){var r,a=1,o=i.ensureSingle(t,"rect","legendtoggle",function(t){t.style("cursor","pointer").attr("pointer-events","all").call(u.fill,"rgba(0,0,0,0)")});o.on("mousedown",function(){(r=(new Date).getTime())-e._legendMouseDownTimek&&(a=Math.max(a-1,1)),M(e,r,t,a,n.event)}})}function C(t,e,r){var i=t._fullLayout,a=i.legend,o=a.borderwidth,s=_.isGrouped(a),l=0;if(a._width=0,a._height=0,_.isVertical(a))s&&e.each(function(t,e){c.setTranslate(this,0,e*a.tracegroupgap)}),r.each(function(t){var e=t[0],r=e.height,n=e.width;c.setTranslate(this,o,5+o+a._height+r/2),a._height+=r,a._width=Math.max(a._width,n)}),a._width+=45+2*o,a._height+=10+2*o,s&&(a._height+=(a._lgroupsLength-1)*a.tracegroupgap),l=40;else if(s){for(var u=[a._width],f=e.data(),h=0,p=f.length;ho+w-k,r.each(function(t){var e=t[0],r=m?40+t[0].width:x;o+b+k+r>i.width-(i.margin.r+i.margin.l)&&(b=0,v+=y,a._height=a._height+y,y=0),c.setTranslate(this,o+b,5+o+e.height/2+v),a._width+=k+r,a._height=Math.max(a._height,e.height),b+=k+r,y=Math.max(e.height,y)}),a._width+=2*o,a._height+=10+2*o}a._width=Math.ceil(a._width),a._height=Math.ceil(a._height),r.each(function(e){var r=e[0],i=n.select(this).select(".legendtoggle");c.setRect(i,0,-r.height/2,(t._context.edits.legendText?0:a._width)+l,r.height)})}function E(t){var e=t._fullLayout.legend,r="left";w.isRightAnchor(e)?r="right":w.isCenterAnchor(e)&&(r="center");var n="top";w.isBottomAnchor(e)?n="bottom":w.isMiddleAnchor(e)&&(n="middle"),a.autoMargin(t,"legend",{x:e.x,y:e.y,l:e._width*v[r],r:e._width*y[r],b:e._height*y[n],t:e._height*v[n]})}e.exports=function(t){var e=t._fullLayout,r="legend"+e._uid;if(e._infolayer&&t.calcdata){t._legendMouseDownTime||(t._legendMouseDownTime=0);var s=e.legend,f=e.showlegend&&x(t.calcdata,s),h=e.hiddenlabels||[];if(!e.showlegend||!f.length)return e._infolayer.selectAll(".legend").remove(),e._topdefs.select("#"+r).remove(),void a.autoMargin(t,"legend");for(var d=0,g=0;gN?function(t){var e=t._fullLayout.legend,r="left";w.isRightAnchor(e)?r="right":w.isCenterAnchor(e)&&(r="center");a.autoMargin(t,"legend",{x:e.x,y:.5,l:e._width*v[r],r:e._width*y[r],b:0,t:0})}(t):E(t);var j=e._size,V=j.l+j.w*s.x,U=j.t+j.h*(1-s.y);w.isRightAnchor(s)?V-=s._width:w.isCenterAnchor(s)&&(V-=s._width/2),w.isBottomAnchor(s)?U-=s._height:w.isMiddleAnchor(s)&&(U-=s._height/2);var q=s._width,H=j.w;q>H?(V=j.l,q=H):(V+q>F&&(V=F-q),V<0&&(V=0),q=Math.min(F-V,s._width));var G,W,Y,X,Z=s._height,J=j.h;if(Z>J?(U=j.t,Z=J):(U+Z>N&&(U=N-Z),U<0&&(U=0),Z=Math.min(N-U,s._height)),c.setTranslate(z,V,U),I.on(".drag",null),z.on("wheel",null),s._height<=Z||t._context.staticPlot)D.attr({width:q-s.borderwidth,height:Z-s.borderwidth,x:s.borderwidth/2,y:s.borderwidth/2}),c.setTranslate(O,0,0),P.select("rect").attr({width:q-2*s.borderwidth,height:Z-2*s.borderwidth,x:s.borderwidth,y:s.borderwidth}),c.setClipUrl(O,r),c.setRect(I,0,0,0,0),delete s._scrollY;else{var K,Q,$=Math.max(p.scrollBarMinHeight,Z*Z/s._height),tt=Z-$-2*p.scrollBarMargin,et=s._height-Z,rt=tt/et,nt=Math.min(s._scrollY||0,et);D.attr({width:q-2*s.borderwidth+p.scrollBarWidth+p.scrollBarMargin,height:Z-s.borderwidth,x:s.borderwidth/2,y:s.borderwidth/2}),P.select("rect").attr({width:q-2*s.borderwidth+p.scrollBarWidth+p.scrollBarMargin,height:Z-2*s.borderwidth,x:s.borderwidth,y:s.borderwidth+nt}),c.setClipUrl(O,r),at(nt,$,rt),z.on("wheel",function(){at(nt=i.constrain(s._scrollY+n.event.deltaY/tt*et,0,et),$,rt),0!==nt&&nt!==et&&n.event.preventDefault()});var it=n.behavior.drag().on("dragstart",function(){K=n.event.sourceEvent.clientY,Q=nt}).on("drag",function(){var t=n.event.sourceEvent;2===t.buttons||t.ctrlKey||at(nt=i.constrain((t.clientY-K)/rt+Q,0,et),$,rt)});I.call(it)}if(t._context.edits.legendPosition)z.classed("cursor-move",!0),l.init({element:z.node(),gd:t,prepFn:function(){var t=c.getTranslate(z);Y=t.x,X=t.y},moveFn:function(t,e){var r=Y+t,n=X+e;c.setTranslate(z,r,n),G=l.align(r,0,j.l,j.l+j.w,s.xanchor),W=l.align(n,0,j.t+j.h,j.t,s.yanchor)},doneFn:function(){void 0!==G&&void 0!==W&&o.call("relayout",t,{"legend.x":G,"legend.y":W})},clickFn:function(r,n){var i=e._infolayer.selectAll("g.traces").filter(function(){var t=this.getBoundingClientRect();return n.clientX>=t.left&&n.clientX<=t.right&&n.clientY>=t.top&&n.clientY<=t.bottom});i.size()>0&&M(t,z,i,r,n)}})}function at(e,r,n){s._scrollY=t._fullLayout.legend._scrollY=e,c.setTranslate(O,0,-e),c.setRect(I,q,p.scrollBarMargin+e*n,p.scrollBarWidth,r),P.select("rect").attr({y:s.borderwidth+e})}}},{"../../constants/alignment":632,"../../constants/interactions":636,"../../lib":660,"../../lib/events":648,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../../registry":790,"../color":532,"../dragelement":554,"../drawing":557,"./anchor_utils":584,"./constants":586,"./get_legend_data":589,"./handle_click":590,"./helpers":591,"./style":593,d3:131}],589:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("./helpers");e.exports=function(t,e){var r,a,o={},s=[],l=!1,c={},u=0;function f(t,r){if(""!==t&&i.isGrouped(e))-1===s.indexOf(t)?(s.push(t),l=!0,o[t]=[[r]]):o[t].push([r]);else{var n="~~i"+u;s.push(n),o[n]=[[r]],u++}}for(r=0;rr[1])return r[1]}return i}function d(t){return t[0]}if(u||f||h){var g={},m={};u&&(g.mc=p("marker.color",d),g.mo=p("marker.opacity",a.mean,[.2,1]),g.ms=p("marker.size",a.mean,[2,16]),g.mlc=p("marker.line.color",d),g.mlw=p("marker.line.width",a.mean,[0,5]),m.marker={sizeref:1,sizemin:1,sizemode:"diameter"}),h&&(m.line={width:p("line.width",d,[0,10])}),f&&(g.tx="Aa",g.tp=p("textposition",d),g.ts=10,g.tc=p("textfont.color",d),g.tf=p("textfont.family",d)),r=[a.minExtend(s,g)],(i=a.minExtend(c,m)).selectedpoints=null}var v=n.select(this).select("g.legendpoints"),y=v.selectAll("path.scatterpts").data(u?r:[]);y.enter().append("path").classed("scatterpts",!0).attr("transform","translate(20,0)"),y.exit().remove(),y.call(o.pointStyle,i,e),u&&(r[0].mrc=3);var x=v.selectAll("g.pointtext").data(f?r:[]);x.enter().append("g").classed("pointtext",!0).append("text").attr("transform","translate(20,0)"),x.exit().remove(),x.selectAll("text").call(o.textPointStyle,i,e)}).each(function(t){var e=t[0].trace,r=n.select(this).select("g.legendpoints").selectAll("path.legendcandle").data("candlestick"===e.type&&e.visible?[t,t]:[]);r.enter().append("path").classed("legendcandle",!0).attr("d",function(t,e){return e?"M-15,0H-8M-8,6V-6H8Z":"M15,0H8M8,-6V6H-8Z"}).attr("transform","translate(20,0)").style("stroke-miterlimit",1),r.exit().remove(),r.each(function(t,r){var i=e[r?"increasing":"decreasing"],a=i.line.width,o=n.select(this);o.style("stroke-width",a+"px").call(s.fill,i.fillcolor),a&&s.stroke(o,i.line.color)})}).each(function(t){var e=t[0].trace,r=n.select(this).select("g.legendpoints").selectAll("path.legendohlc").data("ohlc"===e.type&&e.visible?[t,t]:[]);r.enter().append("path").classed("legendohlc",!0).attr("d",function(t,e){return e?"M-15,0H0M-8,-6V0":"M15,0H0M8,6V0"}).attr("transform","translate(20,0)").style("stroke-miterlimit",1),r.exit().remove(),r.each(function(t,r){var i=e[r?"increasing":"decreasing"],a=i.line.width,l=n.select(this);l.style("fill","none").call(o.dashLine,i.line.dash,a),a&&s.stroke(l,i.line.color)})})}},{"../../lib":660,"../../registry":790,"../../traces/pie/style_one":976,"../../traces/scatter/subtypes":1012,"../color":532,"../drawing":557,d3:131}],594:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../plots/plots"),a=t("../../plots/cartesian/axis_ids"),o=t("../../lib"),s=t("../../../build/ploticon"),l=o._,c=e.exports={};function u(t,e){var r,i,o=e.currentTarget,s=o.getAttribute("data-attr"),l=o.getAttribute("data-val")||!0,c=t._fullLayout,u={},f=a.list(t,null,!0),h="on";if("zoom"===s){var p,d="in"===l?.5:2,g=(1+d)/2,m=(1-d)/2;for(i=0;i1?(_=["toggleHover"],w=["resetViews"]):f?(b=["zoomInGeo","zoomOutGeo"],_=["hoverClosestGeo"],w=["resetGeo"]):u?(_=["hoverClosest3d"],w=["resetCameraDefault3d","resetCameraLastSave3d"]):g?(_=["toggleHover"],w=["resetViewMapbox"]):_=p?["hoverClosestGl2d"]:h?["hoverClosestPie"]:["toggleHover"];c&&(_=["toggleSpikelines","hoverClosestCartesian","hoverCompareCartesian"]);!c&&!p||v||(b=["zoomIn2d","zoomOut2d","autoScale2d"],"resetViews"!==w[0]&&(w=["resetScale2d"]));u?k=["zoom3d","pan3d","orbitRotation","tableRotation"]:(c||p)&&!v||d?k=["zoom2d","pan2d"]:g||f?k=["pan2d"]:m&&(k=["zoom2d"]);(function(t){for(var e=!1,r=0;r0)){var p=function(t,e,r){for(var n=r.filter(function(r){return e[r].anchor===t._id}),i=0,a=0;a0?h+c:c;return{ppad:c,ppadplus:u?d:g,ppadminus:u?g:d}}return{ppad:c}}function u(t,e,r,n,i){var s="category"===t.type?t.r2c:t.d2c;if(void 0!==e)return[s(e),s(r)];if(n){var l,c,u,f,h=1/0,p=-1/0,d=n.match(a.segmentRE);for("date"===t.type&&(s=o.decodeDate(s)),l=0;lp&&(p=f)));return p>=h?[h,p]:void 0}}e.exports=function(t){var e=t._fullLayout,r=n.filterVisible(e.shapes);if(r.length&&t._fullData.length)for(var o=0;o10?t/2:10;return n.append("circle").attr({"data-line-point":"start-point",cx:W?Q(r.xanchor)+r.x0:Q(r.x0),cy:Y?$(r.yanchor)-r.y0:$(r.y0),r:a}).style(i).classed("cursor-grab",!0),n.append("circle").attr({"data-line-point":"end-point",cx:W?Q(r.xanchor)+r.x1:Q(r.x1),cy:Y?$(r.yanchor)-r.y1:$(r.y1),r:a}).style(i).classed("cursor-grab",!0),n}():e,nt={element:rt.node(),gd:t,prepFn:function(n){var i="shapes["+o+"]";W&&(_=Q(r.xanchor),S=i+".xanchor");Y&&(w=$(r.yanchor),C=i+".yanchor");"path"===r.type?(V=r.path,U=i+".path"):(v=W?r.x0:Q(r.x0),y=Y?r.y0:$(r.y0),x=W?r.x1:Q(r.x1),b=Y?r.y1:$(r.y1),k=i+".x0",M=i+".y0",A=i+".x1",T=i+".y1");vb?(E=y,D=i+".y0",B="y0",L=b,O=i+".y1",F="y1"):(E=b,D=i+".y1",B="y1",L=y,O=i+".y0",F="y0");m={},it(n),st(h,r),function(t,e,r){var n=e.xref,i=e.yref,o=a.getFromId(r,n),l=a.getFromId(r,i),c="";"paper"===n||o.autorange||(c+=n);"paper"===i||l.autorange||(c+=i);t.call(s.setClipUrl,c?"clip"+r._fullLayout._uid+c:null)}(e,r,t),nt.moveFn="move"===q?at:ot},doneFn:function(){c(e),lt(h),p(e,t,r),n.call("relayout",t,m)},clickFn:function(){lt(h)}};function it(t){if(X)q="path"===t.target.tagName?"move":"start-point"===t.target.attributes["data-line-point"].value?"resize-over-start-point":"resize-over-end-point";else{var r=nt.element.getBoundingClientRect(),n=r.right-r.left,i=r.bottom-r.top,a=t.clientX-r.left,o=t.clientY-r.top,s=!Z&&n>H&&i>G&&!t.shiftKey?l.getCursor(a/n,1-o/i):"move";c(e,s),q=s.split("-")[0]}}function at(n,i){if("path"===r.type){var a=function(t){return t},o=a,s=a;W?m[S]=r.xanchor=tt(_+n):(o=function(t){return tt(Q(t)+n)},J&&"date"===J.type&&(o=f.encodeDate(o))),Y?m[C]=r.yanchor=et(w+i):(s=function(t){return et($(t)+i)},K&&"date"===K.type&&(s=f.encodeDate(s))),r.path=g(V,o,s),m[U]=r.path}else W?m[S]=r.xanchor=tt(_+n):(m[k]=r.x0=tt(v+n),m[A]=r.x1=tt(x+n)),Y?m[C]=r.yanchor=et(w+i):(m[M]=r.y0=et(y+i),m[T]=r.y1=et(b+i));e.attr("d",d(t,r)),st(h,r)}function ot(n,i){if(Z){var a=function(t){return t},o=a,s=a;W?m[S]=r.xanchor=tt(_+n):(o=function(t){return tt(Q(t)+n)},J&&"date"===J.type&&(o=f.encodeDate(o))),Y?m[C]=r.yanchor=et(w+i):(s=function(t){return et($(t)+i)},K&&"date"===K.type&&(s=f.encodeDate(s))),r.path=g(V,o,s),m[U]=r.path}else if(X){if("resize-over-start-point"===q){var l=v+n,c=Y?y-i:y+i;m[k]=r.x0=W?l:tt(l),m[M]=r.y0=Y?c:et(c)}else if("resize-over-end-point"===q){var u=x+n,p=Y?b-i:b+i;m[A]=r.x1=W?u:tt(u),m[T]=r.y1=Y?p:et(p)}}else{var rt=~q.indexOf("n")?E+i:E,nt=~q.indexOf("s")?L+i:L,it=~q.indexOf("w")?z+n:z,at=~q.indexOf("e")?P+n:P;~q.indexOf("n")&&Y&&(rt=E-i),~q.indexOf("s")&&Y&&(nt=L-i),(!Y&&nt-rt>G||Y&&rt-nt>G)&&(m[D]=r[B]=Y?rt:et(rt),m[O]=r[F]=Y?nt:et(nt)),at-it>H&&(m[I]=r[N]=W?it:tt(it),m[R]=r[j]=W?at:tt(at))}e.attr("d",d(t,r)),st(h,r)}function st(t,e){(W||Y)&&function(){var r="path"!==e.type,n=t.selectAll(".visual-cue").data([0]);n.enter().append("path").attr({fill:"#fff","fill-rule":"evenodd",stroke:"#000","stroke-width":1}).classed("visual-cue",!0);var a=Q(W?e.xanchor:i.midRange(r?[e.x0,e.x1]:f.extractPathCoords(e.path,u.paramIsX))),o=$(Y?e.yanchor:i.midRange(r?[e.y0,e.y1]:f.extractPathCoords(e.path,u.paramIsY)));if(a=f.roundPositionForSharpStrokeRendering(a,1),o=f.roundPositionForSharpStrokeRendering(o,1),W&&Y){var s="M"+(a-1-1)+","+(o-1-1)+"h-8v2h8 v8h2v-8 h8v-2h-8 v-8h-2 Z";n.attr("d",s)}else if(W){var l="M"+(a-1-1)+","+(o-9-1)+"v18 h2 v-18 Z";n.attr("d",l)}else{var c="M"+(a-9-1)+","+(o-1-1)+"h18 v2 h-18 Z";n.attr("d",c)}}()}function lt(t){t.selectAll(".visual-cue").remove()}l.init(nt),rt.node().onmousemove=it}(t,y,h,e,r)}}function p(t,e,r){var n=(r.xref+r.yref).replace(/paper/g,"");t.call(s.setClipUrl,n?"clip"+e._fullLayout._uid+n:null)}function d(t,e){var r,n,o,s,l,c,h,p,d=e.type,g=a.getFromId(t,e.xref),m=a.getFromId(t,e.yref),v=t._fullLayout._size;if(g?(r=f.shapePositionToRange(g),n=function(t){return g._offset+g.r2p(r(t,!0))}):n=function(t){return v.l+v.w*t},m?(o=f.shapePositionToRange(m),s=function(t){return m._offset+m.r2p(o(t,!0))}):s=function(t){return v.t+v.h*(1-t)},"path"===d)return g&&"date"===g.type&&(n=f.decodeDate(n)),m&&"date"===m.type&&(s=f.decodeDate(s)),function(t,e,r){var n=t.path,a=t.xsizemode,o=t.ysizemode,s=t.xanchor,l=t.yanchor;return n.replace(u.segmentRE,function(t){var n=0,c=t.charAt(0),f=u.paramIsX[c],h=u.paramIsY[c],p=u.numParams[c],d=t.substr(1).replace(u.paramRE,function(t){return f[n]?t="pixel"===a?e(s)+Number(t):e(t):h[n]&&(t="pixel"===o?r(l)-Number(t):r(t)),++n>p&&(t="X"),t});return n>p&&(d=d.replace(/[\s,]*X.*/,""),i.log("Ignoring extra params in segment "+t)),c+d})}(e,n,s);if("pixel"===e.xsizemode){var y=n(e.xanchor);l=y+e.x0,c=y+e.x1}else l=n(e.x0),c=n(e.x1);if("pixel"===e.ysizemode){var x=s(e.yanchor);h=x-e.y0,p=x-e.y1}else h=s(e.y0),p=s(e.y1);if("line"===d)return"M"+l+","+h+"L"+c+","+p;if("rect"===d)return"M"+l+","+h+"H"+c+"V"+p+"H"+l+"Z";var b=(l+c)/2,_=(h+p)/2,w=Math.abs(b-l),k=Math.abs(_-h),M="A"+w+","+k,A=b+w+","+_;return"M"+A+M+" 0 1,1 "+(b+","+(_-k))+M+" 0 0,1 "+A+"Z"}function g(t,e,r){return t.replace(u.segmentRE,function(t){var n=0,i=t.charAt(0),a=u.paramIsX[i],o=u.paramIsY[i],s=u.numParams[i];return i+t.substr(1).replace(u.paramRE,function(t){return n>=s?t:(a[n]?t=e(t):o[n]&&(t=r(t)),n++,t)})})}e.exports={draw:function(t){var e=t._fullLayout;for(var r in e._shapeUpperLayer.selectAll("path").remove(),e._shapeLowerLayer.selectAll("path").remove(),e._plots){var n=e._plots[r].shapelayer;n&&n.selectAll("path").remove()}for(var i=0;i0)&&(i("active"),i("x"),i("y"),n.noneOrAll(t,e,["x","y"]),i("xanchor"),i("yanchor"),i("len"),i("lenmode"),i("pad.t"),i("pad.r"),i("pad.b"),i("pad.l"),n.coerceFont(i,"font",r.font),i("currentvalue.visible")&&(i("currentvalue.xanchor"),i("currentvalue.prefix"),i("currentvalue.suffix"),i("currentvalue.offset"),n.coerceFont(i,"currentvalue.font",e.font)),i("transition.duration"),i("transition.easing"),i("bgcolor"),i("activebgcolor"),i("bordercolor"),i("borderwidth"),i("ticklen"),i("tickwidth"),i("tickcolor"),i("minorticklen"))}e.exports=function(t,e){i(t,e,{name:o,handleItemDefaults:l})}},{"../../lib":660,"../../plots/array_container_defaults":702,"./attributes":620,"./constants":621}],623:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/plots"),a=t("../color"),o=t("../drawing"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../legend/anchor_utils"),u=t("./constants"),f=t("../../constants/alignment"),h=f.LINE_SPACING,p=f.FROM_TL,d=f.FROM_BR;function g(t){return t._index}function m(t,e){var r=o.tester.selectAll("g."+u.labelGroupClass).data(e.steps);r.enter().append("g").classed(u.labelGroupClass,!0);var a=0,s=0;r.each(function(t){var r=x(n.select(this),{step:t},e).node();if(r){var i=o.bBox(r);s=Math.max(s,i.height),a=Math.max(a,i.width)}}),r.remove();var f=e._dims={};f.inputAreaWidth=Math.max(u.railWidth,u.gripHeight);var h=t._fullLayout._size;f.lx=h.l+h.w*e.x,f.ly=h.t+h.h*(1-e.y),"fraction"===e.lenmode?f.outerLength=Math.round(h.w*e.len):f.outerLength=e.len,f.inputAreaStart=0,f.inputAreaLength=Math.round(f.outerLength-e.pad.l-e.pad.r);var g=(f.inputAreaLength-2*u.stepInset)/(e.steps.length-1),m=a+u.labelPadding;if(f.labelStride=Math.max(1,Math.ceil(m/g)),f.labelHeight=s,f.currentValueMaxWidth=0,f.currentValueHeight=0,f.currentValueTotalHeight=0,f.currentValueMaxLines=1,e.currentvalue.visible){var y=o.tester.append("g");r.each(function(t){var r=v(y,e,t.label),n=r.node()&&o.bBox(r.node())||{width:0,height:0},i=l.lineCount(r);f.currentValueMaxWidth=Math.max(f.currentValueMaxWidth,Math.ceil(n.width)),f.currentValueHeight=Math.max(f.currentValueHeight,Math.ceil(n.height)),f.currentValueMaxLines=Math.max(f.currentValueMaxLines,i)}),f.currentValueTotalHeight=f.currentValueHeight+e.currentvalue.offset,y.remove()}f.height=f.currentValueTotalHeight+u.tickOffset+e.ticklen+u.labelOffset+f.labelHeight+e.pad.t+e.pad.b;var b="left";c.isRightAnchor(e)&&(f.lx-=f.outerLength,b="right"),c.isCenterAnchor(e)&&(f.lx-=f.outerLength/2,b="center");var _="top";c.isBottomAnchor(e)&&(f.ly-=f.height,_="bottom"),c.isMiddleAnchor(e)&&(f.ly-=f.height/2,_="middle"),f.outerLength=Math.ceil(f.outerLength),f.height=Math.ceil(f.height),f.lx=Math.round(f.lx),f.ly=Math.round(f.ly),i.autoMargin(t,u.autoMarginIdRoot+e._index,{x:e.x,y:e.y,l:f.outerLength*p[b],r:f.outerLength*d[b],b:f.height*d[_],t:f.height*p[_]})}function v(t,e,r){if(e.currentvalue.visible){var n,i,a=e._dims;switch(e.currentvalue.xanchor){case"right":n=a.inputAreaLength-u.currentValueInset-a.currentValueMaxWidth,i="left";break;case"center":n=.5*a.inputAreaLength,i="middle";break;default:n=u.currentValueInset,i="left"}var c=s.ensureSingle(t,"text",u.labelClass,function(t){t.classed("user-select-none",!0).attr({"text-anchor":i,"data-notex":1})}),f=e.currentvalue.prefix?e.currentvalue.prefix:"";if("string"==typeof r)f+=r;else f+=e.steps[e.active].label;e.currentvalue.suffix&&(f+=e.currentvalue.suffix),c.call(o.font,e.currentvalue.font).text(f).call(l.convertToTspans,e._gd);var p=l.lineCount(c),d=(a.currentValueMaxLines+1-p)*e.currentvalue.font.size*h;return l.positionText(c,n,d),c}}function y(t,e,r){s.ensureSingle(t,"rect",u.gripRectClass,function(n){n.call(k,e,t,r).style("pointer-events","all")}).attr({width:u.gripWidth,height:u.gripHeight,rx:u.gripRadius,ry:u.gripRadius}).call(a.stroke,r.bordercolor).call(a.fill,r.bgcolor).style("stroke-width",r.borderwidth+"px")}function x(t,e,r){var n=s.ensureSingle(t,"text",u.labelClass,function(t){t.classed("user-select-none",!0).attr({"text-anchor":"middle","data-notex":1})});return n.call(o.font,r.font).text(e.step.label).call(l.convertToTspans,r._gd),n}function b(t,e){var r=s.ensureSingle(t,"g",u.labelsClass),i=e._dims,a=r.selectAll("g."+u.labelGroupClass).data(i.labelSteps);a.enter().append("g").classed(u.labelGroupClass,!0),a.exit().remove(),a.each(function(t){var r=n.select(this);r.call(x,t,e),o.setTranslate(r,T(e,t.fraction),u.tickOffset+e.ticklen+e.font.size*h+u.labelOffset+i.currentValueTotalHeight)})}function _(t,e,r,n,i){var a=Math.round(n*(r.steps.length-1));a!==r.active&&w(t,e,r,a,!0,i)}function w(t,e,r,n,a,o){var s=r.active;r._input.active=r.active=n;var l=r.steps[r.active];e.call(A,r,r.active/(r.steps.length-1),o),e.call(v,r),t.emit("plotly_sliderchange",{slider:r,step:r.steps[r.active],interaction:a,previousActive:s}),l&&l.method&&a&&(e._nextMethod?(e._nextMethod.step=l,e._nextMethod.doCallback=a,e._nextMethod.doTransition=o):(e._nextMethod={step:l,doCallback:a,doTransition:o},e._nextMethodRaf=window.requestAnimationFrame(function(){var r=e._nextMethod.step;r.method&&(r.execute&&i.executeAPICommand(t,r.method,r.args),e._nextMethod=null,e._nextMethodRaf=null)})))}function k(t,e,r){var i=r.node(),o=n.select(e);function s(){return r.data()[0]}t.on("mousedown",function(){var t=s();e.emit("plotly_sliderstart",{slider:t});var l=r.select("."+u.gripRectClass);n.event.stopPropagation(),n.event.preventDefault(),l.call(a.fill,t.activebgcolor);var c=S(t,n.mouse(i)[0]);_(e,r,t,c,!0),t._dragging=!0,o.on("mousemove",function(){var t=s(),a=S(t,n.mouse(i)[0]);_(e,r,t,a,!1)}),o.on("mouseup",function(){var t=s();t._dragging=!1,l.call(a.fill,t.bgcolor),o.on("mouseup",null),o.on("mousemove",null),e.emit("plotly_sliderend",{slider:t,step:t.steps[t.active]})})})}function M(t,e){var r=t.selectAll("rect."+u.tickRectClass).data(e.steps),i=e._dims;r.enter().append("rect").classed(u.tickRectClass,!0),r.exit().remove(),r.attr({width:e.tickwidth+"px","shape-rendering":"crispEdges"}),r.each(function(t,r){var s=r%i.labelStride==0,l=n.select(this);l.attr({height:s?e.ticklen:e.minorticklen}).call(a.fill,e.tickcolor),o.setTranslate(l,T(e,r/(e.steps.length-1))-.5*e.tickwidth,(s?u.tickOffset:u.minorTickOffset)+i.currentValueTotalHeight)})}function A(t,e,r,n){var i=t.select("rect."+u.gripRectClass),a=T(e,r);if(!e._invokingCommand){var o=i;n&&e.transition.duration>0&&(o=o.transition().duration(e.transition.duration).ease(e.transition.easing)),o.attr("transform","translate("+(a-.5*u.gripWidth)+","+e._dims.currentValueTotalHeight+")")}}function T(t,e){var r=t._dims;return r.inputAreaStart+u.stepInset+(r.inputAreaLength-2*u.stepInset)*Math.min(1,Math.max(0,e))}function S(t,e){var r=t._dims;return Math.min(1,Math.max(0,(e-u.stepInset-r.inputAreaStart)/(r.inputAreaLength-2*u.stepInset-2*r.inputAreaStart)))}function C(t,e,r){var n=r._dims,i=s.ensureSingle(t,"rect",u.railTouchRectClass,function(n){n.call(k,e,t,r).style("pointer-events","all")});i.attr({width:n.inputAreaLength,height:Math.max(n.inputAreaWidth,u.tickOffset+r.ticklen+n.labelHeight)}).call(a.fill,r.bgcolor).attr("opacity",0),o.setTranslate(i,0,n.currentValueTotalHeight)}function E(t,e){var r=e._dims,n=r.inputAreaLength-2*u.railInset,i=s.ensureSingle(t,"rect",u.railRectClass);i.attr({width:n,height:u.railWidth,rx:u.railRadius,ry:u.railRadius,"shape-rendering":"crispEdges"}).call(a.stroke,e.bordercolor).call(a.fill,e.bgcolor).style("stroke-width",e.borderwidth+"px"),o.setTranslate(i,u.railInset,.5*(r.inputAreaWidth-u.railWidth)+r.currentValueTotalHeight)}e.exports=function(t){var e=t._fullLayout,r=function(t,e){for(var r=t[u.name],n=[],i=0;i0?[0]:[]);if(a.enter().append("g").classed(u.containerClassName,!0).style("cursor","ew-resize"),a.exit().remove(),a.exit().size()&&function(t){for(var e=t._fullLayout._pushmargin||{},r=Object.keys(e),n=0;n=r.steps.length&&(r.active=0);e.call(v,r).call(E,r).call(b,r).call(M,r).call(C,t,r).call(y,t,r);var n=r._dims;o.setTranslate(e,n.lx+r.pad.l,n.ly+r.pad.t),e.call(A,r,r.active/(r.steps.length-1),!1),e.call(v,r)}(t,n.select(this),e)}})}}},{"../../constants/alignment":632,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../color":532,"../drawing":557,"../legend/anchor_utils":584,"./constants":621,d3:131}],624:[function(t,e,r){"use strict";var n=t("./constants");e.exports={moduleType:"component",name:n.name,layoutAttributes:t("./attributes"),supplyLayoutDefaults:t("./defaults"),draw:t("./draw")}},{"./attributes":620,"./constants":621,"./defaults":622,"./draw":623}],625:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib"),l=t("../drawing"),c=t("../color"),u=t("../../lib/svg_text_utils"),f=t("../../constants/interactions");e.exports={draw:function(t,e,r){var p,d=r.propContainer,g=r.propName,m=r.placeholder,v=r.traceIndex,y=r.avoid||{},x=r.attributes,b=r.transform,_=r.containerGroup,w=t._fullLayout,k=d.titlefont||{},M=k.family,A=k.size,T=k.color,S=1,C=!1,E=(d.title||"").trim();"title"===g?p="titleText":-1!==g.indexOf("axis")?p="axisTitleText":g.indexOf(!0)&&(p="colorbarTitleText");var L=t._context.edits[p];""===E?S=0:E.replace(h," % ")===m.replace(h," % ")&&(S=.2,C=!0,L||(E=""));var z=E||L;_||(_=s.ensureSingle(w._infolayer,"g","g-"+e));var P=_.selectAll("text").data(z?[0]:[]);if(P.enter().append("text"),P.text(E).attr("class",e),P.exit().remove(),!z)return _;function D(t){s.syncOrAsync([O,I],t)}function O(e){var r;return b?(r="",b.rotate&&(r+="rotate("+[b.rotate,x.x,x.y]+")"),b.offset&&(r+="translate(0, "+b.offset+")")):r=null,e.attr("transform",r),e.style({"font-family":M,"font-size":n.round(A,2)+"px",fill:c.rgb(T),opacity:S*c.opacity(T),"font-weight":a.fontWeight}).attr(x).call(u.convertToTspans,t),a.previousPromises(t)}function I(t){var e=n.select(t.node().parentNode);if(y&&y.selection&&y.side&&E){e.attr("transform",null);var r=0,a={left:"right",right:"left",top:"bottom",bottom:"top"}[y.side],o=-1!==["left","top"].indexOf(y.side)?-1:1,c=i(y.pad)?y.pad:2,u=l.bBox(e.node()),f={left:0,top:0,right:w.width,bottom:w.height},h=y.maxShift||(f[y.side]-u[y.side])*("left"===y.side||"top"===y.side?-1:1);if(h<0)r=h;else{var p=y.offsetLeft||0,d=y.offsetTop||0;u.left-=p,u.right-=p,u.top-=d,u.bottom-=d,y.selection.each(function(){var t=l.bBox(this);s.bBoxIntersect(u,t,c)&&(r=Math.max(r,o*(t[y.side]-u[a])+c))}),r=Math.min(h,r)}if(r>0||h<0){var g={left:[-r,0],right:[r,0],top:[0,-r],bottom:[0,r]}[y.side];e.attr("transform","translate("+g+")")}}}P.call(D),L&&(E?P.on(".opacity",null):(S=0,C=!0,P.text(m).on("mouseover.opacity",function(){n.select(this).transition().duration(f.SHOW_PLACEHOLDER).style("opacity",1)}).on("mouseout.opacity",function(){n.select(this).transition().duration(f.HIDE_PLACEHOLDER).style("opacity",0)})),P.call(u.makeEditable,{gd:t}).on("edit",function(e){void 0!==v?o.call("restyle",t,g,e,v):o.call("relayout",t,g,e)}).on("cancel",function(){this.text(this.attr("data-unformatted")).call(D)}).on("input",function(t){this.text(t||" ").call(u.positionText,x.x,x.y)}));return P.classed("js-placeholder",C),_}};var h=/ [XY][0-9]* /},{"../../constants/interactions":636,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../../registry":790,"../color":532,"../drawing":557,d3:131,"fast-isnumeric":197}],626:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../color/attributes"),a=t("../../lib/extend").extendFlat,o=t("../../plot_api/edit_types").overrideAll,s=t("../../plots/pad_attributes");e.exports=o({_isLinkedToArray:"updatemenu",_arrayAttrRegexps:[/^updatemenus\[(0|[1-9][0-9]+)\]\.buttons/],visible:{valType:"boolean"},type:{valType:"enumerated",values:["dropdown","buttons"],dflt:"dropdown"},direction:{valType:"enumerated",values:["left","right","up","down"],dflt:"down"},active:{valType:"integer",min:-1,dflt:0},showactive:{valType:"boolean",dflt:!0},buttons:{_isLinkedToArray:"button",method:{valType:"enumerated",values:["restyle","relayout","animate","update","skip"],dflt:"restyle"},args:{valType:"info_array",freeLength:!0,items:[{valType:"any"},{valType:"any"},{valType:"any"}]},label:{valType:"string",dflt:""},execute:{valType:"boolean",dflt:!0}},x:{valType:"number",min:-2,max:3,dflt:-.05},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"right"},y:{valType:"number",min:-2,max:3,dflt:1},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"top"},pad:a({},s,{}),font:n({}),bgcolor:{valType:"color"},bordercolor:{valType:"color",dflt:i.borderLine},borderwidth:{valType:"number",min:0,dflt:1,editType:"arraydraw"}},"arraydraw","from-root")},{"../../lib/extend":649,"../../plot_api/edit_types":691,"../../plots/font_attributes":732,"../../plots/pad_attributes":767,"../color/attributes":531}],627:[function(t,e,r){"use strict";e.exports={name:"updatemenus",containerClassName:"updatemenu-container",headerGroupClassName:"updatemenu-header-group",headerClassName:"updatemenu-header",headerArrowClassName:"updatemenu-header-arrow",dropdownButtonGroupClassName:"updatemenu-dropdown-button-group",dropdownButtonClassName:"updatemenu-dropdown-button",buttonClassName:"updatemenu-button",itemRectClassName:"updatemenu-item-rect",itemTextClassName:"updatemenu-item-text",menuIndexAttrName:"updatemenu-active-index",autoMarginIdRoot:"updatemenu-",blankHeaderOpts:{label:" "},minWidth:30,minHeight:30,textPadX:24,arrowPadX:16,rx:2,ry:2,textOffsetX:12,textOffsetY:3,arrowOffsetX:4,gapButtonHeader:5,gapButton:2,activeColor:"#F4FAFF",hoverColor:"#F4FAFF",arrowSymbol:{left:"\u25c4",right:"\u25ba",up:"\u25b2",down:"\u25bc"}}},{}],628:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/array_container_defaults"),a=t("./attributes"),o=t("./constants").name,s=a.buttons;function l(t,e,r){function i(r,i){return n.coerce(t,e,a,r,i)}i("visible",function(t,e){var r,i,a=t.buttons||[],o=e.buttons=[];function l(t,e){return n.coerce(r,i,s,t,e)}for(var c=0;c0)&&(i("active"),i("direction"),i("type"),i("showactive"),i("x"),i("y"),n.noneOrAll(t,e,["x","y"]),i("xanchor"),i("yanchor"),i("pad.t"),i("pad.r"),i("pad.b"),i("pad.l"),n.coerceFont(i,"font",r.font),i("bgcolor",r.paper_bgcolor),i("bordercolor"),i("borderwidth"))}e.exports=function(t,e){i(t,e,{name:o,handleItemDefaults:l})}},{"../../lib":660,"../../plots/array_container_defaults":702,"./attributes":626,"./constants":627}],629:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/plots"),a=t("../color"),o=t("../drawing"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../legend/anchor_utils"),u=t("../../constants/alignment").LINE_SPACING,f=t("./constants"),h=t("./scrollbox");function p(t){return t._index}function d(t,e){return+t.attr(f.menuIndexAttrName)===e._index}function g(t,e,r,n,i,a,o,s){e._input.active=e.active=o,"buttons"===e.type?v(t,n,null,null,e):"dropdown"===e.type&&(i.attr(f.menuIndexAttrName,"-1"),m(t,n,i,a,e),s||v(t,n,i,a,e))}function m(t,e,r,n,i){var a=s.ensureSingle(e,"g",f.headerClassName,function(t){t.style("pointer-events","all")}),l=i._dims,c=i.active,u=i.buttons[c]||f.blankHeaderOpts,h={y:i.pad.t,yPad:0,x:i.pad.l,xPad:0,index:0},p={width:l.headerWidth,height:l.headerHeight};a.call(y,i,u,t).call(A,i,h,p),s.ensureSingle(e,"text",f.headerArrowClassName,function(t){t.classed("user-select-none",!0).attr("text-anchor","end").call(o.font,i.font).text(f.arrowSymbol[i.direction])}).attr({x:l.headerWidth-f.arrowOffsetX+i.pad.l,y:l.headerHeight/2+f.textOffsetY+i.pad.t}),a.on("click",function(){r.call(T),r.attr(f.menuIndexAttrName,d(r,i)?-1:String(i._index)),v(t,e,r,n,i)}),a.on("mouseover",function(){a.call(w)}),a.on("mouseout",function(){a.call(k,i)}),o.setTranslate(e,l.lx,l.ly)}function v(t,e,r,a,o){r||(r=e).attr("pointer-events","all");var s=function(t){return-1==+t.attr(f.menuIndexAttrName)}(r)&&"buttons"!==o.type?[]:o.buttons,l="dropdown"===o.type?f.dropdownButtonClassName:f.buttonClassName,c=r.selectAll("g."+l).data(s),u=c.enter().append("g").classed(l,!0),h=c.exit();"dropdown"===o.type?(u.attr("opacity","0").transition().attr("opacity","1"),h.transition().attr("opacity","0").remove()):h.remove();var p=0,d=0,m=o._dims,v=-1!==["up","down"].indexOf(o.direction);"dropdown"===o.type&&(v?d=m.headerHeight+f.gapButtonHeader:p=m.headerWidth+f.gapButtonHeader),"dropdown"===o.type&&"up"===o.direction&&(d=-f.gapButtonHeader+f.gapButton-m.openHeight),"dropdown"===o.type&&"left"===o.direction&&(p=-f.gapButtonHeader+f.gapButton-m.openWidth);var x={x:m.lx+p+o.pad.l,y:m.ly+d+o.pad.t,yPad:f.gapButton,xPad:f.gapButton,index:0},b={l:x.x+o.borderwidth,t:x.y+o.borderwidth};c.each(function(s,l){var u=n.select(this);u.call(y,o,s,t).call(A,o,x),u.on("click",function(){n.event.defaultPrevented||(g(t,o,0,e,r,a,l),s.execute&&i.executeAPICommand(t,s.method,s.args),t.emit("plotly_buttonclicked",{menu:o,button:s,active:o.active}))}),u.on("mouseover",function(){u.call(w)}),u.on("mouseout",function(){u.call(k,o),c.call(_,o)})}),c.call(_,o),v?(b.w=Math.max(m.openWidth,m.headerWidth),b.h=x.y-b.t):(b.w=x.x-b.l,b.h=Math.max(m.openHeight,m.headerHeight)),b.direction=o.direction,a&&(c.size()?function(t,e,r,n,i,a){var o,s,l,c=i.direction,u="up"===c||"down"===c,h=i._dims,p=i.active;if(u)for(s=0,l=0;l0?[0]:[]);if(a.enter().append("g").classed(f.containerClassName,!0).style("cursor","pointer"),a.exit().remove(),a.exit().size()&&function(t){for(var e=t._fullLayout._pushmargin||{},r=Object.keys(e),n=0;nw,A=s.barLength+2*s.barPad,T=s.barWidth+2*s.barPad,S=d,C=m+v;C+T>c&&(C=c-T);var E=this.container.selectAll("rect.scrollbar-horizontal").data(M?[0]:[]);E.exit().on(".drag",null).remove(),E.enter().append("rect").classed("scrollbar-horizontal",!0).call(i.fill,s.barColor),M?(this.hbar=E.attr({rx:s.barRadius,ry:s.barRadius,x:S,y:C,width:A,height:T}),this._hbarXMin=S+A/2,this._hbarTranslateMax=w-A):(delete this.hbar,delete this._hbarXMin,delete this._hbarTranslateMax);var L=v>k,z=s.barWidth+2*s.barPad,P=s.barLength+2*s.barPad,D=d+g,O=m;D+z>l&&(D=l-z);var I=this.container.selectAll("rect.scrollbar-vertical").data(L?[0]:[]);I.exit().on(".drag",null).remove(),I.enter().append("rect").classed("scrollbar-vertical",!0).call(i.fill,s.barColor),L?(this.vbar=I.attr({rx:s.barRadius,ry:s.barRadius,x:D,y:O,width:z,height:P}),this._vbarYMin=O+P/2,this._vbarTranslateMax=k-P):(delete this.vbar,delete this._vbarYMin,delete this._vbarTranslateMax);var R=this.id,B=u-.5,F=L?f+z+.5:f+.5,N=h-.5,j=M?p+T+.5:p+.5,V=o._topdefs.selectAll("#"+R).data(M||L?[0]:[]);if(V.exit().remove(),V.enter().append("clipPath").attr("id",R).append("rect"),M||L?(this._clipRect=V.select("rect").attr({x:Math.floor(B),y:Math.floor(N),width:Math.ceil(F)-Math.floor(B),height:Math.ceil(j)-Math.floor(N)}),this.container.call(a.setClipUrl,R),this.bg.attr({x:d,y:m,width:g,height:v})):(this.bg.attr({width:0,height:0}),this.container.on("wheel",null).on(".drag",null).call(a.setClipUrl,null),delete this._clipRect),M||L){var U=n.behavior.drag().on("dragstart",function(){n.event.sourceEvent.preventDefault()}).on("drag",this._onBoxDrag.bind(this));this.container.on("wheel",null).on("wheel",this._onBoxWheel.bind(this)).on(".drag",null).call(U);var q=n.behavior.drag().on("dragstart",function(){n.event.sourceEvent.preventDefault(),n.event.sourceEvent.stopPropagation()}).on("drag",this._onBarDrag.bind(this));M&&this.hbar.on(".drag",null).call(q),L&&this.vbar.on(".drag",null).call(q)}this.setTranslate(e,r)},s.prototype.disable=function(){(this.hbar||this.vbar)&&(this.bg.attr({width:0,height:0}),this.container.on("wheel",null).on(".drag",null).call(a.setClipUrl,null),delete this._clipRect),this.hbar&&(this.hbar.on(".drag",null),this.hbar.remove(),delete this.hbar,delete this._hbarXMin,delete this._hbarTranslateMax),this.vbar&&(this.vbar.on(".drag",null),this.vbar.remove(),delete this.vbar,delete this._vbarYMin,delete this._vbarTranslateMax)},s.prototype._onBoxDrag=function(){var t=this.translateX,e=this.translateY;this.hbar&&(t-=n.event.dx),this.vbar&&(e-=n.event.dy),this.setTranslate(t,e)},s.prototype._onBoxWheel=function(){var t=this.translateX,e=this.translateY;this.hbar&&(t+=n.event.deltaY),this.vbar&&(e+=n.event.deltaY),this.setTranslate(t,e)},s.prototype._onBarDrag=function(){var t=this.translateX,e=this.translateY;if(this.hbar){var r=t+this._hbarXMin,i=r+this._hbarTranslateMax;t=(o.constrain(n.event.x,r,i)-r)/(i-r)*(this.position.w-this._box.w)}if(this.vbar){var a=e+this._vbarYMin,s=a+this._vbarTranslateMax;e=(o.constrain(n.event.y,a,s)-a)/(s-a)*(this.position.h-this._box.h)}this.setTranslate(t,e)},s.prototype.setTranslate=function(t,e){var r=this.position.w-this._box.w,n=this.position.h-this._box.h;if(t=o.constrain(t||0,0,r),e=o.constrain(e||0,0,n),this.translateX=t,this.translateY=e,this.container.call(a.setTranslate,this._box.l-this.position.l-t,this._box.t-this.position.t-e),this._clipRect&&this._clipRect.attr({x:Math.floor(this.position.l+t-.5),y:Math.floor(this.position.t+e-.5)}),this.hbar){var i=t/r;this.hbar.call(a.setTranslate,t+i*this._hbarTranslateMax,e)}if(this.vbar){var s=e/n;this.vbar.call(a.setTranslate,t,e+s*this._vbarTranslateMax)}}},{"../../lib":660,"../color":532,"../drawing":557,d3:131}],632:[function(t,e,r){"use strict";e.exports={FROM_BL:{left:0,center:.5,right:1,bottom:0,middle:.5,top:1},FROM_TL:{left:0,center:.5,right:1,bottom:1,middle:.5,top:0},FROM_BR:{left:1,center:.5,right:0,bottom:0,middle:.5,top:1},LINE_SPACING:1.3,MID_SHIFT:.35,OPPOSITE_SIDE:{left:"right",right:"left",top:"bottom",bottom:"top"}}},{}],633:[function(t,e,r){"use strict";e.exports={COMPARISON_OPS:["=","!=","<",">=",">","<="],COMPARISON_OPS2:["=","<",">=",">","<="],INTERVAL_OPS:["[]","()","[)","(]","][",")(","](",")["],SET_OPS:["{}","}{"],CONSTRAINT_REDUCTION:{"=":"=","<":"<","<=":"<",">":">",">=":">","[]":"[]","()":"[]","[)":"[]","(]":"[]","][":"][",")(":"][","](":"][",")[":"]["}}},{}],634:[function(t,e,r){"use strict";e.exports={solid:[[],0],dot:[[.5,1],200],dash:[[.5,1],50],longdash:[[.5,1],10],dashdot:[[.5,.625,.875,1],50],longdashdot:[[.5,.7,.8,1],10]}},{}],635:[function(t,e,r){"use strict";e.exports={circle:"\u25cf","circle-open":"\u25cb",square:"\u25a0","square-open":"\u25a1",diamond:"\u25c6","diamond-open":"\u25c7",cross:"+",x:"\u274c"}},{}],636:[function(t,e,r){"use strict";e.exports={SHOW_PLACEHOLDER:100,HIDE_PLACEHOLDER:1e3,DBLCLICKDELAY:300,DESELECTDIM:.2}},{}],637:[function(t,e,r){"use strict";e.exports={BADNUM:void 0,FP_SAFE:Number.MAX_VALUE/1e4,ONEAVGYEAR:315576e5,ONEAVGMONTH:26298e5,ONEDAY:864e5,ONEHOUR:36e5,ONEMIN:6e4,ONESEC:1e3,EPOCHJD:2440587.5,ALMOST_EQUAL:1-1e-6,MINUS_SIGN:"\u2212"}},{}],638:[function(t,e,r){"use strict";e.exports={entityToUnicode:{mu:"\u03bc","#956":"\u03bc",amp:"&","#28":"&",lt:"<","#60":"<",gt:">","#62":">",nbsp:"\xa0","#160":"\xa0",times:"\xd7","#215":"\xd7",plusmn:"\xb1","#177":"\xb1",deg:"\xb0","#176":"\xb0"}}},{}],639:[function(t,e,r){"use strict";r.xmlns="http://www.w3.org/2000/xmlns/",r.svg="http://www.w3.org/2000/svg",r.xlink="http://www.w3.org/1999/xlink",r.svgAttrs={xmlns:r.svg,"xmlns:xlink":r.xlink}},{}],640:[function(t,e,r){"use strict";r.version="1.38.0",t("es6-promise").polyfill(),t("../build/plotcss"),t("./fonts/mathjax_config");for(var n=t("./registry"),i=r.register=n.register,a=t("./plot_api"),o=Object.keys(a),s=0;s180&&(t-=360*Math.round(t/360)),t}},{}],643:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../constants/numerical").BADNUM,a=/^['"%,$#\s']+|[, ]|['"%,$#\s']+$/g;e.exports=function(t){return"string"==typeof t&&(t=t.replace(a,"")),n(t)?Number(t):i}},{"../constants/numerical":637,"fast-isnumeric":197}],644:[function(t,e,r){"use strict";e.exports=function(t){var e=t._fullLayout;e._glcanvas&&e._glcanvas.size()&&e._glcanvas.each(function(t){t.regl&&t.regl.clear({color:!0,depth:!0})})}},{}],645:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("tinycolor2"),a=t("../plots/attributes"),o=t("../components/colorscale/get_scale"),s=(Object.keys(t("../components/colorscale/scales")),t("./nested_property")),l=t("./regex").counter,c=t("../constants/interactions").DESELECTDIM,u=t("./angles").wrap180,f=t("./is_array").isArrayOrTypedArray;r.valObjectMeta={data_array:{coerceFunction:function(t,e,r){f(t)?e.set(t):void 0!==r&&e.set(r)}},enumerated:{coerceFunction:function(t,e,r,n){n.coerceNumber&&(t=+t),-1===n.values.indexOf(t)?e.set(r):e.set(t)},validateFunction:function(t,e){e.coerceNumber&&(t=+t);for(var r=e.values,n=0;ni.max?e.set(r):e.set(+t)}},integer:{coerceFunction:function(t,e,r,i){t%1||!n(t)||void 0!==i.min&&ti.max?e.set(r):e.set(+t)}},string:{coerceFunction:function(t,e,r,n){if("string"!=typeof t){var i="number"==typeof t;!0!==n.strict&&i?e.set(String(t)):e.set(r)}else n.noBlank&&!t?e.set(r):e.set(t)}},color:{coerceFunction:function(t,e,r){i(t).isValid()?e.set(t):e.set(r)}},colorlist:{coerceFunction:function(t,e,r){Array.isArray(t)&&t.length&&t.every(function(t){return i(t).isValid()})?e.set(t):e.set(r)}},colorscale:{coerceFunction:function(t,e,r){e.set(o(t,r))}},angle:{coerceFunction:function(t,e,r){"auto"===t?e.set("auto"):n(t)?e.set(u(+t)):e.set(r)}},subplotid:{coerceFunction:function(t,e,r,n){var i=n.regex||l(r);"string"==typeof t&&i.test(t)?e.set(t):e.set(r)},validateFunction:function(t,e){var r=e.dflt;return t===r||"string"==typeof t&&!!l(r).test(t)}},flaglist:{coerceFunction:function(t,e,r,n){if("string"==typeof t)if(-1===(n.extras||[]).indexOf(t)){for(var i=t.split("+"),a=0;a=n&&t<=i?t:u;if("string"!=typeof t&&"number"!=typeof t)return u;t=String(t);var a=_(e),o=t.charAt(0);!a||"G"!==o&&"g"!==o||(t=t.substr(1),e="");var s=a&&"chinese"===e.substr(0,7),l=t.match(s?x:y);if(!l)return u;var c=l[1],v=l[3]||"1",w=Number(l[5]||1),k=Number(l[7]||0),M=Number(l[9]||0),A=Number(l[11]||0);if(a){if(2===c.length)return u;var T;c=Number(c);try{var S=m.getComponentMethod("calendars","getCal")(e);if(s){var C="i"===v.charAt(v.length-1);v=parseInt(v,10),T=S.newDate(c,S.toMonthIndex(c,v,C),w)}else T=S.newDate(c,Number(v),w)}catch(t){return u}return T?(T.toJD()-g)*f+k*h+M*p+A*d:u}c=2===c.length?(Number(c)+2e3-b)%100+b:Number(c),v-=1;var E=new Date(Date.UTC(2e3,v,w,k,M));return E.setUTCFullYear(c),E.getUTCMonth()!==v?u:E.getUTCDate()!==w?u:E.getTime()+A*d},n=r.MIN_MS=r.dateTime2ms("-9999"),i=r.MAX_MS=r.dateTime2ms("9999-12-31 23:59:59.9999"),r.isDateTime=function(t,e){return r.dateTime2ms(t,e)!==u};var k=90*f,M=3*h,A=5*p;function T(t,e,r,n,i){if((e||r||n||i)&&(t+=" "+w(e,2)+":"+w(r,2),(n||i)&&(t+=":"+w(n,2),i))){for(var a=4;i%10==0;)a-=1,i/=10;t+="."+w(i,a)}return t}r.ms2DateTime=function(t,e,r){if("number"!=typeof t||!(t>=n&&t<=i))return u;e||(e=0);var a,o,s,c,y,x,b=Math.floor(10*l(t+.05,1)),w=Math.round(t-b/10);if(_(r)){var S=Math.floor(w/f)+g,C=Math.floor(l(t,f));try{a=m.getComponentMethod("calendars","getCal")(r).fromJD(S).formatDate("yyyy-mm-dd")}catch(t){a=v("G%Y-%m-%d")(new Date(w))}if("-"===a.charAt(0))for(;a.length<11;)a="-0"+a.substr(1);else for(;a.length<10;)a="0"+a;o=e=n+f&&t<=i-f))return u;var e=Math.floor(10*l(t+.05,1)),r=new Date(Math.round(t-e/10));return T(a.time.format("%Y-%m-%d")(r),r.getHours(),r.getMinutes(),r.getSeconds(),10*r.getUTCMilliseconds()+e)},r.cleanDate=function(t,e,n){if(r.isJSDate(t)||"number"==typeof t){if(_(n))return s.error("JS Dates and milliseconds are incompatible with world calendars",t),e;if(!(t=r.ms2DateTimeLocal(+t))&&void 0!==e)return e}else if(!r.isDateTime(t,n))return s.error("unrecognized date",t),e;return t};var S=/%\d?f/g;function C(t,e,r,n){t=t.replace(S,function(t){var r=Math.min(+t.charAt(1)||6,6);return(e/1e3%1+2).toFixed(r).substr(2).replace(/0+$/,"")||"0"});var i=new Date(Math.floor(e+.05));if(_(n))try{t=m.getComponentMethod("calendars","worldCalFmt")(t,e,n)}catch(t){return"Invalid"}return r(t)(i)}var E=[59,59.9,59.99,59.999,59.9999];r.formatDate=function(t,e,r,n,i,a){if(i=_(i)&&i,!e)if("y"===r)e=a.year;else if("m"===r)e=a.month;else{if("d"!==r)return function(t,e){var r=l(t+.05,f),n=w(Math.floor(r/h),2)+":"+w(l(Math.floor(r/p),60),2);if("M"!==e){o(e)||(e=0);var i=(100+Math.min(l(t/d,60),E[e])).toFixed(e).substr(1);e>0&&(i=i.replace(/0+$/,"").replace(/[\.]$/,"")),n+=":"+i}return n}(t,r)+"\n"+C(a.dayMonthYear,t,n,i);e=a.dayMonth+"\n"+a.year}return C(e,t,n,i)};var L=3*f;r.incrementMonth=function(t,e,r){r=_(r)&&r;var n=l(t,f);if(t=Math.round(t-n),r)try{var i=Math.round(t/f)+g,a=m.getComponentMethod("calendars","getCal")(r),o=a.fromJD(i);return e%12?a.add(o,e,"m"):a.add(o,e/12,"y"),(o.toJD()-g)*f+n}catch(e){s.error("invalid ms "+t+" in calendar "+r)}var c=new Date(t+L);return c.setUTCMonth(c.getUTCMonth()+e)+n-L},r.findExactDates=function(t,e){for(var r,n,i=0,a=0,s=0,l=0,c=_(e)&&m.getComponentMethod("calendars","getCal")(e),u=0;u0&&(r.push(i),i=[])}return i.length>0&&r.push(i),r},r.makeLine=function(t){return 1===t.length?{type:"LineString",coordinates:t[0]}:{type:"MultiLineString",coordinates:t}},r.makePolygon=function(t){if(1===t.length)return{type:"Polygon",coordinates:t};for(var e=new Array(t.length),r=0;r1||g<0||g>1?null:{x:t+l*g,y:e+f*g}}function l(t,e,r,n,i){var a=n*t+i*e;if(a<0)return n*n+i*i;if(a>r){var o=n-t,s=i-e;return o*o+s*s}var l=n*e-i*t;return l*l/r}r.segmentsIntersect=s,r.segmentDistance=function(t,e,r,n,i,a,o,c){if(s(t,e,r,n,i,a,o,c))return 0;var u=r-t,f=n-e,h=o-i,p=c-a,d=u*u+f*f,g=h*h+p*p,m=Math.min(l(u,f,d,i-t,a-e),l(u,f,d,o-t,c-e),l(h,p,g,t-i,e-a),l(h,p,g,r-i,n-a));return Math.sqrt(m)},r.getTextLocation=function(t,e,r,s){if(t===i&&s===a||(n={},i=t,a=s),n[r])return n[r];var l=t.getPointAtLength(o(r-s/2,e)),c=t.getPointAtLength(o(r+s/2,e)),u=Math.atan((c.y-l.y)/(c.x-l.x)),f=t.getPointAtLength(o(r,e)),h={x:(4*f.x+l.x+c.x)/6,y:(4*f.y+l.y+c.y)/6,theta:u};return n[r]=h,h},r.clearLocationCache=function(){i=null},r.getVisibleSegment=function(t,e,r){var n,i,a=e.left,o=e.right,s=e.top,l=e.bottom,c=0,u=t.getTotalLength(),f=u;function h(e){var r=t.getPointAtLength(e);0===e?n=r:e===u&&(i=r);var c=r.xo?r.x-o:0,f=r.yl?r.y-l:0;return Math.sqrt(c*c+f*f)}for(var p=h(c);p;){if((c+=p+r)>f)return;p=h(c)}for(p=h(f);p;){if(c>(f-=p+r))return;p=h(f)}return{min:c,max:f,len:f-c,total:u,isClosed:0===c&&f===u&&Math.abs(n.x-i.x)<.1&&Math.abs(n.y-i.y)<.1}},r.findPointOnPath=function(t,e,r,n){for(var i,a,o,s=(n=n||{}).pathLength||t.getTotalLength(),l=n.tolerance||.001,c=n.iterationLimit||30,u=t.getPointAtLength(0)[r]>t.getPointAtLength(s)[r]?-1:1,f=0,h=0,p=s;f0?p=i:h=i,f++}return a}},{"./mod":667}],655:[function(t,e,r){"use strict";e.exports=function(t){var e;if("string"==typeof t){if(null===(e=document.getElementById(t)))throw new Error("No DOM element with id '"+t+"' exists on the page.");return e}if(null===t||void 0===t)throw new Error("DOM element provided is null or undefined");return t}},{}],656:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("tinycolor2"),a=t("color-normalize"),o=t("../components/colorscale"),s=t("../components/color/attributes").defaultLine,l=t("./is_array").isArrayOrTypedArray,c=a(s),u=1;function f(t,e){var r=t;return r[3]*=e,r}function h(t){if(n(t))return c;var e=a(t);return e.length?e:c}function p(t){return n(t)?t:u}e.exports={formatColor:function(t,e,r){var n,i,s,d,g,m=t.color,v=l(m),y=l(e),x=[];if(n=void 0!==t.colorscale?o.makeColorScaleFunc(o.extractScale(t.colorscale,t.cmin,t.cmax)):h,i=v?function(t,e){return void 0===t[e]?c:a(n(t[e]))}:h,s=y?function(t,e){return void 0===t[e]?u:p(t[e])}:p,v||y)for(var b=0;b=0;){var n=t.indexOf(";",r);if(n/g,"")}(function(t){for(var e=0;(e=t.indexOf("",e))>=0;){var r=t.indexOf("",e);if(r/g,"\n"))))}},{"../constants/string_mappings":638,"superscript-text":466}],659:[function(t,e,r){"use strict";e.exports=function(t){return t}},{}],660:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../constants/numerical"),o=a.FP_SAFE,s=a.BADNUM,l=e.exports={};l.nestedProperty=t("./nested_property"),l.keyedContainer=t("./keyed_container"),l.relativeAttr=t("./relative_attr"),l.isPlainObject=t("./is_plain_object"),l.mod=t("./mod"),l.toLogRange=t("./to_log_range"),l.relinkPrivateKeys=t("./relink_private"),l.ensureArray=t("./ensure_array");var c=t("./is_array");l.isTypedArray=c.isTypedArray,l.isArrayOrTypedArray=c.isArrayOrTypedArray,l.isArray1D=c.isArray1D;var u=t("./coerce");l.valObjectMeta=u.valObjectMeta,l.coerce=u.coerce,l.coerce2=u.coerce2,l.coerceFont=u.coerceFont,l.coerceHoverinfo=u.coerceHoverinfo,l.coerceSelectionMarkerOpacity=u.coerceSelectionMarkerOpacity,l.validate=u.validate;var f=t("./dates");l.dateTime2ms=f.dateTime2ms,l.isDateTime=f.isDateTime,l.ms2DateTime=f.ms2DateTime,l.ms2DateTimeLocal=f.ms2DateTimeLocal,l.cleanDate=f.cleanDate,l.isJSDate=f.isJSDate,l.formatDate=f.formatDate,l.incrementMonth=f.incrementMonth,l.dateTick0=f.dateTick0,l.dfltRange=f.dfltRange,l.findExactDates=f.findExactDates,l.MIN_MS=f.MIN_MS,l.MAX_MS=f.MAX_MS;var h=t("./search");l.findBin=h.findBin,l.sorterAsc=h.sorterAsc,l.sorterDes=h.sorterDes,l.distinctVals=h.distinctVals,l.roundUp=h.roundUp;var p=t("./stats");l.aggNums=p.aggNums,l.len=p.len,l.mean=p.mean,l.midRange=p.midRange,l.variance=p.variance,l.stdev=p.stdev,l.interp=p.interp;var d=t("./matrix");l.init2dArray=d.init2dArray,l.transposeRagged=d.transposeRagged,l.dot=d.dot,l.translationMatrix=d.translationMatrix,l.rotationMatrix=d.rotationMatrix,l.rotationXYMatrix=d.rotationXYMatrix,l.apply2DTransform=d.apply2DTransform,l.apply2DTransform2=d.apply2DTransform2;var g=t("./angles");l.deg2rad=g.deg2rad,l.rad2deg=g.rad2deg,l.wrap360=g.wrap360,l.wrap180=g.wrap180;var m=t("./geometry2d");l.segmentsIntersect=m.segmentsIntersect,l.segmentDistance=m.segmentDistance,l.getTextLocation=m.getTextLocation,l.clearLocationCache=m.clearLocationCache,l.getVisibleSegment=m.getVisibleSegment,l.findPointOnPath=m.findPointOnPath;var v=t("./extend");l.extendFlat=v.extendFlat,l.extendDeep=v.extendDeep,l.extendDeepAll=v.extendDeepAll,l.extendDeepNoArrays=v.extendDeepNoArrays;var y=t("./loggers");l.log=y.log,l.warn=y.warn,l.error=y.error;var x=t("./regex");l.counterRegex=x.counter;var b=t("./throttle");l.throttle=b.throttle,l.throttleDone=b.done,l.clearThrottle=b.clear,l.getGraphDiv=t("./get_graph_div"),l._=t("./localize"),l.notifier=t("./notifier"),l.filterUnique=t("./filter_unique"),l.filterVisible=t("./filter_visible"),l.pushUnique=t("./push_unique"),l.cleanNumber=t("./clean_number"),l.ensureNumber=function(t){return i(t)?(t=Number(t))<-o||t>o?s:i(t)?Number(t):s:s},l.isIndex=function(t,e){return!(void 0!==e&&t>=e)&&(i(t)&&t>=0&&t%1==0)},l.noop=t("./noop"),l.identity=t("./identity"),l.swapAttrs=function(t,e,r,n){r||(r="x"),n||(n="y");for(var i=0;ir?Math.max(r,Math.min(e,t)):Math.max(e,Math.min(r,t))},l.bBoxIntersect=function(t,e,r){return r=r||0,t.left<=e.right+r&&e.left<=t.right+r&&t.top<=e.bottom+r&&e.top<=t.bottom+r},l.simpleMap=function(t,e,r,n){for(var i=t.length,a=new Array(i),o=0;o-1||c!==1/0&&c>=Math.pow(2,r)?t(e,r,n):s},l.OptionControl=function(t,e){t||(t={}),e||(e="opt");var r={optionList:[],_newoption:function(n){n[e]=t,r[n.name]=n,r.optionList.push(n)}};return r["_"+e]=t,r},l.smooth=function(t,e){if((e=Math.round(e)||0)<2)return t;var r,n,i,a,o=t.length,s=2*o,l=2*e-1,c=new Array(l),u=new Array(o);for(r=0;r=s&&(i-=s*Math.floor(i/s)),i<0?i=-1-i:i>=o&&(i=s-1-i),a+=t[i]*c[n];u[r]=a}return u},l.syncOrAsync=function(t,e,r){var n;function i(){return l.syncOrAsync(t,e,r)}for(;t.length;)if((n=(0,t.splice(0,1)[0])(e))&&n.then)return n.then(i).then(void 0,l.promiseError);return r&&r(e)},l.stripTrailingSlash=function(t){return"/"===t.substr(-1)?t.substr(0,t.length-1):t},l.noneOrAll=function(t,e,r){if(t){var n,i,a=!1,o=!0;for(n=0;n1?i+o[1]:"";if(a&&(o.length>1||s.length>4||r))for(;n.test(s);)s=s.replace(n,"$1"+a+"$2");return s+l};var k=/%{([^\s%{}]*)}/g,M=/^\w*$/;l.templateString=function(t,e){var r={};return t.replace(k,function(t,n){return M.test(n)?e[n]||"":(r[n]=r[n]||l.nestedProperty(e,n).get,r[n]()||"")})};l.subplotSort=function(t,e){for(var r=Math.min(t.length,e.length)+1,n=0,i=0,a=0;a=48&&o<=57,c=s>=48&&s<=57;if(l&&(n=10*n+o-48),c&&(i=10*i+s-48),!l||!c){if(n!==i)return n-i;if(o!==s)return o-s}}return i-n};var A=2e9;l.seedPseudoRandom=function(){A=2e9},l.pseudoRandom=function(){var t=A;return A=(69069*A+1)%4294967296,Math.abs(A-t)<429496729?l.pseudoRandom():A/4294967296}},{"../constants/numerical":637,"./angles":642,"./clean_number":643,"./coerce":645,"./dates":646,"./ensure_array":647,"./extend":649,"./filter_unique":650,"./filter_visible":651,"./geometry2d":654,"./get_graph_div":655,"./identity":659,"./is_array":661,"./is_plain_object":662,"./keyed_container":663,"./localize":664,"./loggers":665,"./matrix":666,"./mod":667,"./nested_property":668,"./noop":669,"./notifier":670,"./push_unique":674,"./regex":676,"./relative_attr":677,"./relink_private":678,"./search":679,"./stats":682,"./throttle":685,"./to_log_range":686,d3:131,"fast-isnumeric":197}],661:[function(t,e,r){"use strict";var n="undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer:{isView:function(){return!1}},i="undefined"==typeof DataView?function(){}:DataView;function a(t){return n.isView(t)&&!(t instanceof i)}function o(t){return Array.isArray(t)||a(t)}e.exports={isTypedArray:a,isArrayOrTypedArray:o,isArray1D:function(t){return!o(t[0])}}},{}],662:[function(t,e,r){"use strict";e.exports=function(t){return window&&window.process&&window.process.versions?"[object Object]"===Object.prototype.toString.call(t):"[object Object]"===Object.prototype.toString.call(t)&&Object.getPrototypeOf(t)===Object.prototype}},{}],663:[function(t,e,r){"use strict";var n=t("./nested_property"),i=/^\w*$/;e.exports=function(t,e,r,a){var o,s,l;r=r||"name",a=a||"value";var c={};e&&e.length?(l=n(t,e),s=l.get()):s=t,e=e||"";var u={};if(s)for(o=0;o2)return c[e]=2|c[e],h.set(t,null);if(f){for(o=e;o1){for(var t=["LOG:"],e=0;e0){for(var t=["WARN:"],e=0;e0){for(var t=["ERROR:"],e=0;e/g),o=0;oo||a===i||al||e&&c(t))}:function(t,e){var a=t[0],c=t[1];if(a===i||ao||c===i||cl)return!1;var u,f,h,p,d,g=r.length,m=r[0][0],v=r[0][1],y=0;for(u=1;uMath.max(f,m)||c>Math.max(h,v)))if(cu||Math.abs(n(o,h))>i)return!0;return!1};a.filter=function(t,e){var r=[t[0]],n=0,i=0;function a(a){t.push(a);var s=r.length,l=n;r.splice(i+1);for(var c=l+1;c1&&a(t.pop());return{addPt:a,raw:t,filtered:r}}},{"../constants/numerical":637,"./matrix":666}],673:[function(t,e,r){(function(r){"use strict";var n=t("regl");e.exports=function(t,e){t._fullLayout._glcanvas.each(function(i){i.regl||(i.regl=n({canvas:this,attributes:{antialias:!i.pick,preserveDrawingBuffer:!0},pixelRatio:t._context.plotGlPixelRatio||r.devicePixelRatio,extensions:e||[]}))})}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{regl:438}],674:[function(t,e,r){"use strict";e.exports=function(t,e){if(e instanceof RegExp){var r,n=e.toString();for(r=0;ri.queueLength&&(t.undoQueue.queue.shift(),t.undoQueue.index--))},startSequence:function(t){t.undoQueue=t.undoQueue||{index:0,queue:[],sequence:!1},t.undoQueue.sequence=!0,t.undoQueue.beginSequence=!0},stopSequence:function(t){t.undoQueue=t.undoQueue||{index:0,queue:[],sequence:!1},t.undoQueue.sequence=!1,t.undoQueue.beginSequence=!1},undo:function(t){var e,r;if(t.framework&&t.framework.isPolar)t.framework.undo();else if(!(void 0===t.undoQueue||isNaN(t.undoQueue.index)||t.undoQueue.index<=0)){for(t.undoQueue.index--,e=t.undoQueue.queue[t.undoQueue.index],t.undoQueue.inSequence=!0,r=0;r=t.undoQueue.queue.length)){for(e=t.undoQueue.queue[t.undoQueue.index],t.undoQueue.inSequence=!0,r=0;re}function l(t,e){return t>=e}r.findBin=function(t,e,r){if(n(e.start))return r?Math.ceil((t-e.start)/e.size-1e-9)-1:Math.floor((t-e.start)/e.size+1e-9);var c,u,f=0,h=e.length,p=0,d=h>1?(e[h-1]-e[0])/(h-1):1;for(u=d>=0?r?a:o:r?l:s,t+=1e-9*d*(r?-1:1)*(d>=0?1:-1);f90&&i.log("Long binary search..."),f-1},r.sorterAsc=function(t,e){return t-e},r.sorterDes=function(t,e){return e-t},r.distinctVals=function(t){var e=t.slice();e.sort(r.sorterAsc);for(var n=e.length-1,i=e[n]-e[0]||1,a=i/(n||1)/1e4,o=[e[0]],s=0;se[s]+a&&(i=Math.min(i,e[s+1]-e[s]),o.push(e[s+1]));return{vals:o,minDiff:i}},r.roundUp=function(t,e,r){for(var n,i=0,a=e.length-1,o=0,s=r?0:1,l=r?1:0,c=r?Math.ceil:Math.floor;ia.length)&&(o=a.length),n(e)||(e=!1),i(a[0])){for(l=new Array(o),s=0;st.length-1)return t[t.length-1];var r=e%1;return r*t[Math.ceil(e)]+(1-r)*t[Math.floor(e)]}},{"./is_array":661,"fast-isnumeric":197}],683:[function(t,e,r){"use strict";var n=t("color-normalize");e.exports=function(t){return t?n(t):[0,0,0,1]}},{"color-normalize":101}],684:[function(t,e,r){"use strict";var n=t("d3"),i=t("../lib"),a=t("../constants/xmlns_namespaces"),o=t("../constants/string_mappings"),s=t("../constants/alignment").LINE_SPACING;function l(t,e){return t.node().getBoundingClientRect()[e]}var c=/([^$]*)([$]+[^$]*[$]+)([^$]*)/;r.convertToTspans=function(t,e,o){var v=t.text(),E=!t.attr("data-notex")&&"undefined"!=typeof MathJax&&v.match(c),L=n.select(t.node().parentNode);if(!L.empty()){var z=t.attr("class")?t.attr("class").split(" ")[0]:"text";return z+="-math",L.selectAll("svg."+z).remove(),L.selectAll("g."+z+"-group").remove(),t.style("display",null).attr({"data-unformatted":v,"data-math":"N"}),E?(e&&e._promises||[]).push(new Promise(function(e){t.style("display","none");var r=parseInt(t.node().style.fontSize,10),a={fontSize:r};!function(t,e,r){var a="math-output-"+i.randstr([],64),o=n.select("body").append("div").attr({id:a}).style({visibility:"hidden",position:"absolute"}).style({"font-size":e.fontSize+"px"}).text((s=t,s.replace(u,"\\lt ").replace(f,"\\gt ")));var s;MathJax.Hub.Queue(["Typeset",MathJax.Hub,o.node()],function(){var e=n.select("body").select("#MathJax_SVG_glyphs");if(o.select(".MathJax_SVG").empty()||!o.select("svg").node())i.log("There was an error in the tex syntax.",t),r();else{var a=o.select("svg").node().getBoundingClientRect();r(o.select(".MathJax_SVG"),e,a)}o.remove()})}(E[2],a,function(n,i,a){L.selectAll("svg."+z).remove(),L.selectAll("g."+z+"-group").remove();var s=n&&n.select("svg");if(!s||!s.node())return P(),void e();var c=L.append("g").classed(z+"-group",!0).attr({"pointer-events":"none","data-unformatted":v,"data-math":"Y"});c.node().appendChild(s.node()),i&&i.node()&&s.node().insertBefore(i.node().cloneNode(!0),s.node().firstChild),s.attr({class:z,height:a.height,preserveAspectRatio:"xMinYMin meet"}).style({overflow:"visible","pointer-events":"none"});var u=t.node().style.fill||"black";s.select("g").attr({fill:u,stroke:u});var f=l(s,"width"),h=l(s,"height"),p=+t.attr("x")-f*{start:0,middle:.5,end:1}[t.attr("text-anchor")||"start"],d=-(r||l(t,"height"))/4;"y"===z[0]?(c.attr({transform:"rotate("+[-90,+t.attr("x"),+t.attr("y")]+") translate("+[-f/2,d-h/2]+")"}),s.attr({x:+t.attr("x"),y:+t.attr("y")})):"l"===z[0]?s.attr({x:t.attr("x"),y:d-h/2}):"a"===z[0]?s.attr({x:0,y:d}):s.attr({x:p,y:+t.attr("y")+d-h/2}),o&&o.call(t,c),e(c)})})):P(),t}function P(){L.empty()||(z=t.attr("class")+"-math",L.select("svg."+z).remove()),t.text("").style("white-space","pre"),function(t,e){e=(r=e,function(t,e){if(!t)return"";for(var r=0;r1)for(var i=1;i doesnt match end tag <"+t+">. Pretending it did match.",e),o=c[c.length-1].node}else i.log("Ignoring unexpected end tag .",e)}w.test(e)?f():(o=t,c=[{node:t}]);for(var z=e.split(b),P=0;P|>|>)/g;var h={sup:"font-size:70%",sub:"font-size:70%",b:"font-weight:bold",i:"font-style:italic",a:"cursor:pointer",span:"",em:"font-style:italic;font-weight:bold"},p={sub:"0.3em",sup:"-0.6em"},d={sub:"-0.21em",sup:"0.42em"},g="\u200b",m=["http:","https:","mailto:","",void 0,":"],v=new RegExp("]*)?/?>","g"),y=Object.keys(o.entityToUnicode).map(function(t){return{regExp:new RegExp("&"+t+";","g"),sub:o.entityToUnicode[t]}}),x=/(\r\n?|\n)/g,b=/(<[^<>]*>)/,_=/<(\/?)([^ >]*)(\s+(.*))?>/i,w=//i,k=/(^|[\s"'])style\s*=\s*("([^"]*);?"|'([^']*);?')/i,M=/(^|[\s"'])href\s*=\s*("([^"]*)"|'([^']*)')/i,A=/(^|[\s"'])target\s*=\s*("([^"\s]*)"|'([^'\s]*)')/i,T=/(^|[\s"'])popup\s*=\s*("([\w=,]*)"|'([\w=,]*)')/i;function S(t,e){if(!t)return null;var r=t.match(e);return r&&(r[3]||r[4])}var C=/(^|;)\s*color:/;function E(t,e,r){var n,i,a,o=r.horizontalAlign,s=r.verticalAlign||"top",l=t.node().getBoundingClientRect(),c=e.node().getBoundingClientRect();return i="bottom"===s?function(){return l.bottom-n.height}:"middle"===s?function(){return l.top+(l.height-n.height)/2}:function(){return l.top},a="right"===o?function(){return l.right-n.width}:"center"===o?function(){return l.left+(l.width-n.width)/2}:function(){return l.left},function(){return n=this.node().getBoundingClientRect(),this.style({top:i()-c.top+"px",left:a()-c.left+"px","z-index":1e3}),this}}r.plainText=function(t){return(t||"").replace(v," ")},r.lineCount=function(t){return t.selectAll("tspan.line").size()||1},r.positionText=function(t,e,r){return t.each(function(){var t=n.select(this);function i(e,r){return void 0===r?null===(r=t.attr(e))&&(t.attr(e,0),r=0):t.attr(e,r),r}var a=i("x",e),o=i("y",r);"text"===this.nodeName&&t.selectAll("tspan.line").attr({x:a,y:o})})},r.makeEditable=function(t,e){var r=e.gd,i=e.delegate,a=n.dispatch("edit","input","cancel"),o=i||t;if(t.style({"pointer-events":i?"none":"all"}),1!==t.size())throw new Error("boo");function s(){!function(){var i=n.select(r).select(".svg-container"),o=i.append("div"),s=t.node().style,c=parseFloat(s.fontSize||12),u=e.text;void 0===u&&(u=t.attr("data-unformatted"));o.classed("plugin-editable editable",!0).style({position:"absolute","font-family":s.fontFamily||"Arial","font-size":c,color:e.fill||s.fill||"black",opacity:1,"background-color":e.background||"transparent",outline:"#ffffff33 1px solid",margin:[-c/8+1,0,0,-1].join("px ")+"px",padding:"0","box-sizing":"border-box"}).attr({contenteditable:!0}).text(u).call(E(t,i,e)).on("blur",function(){r._editing=!1,t.text(this.textContent).style({opacity:1});var e,i=n.select(this).attr("class");(e=i?"."+i.split(" ")[0]+"-math-group":"[class*=-math-group]")&&n.select(t.node().parentNode).select(e).style({opacity:0});var o=this.textContent;n.select(this).transition().duration(0).remove(),n.select(document).on("mouseup",null),a.edit.call(t,o)}).on("focus",function(){var t=this;r._editing=!0,n.select(document).on("mouseup",function(){if(n.event.target===t)return!1;document.activeElement===o.node()&&o.node().blur()})}).on("keyup",function(){27===n.event.which?(r._editing=!1,t.style({opacity:1}),n.select(this).style({opacity:0}).on("blur",function(){return!1}).transition().remove(),a.cancel.call(t,this.textContent)):(a.input.call(t,this.textContent),n.select(this).call(E(t,i,e)))}).on("keydown",function(){13===n.event.which&&this.blur()}).call(l)}(),t.style({opacity:0});var i,s=o.attr("class");(i=s?"."+s.split(" ")[0]+"-math-group":"[class*=-math-group]")&&n.select(t.node().parentNode).select(i).style({opacity:0})}function l(t){var e=t.node(),r=document.createRange();r.selectNodeContents(e);var n=window.getSelection();n.removeAllRanges(),n.addRange(r),e.focus()}return e.immediate?s():o.on("click",s),n.rebind(t,a,"on")}},{"../constants/alignment":632,"../constants/string_mappings":638,"../constants/xmlns_namespaces":639,"../lib":660,d3:131}],685:[function(t,e,r){"use strict";var n={};function i(t){t&&null!==t.timer&&(clearTimeout(t.timer),t.timer=null)}r.throttle=function(t,e,r){var a=n[t],o=Date.now();if(!a){for(var s in n)n[s].tsa.ts+e?l():a.timer=setTimeout(function(){l(),a.timer=null},e)},r.done=function(t){var e=n[t];return e&&e.timer?new Promise(function(t){var r=e.onDone;e.onDone=function(){r&&r(),t(),e.onDone=null}}):Promise.resolve()},r.clear=function(t){if(t)i(n[t]),delete n[t];else for(var e in n)r.clear(e)}},{}],686:[function(t,e,r){"use strict";var n=t("fast-isnumeric");e.exports=function(t,e){if(t>0)return Math.log(t)/Math.LN10;var r=Math.log(Math.min(e[0],e[1]))/Math.LN10;return n(r)||(r=Math.log(Math.max(e[0],e[1]))/Math.LN10-6),r}},{"fast-isnumeric":197}],687:[function(t,e,r){"use strict";var n=e.exports={},i=t("../plots/geo/constants").locationmodeToLayer,a=t("topojson-client").feature;n.getTopojsonName=function(t){return[t.scope.replace(/ /g,"-"),"_",t.resolution.toString(),"m"].join("")},n.getTopojsonPath=function(t,e){return t+e+".json"},n.getTopojsonFeatures=function(t,e){var r=i[t.locationmode],n=e.objects[r];return a(e,n).features}},{"../plots/geo/constants":734,"topojson-client":476}],688:[function(t,e,r){"use strict";e.exports={moduleType:"locale",name:"en-US",dictionary:{"Click to enter Colorscale title":"Click to enter Colorscale title"},format:{date:"%m/%d/%Y"}}},{}],689:[function(t,e,r){"use strict";e.exports={moduleType:"locale",name:"en",dictionary:{"Click to enter Colorscale title":"Click to enter Colourscale title"},format:{days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],periods:["AM","PM"],dateTime:"%a %b %e %X %Y",date:"%d/%m/%Y",time:"%H:%M:%S",decimal:".",thousands:",",grouping:[3],currency:["$",""],year:"%Y",month:"%b %Y",dayMonth:"%b %-d",dayMonthYear:"%b %-d, %Y"}}},{}],690:[function(t,e,r){"use strict";var n=t("../registry");e.exports=function(t){for(var e,r,i=n.layoutArrayContainers,a=n.layoutArrayRegexes,o=t.split("[")[0],s=0;s0&&o.log("Clearing previous rejected promises from queue."),t._promises=[]},r.cleanLayout=function(t){var e,r;t||(t={}),t.xaxis1&&(t.xaxis||(t.xaxis=t.xaxis1),delete t.xaxis1),t.yaxis1&&(t.yaxis||(t.yaxis=t.yaxis1),delete t.yaxis1),t.scene1&&(t.scene||(t.scene=t.scene1),delete t.scene1);var n=(s.subplotsRegistry.cartesian||{}).attrRegex,a=(s.subplotsRegistry.gl3d||{}).attrRegex,l=Object.keys(t);for(e=0;e3?(T.x=1.02,T.xanchor="left"):T.x<-2&&(T.x=-.02,T.xanchor="right"),T.y>3?(T.y=1.02,T.yanchor="bottom"):T.y<-2&&(T.y=-.02,T.yanchor="top")),"rotate"===t.dragmode&&(t.dragmode="orbit"),f.clean(t),t},r.cleanData=function(t,e){for(var n=[],i=t.concat(Array.isArray(e)?e:[]).filter(function(t){return"uid"in t}).map(function(t){return t.uid}),l=0;l0)return t.substr(0,e)}r.hasParent=function(t,e){for(var r=y(e);r;){if(r in t)return!0;r=y(r)}return!1};var x=["x","y","z"];r.clearAxisTypes=function(t,e,r){for(var n=0;n1&&o.warn("Full array edits are incompatible with other edits",f);var y=r[""][""];if(u(y))e.set(null);else{if(!Array.isArray(y))return o.warn("Unrecognized full array edit value",f,y),!0;e.set(y)}return!g&&(h(m,v),p(t),!0)}var x,b,_,w,k,M,A,T=Object.keys(r).map(Number).sort(s),S=e.get(),C=S||[],E=n(v,f).get(),L=[],z=-1,P=C.length;for(x=0;xC.length-(A?0:1))o.warn("index out of range",f,_);else if(void 0!==M)k.length>1&&o.warn("Insertion & removal are incompatible with edits to the same index.",f,_),u(M)?L.push(_):A?("add"===M&&(M={}),C.splice(_,0,M),E&&E.splice(_,0,{})):o.warn("Unrecognized full object edit value",f,_,M),-1===z&&(z=_);else for(b=0;b=0;x--)C.splice(L[x],1),E&&E.splice(L[x],1);if(C.length?S||e.set(C):e.set(null),g)return!1;if(h(m,v),d!==a){var D;if(-1===z)D=T;else{for(P=Math.max(C.length,P),D=[],x=0;x=z);x++)D.push(_);for(x=z;x=t.data.length||i<-t.data.length)throw new Error(r+" must be valid indices for gd.data.");if(e.indexOf(i,n+1)>-1||i>=0&&e.indexOf(-t.data.length+i)>-1||i<0&&e.indexOf(t.data.length+i)>-1)throw new Error("each index in "+r+" must be unique.")}}function z(t,e,r){if(!Array.isArray(t.data))throw new Error("gd.data must be an array.");if(void 0===e)throw new Error("currentIndices is a required argument.");if(Array.isArray(e)||(e=[e]),L(t,e,"currentIndices"),void 0===r||Array.isArray(r)||(r=[r]),void 0!==r&&L(t,r,"newIndices"),void 0!==r&&e.length!==r.length)throw new Error("current and new indices must be of equal length.")}function P(t,e,r,n,a){!function(t,e,r,n){var i=o.isPlainObject(n);if(!Array.isArray(t.data))throw new Error("gd.data must be an array");if(!o.isPlainObject(e))throw new Error("update must be a key:value object");if(void 0===r)throw new Error("indices must be an integer or array of integers");for(var a in L(t,r,"indices"),e){if(!Array.isArray(e[a])||e[a].length!==r.length)throw new Error("attribute "+a+" must be an array of length equal to indices array length");if(i&&(!(a in n)||!Array.isArray(n[a])||n[a].length!==e[a].length))throw new Error("when maxPoints is set as a key:value object it must contain a 1:1 corrispondence with the keys and number of traces in the update object")}}(t,e,r,n);for(var s=function(t,e,r,n){var a,s,l,c,u,f=o.isPlainObject(n),h=[];for(var p in Array.isArray(r)||(r=[r]),r=E(r,t.data.length-1),e)for(var d=0;d=0&&r=0&&r0&&"string"!=typeof E.parts[z];)z--;var P=E.parts[z],D=E.parts[z-1]+"."+P,I=E.parts.slice(0,z).join("."),N=o.nestedProperty(t.layout,I).get(),U=o.nestedProperty(s,I).get(),q=E.get();if(void 0!==L){y[C]=L,x[C]="reverse"===P?L:O(q);var H=u.getLayoutValObject(s,E.parts);if(H&&H.impliedEdits&&null!==L)for(var G in H.impliedEdits)w(o.relativeAttr(C,G),H.impliedEdits[G]);if(-1!==["width","height"].indexOf(C)&&null===L)s[C]=t._initialAutoSize[C];else if(D.match(R))S(D),o.nestedProperty(s,I+"._inputRange").set(null);else if(D.match(B)){S(D),o.nestedProperty(s,I+"._inputRange").set(null);var W=o.nestedProperty(s,I).get();W._inputDomain&&(W._input.domain=W._inputDomain.slice())}else D.match(F)&&o.nestedProperty(s,I+"._inputDomain").set(null);if("type"===P){var Y=N,X="linear"===U.type&&"log"===L,Z="log"===U.type&&"linear"===L;if(X||Z){if(Y&&Y.range)if(U.autorange)X&&(Y.range=Y.range[1]>Y.range[0]?[1,2]:[2,1]);else{var J=Y.range[0],K=Y.range[1];X?(J<=0&&K<=0&&w(I+".autorange",!0),J<=0?J=K/1e6:K<=0&&(K=J/1e6),w(I+".range[0]",Math.log(J)/Math.LN10),w(I+".range[1]",Math.log(K)/Math.LN10)):(w(I+".range[0]",Math.pow(10,J)),w(I+".range[1]",Math.pow(10,K)))}else w(I+".autorange",!0);Array.isArray(s._subplots.polar)&&s._subplots.polar.length&&s[E.parts[0]]&&"radialaxis"===E.parts[1]&&delete s[E.parts[0]]._subplot.viewInitial["radialaxis.range"],c.getComponentMethod("annotations","convertCoords")(t,U,L,w),c.getComponentMethod("images","convertCoords")(t,U,L,w)}else w(I+".autorange",!0),w(I+".range",null);o.nestedProperty(s,I+"._inputRange").set(null)}else if(P.match(M)){var Q=o.nestedProperty(s,C).get(),$=(L||{}).type;$&&"-"!==$||($="linear"),c.getComponentMethod("annotations","convertCoords")(t,Q,$,w),c.getComponentMethod("images","convertCoords")(t,Q,$,w)}var tt=b.containerArrayMatch(C);if(tt){r=tt.array,n=tt.index;var et=tt.property,rt=(o.nestedProperty(a,r)||[])[n]||{},nt=rt,it=H||{editType:"calc"},at=-1!==it.editType.indexOf("calcIfAutorange");""===n?(at?v.calc=!0:k.update(v,it),at=!1):""===et&&(nt=L,b.isAddVal(L)?x[C]=null:b.isRemoveVal(L)?(x[C]=rt,nt=rt):o.warn("unrecognized full object value",e)),at&&(V(t,nt,"x")||V(t,nt,"y"))?v.calc=!0:k.update(v,it),h[r]||(h[r]={});var ot=h[r][n];ot||(ot=h[r][n]={}),ot[et]=L,delete e[C]}else"reverse"===P?(N.range?N.range.reverse():(w(I+".autorange",!0),N.range=[1,0]),U.autorange?v.calc=!0:v.plot=!0):(s._has("scatter-like")&&s._has("regl")&&"dragmode"===C&&("lasso"===L||"select"===L)&&"lasso"!==q&&"select"!==q?v.plot=!0:H?k.update(v,H):v.calc=!0,E.set(L))}}for(r in h){b.applyContainerArrayChanges(t,o.nestedProperty(a,r),h[r],v)||(v.plot=!0)}var st=s._axisConstraintGroups||[];for(A in T)for(n=0;n=i.length?i[0]:i[t]:i}function l(t){return Array.isArray(a)?t>=a.length?a[0]:a[t]:a}function c(t,e){var r=0;return function(){if(t&&++r===e)return t()}}return void 0===n._frameWaitingCnt&&(n._frameWaitingCnt=0),new Promise(function(a,u){function h(){n._currentFrame&&n._currentFrame.onComplete&&n._currentFrame.onComplete();var e=n._currentFrame=n._frameQueue.shift();if(e){var r=e.name?e.name.toString():null;t._fullLayout._currentFrame=r,n._lastFrameAt=Date.now(),n._timeToNext=e.frameOpts.duration,f.transition(t,e.frame.data,e.frame.layout,_.coerceTraceIndices(t,e.frame.traces),e.frameOpts,e.transitionOpts).then(function(){e.onComplete&&e.onComplete()}),t.emit("plotly_animatingframe",{name:r,frame:e.frame,animation:{frame:e.frameOpts,transition:e.transitionOpts}})}else t.emit("plotly_animated"),window.cancelAnimationFrame(n._animationRaf),n._animationRaf=null}function p(){t.emit("plotly_animating"),n._lastFrameAt=-1/0,n._timeToNext=0,n._runningTransitions=0,n._currentFrame=null;var e=function(){n._animationRaf=window.requestAnimationFrame(e),Date.now()-n._lastFrameAt>n._timeToNext&&h()};e()}var d,g,m=0;function v(t){return Array.isArray(i)?m>=i.length?t.transitionOpts=i[m]:t.transitionOpts=i[0]:t.transitionOpts=i,m++,t}var y=[],x=void 0===e||null===e,b=Array.isArray(e);if(!x&&!b&&o.isPlainObject(e))y.push({type:"object",data:v(o.extendFlat({},e))});else if(x||-1!==["string","number"].indexOf(typeof e))for(d=0;d0&&MM)&&A.push(g);y=A}}y.length>0?function(e){if(0!==e.length){for(var i=0;i=0;n--)if(o.isPlainObject(e[n])){var g=e[n].name,m=(u[g]||d[g]||{}).name,v=e[n].name,y=u[m]||d[m];m&&v&&"number"==typeof v&&y&&A<5&&(A++,o.warn('addFrames: overwriting frame "'+(u[m]||d[m]).name+'" with a frame whose name of type "number" also equates to "'+m+'". This is valid but may potentially lead to unexpected behavior since all plotly.js frame names are stored internally as strings.'),5===A&&o.warn("addFrames: This API call has yielded too many of these warnings. For the rest of this call, further warnings about numeric frame names will be suppressed.")),d[g]={name:g},p.push({frame:f.supplyFrameDefaults(e[n]),index:r&&void 0!==r[n]&&null!==r[n]?r[n]:h+n})}p.sort(function(t,e){return t.index>e.index?-1:t.index=0;n--){if("number"==typeof(i=p[n].frame).name&&o.warn("Warning: addFrames accepts frames with numeric names, but the numbers areimplicitly cast to strings"),!i.name)for(;u[i.name="frame "+t._transitionData._counter++];);if(u[i.name]){for(a=0;a=0;r--)n=e[r],a.push({type:"delete",index:n}),s.unshift({type:"insert",index:n,value:i[n]});var c=f.modifyFrames,u=f.modifyFrames,h=[t,s],p=[t,a];return l&&l.add(t,c,h,u,p),f.modifyFrames(t,a)},r.purge=function(t){var e=(t=o.getGraphDiv(t))._fullLayout||{},r=t._fullData||[],n=t.calcdata||[];return f.cleanPlot([],{},r,e,n),f.purge(t),s.purge(t),e._container&&e._container.remove(),delete t._context,t}},{"../components/color":532,"../components/drawing":557,"../constants/xmlns_namespaces":639,"../lib":660,"../lib/events":648,"../lib/queue":675,"../lib/svg_text_utils":684,"../plots/cartesian/axes":706,"../plots/cartesian/constants":711,"../plots/cartesian/graph_interact":715,"../plots/plots":768,"../plots/polar/legacy":776,"../registry":790,"./edit_types":691,"./helpers":692,"./manage_arrays":694,"./plot_config":696,"./plot_schema":697,"./subroutines":698,d3:131,"fast-isnumeric":197,"has-hover":354}],696:[function(t,e,r){"use strict";e.exports={staticPlot:!1,editable:!1,edits:{annotationPosition:!1,annotationTail:!1,annotationText:!1,axisTitleText:!1,colorbarPosition:!1,colorbarTitleText:!1,legendPosition:!1,legendText:!1,shapePosition:!1,titleText:!1},autosizable:!1,queueLength:0,fillFrame:!1,frameMargins:0,scrollZoom:!1,doubleClick:"reset+autosize",showTips:!0,showAxisDragHandles:!0,showAxisRangeEntryBoxes:!0,showLink:!1,sendData:!0,linkText:"Edit chart",showSources:!1,displayModeBar:"hover",modeBarButtonsToRemove:[],modeBarButtonsToAdd:[],modeBarButtons:!1,toImageButtonOptions:{},displaylogo:!0,plotGlPixelRatio:2,setBackground:"transparent",topojsonURL:"https://cdn.plot.ly/",mapboxAccessToken:null,logging:1,globalTransforms:[],locale:"en-US",locales:{}}},{}],697:[function(t,e,r){"use strict";var n=t("../registry"),i=t("../lib"),a=t("../plots/attributes"),o=t("../plots/layout_attributes"),s=t("../plots/frame_attributes"),l=t("../plots/animation_attributes"),c=t("../plots/polar/legacy/area_attributes"),u=t("../plots/polar/legacy/axis_attributes"),f=t("./edit_types"),h=i.extendFlat,p=i.extendDeepAll,d=i.isPlainObject,g="_isSubplotObj",m="_isLinkedToArray",v=[g,m,"_arrayAttrRegexps","_deprecated"];function y(t,e,r){if(!t)return!1;if(t._isLinkedToArray)if(x(e[r]))r++;else if(r=a.length)return!1;if(2===t.dimensions){if(r++,e.length===r)return t;var o=e[r];if(!x(o))return!1;t=a[i][o]}else t=a[i]}else t=a}}return t}function x(t){return t===Math.round(t)&&t>=0}function b(t){return function(t){r.crawl(t,function(t,e,n){r.isValObject(t)?"data_array"===t.valType?(t.role="data",n[e+"src"]={valType:"string",editType:"none"}):!0===t.arrayOk&&(n[e+"src"]={valType:"string",editType:"none"}):d(t)&&(t.role="object")})}(t),function(t){r.crawl(t,function(t,e,r){if(!t)return;var n=t[m];if(!n)return;delete t[m],r[e]={items:{}},r[e].items[n]=t,r[e].role="object"})}(t),function(t){!function t(e){for(var r in e)if(d(e[r]))t(e[r]);else if(Array.isArray(e[r]))for(var n=0;n=l.length)return!1;i=(r=(n.transformsRegistry[l[u].type]||{}).attributes)&&r[e[2]],s=3}else if("area"===t.type)i=c[o];else{var f=t._module;if(f||(f=(n.modules[t.type||a.type.dflt]||{})._module),!f)return!1;if(!(i=(r=f.attributes)&&r[o])){var h=f.basePlotModule;h&&h.attributes&&(i=h.attributes[o])}i||(i=a[o])}return y(i,e,s)},r.getLayoutValObject=function(t,e){return y(function(t,e){var r,i,a,s,l=t._basePlotModules;if(l){var c;for(r=0;r=t[1]||i[1]<=t[0])&&a[0]e[0])return!0}return!1}(r,n,k)){var s=a.node(),l=e.bg=o.ensureSingle(a,"rect","bg");s.insertBefore(l.node(),s.childNodes[0])}else a.select("rect.bg").remove(),w.push(t),k.push([r,n])});var M=i._bgLayer.selectAll(".bg").data(w);return M.enter().append("rect").classed("bg",!0),M.exit().remove(),M.each(function(t){i._plots[t].bg=n.select(this)}),b.each(function(t){var e=i._plots[t],r=e.xaxis,n=e.yaxis;e.bg&&d&&e.bg.call(c.setRect,r._offset-s,n._offset-s,r._length+2*s,n._length+2*s).call(l.fill,i.plot_bgcolor).style("stroke-width",0);var a,f,h=e.clipId="clip"+i._uid+t+"plot",p=o.ensureSingleById(i._clips,"clipPath",h,function(t){t.classed("plotclip",!0).append("rect")});if(e.clipRect=p.select("rect").attr({width:r._length,height:n._length}),c.setTranslate(e.plot,r._offset,n._offset),e._hasClipOnAxisFalse?(a=null,f=h):(a=h,f=null),c.setClipUrl(e.plot,a),e.layerClipId=f,d){var m,v,y,b,w,k,M,A,T,S,C,E,L,z="M0,0";x(r,t)&&(w=_(r,"left",n,u),m=r._offset-(w?s+w:0),k=_(r,"right",n,u),v=r._offset+r._length+(k?s+k:0),y=g(r,n,"bottom"),b=g(r,n,"top"),(L=!r._anchorAxis||t!==r._mainSubplot)&&r.ticks&&"allticks"===r.mirror&&(r._linepositions[t]=[y,b]),z=I(r,D,function(t){return"M"+r._offset+","+t+"h"+r._length}),L&&r.showline&&("all"===r.mirror||"allticks"===r.mirror)&&(z+=D(y)+D(b)),e.xlines.style("stroke-width",r._lw+"px").call(l.stroke,r.showline?r.linecolor:"rgba(0,0,0,0)")),e.xlines.attr("d",z);var P="M0,0";x(n,t)&&(C=_(n,"bottom",r,u),M=n._offset+n._length+(C?s:0),E=_(n,"top",r,u),A=n._offset-(E?s:0),T=g(n,r,"left"),S=g(n,r,"right"),(L=!n._anchorAxis||t!==r._mainSubplot)&&n.ticks&&"allticks"===n.mirror&&(n._linepositions[t]=[T,S]),P=I(n,O,function(t){return"M"+t+","+n._offset+"v"+n._length}),L&&n.showline&&("all"===n.mirror||"allticks"===n.mirror)&&(P+=O(T)+O(S)),e.ylines.style("stroke-width",n._lw+"px").call(l.stroke,n.showline?n.linecolor:"rgba(0,0,0,0)")),e.ylines.attr("d",P)}function D(t){return"M"+m+","+t+"H"+v}function O(t){return"M"+t+","+A+"V"+M}function I(e,r,n){if(!e.showline||t!==e._mainSubplot)return"";if(!e._anchorAxis)return n(e._mainLinePosition);var i=r(e._mainLinePosition);return e.mirror&&(i+=r(e._mainMirrorPosition)),i}}),h.makeClipPaths(t),r.drawMainTitle(t),f.manage(t),t._promises.length&&Promise.all(t._promises)},r.drawMainTitle=function(t){var e=t._fullLayout;u.draw(t,"gtitle",{propContainer:e,propName:"title",placeholder:e._dfltTitle.plot,attributes:{x:e.width/2,y:e._size.t/2,"text-anchor":"middle"}})},r.doTraceStyle=function(t){for(var e=0;ex.length&&i.push(p("unused",a,v.concat(x.length)));var M,A,T,S,C,E=x.length,L=Array.isArray(k);if(L&&(E=Math.min(E,k.length)),2===b.dimensions)for(A=0;Ax[A].length&&i.push(p("unused",a,v.concat(A,x[A].length)));var z=x[A].length;for(M=0;M<(L?Math.min(z,k[A].length):z);M++)T=L?k[A][M]:k,S=y[A][M],C=x[A][M],n.validate(S,T)?C!==S&&C!==+S&&i.push(p("dynamic",a,v.concat(A,M),S,C)):i.push(p("value",a,v.concat(A,M),S))}else i.push(p("array",a,v.concat(A),y[A]));else for(A=0;A1&&h.push(p("object","layout"))),i.supplyDefaults(d);for(var g=d._fullData,m=r.length,v=0;v0&&c>0&&u/c>d&&(o=n,l=a,d=u/c);if(h===p){var y=h-1,x=h+1;f="tozero"===t.rangemode?h<0?[y,0]:[0,x]:"nonnegative"===t.rangemode?[Math.max(0,y),Math.max(0,x)]:[y,x]}else d&&("linear"!==t.type&&"-"!==t.type||("tozero"===t.rangemode?(o.val>=0&&(o={val:0,pad:0}),l.val<=0&&(l={val:0,pad:0})):"nonnegative"===t.rangemode&&(o.val-d*m(o)<0&&(o={val:0,pad:0}),l.val<0&&(l={val:1,pad:0})),d=(l.val-o.val)/(t._length-m(o)-m(l))),f=[o.val-d*m(o),l.val+d*m(l)]);return f[0]===f[1]&&("tozero"===t.rangemode?f=f[0]<0?[f[0],0]:f[0]>0?[0,f[0]]:[0,1]:(f=[f[0]-1,f[0]+1],"nonnegative"===t.rangemode&&(f[0]=Math.max(0,f[0])))),g&&f.reverse(),i.simpleMap(f,t.l2r||Number)}function s(t){var e=t._length/20;return"domain"===t.constrain&&t._inputDomain&&(e*=(t._inputDomain[1]-t._inputDomain[0])/(t.domain[1]-t.domain[0])),function(t){return t.pad+(t.extrapad?e:0)}}function l(t){return n(t)&&Math.abs(t)=e}e.exports={getAutoRange:o,makePadFn:s,doAutoRange:function(t){t._length||t.setScale();var e,r=t._min&&t._max&&t._min.length&&t._max.length;t.autorange&&r&&(t.range=o(t),t._r=t.range.slice(),t._rl=i.simpleMap(t._r,t.r2l),(e=t._input).range=t.range.slice(),e.autorange=t.autorange);if(t._anchorAxis&&t._anchorAxis.rangeslider){var n=t._anchorAxis.rangeslider[t._name];n&&"auto"===n.rangemode&&(n.range=r?o(t):t._rangeInitial?t._rangeInitial.slice():t.range.slice()),(e=t._anchorAxis._input).rangeslider[t._name]=i.extendFlat({},n)}},expand:function(t,e,r){if(!function(t){return t.autorange||t._rangesliderAutorange}(t)||!e)return;t._min||(t._min=[]);t._max||(t._max=[]);r||(r={});t._m||t.setScale();var i,o,s,f,h,p,d,g,m,v,y,x,b=e.length,_=r.padded||!1,w=r.tozero&&("linear"===t.type||"-"===t.type),k="log"===t.type,M=!1;function A(t){if(Array.isArray(t))return M=!0,function(e){return Math.max(Number(t[e]||0),0)};var e=Math.max(Number(t||0),0);return function(){return e}}var T=A((t._m>0?r.ppadplus:r.ppadminus)||r.ppad||0),S=A((t._m>0?r.ppadminus:r.ppadplus)||r.ppad||0),C=A(r.vpadplus||r.vpad),E=A(r.vpadminus||r.vpad);if(!M){if(y=1/0,x=-1/0,k)for(i=0;i0&&(y=f),f>x&&f-a&&(y=f),f>x&&f=b&&(f.extrapad||!_)){v=!1;break}M(i,f.val)&&f.pad<=b&&(_||!f.extrapad)&&(a.splice(o,1),o--)}if(v){var A=w&&0===i;a.push({val:i,pad:A?0:b,extrapad:!A&&_})}}}}var z=Math.min(6,b);for(i=0;i=z;i--)L(i)}}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],706:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../../components/titles"),u=t("../../components/color"),f=t("../../components/drawing"),h=t("../../constants/numerical"),p=h.ONEAVGYEAR,d=h.ONEAVGMONTH,g=h.ONEDAY,m=h.ONEHOUR,v=h.ONEMIN,y=h.ONESEC,x=h.MINUS_SIGN,b=h.BADNUM,_=t("../../constants/alignment").MID_SHIFT,w=t("../../constants/alignment").LINE_SPACING,k=e.exports={};k.setConvert=t("./set_convert");var M=t("./axis_autotype"),A=t("./axis_ids");k.id2name=A.id2name,k.name2id=A.name2id,k.cleanId=A.cleanId,k.list=A.list,k.listIds=A.listIds,k.getFromId=A.getFromId,k.getFromTrace=A.getFromTrace;var T=t("./autorange");k.expand=T.expand,k.getAutoRange=T.getAutoRange,k.coerceRef=function(t,e,r,n,i,a){var o=n.charAt(n.length-1),l=r._fullLayout._subplots[o+"axis"],c=n+"ref",u={};return i||(i=l[0]||a),a||(a=i),u[c]={valType:"enumerated",values:l.concat(a?[a]:[]),dflt:i},s.coerce(t,e,u,c)},k.coercePosition=function(t,e,r,n,i,a){var o,l;if("paper"===n||"pixel"===n)o=s.ensureNumber,l=r(i,a);else{var c=k.getFromId(e,n);l=r(i,a=c.fraction2r(a)),o=c.cleanPos}t[i]=o(l)},k.cleanPosition=function(t,e,r){return("paper"===r||"pixel"===r?s.ensureNumber:k.getFromId(e,r).cleanPos)(t)};var S=k.getDataConversions=function(t,e,r,n){var i,a="x"===r||"y"===r||"z"===r?r:n;if(Array.isArray(a)){if(i={type:M(n),_categories:[]},k.setConvert(i),"category"===i.type)for(var o=0;o2e-6||((r-t._forceTick0)/t._minDtick%1+1.000001)%1>2e-6)&&(t._minDtick=0)):t._minDtick=0},k.saveRangeInitial=function(t,e){for(var r=k.list(t,"",!0),n=!1,i=0;i.3*h||u(n)||u(a))){var p=r.dtick/2;t+=t+p.8){var o=Number(r.substr(1));a.exactYears>.8&&o%12==0?t=k.tickIncrement(t,"M6","reverse")+1.5*g:a.exactMonths>.8?t=k.tickIncrement(t,"M1","reverse")+15.5*g:t-=g/2;var l=k.tickIncrement(t,r);if(l<=n)return l}return t}(m,t,l.dtick,c,a)),d=m,0;d<=u;)d=k.tickIncrement(d,l.dtick,!1,a),0;return{start:e.c2r(m,0,a),end:e.c2r(d,0,a),size:l.dtick,_dataSpan:u-c}},k.prepTicks=function(t){var e=s.simpleMap(t.range,t.r2l);if("auto"===t.tickmode||!t.dtick){var r,n=t.nticks;n||("category"===t.type?(r=t.tickfont?1.2*(t.tickfont.size||12):15,n=t._length/r):(r="y"===t._id.charAt(0)?40:80,n=s.constrain(t._length/r,4,9)+1),"radialaxis"===t._name&&(n*=2)),"array"===t.tickmode&&(n*=100),k.autoTicks(t,Math.abs(e[1]-e[0])/n),t._minDtick>0&&t.dtick<2*t._minDtick&&(t.dtick=t._minDtick,t.tick0=t.l2r(t._forceTick0))}t.tick0||(t.tick0="date"===t.type?"2000-01-01":0),F(t)},k.calcTicks=function(t){k.prepTicks(t);var e=s.simpleMap(t.range,t.r2l);if("array"===t.tickmode)return function(t){var e,r,n=t.tickvals,i=t.ticktext,a=new Array(n.length),o=s.simpleMap(t.range,t.r2l),l=1.0001*o[0]-1e-4*o[1],c=1.0001*o[1]-1e-4*o[0],u=Math.min(l,c),f=Math.max(l,c),h=0;Array.isArray(i)||(i=[]);var p="category"===t.type?t.d2l_noadd:t.d2l;"log"===t.type&&"L"!==String(t.dtick).charAt(0)&&(t.dtick="L"+Math.pow(10,Math.floor(Math.min(t.range[0],t.range[1]))-1));for(r=0;ru&&e=n:c<=n)&&!(a.length>l||c===o);c=k.tickIncrement(c,t.dtick,i,t.calendar))o=c,a.push(c);"angular"===t._id&&360===Math.abs(e[1]-e[0])&&a.pop(),t._tmax=a[a.length-1],t._prevDateHead="",t._inCalcTicks=!0;for(var u=new Array(a.length),f=0;f10||"01-01"!==n.substr(5)?t._tickround="d":t._tickround=+e.substr(1)%12==0?"y":"m";else if(e>=g&&a<=10||e>=15*g)t._tickround="d";else if(e>=v&&a<=16||e>=m)t._tickround="M";else if(e>=y&&a<=19||e>=v)t._tickround="S";else{var o=t.l2r(r+e).replace(/^-/,"").length;t._tickround=Math.max(a,o)-20}}else if(i(e)||"L"===e.charAt(0)){var s=t.range.map(t.r2d||Number);i(e)||(e=Number(e.substr(1))),t._tickround=2-Math.floor(Math.log(e)/Math.LN10+.01);var l=Math.max(Math.abs(s[0]),Math.abs(s[1])),c=Math.floor(Math.log(l)/Math.LN10+.01);Math.abs(c)>3&&(V(t.exponentformat)&&!U(c)?t._tickexponent=3*Math.round((c-1)/3):t._tickexponent=c)}else t._tickround=null}function N(t,e,r){var n=t.tickfont||{};return{x:e,dx:0,dy:0,text:r||"",fontSize:n.size,font:n.family,fontColor:n.color}}k.autoTicks=function(t,e){var r;function n(t){return Math.pow(t,Math.floor(Math.log(e)/Math.LN10))}if("date"===t.type){t.tick0=s.dateTick0(t.calendar);var a=2*e;a>p?(e/=p,r=n(10),t.dtick="M"+12*B(e,r,L)):a>d?(e/=d,t.dtick="M"+B(e,1,z)):a>g?(t.dtick=B(e,g,D),t.tick0=s.dateTick0(t.calendar,!0)):a>m?t.dtick=B(e,m,z):a>v?t.dtick=B(e,v,P):a>y?t.dtick=B(e,y,P):(r=n(10),t.dtick=B(e,r,L))}else if("log"===t.type){t.tick0=0;var o=s.simpleMap(t.range,t.r2l);if(e>.7)t.dtick=Math.ceil(e);else if(Math.abs(o[1]-o[0])<1){var l=1.5*Math.abs((o[1]-o[0])/e);e=Math.abs(Math.pow(10,o[1])-Math.pow(10,o[0]))/l,r=n(10),t.dtick="L"+B(e,r,L)}else t.dtick=e>.3?"D2":"D1"}else"category"===t.type?(t.tick0=0,t.dtick=Math.ceil(Math.max(e,1))):"angular"===t._id?(t.tick0=0,r=1,t.dtick=B(e,r,R)):(t.tick0=0,r=n(10),t.dtick=B(e,r,L));if(0===t.dtick&&(t.dtick=1),!i(t.dtick)&&"string"!=typeof t.dtick){var c=t.dtick;throw t.dtick=1,"ax.dtick error: "+String(c)}},k.tickIncrement=function(t,e,r,a){var o=r?-1:1;if(i(e))return t+o*e;var l=e.charAt(0),c=o*Number(e.substr(1));if("M"===l)return s.incrementMonth(t,c,a);if("L"===l)return Math.log(Math.pow(10,t)+c)/Math.LN10;if("D"===l){var u="D2"===e?I:O,f=t+.01*o,h=s.roundUp(s.mod(f,1),u,r);return Math.floor(f)+Math.log(n.round(Math.pow(10,h),1))/Math.LN10}throw"unrecognized dtick "+String(e)},k.tickFirst=function(t){var e=t.r2l||Number,r=s.simpleMap(t.range,e),a=r[1]"+l,t._prevDateHead=l));e.text=c}(t,o,r,c):"log"===t.type?function(t,e,r,n,a){var o=t.dtick,l=e.x,c=t.tickformat;"never"===a&&(a="");!n||"string"==typeof o&&"L"===o.charAt(0)||(o="L3");if(c||"string"==typeof o&&"L"===o.charAt(0))e.text=q(Math.pow(10,l),t,a,n);else if(i(o)||"D"===o.charAt(0)&&s.mod(l+.01,1)<.1){var u=Math.round(l);-1!==["e","E","power"].indexOf(t.exponentformat)||V(t.exponentformat)&&U(u)?(e.text=0===u?1:1===u?"10":u>1?"10"+u+"":"10"+x+-u+"",e.fontSize*=1.25):(e.text=q(Math.pow(10,l),t,"","fakehover"),"D1"===o&&"y"===t._id.charAt(0)&&(e.dy-=e.fontSize/6))}else{if("D"!==o.charAt(0))throw"unrecognized dtick "+String(o);e.text=String(Math.round(Math.pow(10,s.mod(l,1)))),e.fontSize*=.75}if("D1"===t.dtick){var f=String(e.text).charAt(0);"0"!==f&&"1"!==f||("y"===t._id.charAt(0)?e.dx-=e.fontSize/4:(e.dy+=e.fontSize/2,e.dx+=(t.range[1]>t.range[0]?1:-1)*e.fontSize*(l<0?.5:.25)))}}(t,o,0,c,n):"category"===t.type?function(t,e){var r=t._categories[Math.round(e.x)];void 0===r&&(r="");e.text=String(r)}(t,o):"angular"===t._id?function(t,e,r,n,i){if("radians"!==t.thetaunit||r)e.text=q(e.x,t,i,n);else{var a=e.x/180;if(0===a)e.text="0";else{var o=function(t){function e(t,e){return Math.abs(t-e)<=1e-6}var r=function(t){var r=1;for(;!e(Math.round(t*r)/r,t);)r*=10;return r}(t),n=t*r,i=Math.abs(function t(r,n){return e(n,0)?r:t(n,r%n)}(n,r));return[Math.round(n/i),Math.round(r/i)]}(a);if(o[1]>=100)e.text=q(s.deg2rad(e.x),t,i,n);else{var l=e.x<0;1===o[1]?1===o[0]?e.text="\u03c0":e.text=o[0]+"\u03c0":e.text=["",o[0],"","\u2044","",o[1],"","\u03c0"].join(""),l&&(e.text=x+e.text)}}}}(t,o,r,c,n):function(t,e,r,n,i){"never"===i?i="":"all"===t.showexponent&&Math.abs(e.x/t.dtick)<1e-6&&(i="hide");e.text=q(e.x,t,i,n)}(t,o,0,c,n),t.tickprefix&&!p(t.showtickprefix)&&(o.text=t.tickprefix+o.text),t.ticksuffix&&!p(t.showticksuffix)&&(o.text+=t.ticksuffix),o},k.hoverLabelText=function(t,e,r){if(r!==b&&r!==e)return k.hoverLabelText(t,e)+" - "+k.hoverLabelText(t,r);var n="log"===t.type&&e<=0,i=k.tickText(t,t.c2l(n?-e:e),"hover").text;return n?0===e?"0":x+i:i};var j=["f","p","n","\u03bc","m","","k","M","G","T"];function V(t){return"SI"===t||"B"===t}function U(t){return t>14||t<-15}function q(t,e,r,n){var a=t<0,o=e._tickround,l=r||e.exponentformat||"B",c=e._tickexponent,u=k.getTickFormat(e),f=e.separatethousands;if(n){var h={exponentformat:l,dtick:"none"===e.showexponent?e.dtick:i(t)&&Math.abs(t)||1,range:"none"===e.showexponent?e.range.map(e.r2d):[0,t||1]};F(h),o=(Number(h._tickround)||0)+4,c=h._tickexponent,e.hoverformat&&(u=e.hoverformat)}if(u)return e._numFormat(u)(t).replace(/-/g,x);var p,d=Math.pow(10,-o)/2;if("none"===l&&(c=0),(t=Math.abs(t))"+p+"":"B"===l&&9===c?t+="B":V(l)&&(t+=j[c/3+5]));return a?x+t:t}function H(t,e){for(var r=0;r=0,a=c(t,e[1])<=0;return(r||i)&&(n||a)}if(t.tickformatstops&&t.tickformatstops.length>0)switch(t.type){case"date":case"linear":for(e=0;e=a(n))){r=t.tickformatstops[e];break}break;case"log":for(e=0;e1&&e1)for(n=1;n2*o}(t,e)?"date":function(t){for(var e,r=Math.max(1,(t.length-1)/1e3),n=0,o=0,s=0;s2*n}(t)?"category":function(t){if(!t)return!1;for(var e=0;en?1:-1:+(t.substr(1)||1)-+(e.substr(1)||1)}},{"../../registry":790,"./constants":711}],710:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){if("category"===e.type){var i,a=t.categoryarray,o=Array.isArray(a)&&a.length>0;o&&(i="array");var s,l=r("categoryorder",i);"array"===l&&(s=r("categoryarray")),o||"array"!==l||(l=e.categoryorder="trace"),"trace"===l?e._initialCategories=[]:"array"===l?e._initialCategories=s.slice():(s=function(t,e){var r,n,i,a=e.dataAttr||t._id.charAt(0),o={};if(e.axData)r=e.axData;else for(r=[],n=0;no*y)||w)for(r=0;rP&&IL&&(L=I);h/=(L-E)/(2*z),E=c.l2r(E),L=c.l2r(L),c.range=c._input.range=T=0?Math.min(t,.9):1/(1/Math.max(t,-.3)+3.222))}function P(t,e,r,n,i){return t.append("path").attr("class","zoombox").style({fill:e>.2?"rgba(0,0,0,0)":"rgba(255,255,255,0)","stroke-width":0}).attr("transform","translate("+r+", "+n+")").attr("d",i+"Z")}function D(t,e,r){return t.append("path").attr("class","zoombox-corners").style({fill:u.background,stroke:u.defaultLine,"stroke-width":1,opacity:0}).attr("transform","translate("+e+", "+r+")").attr("d","M0,0Z")}function O(t,e,r,n,i,a){t.attr("d",n+"M"+r.l+","+r.t+"v"+r.h+"h"+r.w+"v-"+r.h+"h-"+r.w+"Z"),I(t,e,i,a)}function I(t,e,r,n){r||(t.transition().style("fill",n>.2?"rgba(0,0,0,0.4)":"rgba(255,255,255,0.3)").duration(200),e.transition().style("opacity",1).duration(200))}function R(t){n.select(t).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove()}function B(t){A&&t.data&&t._context.showTips&&(s.notifier(s._(t,"Double-click to zoom back out"),"long"),A=!1)}function F(t){return"lasso"===t||"select"===t}function N(t){var e=Math.floor(Math.min(t.b-t.t,t.r-t.l,M)/2);return"M"+(t.l-3.5)+","+(t.t-.5+e)+"h3v"+-e+"h"+e+"v-3h-"+(e+3)+"ZM"+(t.r+3.5)+","+(t.t-.5+e)+"h-3v"+-e+"h"+-e+"v-3h"+(e+3)+"ZM"+(t.r+3.5)+","+(t.b+.5-e)+"h-3v"+e+"h"+-e+"v3h"+(e+3)+"ZM"+(t.l-3.5)+","+(t.b+.5-e)+"h3v"+e+"h"+e+"v3h-"+(e+3)+"Z"}function j(t,e){if(a){var r=void 0!==t.onwheel?"wheel":"mousewheel";t._onwheel&&t.removeEventListener(r,t._onwheel),t._onwheel=e,t.addEventListener(r,e,{passive:!1})}else void 0!==t.onwheel?t.onwheel=e:void 0!==t.onmousewheel&&(t.onmousewheel=e)}function V(t){var e=[];for(var r in t)e.push(t[r]);return e}e.exports={makeDragBox:function(t,e,r,a,u,p,A,T){var I,U,q,H,G,W,Y,X,Z,J,K,Q,$,tt,et,rt,nt,it,at,ot,st,lt=t._fullLayout._zoomlayer,ct=A+T==="nsew",ut=1===(A+T).length;function ft(){if(I=e.xaxis,U=e.yaxis,Z=I._length,J=U._length,Y=I._offset,X=U._offset,(q={})[I._id]=I,(H={})[U._id]=U,A&&T)for(var r=e.overlays,n=0;nM||o>M?(bt="xy",a/Z>o/J?(o=a*J/Z,gt>i?mt.t=gt-o:mt.b=gt+o):(a=o*Z/J,dt>n?mt.l=dt-a:mt.r=dt+a),wt.attr("d",N(mt))):s():!$||o10||r.scrollWidth-r.clientWidth>10)){clearTimeout(zt);var n=-e.deltaY;if(isFinite(n)||(n=e.wheelDelta/10),isFinite(n)){var i,a=Math.exp(-Math.min(Math.max(n,-20),20)/200),o=Dt.draglayer.select(".nsewdrag").node().getBoundingClientRect(),l=(e.clientX-o.left)/o.width,c=(o.bottom-e.clientY)/o.height;if(rt){for(T||(l=.5),i=0;ig[1]-.01&&(e.domain=s),i.noneOrAll(t.domain,e.domain,s)}return r("layer"),e}},{"../../lib":660,"fast-isnumeric":197}],722:[function(t,e,r){"use strict";var n=t("../../constants/alignment").FROM_BL;e.exports=function(t,e,r){void 0===r&&(r=n[t.constraintoward||"center"]);var i=[t.r2l(t.range[0]),t.r2l(t.range[1])],a=i[0]+(i[1]-i[0])*r;t.range=t._input.range=[t.l2r(a+(i[0]-a)*e),t.l2r(a+(i[1]-a)*e)]}},{"../../constants/alignment":632}],723:[function(t,e,r){"use strict";var n=t("polybooljs"),i=t("../../registry"),a=t("../../components/color"),o=t("../../components/fx"),s=t("../../lib/polygon"),l=t("../../lib/throttle"),c=t("../../components/fx/helpers").makeEventData,u=t("./axis_ids").getFromId,f=t("../sort_modules").sortModules,h=t("./constants"),p=h.MINSELECT,d=s.filter,g=s.tester,m=s.multitester;function v(t){return t._id}function y(t,e,r){var n,a,o,s;if(r){var l=r.points||[];for(n=0;n0)return Math.log(e)/Math.LN10;if(e<=0&&r&&t.range&&2===t.range.length){var n=t.range[0],i=t.range[1];return.5*(n+i-3*u*Math.abs(n-i))}return h}function v(e,r,n){var a=l(e,n||t.calendar);if(a===h){if(!i(e))return h;a=l(new Date(+e))}return a}function y(e,r,n){return s(e,r,n||t.calendar)}function x(e){return t._categories[Math.round(e)]}function b(e){if(t._categoriesMap){var r=t._categoriesMap[e];if(void 0!==r)return r}if(i(e))return+e}function _(e){return i(e)?n.round(t._b+t._m*e,2):h}function w(e){return(e-t._b)/t._m}t.c2l="log"===t.type?m:c,t.l2c="log"===t.type?g:c,t.l2p=_,t.p2l=w,t.c2p="log"===t.type?function(t,e){return _(m(t,e))}:_,t.p2c="log"===t.type?function(t){return g(w(t))}:w,-1!==["linear","-"].indexOf(t.type)?(t.d2r=t.r2d=t.d2c=t.r2c=t.d2l=t.r2l=o,t.c2d=t.c2r=t.l2d=t.l2r=c,t.d2p=t.r2p=function(e){return t.l2p(o(e))},t.p2d=t.p2r=w,t.cleanPos=c):"log"===t.type?(t.d2r=t.d2l=function(t,e){return m(o(t),e)},t.r2d=t.r2c=function(t){return g(o(t))},t.d2c=t.r2l=o,t.c2d=t.l2r=c,t.c2r=m,t.l2d=g,t.d2p=function(e,r){return t.l2p(t.d2r(e,r))},t.p2d=function(t){return g(w(t))},t.r2p=function(e){return t.l2p(o(e))},t.p2r=w,t.cleanPos=c):"date"===t.type?(t.d2r=t.r2d=a.identity,t.d2c=t.r2c=t.d2l=t.r2l=v,t.c2d=t.c2r=t.l2d=t.l2r=y,t.d2p=t.r2p=function(e,r,n){return t.l2p(v(e,0,n))},t.p2d=t.p2r=function(t,e,r){return y(w(t),e,r)},t.cleanPos=function(e){return a.cleanDate(e,h,t.calendar)}):"category"===t.type&&(t.d2c=t.d2l=function(e){if(null!==e&&void 0!==e){if(void 0===t._categoriesMap&&(t._categoriesMap={}),void 0!==t._categoriesMap[e])return t._categoriesMap[e];t._categories.push(e);var r=t._categories.length-1;return t._categoriesMap[e]=r,r}return h},t.r2d=t.c2d=t.l2d=x,t.d2r=t.d2l_noadd=b,t.r2c=function(e){var r=b(e);return void 0!==r?r:t.fraction2r(.5)},t.l2r=t.c2r=c,t.r2l=b,t.d2p=function(e){return t.l2p(t.r2c(e))},t.p2d=function(t){return x(w(t))},t.r2p=t.d2p,t.p2r=w,t.cleanPos=function(t){return"string"==typeof t&&""!==t?t:c(t)}),t.fraction2r=function(e){var r=t.r2l(t.range[0]),n=t.r2l(t.range[1]);return t.l2r(r+e*(n-r))},t.r2fraction=function(e){var r=t.r2l(t.range[0]),n=t.r2l(t.range[1]);return(t.r2l(e)-r)/(n-r)},t.cleanRange=function(e,n){n||(n={}),e||(e="range");var o,s,l=a.nestedProperty(t,e).get();if(s=(s="date"===t.type?a.dfltRange(t.calendar):"y"===r?p.DFLTRANGEY:n.dfltRange||p.DFLTRANGEX).slice(),l&&2===l.length)for("date"===t.type&&(l[0]=a.cleanDate(l[0],h,t.calendar),l[1]=a.cleanDate(l[1],h,t.calendar)),o=0;o<2;o++)if("date"===t.type){if(!a.isDateTime(l[o],t.calendar)){t[e]=s;break}if(t.r2l(l[0])===t.r2l(l[1])){var c=a.constrain(t.r2l(l[0]),a.MIN_MS+1e3,a.MAX_MS-1e3);l[0]=t.l2r(c-1e3),l[1]=t.l2r(c+1e3);break}}else{if(!i(l[o])){if(!i(l[1-o])){t[e]=s;break}l[o]=l[1-o]*(o?10:.1)}if(l[o]<-f?l[o]=-f:l[o]>f&&(l[o]=f),l[0]===l[1]){var u=Math.max(1,Math.abs(1e-6*l[0]));l[0]-=u,l[1]+=u}}else a.nestedProperty(t,e).set(s)},t.setScale=function(n){var i=e._size;if(t._categories||(t._categories=[]),t._categoriesMap||(t._categoriesMap={}),t.overlaying){var a=d.getFromId({_fullLayout:e},t.overlaying);t.domain=a.domain}var o=n&&t._r?"_r":"range",s=t.calendar;t.cleanRange(o);var l=t.r2l(t[o][0],s),c=t.r2l(t[o][1],s);if("y"===r?(t._offset=i.t+(1-t.domain[1])*i.h,t._length=i.h*(t.domain[1]-t.domain[0]),t._m=t._length/(l-c),t._b=-t._m*c):(t._offset=i.l+t.domain[0]*i.w,t._length=i.w*(t.domain[1]-t.domain[0]),t._m=t._length/(c-l),t._b=-t._m*l),!isFinite(t._m)||!isFinite(t._b))throw e._replotting=!1,new Error("Something went wrong with axis scaling")},t.makeCalcdata=function(e,r){var n,i,o,s,l=t.type,c="date"===l&&e[r+"calendar"];if(r in e){if(n=e[r],s=e._length||n.length,a.isTypedArray(n)&&("linear"===l||"log"===l)){if(s===n.length)return n;if(n.subarray)return n.subarray(0,s)}for(i=new Array(s),o=0;o0?Number(u):c;else if("string"!=typeof u)e.dtick=c;else{var f=u.charAt(0),h=u.substr(1);((h=n(h)?Number(h):0)<=0||!("date"===o&&"M"===f&&h===Math.round(h)||"log"===o&&"L"===f||"log"===o&&"D"===f&&(1===h||2===h)))&&(e.dtick=c)}var p="date"===o?i.dateTick0(e.calendar):0,d=r("tick0",p);"date"===o?e.tick0=i.cleanDate(d,p):n(d)&&"D1"!==u&&"D2"!==u?e.tick0=Number(d):e.tick0=p}else{void 0===r("tickvals")?e.tickmode="auto":r("ticktext")}}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],728:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../registry"),a=t("../../components/drawing"),o=t("./axes"),s=t("./constants").attrRegex;e.exports=function(t,e,r,l){var c=t._fullLayout,u=[];var f,h,p,d,g=function(t){var e,r,n,i,a={};for(e in t)if((r=e.split("."))[0].match(s)){var o=e.charAt(0),l=r[0];if(n=c[l],i={},Array.isArray(t[e])?i.to=t[e].slice(0):Array.isArray(t[e].range)&&(i.to=t[e].range.slice(0)),!i.to)continue;i.axisName=l,i.length=n._length,u.push(o),a[o]=i}return a}(e),m=Object.keys(g),v=function(t,e,r){var n,i,a,o=t._plots,s=[];for(n in o){var l=o[n];if(-1===s.indexOf(l)){var c=l.xaxis._id,u=l.yaxis._id,f=l.xaxis.range,h=l.yaxis.range;l.xaxis._r=l.xaxis.range.slice(),l.yaxis._r=l.yaxis.range.slice(),i=r[c]?r[c].to:f,a=r[u]?r[u].to:h,f[0]===i[0]&&f[1]===i[1]&&h[0]===a[0]&&h[1]===a[1]||-1===e.indexOf(c)&&-1===e.indexOf(u)||s.push(l)}}return s}(c,m,g);if(!v.length)return function(){function e(e,r,n){for(var i=0;i rect").call(a.setTranslate,0,0).call(a.setScale,1,1),t.plot.call(a.setTranslate,e._offset,r._offset).call(a.setScale,1,1);var n=t.plot.selectAll(".scatterlayer .trace");n.selectAll(".point").call(a.setPointGroupScale,1,1),n.selectAll(".textpoint").call(a.setTextPointsScale,1,1),n.call(a.hideOutsideRangePoints,t)}function x(e,r){var n,s,l,u=g[e.xaxis._id],f=g[e.yaxis._id],h=[];if(u){s=(n=t._fullLayout[u.axisName])._r,l=u.to,h[0]=(s[0]*(1-r)+r*l[0]-s[0])/(s[1]-s[0])*e.xaxis._length;var p=s[1]-s[0],d=l[1]-l[0];n.range[0]=s[0]*(1-r)+r*l[0],n.range[1]=s[1]*(1-r)+r*l[1],h[2]=e.xaxis._length*(1-r+r*d/p)}else h[0]=0,h[2]=e.xaxis._length;if(f){s=(n=t._fullLayout[f.axisName])._r,l=f.to,h[1]=(s[1]*(1-r)+r*l[1]-s[1])/(s[0]-s[1])*e.yaxis._length;var m=s[1]-s[0],v=l[1]-l[0];n.range[0]=s[0]*(1-r)+r*l[0],n.range[1]=s[1]*(1-r)+r*l[1],h[3]=e.yaxis._length*(1-r+r*v/m)}else h[1]=0,h[3]=e.yaxis._length;!function(e,r){var n,a=[];for(a=[e._id,r._id],n=0;nr.duration?(function(){for(var e={},r=0;r0&&i["_"+r+"axes"][e])return i;if((i[r+"axis"]||r)===e){if(s(i,r))return i;if((i[r]||[]).length||i[r+"0"])return i}}}(e,r,a);if(!l)return;if("histogram"===l.type&&a==={v:"y",h:"x"}[l.orientation||"v"])return void(t.type="linear");var c,u=a+"calendar",f=l[u];if(s(l,a)){var h=o(l),p=[];for(c=0;c0?".":"")+a;i.isPlainObject(o)?l(o,e,s,n+1):e(s,a,o)}})}r.manageCommandObserver=function(t,e,n,o){var s={},l=!0;e&&e._commandObserver&&(s=e._commandObserver),s.cache||(s.cache={}),s.lookupTable={};var c=r.hasSimpleAPICommandBindings(t,n,s.lookupTable);if(e&&e._commandObserver){if(c)return s;if(e._commandObserver.remove)return e._commandObserver.remove(),e._commandObserver=null,s}if(c){a(t,c,s.cache),s.check=function(){if(l){var e=a(t,c,s.cache);return e.changed&&o&&void 0!==s.lookupTable[e.value]&&(s.disable(),Promise.resolve(o({value:e.value,type:c.type,prop:c.prop,traces:c.traces,index:s.lookupTable[e.value]})).then(s.enable,s.enable)),e.changed}};for(var u=["plotly_relayout","plotly_redraw","plotly_restyle","plotly_update","plotly_animatingframe","plotly_afterplot"],f=0;fi*Math.PI/180}return!1},r.getPath=function(){return n.geo.path().projection(r)},r.getBounds=function(t){return r.getPath().bounds(t)},r.fitExtent=function(t,e){var n=t[1][0]-t[0][0],i=t[1][1]-t[0][1],a=r.clipExtent&&r.clipExtent();r.scale(150).translate([0,0]),a&&r.clipExtent(null);var o=r.getBounds(e),s=Math.min(n/(o[1][0]-o[0][0]),i/(o[1][1]-o[0][1])),l=+t[0][0]+(n-s*(o[1][0]+o[0][0]))/2,c=+t[0][1]+(i-s*(o[1][1]+o[0][1]))/2;return a&&r.clipExtent(a),r.scale(150*s).translate([l,c])},r.precision(d.precision),i&&r.clipAngle(i-d.clipPad);return r}(e);u.center([c.lon-l.lon,c.lat-l.lat]).rotate([-l.lon,-l.lat,l.roll]).parallels(s.parallels);var f=[[r.l+r.w*o.x[0],r.t+r.h*(1-o.y[1])],[r.l+r.w*o.x[1],r.t+r.h*(1-o.y[0])]],h=e.lonaxis,p=e.lataxis,g=function(t,e){var r=d.clipPad,n=t[0]+r,i=t[1]-r,a=e[0]+r,o=e[1]-r;n>0&&i<0&&(i+=360);var s=(i-n)/4;return{type:"Polygon",coordinates:[[[n,a],[n,o],[n+s,o],[n+2*s,o],[n+3*s,o],[i,o],[i,a],[i-s,a],[i-2*s,a],[i-3*s,a],[n,a]]]}}(h.range,p.range);u.fitExtent(f,g);var m=this.bounds=u.getBounds(g),v=this.fitScale=u.scale(),y=u.translate();if(!isFinite(m[0][0])||!isFinite(m[0][1])||!isFinite(m[1][0])||!isFinite(m[1][1])||isNaN(y[0])||isNaN(y[0])){for(var x=this.graphDiv,b=["projection.rotation","center","lonaxis.range","lataxis.range"],_="Invalid geo settings, relayout'ing to default view.",w={},k=0;k0&&w<0&&(w+=360);var k,M,A,T=(_+w)/2;if(!c){var S=u?s.projRotate:[T,0,0];k=r("projection.rotation.lon",S[0]),r("projection.rotation.lat",S[1]),r("projection.rotation.roll",S[2]),r("showcoastlines",!u)&&(r("coastlinecolor"),r("coastlinewidth")),r("showocean")&&r("oceancolor")}(c?(M=-96.6,A=38.7):(M=u?T:k,A=(b[0]+b[1])/2),r("center.lon",M),r("center.lat",A),f)&&r("projection.parallels",s.projParallels||[0,60]);r("projection.scale"),r("showland")&&r("landcolor"),r("showlakes")&&r("lakecolor"),r("showrivers")&&(r("rivercolor"),r("riverwidth")),r("showcountries",u&&"usa"!==a)&&(r("countrycolor"),r("countrywidth")),("usa"===a||"north america"===a&&50===n)&&(r("showsubunits",!0),r("subunitcolor"),r("subunitwidth")),u||r("showframe",!0)&&(r("framecolor"),r("framewidth")),r("bgcolor")}e.exports=function(t,e,r){n(t,e,r,{type:"geo",attributes:a,handleDefaults:s,partition:"y"})}},{"../../subplot_defaults":782,"../constants":734,"./layout_attributes":739}],739:[function(t,e,r){"use strict";var n=t("../../../components/color/attributes"),i=t("../../domain").attributes,a=t("../constants"),o=t("../../../plot_api/edit_types").overrideAll,s={range:{valType:"info_array",items:[{valType:"number"},{valType:"number"}]},showgrid:{valType:"boolean",dflt:!1},tick0:{valType:"number"},dtick:{valType:"number"},gridcolor:{valType:"color",dflt:n.lightLine},gridwidth:{valType:"number",min:0,dflt:1}};e.exports=o({domain:i({name:"geo"},{}),resolution:{valType:"enumerated",values:[110,50],dflt:110,coerceNumber:!0},scope:{valType:"enumerated",values:Object.keys(a.scopeDefaults),dflt:"world"},projection:{type:{valType:"enumerated",values:Object.keys(a.projNames)},rotation:{lon:{valType:"number"},lat:{valType:"number"},roll:{valType:"number"}},parallels:{valType:"info_array",items:[{valType:"number"},{valType:"number"}]},scale:{valType:"number",min:0,dflt:1}},center:{lon:{valType:"number"},lat:{valType:"number"}},showcoastlines:{valType:"boolean"},coastlinecolor:{valType:"color",dflt:n.defaultLine},coastlinewidth:{valType:"number",min:0,dflt:1},showland:{valType:"boolean",dflt:!1},landcolor:{valType:"color",dflt:a.landColor},showocean:{valType:"boolean",dflt:!1},oceancolor:{valType:"color",dflt:a.waterColor},showlakes:{valType:"boolean",dflt:!1},lakecolor:{valType:"color",dflt:a.waterColor},showrivers:{valType:"boolean",dflt:!1},rivercolor:{valType:"color",dflt:a.waterColor},riverwidth:{valType:"number",min:0,dflt:1},showcountries:{valType:"boolean"},countrycolor:{valType:"color",dflt:n.defaultLine},countrywidth:{valType:"number",min:0,dflt:1},showsubunits:{valType:"boolean"},subunitcolor:{valType:"color",dflt:n.defaultLine},subunitwidth:{valType:"number",min:0,dflt:1},showframe:{valType:"boolean"},framecolor:{valType:"color",dflt:n.defaultLine},framewidth:{valType:"number",min:0,dflt:1},bgcolor:{valType:"color",dflt:n.background},lonaxis:s,lataxis:s},"plot","from-root")},{"../../../components/color/attributes":531,"../../../plot_api/edit_types":691,"../../domain":731,"../constants":734}],740:[function(t,e,r){"use strict";e.exports=function(t){function e(t,e){return{type:"Feature",id:t.id,properties:t.properties,geometry:r(t.geometry,e)}}function r(e,n){if(!e)return null;if("GeometryCollection"===e.type)return{type:"GeometryCollection",geometries:object.geometries.map(function(t){return r(t,n)})};if(!c.hasOwnProperty(e.type))return null;var i=c[e.type];return t.geo.stream(e,n(i)),i.result()}t.geo.project=function(t,e){var i=e.stream;if(!i)throw new Error("not yet supported");return(t&&n.hasOwnProperty(t.type)?n[t.type]:r)(t,i)};var n={Feature:e,FeatureCollection:function(t,r){return{type:"FeatureCollection",features:t.features.map(function(t){return e(t,r)})}}},i=[],a=[],o={point:function(t,e){i.push([t,e])},result:function(){var t=i.length?i.length<2?{type:"Point",coordinates:i[0]}:{type:"MultiPoint",coordinates:i}:null;return i=[],t}},s={lineStart:u,point:function(t,e){i.push([t,e])},lineEnd:function(){i.length&&(a.push(i),i=[])},result:function(){var t=a.length?a.length<2?{type:"LineString",coordinates:a[0]}:{type:"MultiLineString",coordinates:a}:null;return a=[],t}},l={polygonStart:u,lineStart:u,point:function(t,e){i.push([t,e])},lineEnd:function(){var t=i.length;if(t){do{i.push(i[0].slice())}while(++t<4);a.push(i),i=[]}},polygonEnd:u,result:function(){if(!a.length)return null;var t=[],e=[];return a.forEach(function(r){!function(t){if((e=t.length)<4)return!1;for(var e,r=0,n=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++rn^p>n&&r<(h-c)*(n-u)/(p-u)+c&&(i=!i)}return i}(t[0],r))return t.push(e),!0})||t.push([e])}),a=[],t.length?t.length>1?{type:"MultiPolygon",coordinates:t}:{type:"Polygon",coordinates:t[0]}:null}},c={Point:o,MultiPoint:o,LineString:s,MultiLineString:s,Polygon:l,MultiPolygon:l,Sphere:l};function u(){}var f=1e-6,h=f*f,p=Math.PI,d=p/2,g=(Math.sqrt(p),p/180),m=180/p;function v(t){return t>1?d:t<-1?-d:Math.asin(t)}function y(t){return t>1?0:t<-1?p:Math.acos(t)}var x=t.geo.projection,b=t.geo.projectionMutator;function _(t,e){var r=(2+d)*Math.sin(e);e/=2;for(var n=0,i=1/0;n<10&&Math.abs(i)>f;n++){var a=Math.cos(e);e-=i=(e+Math.sin(e)*(a+2)-r)/(2*a*(1+a))}return[2/Math.sqrt(p*(4+p))*t*(1+Math.cos(e)),2*Math.sqrt(p/(4+p))*Math.sin(e)]}t.geo.interrupt=function(e){var r,n=[[[[-p,0],[0,d],[p,0]]],[[[-p,0],[0,-d],[p,0]]]];function i(t,r){for(var i=r<0?-1:1,a=n[+(r<0)],o=0,s=a.length-1;oa[o][2][0];++o);var l=e(t-a[o][1][0],r);return l[0]+=e(a[o][1][0],i*r>i*a[o][0][1]?a[o][0][1]:r)[0],l}e.invert&&(i.invert=function(t,a){for(var o=r[+(a<0)],s=n[+(a<0)],c=0,u=o.length;c=0;--i){var o=n[1][i],l=180*o[0][0]/p,c=180*o[0][1]/p,u=180*o[1][1]/p,f=180*o[2][0]/p,h=180*o[2][1]/p;r.push(s([[f-e,h-e],[f-e,u+e],[l+e,u+e],[l+e,c-e]],30))}return{type:"Polygon",coordinates:[t.merge(r)]}}(),l)},i},a.lobes=function(t){return arguments.length?(n=t.map(function(t){return t.map(function(t){return[[t[0][0]*p/180,t[0][1]*p/180],[t[1][0]*p/180,t[1][1]*p/180],[t[2][0]*p/180,t[2][1]*p/180]]})}),r=n.map(function(t){return t.map(function(t){var r,n=e(t[0][0],t[0][1])[0],i=e(t[2][0],t[2][1])[0],a=e(t[1][0],t[0][1])[1],o=e(t[1][0],t[1][1])[1];return a>o&&(r=a,a=o,o=r),[[n,a],[i,o]]})}),a):n.map(function(t){return t.map(function(t){return[[180*t[0][0]/p,180*t[0][1]/p],[180*t[1][0]/p,180*t[1][1]/p],[180*t[2][0]/p,180*t[2][1]/p]]})})},a},_.invert=function(t,e){var r=.5*e*Math.sqrt((4+p)/p),n=v(r),i=Math.cos(n);return[t/(2/Math.sqrt(p*(4+p))*(1+i)),v((n+r*(i+2))/(2+d))]},(t.geo.eckert4=function(){return x(_)}).raw=_;var w=t.geo.azimuthalEqualArea.raw;function k(t,e){if(arguments.length<2&&(e=t),1===e)return w;if(e===1/0)return M;function r(r,n){var i=w(r/e,n);return i[0]*=t,i}return r.invert=function(r,n){var i=w.invert(r/t,n);return i[0]*=e,i},r}function M(t,e){return[t*Math.cos(e)/Math.cos(e/=2),2*Math.sin(e)]}function A(t,e){return[3*t/(2*p)*Math.sqrt(p*p/3-e*e),e]}function T(t,e){return[t,1.25*Math.log(Math.tan(p/4+.4*e))]}function S(t){return function(e){var r,n=t*Math.sin(e),i=30;do{e-=r=(e+Math.sin(e)-n)/(1+Math.cos(e))}while(Math.abs(r)>f&&--i>0);return e/2}}M.invert=function(t,e){var r=2*v(e/2);return[t*Math.cos(r/2)/Math.cos(r),r]},(t.geo.hammer=function(){var t=2,e=b(k),r=e(t);return r.coefficient=function(r){return arguments.length?e(t=+r):t},r}).raw=k,A.invert=function(t,e){return[2/3*p*t/Math.sqrt(p*p/3-e*e),e]},(t.geo.kavrayskiy7=function(){return x(A)}).raw=A,T.invert=function(t,e){return[t,2.5*Math.atan(Math.exp(.8*e))-.625*p]},(t.geo.miller=function(){return x(T)}).raw=T,S(p);var C=function(t,e,r){var n=S(r);function i(r,i){return[t*r*Math.cos(i=n(i)),e*Math.sin(i)]}return i.invert=function(n,i){var a=v(i/e);return[n/(t*Math.cos(a)),v((2*a+Math.sin(2*a))/r)]},i}(Math.SQRT2/d,Math.SQRT2,p);function E(t,e){var r=e*e,n=r*r;return[t*(.8707-.131979*r+n*(n*(.003971*r-.001529*n)-.013791)),e*(1.007226+r*(.015085+n*(.028874*r-.044475-.005916*n)))]}(t.geo.mollweide=function(){return x(C)}).raw=C,E.invert=function(t,e){var r,n=e,i=25;do{var a=n*n,o=a*a;n-=r=(n*(1.007226+a*(.015085+o*(.028874*a-.044475-.005916*o)))-e)/(1.007226+a*(.045255+o*(.259866*a-.311325-.005916*11*o)))}while(Math.abs(r)>f&&--i>0);return[t/(.8707+(a=n*n)*(a*(a*a*a*(.003971-.001529*a)-.013791)-.131979)),n]},(t.geo.naturalEarth=function(){return x(E)}).raw=E;var L=[[.9986,-.062],[1,0],[.9986,.062],[.9954,.124],[.99,.186],[.9822,.248],[.973,.31],[.96,.372],[.9427,.434],[.9216,.4958],[.8962,.5571],[.8679,.6176],[.835,.6769],[.7986,.7346],[.7597,.7903],[.7186,.8435],[.6732,.8936],[.6213,.9394],[.5722,.9761],[.5322,1]];function z(t,e){var r,n=Math.min(18,36*Math.abs(e)/p),i=Math.floor(n),a=n-i,o=(r=L[i])[0],s=r[1],l=(r=L[++i])[0],c=r[1],u=(r=L[Math.min(19,++i)])[0],f=r[1];return[t*(l+a*(u-o)/2+a*a*(u-2*l+o)/2),(e>0?d:-d)*(c+a*(f-s)/2+a*a*(f-2*c+s)/2)]}function P(t,e){return[t*Math.cos(e),e]}function D(t,e){var r,n=Math.cos(e),i=(r=y(n*Math.cos(t/=2)))?r/Math.sin(r):1;return[2*n*Math.sin(t)*i,Math.sin(e)*i]}function O(t,e){var r=D(t,e);return[(r[0]+t/d)/2,(r[1]+e)/2]}L.forEach(function(t){t[1]*=1.0144}),z.invert=function(t,e){var r=e/d,n=90*r,i=Math.min(18,Math.abs(n/5)),a=Math.max(0,Math.floor(i));do{var o=L[a][1],s=L[a+1][1],l=L[Math.min(19,a+2)][1],c=l-o,u=l-2*s+o,f=2*(Math.abs(r)-s)/c,p=u/c,v=f*(1-p*f*(1-2*p*f));if(v>=0||1===a){n=(e>=0?5:-5)*(v+i);var y,x=50;do{v=(i=Math.min(18,Math.abs(n)/5))-(a=Math.floor(i)),o=L[a][1],s=L[a+1][1],l=L[Math.min(19,a+2)][1],n-=(y=(e>=0?d:-d)*(s+v*(l-o)/2+v*v*(l-2*s+o)/2)-e)*m}while(Math.abs(y)>h&&--x>0);break}}while(--a>=0);var b=L[a][0],_=L[a+1][0],w=L[Math.min(19,a+2)][0];return[t/(_+v*(w-b)/2+v*v*(w-2*_+b)/2),n*g]},(t.geo.robinson=function(){return x(z)}).raw=z,P.invert=function(t,e){return[t/Math.cos(e),e]},(t.geo.sinusoidal=function(){return x(P)}).raw=P,D.invert=function(t,e){if(!(t*t+4*e*e>p*p+f)){var r=t,n=e,i=25;do{var a,o=Math.sin(r),s=Math.sin(r/2),l=Math.cos(r/2),c=Math.sin(n),u=Math.cos(n),h=Math.sin(2*n),d=c*c,g=u*u,m=s*s,v=1-g*l*l,x=v?y(u*l)*Math.sqrt(a=1/v):a=0,b=2*x*u*s-t,_=x*c-e,w=a*(g*m+x*u*l*d),k=a*(.5*o*h-2*x*c*s),M=.25*a*(h*s-x*c*g*o),A=a*(d*l+x*m*u),T=k*M-A*w;if(!T)break;var S=(_*k-b*A)/T,C=(b*M-_*w)/T;r-=S,n-=C}while((Math.abs(S)>f||Math.abs(C)>f)&&--i>0);return[r,n]}},(t.geo.aitoff=function(){return x(D)}).raw=D,O.invert=function(t,e){var r=t,n=e,i=25;do{var a,o=Math.cos(n),s=Math.sin(n),l=Math.sin(2*n),c=s*s,u=o*o,h=Math.sin(r),p=Math.cos(r/2),g=Math.sin(r/2),m=g*g,v=1-u*p*p,x=v?y(o*p)*Math.sqrt(a=1/v):a=0,b=.5*(2*x*o*g+r/d)-t,_=.5*(x*s+n)-e,w=.5*a*(u*m+x*o*p*c)+.5/d,k=a*(h*l/4-x*s*g),M=.125*a*(l*g-x*s*u*h),A=.5*a*(c*p+x*m*o)+.5,T=k*M-A*w,S=(_*k-b*A)/T,C=(b*M-_*w)/T;r-=S,n-=C}while((Math.abs(S)>f||Math.abs(C)>f)&&--i>0);return[r,n]},(t.geo.winkel3=function(){return x(O)}).raw=O}},{}],741:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=Math.PI/180,o=180/Math.PI,s={cursor:"pointer"},l={cursor:"auto"};function c(t,e){return n.behavior.zoom().translate(e.translate()).scale(e.scale())}function u(t,e,r){var n=t.id,a=t.graphDiv,o=a.layout[n],s=a._fullLayout[n],l={};function c(t,e){var r=i.nestedProperty(s,t);r.get()!==e&&(r.set(e),i.nestedProperty(o,t).set(e),l[n+"."+t]=e)}r(c),c("projection.scale",e.scale()/t.fitScale),a.emit("plotly_relayout",l)}function f(t,e){var r=c(0,e);function i(r){var n=e.invert(t.midPt);r("center.lon",n[0]),r("center.lat",n[1])}return r.on("zoomstart",function(){n.select(this).style(s)}).on("zoom",function(){e.scale(n.event.scale).translate(n.event.translate),t.render()}).on("zoomend",function(){n.select(this).style(l),u(t,e,i)}),r}function h(t,e){var r,i,a,o,f,h,p,d,g=c(0,e),m=2;function v(t){return e.invert(t)}function y(r){var n=e.rotate(),i=e.invert(t.midPt);r("projection.rotation.lon",-n[0]),r("center.lon",i[0]),r("center.lat",i[1])}return g.on("zoomstart",function(){n.select(this).style(s),r=n.mouse(this),i=e.rotate(),a=e.translate(),o=i,f=v(r)}).on("zoom",function(){if(h=n.mouse(this),l=e(v(s=r)),Math.abs(l[0]-s[0])>m||Math.abs(l[1]-s[1])>m)return g.scale(e.scale()),void g.translate(e.translate());var s,l;e.scale(n.event.scale),e.translate([a[0],n.event.translate[1]]),f?v(h)&&(d=v(h),p=[o[0]+(d[0]-f[0]),i[1],i[2]],e.rotate(p),o=p):f=v(r=h),t.render()}).on("zoomend",function(){n.select(this).style(l),u(t,e,y)}),g}function p(t,e){var r,i={r:e.rotate(),k:e.scale()},f=c(0,e),h=function(t){var e=0,r=arguments.length,i=[];for(;++ed?(a=(f>0?90:-90)-p,i=0):(a=Math.asin(f/d)*o-p,i=Math.sqrt(d*d-f*f));var m=180-a-2*p,y=(Math.atan2(h,u)-Math.atan2(c,i))*o,x=(Math.atan2(h,u)-Math.atan2(c,-i))*o,b=g(r[0],r[1],a,y),_=g(r[0],r[1],m,x);return b<=_?[a,y,r[2]]:[m,x,r[2]]}(k,r,C);isFinite(M[0])&&isFinite(M[1])&&isFinite(M[2])||(M=C),e.rotate(M),C=M}}else r=d(e,T=b);h.of(this,arguments)({type:"zoom"})}),A=h.of(this,arguments),p++||A({type:"zoomstart"})}).on("zoomend",function(){var r;n.select(this).style(l),m.call(f,"zoom",null),r=h.of(this,arguments),--p||r({type:"zoomend"}),u(t,e,x)}).on("zoom.redraw",function(){t.render()}),n.rebind(f,h,"on")}function d(t,e){var r=t.invert(e);return r&&isFinite(r[0])&&isFinite(r[1])&&function(t){var e=t[0]*a,r=t[1]*a,n=Math.cos(r);return[n*Math.cos(e),n*Math.sin(e),Math.sin(r)]}(r)}function g(t,e,r,n){var i=m(r-t),a=m(n-e);return Math.sqrt(i*i+a*a)}function m(t){return(t%360+540)%360-180}function v(t,e,r){var n=r*a,i=t.slice(),o=0===e?1:0,s=2===e?1:2,l=Math.cos(n),c=Math.sin(n);return i[o]=t[o]*l-t[s]*c,i[s]=t[s]*l+t[o]*c,i}function y(t,e){for(var r=0,n=0,i=t.length;nMath.abs(s)?(l.boxEnd[1]=l.boxStart[1]+Math.abs(a)*_*(s>=0?1:-1),l.boxEnd[1]u[3]&&(l.boxEnd[1]=u[3],l.boxEnd[0]=l.boxStart[0]+(u[3]-l.boxStart[1])/Math.abs(_))):(l.boxEnd[0]=l.boxStart[0]+Math.abs(s)/_*(a>=0?1:-1),l.boxEnd[0]u[2]&&(l.boxEnd[0]=u[2],l.boxEnd[1]=l.boxStart[1]+(u[2]-l.boxStart[0])*Math.abs(_)))}}else l.boxEnabled?(a=l.boxStart[0]!==l.boxEnd[0],s=l.boxStart[1]!==l.boxEnd[1],a||s?(a&&(m(0,l.boxStart[0],l.boxEnd[0]),t.xaxis.autorange=!1),s&&(m(1,l.boxStart[1],l.boxEnd[1]),t.yaxis.autorange=!1),t.relayoutCallback()):t.glplot.setDirty(),l.boxEnabled=!1,l.boxInited=!1):l.boxInited&&(l.boxInited=!1);break;case"pan":l.boxEnabled=!1,l.boxInited=!1,e?(l.panning||(l.dragStart[0]=n,l.dragStart[1]=i),Math.abs(l.dragStart[0]-n)Math.abs(e))c.rotate(a,0,0,-t*r*Math.PI*d.rotateSpeed/window.innerWidth);else{var o=-d.zoomSpeed*i*e/window.innerHeight*(a-c.lastT())/20;c.pan(a,0,0,f*(Math.exp(o)-1))}}},!0),d};var n=t("right-now"),i=t("3d-view"),a=t("mouse-change"),o=t("mouse-wheel"),s=t("mouse-event-offset"),l=t("has-passive-events")},{"3d-view":42,"has-passive-events":355,"mouse-change":378,"mouse-event-offset":379,"mouse-wheel":381,"right-now":440}],748:[function(t,e,r){"use strict";var n=t("../../plot_api/edit_types").overrideAll,i=t("../../components/fx/layout_attributes"),a=t("./scene"),o=t("../get_data").getSubplotData,s=t("../../lib"),l=t("../../constants/xmlns_namespaces");r.name="gl3d",r.attr="scene",r.idRoot="scene",r.idRegex=r.attrRegex=s.counterRegex("scene"),r.attributes=t("./layout/attributes"),r.layoutAttributes=t("./layout/layout_attributes"),r.baseLayoutAttrOverrides=n({hoverlabel:i.hoverlabel},"plot","nested"),r.supplyLayoutDefaults=t("./layout/defaults"),r.plot=function(t){for(var e=t._fullLayout,r=t._fullData,n=e._subplots.gl3d,i=0;i1;o(t,e,r,{type:"gl3d",attributes:l,handleDefaults:c,fullLayout:e,font:e.font,fullData:r,getDfltFromLayout:function(e){if(!i)return n.validate(t[e],l[e])?t[e]:void 0},paper_bgcolor:e.paper_bgcolor,calendar:e.calendar})}},{"../../../components/color":532,"../../../lib":660,"../../../registry":790,"../../subplot_defaults":782,"./axis_defaults":751,"./layout_attributes":754}],754:[function(t,e,r){"use strict";var n=t("./axis_attributes"),i=t("../../domain").attributes,a=t("../../../lib/extend").extendFlat,o=t("../../../lib").counterRegex;function s(t,e,r){return{x:{valType:"number",dflt:t,editType:"camera"},y:{valType:"number",dflt:e,editType:"camera"},z:{valType:"number",dflt:r,editType:"camera"},editType:"camera"}}e.exports={_arrayAttrRegexps:[o("scene",".annotations",!0)],bgcolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"plot"},camera:{up:a(s(0,0,1),{}),center:a(s(0,0,0),{}),eye:a(s(1.25,1.25,1.25),{}),editType:"camera"},domain:i({name:"scene",editType:"plot"}),aspectmode:{valType:"enumerated",values:["auto","cube","data","manual"],dflt:"auto",editType:"plot",impliedEdits:{"aspectratio.x":void 0,"aspectratio.y":void 0,"aspectratio.z":void 0}},aspectratio:{x:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},y:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},z:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},editType:"plot",impliedEdits:{aspectmode:"manual"}},xaxis:n,yaxis:n,zaxis:n,dragmode:{valType:"enumerated",values:["orbit","turntable","zoom","pan",!1],dflt:"turntable",editType:"plot"},hovermode:{valType:"enumerated",values:["closest",!1],dflt:"closest",editType:"modebar"},editType:"plot",_deprecated:{cameraposition:{valType:"info_array",editType:"camera"}}}},{"../../../lib":660,"../../../lib/extend":649,"../../domain":731,"./axis_attributes":750}],755:[function(t,e,r){"use strict";var n=t("../../../lib/str2rgbarray"),i=["xaxis","yaxis","zaxis"];function a(){this.enabled=[!0,!0,!0],this.colors=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.drawSides=[!0,!0,!0],this.lineWidth=[1,1,1]}a.prototype.merge=function(t){for(var e=0;e<3;++e){var r=t[i[e]];r.visible?(this.enabled[e]=r.showspikes,this.colors[e]=n(r.spikecolor),this.drawSides[e]=r.spikesides,this.lineWidth[e]=r.spikethickness):(this.enabled[e]=!1,this.drawSides[e]=!1)}},e.exports=function(t){var e=new a;return e.merge(t),e}},{"../../../lib/str2rgbarray":683}],756:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.axesOptions,r=t.glplot.axesPixels,l=t.fullSceneLayout,c=[[],[],[]],u=0;u<3;++u){var f=l[o[u]];if(f._length=(r[u].hi-r[u].lo)*r[u].pixelsPerDataUnit/t.dataScale[u],Math.abs(f._length)===1/0)c[u]=[];else{f._input_range=f.range.slice(),f.range[0]=r[u].lo/t.dataScale[u],f.range[1]=r[u].hi/t.dataScale[u],f._m=1/(t.dataScale[u]*r[u].pixelsPerDataUnit),f.range[0]===f.range[1]&&(f.range[0]-=1,f.range[1]+=1);var h=f.tickmode;if("auto"===f.tickmode){f.tickmode="linear";var p=f.nticks||i.constrain(f._length/40,4,9);n.autoTicks(f,Math.abs(f.range[1]-f.range[0])/p)}for(var d=n.calcTicks(f),g=0;g")}else m=c.textLabel;t.fullSceneLayout.hovermode&&f.loneHover({x:(.5+.5*d[0]/d[3])*i,y:(.5-.5*d[1]/d[3])*a,xLabel:w,yLabel:k,zLabel:M,text:m,name:l.name,color:f.castHoverOption(e,v,"bgcolor")||l.color,borderColor:f.castHoverOption(e,v,"bordercolor"),fontFamily:f.castHoverOption(e,v,"font.family"),fontSize:f.castHoverOption(e,v,"font.size"),fontColor:f.castHoverOption(e,v,"font.color")},{container:r,gd:t.graphDiv});var T={x:c.traceCoordinate[0],y:c.traceCoordinate[1],z:c.traceCoordinate[2],data:e._input,fullData:e,curveNumber:e.index,pointNumber:v};f.appendArrayPointValue(T,e,v);var S={points:[T]};c.buttons&&c.distance<5?t.graphDiv.emit("plotly_click",S):t.graphDiv.emit("plotly_hover",S),o=S}else f.loneUnhover(r),t.graphDiv.emit("plotly_unhover",o);t.drawAnnotations(t)}.bind(null,t),t.traces={},!0}function b(t,e){var r=document.createElement("div"),n=t.container;this.graphDiv=t.graphDiv;var i=document.createElementNS("http://www.w3.org/2000/svg","svg");i.style.position="absolute",i.style.top=i.style.left="0px",i.style.width=i.style.height="100%",i.style["z-index"]=20,i.style["pointer-events"]="none",r.appendChild(i),this.svgContainer=i,r.id=t.id,r.style.position="absolute",r.style.top=r.style.left="0px",r.style.width=r.style.height="100%",n.appendChild(r),this.fullLayout=e,this.id=t.id||"scene",this.fullSceneLayout=e[this.id],this.plotArgs=[[],{},{}],this.axesOptions=m(e[this.id]),this.spikeOptions=v(e[this.id]),this.container=r,this.staticMode=!!t.staticPlot,this.pixelRatio=t.plotGlPixelRatio||2,this.dataScale=[1,1,1],this.contourLevels=[[],[],[]],this.convertAnnotations=l.getComponentMethod("annotations3d","convert"),this.drawAnnotations=l.getComponentMethod("annotations3d","draw"),x(this)}var _=b.prototype;_.recoverContext=function(){var t=this,e=this.glplot.gl,r=this.glplot.canvas;this.glplot.dispose(),requestAnimationFrame(function n(){e.isContextLost()?requestAnimationFrame(n):x(t,t.fullLayout,r,e)?t.plot.apply(t,t.plotArgs):c.error("Catastrophic and unrecoverable WebGL error. Context lost.")})};var w=["xaxis","yaxis","zaxis"];function k(t,e,r){for(var n=t.fullSceneLayout,i=0;i<3;i++){var a=w[i],o=a.charAt(0),s=n[a],l=e[o],u=e[o+"calendar"],f=e["_"+o+"length"];if(c.isArrayOrTypedArray(l))for(var h,p=0;p<(f||l.length);p++)if(c.isArrayOrTypedArray(l[p]))for(var d=0;df[1][o]?p[o]=1:f[1][o]===f[0][o]?p[o]=1:p[o]=1/(f[1][o]-f[0][o]);for(this.dataScale=p,this.convertAnnotations(this),a=0;ag[1][a])g[0][a]=-1,g[1][a]=1;else{var C=g[1][a]-g[0][a];g[0][a]-=C/32,g[1][a]+=C/32}}else{var E=s.range;g[0][a]=s.r2l(E[0]),g[1][a]=s.r2l(E[1])}g[0][a]===g[1][a]&&(g[0][a]-=1,g[1][a]+=1),m[a]=g[1][a]-g[0][a],this.glplot.bounds[0][a]=g[0][a]*p[a],this.glplot.bounds[1][a]=g[1][a]*p[a]}var L=[1,1,1];for(a=0;a<3;++a){var z=v[l=(s=c[w[a]]).type];L[a]=Math.pow(z.acc,1/z.count)/p[a]}var P;if("auto"===c.aspectmode)P=Math.max.apply(null,L)/Math.min.apply(null,L)<=4?L:[1,1,1];else if("cube"===c.aspectmode)P=[1,1,1];else if("data"===c.aspectmode)P=L;else{if("manual"!==c.aspectmode)throw new Error("scene.js aspectRatio was not one of the enumerated types");var D=c.aspectratio;P=[D.x,D.y,D.z]}c.aspectratio.x=u.aspectratio.x=P[0],c.aspectratio.y=u.aspectratio.y=P[1],c.aspectratio.z=u.aspectratio.z=P[2],this.glplot.aspect=P;var O=c.domain||null,I=e._size||null;if(O&&I){var R=this.container.style;R.position="absolute",R.left=I.l+O.x[0]*I.w+"px",R.top=I.t+(1-O.y[1])*I.h+"px",R.width=I.w*(O.x[1]-O.x[0])+"px",R.height=I.h*(O.y[1]-O.y[0])+"px"}this.glplot.redraw()}},_.destroy=function(){this.glplot&&(this.camera.mouseListener.enabled=!1,this.container.removeEventListener("wheel",this.camera.wheelListener),this.camera=this.glplot.camera=null,this.glplot.dispose(),this.container.parentNode.removeChild(this.container),this.glplot=null)},_.getCamera=function(){return this.glplot.camera.view.recalcMatrix(this.camera.view.lastT()),M(this.glplot.camera)},_.setCamera=function(t){var e;this.glplot.camera.lookAt.apply(this,[[(e=t).eye.x,e.eye.y,e.eye.z],[e.center.x,e.center.y,e.center.z],[e.up.x,e.up.y,e.up.z]])},_.saveCamera=function(t){var e=this.getCamera(),r=c.nestedProperty(t,this.id+".camera"),n=r.get(),i=!1;function a(t,e,r,n){var i=["up","center","eye"],a=["x","y","z"];return e[i[r]]&&t[i[r]][a[n]]===e[i[r]][a[n]]}if(void 0===n)i=!0;else for(var o=0;o<3;o++)for(var s=0;s<3;s++)if(!a(e,n,o,s)){i=!0;break}return i&&r.set(e),i},_.updateFx=function(t,e){var r=this.camera;r&&("orbit"===t?(r.mode="orbit",r.keyBindingMode="rotate"):"turntable"===t?(r.up=[0,0,1],r.mode="turntable",r.keyBindingMode="rotate"):r.keyBindingMode=t),this.fullSceneLayout.hovermode=e},_.toImage=function(t){t||(t="png"),this.staticMode&&this.container.appendChild(n),this.glplot.redraw();var e=this.glplot.gl,r=e.drawingBufferWidth,i=e.drawingBufferHeight;e.bindFramebuffer(e.FRAMEBUFFER,null);var a=new Uint8Array(r*i*4);e.readPixels(0,0,r,i,e.RGBA,e.UNSIGNED_BYTE,a);for(var o=0,s=i-1;o0}function l(t){var e={},r={};switch(t.type){case"circle":n.extendFlat(r,{"circle-radius":t.circle.radius,"circle-color":t.color,"circle-opacity":t.opacity});break;case"line":n.extendFlat(r,{"line-width":t.line.width,"line-color":t.color,"line-opacity":t.opacity});break;case"fill":n.extendFlat(r,{"fill-color":t.color,"fill-outline-color":t.fill.outlinecolor,"fill-opacity":t.opacity});break;case"symbol":var a=t.symbol,o=i(a.textposition,a.iconsize);n.extendFlat(e,{"icon-image":a.icon+"-15","icon-size":a.iconsize/10,"text-field":a.text,"text-size":a.textfont.size,"text-anchor":o.anchor,"text-offset":o.offset}),n.extendFlat(r,{"icon-color":t.color,"text-color":a.textfont.color,"text-opacity":t.opacity})}return{layout:e,paint:r}}o.update=function(t){this.visible?this.needsNewSource(t)?(this.updateLayer(t),this.updateSource(t)):this.needsNewLayer(t)?this.updateLayer(t):this.updateStyle(t):(this.updateSource(t),this.updateLayer(t)),this.visible=s(t)},o.needsNewSource=function(t){return this.sourceType!==t.sourcetype||this.source!==t.source||this.layerType!==t.type},o.needsNewLayer=function(t){return this.layerType!==t.type||this.below!==t.below},o.updateSource=function(t){var e=this.map;if(e.getSource(this.idSource)&&e.removeSource(this.idSource),this.sourceType=t.sourcetype,this.source=t.source,s(t)){var r=function(t){var e,r=t.sourcetype,n=t.source,i={type:r};"geojson"===r?e="data":"vector"===r&&(e="string"==typeof n?"url":"tiles");return i[e]=n,i}(t);e.addSource(this.idSource,r)}},o.updateLayer=function(t){var e=this.map,r=l(t);e.getLayer(this.idLayer)&&e.removeLayer(this.idLayer),this.layerType=t.type,s(t)&&e.addLayer({id:this.idLayer,source:this.idSource,"source-layer":t.sourcelayer||"",type:t.type,layout:r.layout,paint:r.paint},t.below)},o.updateStyle=function(t){if(s(t)){var e=l(t);this.mapbox.setOptions(this.idLayer,"setLayoutProperty",e.layout),this.mapbox.setOptions(this.idLayer,"setPaintProperty",e.paint)}},o.dispose=function(){var t=this.map;t.removeLayer(this.idLayer),t.removeSource(this.idSource)},e.exports=function(t,e,r){var n=new a(t,e);return n.update(r),n}},{"../../lib":660,"./convert_text_opts":761}],764:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../components/color").defaultLine,a=t("../domain").attributes,o=t("../font_attributes"),s=t("../../traces/scatter/attributes").textposition,l=t("../../plot_api/edit_types").overrideAll,c=o({});c.family.dflt="Open Sans Regular, Arial Unicode MS Regular",e.exports=l({_arrayAttrRegexps:[n.counterRegex("mapbox",".layers",!0)],domain:a({name:"mapbox"}),accesstoken:{valType:"string",noBlank:!0,strict:!0},style:{valType:"any",values:["basic","streets","outdoors","light","dark","satellite","satellite-streets"],dflt:"basic"},center:{lon:{valType:"number",dflt:0},lat:{valType:"number",dflt:0}},zoom:{valType:"number",dflt:1},bearing:{valType:"number",dflt:0},pitch:{valType:"number",dflt:0},layers:{_isLinkedToArray:"layer",sourcetype:{valType:"enumerated",values:["geojson","vector"],dflt:"geojson"},source:{valType:"any"},sourcelayer:{valType:"string",dflt:""},type:{valType:"enumerated",values:["circle","line","fill","symbol"],dflt:"circle"},below:{valType:"string",dflt:""},color:{valType:"color",dflt:i},opacity:{valType:"number",min:0,max:1,dflt:1},circle:{radius:{valType:"number",dflt:15}},line:{width:{valType:"number",dflt:2}},fill:{outlinecolor:{valType:"color",dflt:i}},symbol:{icon:{valType:"string",dflt:"marker"},iconsize:{valType:"number",dflt:10},text:{valType:"string",dflt:""},textfont:c,textposition:n.extendFlat({},s,{arrayOk:!1})}}},"plot","from-root")},{"../../components/color":532,"../../lib":660,"../../plot_api/edit_types":691,"../../traces/scatter/attributes":990,"../domain":731,"../font_attributes":732}],765:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../subplot_defaults"),a=t("./layout_attributes");function o(t,e,r,i){r("accesstoken",i.accessToken),r("style"),r("center.lon"),r("center.lat"),r("zoom"),r("bearing"),r("pitch"),function(t,e){var r,i,o=t.layers||[],s=e.layers=[];function l(t,e){return n.coerce(r,i,a.layers,t,e)}for(var c=0;c=e.width-20?(a["text-anchor"]="start",a.x=5):(a["text-anchor"]="end",a.x=e._paper.attr("width")-7),r.attr(a);var o=r.select(".js-link-to-tool"),c=r.select(".js-link-spacer"),u=r.select(".js-sourcelinks");t._context.showSources&&t._context.showSources(t),t._context.showLink&&function(t,e){e.text("");var r=e.append("a").attr({"xlink:xlink:href":"#",class:"link--impt link--embedview","font-weight":"bold"}).text(t._context.linkText+" "+String.fromCharCode(187));if(t._context.sendData)r.on("click",function(){m.sendDataToCloud(t)});else{var n=window.location.pathname.split("/"),i=window.location.search;r.attr({"xlink:xlink:show":"new","xlink:xlink:href":"/"+n[2].split(".")[0]+"/"+n[1]+i})}}(t,o),c.text(o.text()&&u.text()?" - ":"")}},m.sendDataToCloud=function(t){t.emit("plotly_beforeexport");var e=window.PLOTLYENV&&window.PLOTLYENV.BASE_URL||"https://plot.ly",r=n.select(t).append("div").attr("id","hiddenform").style("display","none"),i=r.append("form").attr({action:e+"/external",method:"post",target:"_blank"});return i.append("input").attr({type:"text",name:"data"}).node().value=m.graphJson(t,!1,"keepdata"),i.node().submit(),r.remove(),t.emit("plotly_afterexport"),!1};var x,b=["days","shortDays","months","shortMonths","periods","dateTime","date","time","decimal","thousands","grouping","currency"],_=["year","month","dayMonth","dayMonthYear"];function w(t,e){var r=t._context.locale,n=!1,i={};function o(t){for(var r=!0,a=0;a1&&O.length>1){for(a.getComponentMethod("grid","sizeDefaults")(c,l),o=0;o15&&O.length>15&&0===l.shapes.length&&0===l.images.length,l._hasCartesian=l._has("cartesian"),l._hasGeo=l._has("geo"),l._hasGL3D=l._has("gl3d"),l._hasGL2D=l._has("gl2d"),l._hasTernary=l._has("ternary"),l._hasPie=l._has("pie"),m.linkSubplots(p,l,h,i),m.cleanPlot(p,l,h,i,y),d(l,i),m.doAutoMargin(t);var F=u.list(t);for(o=0;o0){var u=function(t){var e,r={left:0,right:0,bottom:0,top:0};if(t)for(e in t)t.hasOwnProperty(e)&&(r.left+=t[e].left||0,r.right+=t[e].right||0,r.bottom+=t[e].bottom||0,r.top+=t[e].top||0);return r}(t._boundingBoxMargins),f=u.left+u.right,h=u.bottom+u.top,p=1-2*l,d=r._container&&r._container.node?r._container.node().getBoundingClientRect():{width:r.width,height:r.height};n=Math.round(p*(d.width-f)),a=Math.round(p*(d.height-h))}else{var g=c?window.getComputedStyle(t):{};n=parseFloat(g.width)||r.width,a=parseFloat(g.height)||r.height}var v=m.layoutAttributes.width.min,y=m.layoutAttributes.height.min;n1,b=!e.height&&Math.abs(r.height-a)>1;(b||x)&&(x&&(r.width=n),b&&(r.height=a)),t._initialAutoSize||(t._initialAutoSize={width:n,height:a}),m.sanitizeMargins(r)},m.supplyLayoutModuleDefaults=function(t,e,r,n){var i,o,l,c=a.componentsRegistry,u=e._basePlotModules,f=a.subplotsRegistry.cartesian;for(i in c)(l=c[i]).includeBasePlot&&l.includeBasePlot(t,e);for(var h in u.length||u.push(f),e._has("cartesian")&&(a.getComponentMethod("grid","contentDefaults")(t,e),f.finalizeSubplots(t,e)),e._subplots)e._subplots[h].sort(s.subplotSort);for(o=0;o.5*n.width&&(r.l=r.r=0),r.b+r.t>.5*n.height&&(r.b=r.t=0),n._pushmargin[e]={l:{val:r.x,size:r.l+i},r:{val:r.x,size:r.r+i},b:{val:r.y,size:r.b+i},t:{val:r.y,size:r.t+i}}}else delete n._pushmargin[e];n._replotting||m.doAutoMargin(t)}},m.doAutoMargin=function(t){var e=t._fullLayout;e._size||(e._size={}),e._pushmargin||(e._pushmargin={});var r=e._size,n=JSON.stringify(r),o=Math.max(e.margin.l||0,0),s=Math.max(e.margin.r||0,0),l=Math.max(e.margin.t||0,0),c=Math.max(e.margin.b||0,0),u=e._pushmargin;if(!1!==e.margin.autoexpand)for(var f in u.base={l:{val:0,size:o},r:{val:1,size:s},t:{val:1,size:l},b:{val:0,size:c}},u){var h=u[f].l||{},p=u[f].b||{},d=h.val,g=h.size,m=p.val,v=p.size;for(var y in u){if(i(g)&&u[y].r){var x=u[y].r.val,b=u[y].r.size;if(x>d){var _=(g*x+(b-e.width)*d)/(x-d),w=(b*(1-d)+(g-e.width)*(1-x))/(x-d);_>=0&&w>=0&&_+w>o+s&&(o=_,s=w)}}if(i(v)&&u[y].t){var k=u[y].t.val,M=u[y].t.size;if(k>m){var A=(v*k+(M-e.height)*m)/(k-m),T=(M*(1-m)+(v-e.height)*(1-k))/(k-m);A>=0&&T>=0&&A+T>c+l&&(c=A,l=T)}}}}if(r.l=Math.round(o),r.r=Math.round(s),r.t=Math.round(l),r.b=Math.round(c),r.p=Math.round(e.margin.pad),r.w=Math.round(e.width)-r.l-r.r,r.h=Math.round(e.height)-r.t-r.b,!e._replotting&&"{}"!==n&&n!==JSON.stringify(e._size))return a.call("plot",t)},m.graphJson=function(t,e,r,n,i){(i&&e&&!t._fullData||i&&!e&&!t._fullLayout)&&m.supplyDefaults(t);var a=i?t._fullData:t.data,o=i?t._fullLayout:t.layout,l=(t._transitionData||{})._frames;function c(t){if("function"==typeof t)return null;if(s.isPlainObject(t)){var e,n,i={};for(e in t)if("function"!=typeof t[e]&&-1===["_","["].indexOf(e.charAt(0))){if("keepdata"===r){if("src"===e.substr(e.length-3))continue}else if("keepstream"===r){if("string"==typeof(n=t[e+"src"])&&n.indexOf(":")>0&&!s.isPlainObject(t.stream))continue}else if("keepall"!==r&&"string"==typeof(n=t[e+"src"])&&n.indexOf(":")>0)continue;i[e]=c(t[e])}return i}return Array.isArray(t)?t.map(c):s.isJSDate(t)?s.ms2DateTimeLocal(+t):t}var u={data:(a||[]).map(function(t){var r=c(t);return e&&delete r.fit,r})};return e||(u.layout=c(o)),t.framework&&t.framework.isPolar&&(u=t.framework.getConfig()),l&&(u.frames=c(l)),"object"===n?u:JSON.stringify(u)},m.modifyFrames=function(t,e){var r,n,i,a=t._transitionData._frames,o=t._transitionData._frameHash;for(r=0;r0&&(t._transitioningWithDuration=!0),t._transitionData._interruptCallbacks.push(function(){p=!0}),i.redraw&&t._transitionData._interruptCallbacks.push(function(){return a.call("redraw",t)}),t._transitionData._interruptCallbacks.push(function(){t.emit("plotly_transitioninterrupted",[])});var n,l,c=0,u=0;function f(){return c++,function(){var r;p||++u!==c||(r=e,t._transitionData&&(function(t){if(t)for(;t.length;)t.shift()}(t._transitionData._interruptCallbacks),Promise.resolve().then(function(){if(i.redraw)return a.call("redraw",t)}).then(function(){t._transitioning=!1,t._transitioningWithDuration=!1,t.emit("plotly_transitioned",[])}).then(r)))}}var d=t._fullLayout._basePlotModules,g=!1;if(r)for(l=0;l=0;s--)if(o[s].enabled){r._indexToPoints=o[s]._indexToPoints;break}n&&n.calc&&(a=n.calc(t,r))}Array.isArray(a)&&a[0]||(a=[{x:c,y:c}]),a[0].t||(a[0].t={}),a[0].trace=r,p[e]=a}}for(m&&M(l),i=0;i=0?h.angularAxis.domain:n.extent(w),S=Math.abs(w[1]-w[0]);M&&!k&&(S=0);var C=T.slice();A&&k&&(C[1]+=S);var E=h.angularAxis.ticksCount||4;E>8&&(E=E/(E/8)+E%8),h.angularAxis.ticksStep&&(E=(C[1]-C[0])/E);var L=h.angularAxis.ticksStep||(C[1]-C[0])/(E*(h.minorTicks+1));_&&(L=Math.max(Math.round(L),1)),C[2]||(C[2]=L);var z=n.range.apply(this,C);if(z=z.map(function(t,e){return parseFloat(t.toPrecision(12))}),s=n.scale.linear().domain(C.slice(0,2)).range("clockwise"===h.direction?[0,360]:[360,0]),u.layout.angularAxis.domain=s.domain(),u.layout.angularAxis.endPadding=A?S:0,void 0===(t=n.select(this).select("svg.chart-root"))||t.empty()){var P=(new DOMParser).parseFromString("' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '","application/xml"),D=this.appendChild(this.ownerDocument.importNode(P.documentElement,!0));t=n.select(D)}t.select(".guides-group").style({"pointer-events":"none"}),t.select(".angular.axis-group").style({"pointer-events":"none"}),t.select(".radial.axis-group").style({"pointer-events":"none"});var O,I=t.select(".chart-group"),R={fill:"none",stroke:h.tickColor},B={"font-size":h.font.size,"font-family":h.font.family,fill:h.font.color,"text-shadow":["-1px 0px","1px -1px","-1px 1px","1px 1px"].map(function(t,e){return" "+t+" 0 "+h.font.outlineColor}).join(",")};if(h.showLegend){O=t.select(".legend-group").attr({transform:"translate("+[y,h.margin.top]+")"}).style({display:"block"});var F=p.map(function(t,e){var r=o.util.cloneJson(t);return r.symbol="DotPlot"===t.geometry?t.dotType||"circle":"LinePlot"!=t.geometry?"square":"line",r.visibleInLegend=void 0===t.visibleInLegend||t.visibleInLegend,r.color="LinePlot"===t.geometry?t.strokeColor:t.color,r});o.Legend().config({data:p.map(function(t,e){return t.name||"Element"+e}),legendConfig:i({},o.Legend.defaultConfig().legendConfig,{container:O,elements:F,reverseOrder:h.legend.reverseOrder})})();var N=O.node().getBBox();y=Math.min(h.width-N.width-h.margin.left-h.margin.right,h.height-h.margin.top-h.margin.bottom)/2,y=Math.max(10,y),b=[h.margin.left+y,h.margin.top+y],r.range([0,y]),u.layout.radialAxis.domain=r.domain(),O.attr("transform","translate("+[b[0]+y,b[1]-y]+")")}else O=t.select(".legend-group").style({display:"none"});t.attr({width:h.width,height:h.height}).style({opacity:h.opacity}),I.attr("transform","translate("+b+")").style({cursor:"crosshair"});var j=[(h.width-(h.margin.left+h.margin.right+2*y+(N?N.width:0)))/2,(h.height-(h.margin.top+h.margin.bottom+2*y))/2];if(j[0]=Math.max(0,j[0]),j[1]=Math.max(0,j[1]),t.select(".outer-group").attr("transform","translate("+j+")"),h.title){var V=t.select("g.title-group text").style(B).text(h.title),U=V.node().getBBox();V.attr({x:b[0]-U.width/2,y:b[1]-y-20})}var q=t.select(".radial.axis-group");if(h.radialAxis.gridLinesVisible){var H=q.selectAll("circle.grid-circle").data(r.ticks(5));H.enter().append("circle").attr({class:"grid-circle"}).style(R),H.attr("r",r),H.exit().remove()}q.select("circle.outside-circle").attr({r:y}).style(R);var G=t.select("circle.background-circle").attr({r:y}).style({fill:h.backgroundColor,stroke:h.stroke});function W(t,e){return s(t)%360+h.orientation}if(h.radialAxis.visible){var Y=n.svg.axis().scale(r).ticks(5).tickSize(5);q.call(Y).attr({transform:"rotate("+h.radialAxis.orientation+")"}),q.selectAll(".domain").style(R),q.selectAll("g>text").text(function(t,e){return this.textContent+h.radialAxis.ticksSuffix}).style(B).style({"text-anchor":"start"}).attr({x:0,y:0,dx:0,dy:0,transform:function(t,e){return"horizontal"===h.radialAxis.tickOrientation?"rotate("+-h.radialAxis.orientation+") translate("+[0,B["font-size"]]+")":"translate("+[0,B["font-size"]]+")"}}),q.selectAll("g>line").style({stroke:"black"})}var X=t.select(".angular.axis-group").selectAll("g.angular-tick").data(z),Z=X.enter().append("g").classed("angular-tick",!0);X.attr({transform:function(t,e){return"rotate("+W(t)+")"}}).style({display:h.angularAxis.visible?"block":"none"}),X.exit().remove(),Z.append("line").classed("grid-line",!0).classed("major",function(t,e){return e%(h.minorTicks+1)==0}).classed("minor",function(t,e){return!(e%(h.minorTicks+1)==0)}).style(R),Z.selectAll(".minor").style({stroke:h.minorTickColor}),X.select("line.grid-line").attr({x1:h.tickLength?y-h.tickLength:0,x2:y}).style({display:h.angularAxis.gridLinesVisible?"block":"none"}),Z.append("text").classed("axis-text",!0).style(B);var J=X.select("text.axis-text").attr({x:y+h.labelOffset,dy:a+"em",transform:function(t,e){var r=W(t),n=y+h.labelOffset,i=h.angularAxis.tickOrientation;return"horizontal"==i?"rotate("+-r+" "+n+" 0)":"radial"==i?r<270&&r>90?"rotate(180 "+n+" 0)":null:"rotate("+(r<=180&&r>0?-90:90)+" "+n+" 0)"}}).style({"text-anchor":"middle",display:h.angularAxis.labelsVisible?"block":"none"}).text(function(t,e){return e%(h.minorTicks+1)!=0?"":_?_[t]+h.angularAxis.ticksSuffix:t+h.angularAxis.ticksSuffix}).style(B);h.angularAxis.rewriteTicks&&J.text(function(t,e){return e%(h.minorTicks+1)!=0?"":h.angularAxis.rewriteTicks(this.textContent,e)});var K=n.max(I.selectAll(".angular-tick text")[0].map(function(t,e){return t.getCTM().e+t.getBBox().width}));O.attr({transform:"translate("+[y+K,h.margin.top]+")"});var Q=t.select("g.geometry-group").selectAll("g").size()>0,$=t.select("g.geometry-group").selectAll("g.geometry").data(p);if($.enter().append("g").attr({class:function(t,e){return"geometry geometry"+e}}),$.exit().remove(),p[0]||Q){var tt=[];p.forEach(function(t,e){var n={};n.radialScale=r,n.angularScale=s,n.container=$.filter(function(t,r){return r==e}),n.geometry=t.geometry,n.orientation=h.orientation,n.direction=h.direction,n.index=e,tt.push({data:t,geometryConfig:n})});var et=[];n.nest().key(function(t,e){return void 0!==t.data.groupId||"unstacked"}).entries(tt).forEach(function(t,e){"unstacked"===t.key?et=et.concat(t.values.map(function(t,e){return[t]})):et.push(t.values)}),et.forEach(function(t,e){var r;r=Array.isArray(t)?t[0].geometryConfig.geometry:t.geometryConfig.geometry;var n=t.map(function(t,e){return i(o[r].defaultConfig(),t)});o[r]().config(n)()})}var rt,nt,it=t.select(".guides-group"),at=t.select(".tooltips-group"),ot=o.tooltipPanel().config({container:at,fontSize:8})(),st=o.tooltipPanel().config({container:at,fontSize:8})(),lt=o.tooltipPanel().config({container:at,hasTick:!0})();if(!k){var ct=it.select("line").attr({x1:0,y1:0,y2:0}).style({stroke:"grey","pointer-events":"none"});I.on("mousemove.angular-guide",function(t,e){var r=o.util.getMousePos(G).angle;ct.attr({x2:-y,transform:"rotate("+r+")"}).style({opacity:.5});var n=(r+180+360-h.orientation)%360;rt=s.invert(n);var i=o.util.convertToCartesian(y+12,r+180);ot.text(o.util.round(rt)).move([i[0]+b[0],i[1]+b[1]])}).on("mouseout.angular-guide",function(t,e){it.select("line").style({opacity:0})})}var ut=it.select("circle").style({stroke:"grey",fill:"none"});I.on("mousemove.radial-guide",function(t,e){var n=o.util.getMousePos(G).radius;ut.attr({r:n}).style({opacity:.5}),nt=r.invert(o.util.getMousePos(G).radius);var i=o.util.convertToCartesian(n,h.radialAxis.orientation);st.text(o.util.round(nt)).move([i[0]+b[0],i[1]+b[1]])}).on("mouseout.radial-guide",function(t,e){ut.style({opacity:0}),lt.hide(),ot.hide(),st.hide()}),t.selectAll(".geometry-group .mark").on("mouseover.tooltip",function(e,r){var i=n.select(this),a=this.style.fill,s="black",l=this.style.opacity||1;if(i.attr({"data-opacity":l}),a&&"none"!==a){i.attr({"data-fill":a}),s=n.hsl(a).darker().toString(),i.style({fill:s,opacity:1});var c={t:o.util.round(e[0]),r:o.util.round(e[1])};k&&(c.t=_[e[0]]);var u="t: "+c.t+", r: "+c.r,f=this.getBoundingClientRect(),h=t.node().getBoundingClientRect(),p=[f.left+f.width/2-j[0]-h.left,f.top+f.height/2-j[1]-h.top];lt.config({color:s}).text(u),lt.move(p)}else a=this.style.stroke||"black",i.attr({"data-stroke":a}),s=n.hsl(a).darker().toString(),i.style({stroke:s,opacity:1})}).on("mousemove.tooltip",function(t,e){if(0!=n.event.which)return!1;n.select(this).attr("data-fill")&<.show()}).on("mouseout.tooltip",function(t,e){lt.hide();var r=n.select(this),i=r.attr("data-fill");i?r.style({fill:i,opacity:r.attr("data-opacity")}):r.style({stroke:r.attr("data-stroke"),opacity:r.attr("data-opacity")})})})}(c),this},h.config=function(t){if(!arguments.length)return l;var e=o.util.cloneJson(t);return e.data.forEach(function(t,e){l.data[e]||(l.data[e]={}),i(l.data[e],o.Axis.defaultConfig().data[0]),i(l.data[e],t)}),i(l.layout,o.Axis.defaultConfig().layout),i(l.layout,e.layout),this},h.getLiveConfig=function(){return u},h.getinputConfig=function(){return c},h.radialScale=function(t){return r},h.angularScale=function(t){return s},h.svg=function(){return t},n.rebind(h,f,"on"),h},o.Axis.defaultConfig=function(t,e){return{data:[{t:[1,2,3,4],r:[10,11,12,13],name:"Line1",geometry:"LinePlot",color:null,strokeDash:"solid",strokeColor:null,strokeSize:"1",visibleInLegend:!0,opacity:1}],layout:{defaultColorRange:n.scale.category10().range(),title:null,height:450,width:500,margin:{top:40,right:40,bottom:40,left:40},font:{size:12,color:"gray",outlineColor:"white",family:"Tahoma, sans-serif"},direction:"clockwise",orientation:0,labelOffset:10,radialAxis:{domain:null,orientation:-45,ticksSuffix:"",visible:!0,gridLinesVisible:!0,tickOrientation:"horizontal",rewriteTicks:null},angularAxis:{domain:[0,360],ticksSuffix:"",visible:!0,gridLinesVisible:!0,labelsVisible:!0,tickOrientation:"horizontal",rewriteTicks:null,ticksCount:null,ticksStep:null},minorTicks:0,tickLength:null,tickColor:"silver",minorTickColor:"#eee",backgroundColor:"none",needsEndSpacing:null,showLegend:!0,legend:{reverseOrder:!1},opacity:1}}},o.util={},o.DATAEXTENT="dataExtent",o.AREA="AreaChart",o.LINE="LinePlot",o.DOT="DotPlot",o.BAR="BarChart",o.util._override=function(t,e){for(var r in t)r in e&&(e[r]=t[r])},o.util._extend=function(t,e){for(var r in t)e[r]=t[r]},o.util._rndSnd=function(){return 2*Math.random()-1+(2*Math.random()-1)+(2*Math.random()-1)},o.util.dataFromEquation2=function(t,e){var r=e||6;return n.range(0,360+r,r).map(function(e,r){var n=e*Math.PI/180;return[e,t(n)]})},o.util.dataFromEquation=function(t,e,r){var i=e||6,a=[],o=[];n.range(0,360+i,i).forEach(function(e,r){var n=e*Math.PI/180,i=t(n);a.push(e),o.push(i)});var s={t:a,r:o};return r&&(s.name=r),s},o.util.ensureArray=function(t,e){if(void 0===t)return null;var r=[].concat(t);return n.range(e).map(function(t,e){return r[e]||r[0]})},o.util.fillArrays=function(t,e,r){return e.forEach(function(e,n){t[e]=o.util.ensureArray(t[e],r)}),t},o.util.cloneJson=function(t){return JSON.parse(JSON.stringify(t))},o.util.validateKeys=function(t,e){"string"==typeof e&&(e=e.split("."));var r=e.shift();return t[r]&&(!e.length||objHasKeys(t[r],e))},o.util.sumArrays=function(t,e){return n.zip(t,e).map(function(t,e){return n.sum(t)})},o.util.arrayLast=function(t){return t[t.length-1]},o.util.arrayEqual=function(t,e){for(var r=Math.max(t.length,e.length,1);r-- >=0&&t[r]===e[r];);return-2===r},o.util.flattenArray=function(t){for(var e=[];!o.util.arrayEqual(e,t);)e=t,t=[].concat.apply([],t);return t},o.util.deduplicate=function(t){return t.filter(function(t,e,r){return r.indexOf(t)==e})},o.util.convertToCartesian=function(t,e){var r=e*Math.PI/180;return[t*Math.cos(r),t*Math.sin(r)]},o.util.round=function(t,e){var r=e||2,n=Math.pow(10,r);return Math.round(t*n)/n},o.util.getMousePos=function(t){var e=n.mouse(t.node()),r=e[0],i=e[1],a={};return a.x=r,a.y=i,a.pos=e,a.angle=180*(Math.atan2(i,r)+Math.PI)/Math.PI,a.radius=Math.sqrt(r*r+i*i),a},o.util.duplicatesCount=function(t){for(var e,r={},n={},i=0,a=t.length;i0)){var l=n.select(this.parentNode).selectAll("path.line").data([0]);l.enter().insert("path"),l.attr({class:"line",d:u(s),transform:function(t,r){return"rotate("+(e.orientation+90)+")"},"pointer-events":"none"}).style({fill:function(t,e){return d.fill(r,i,a)},"fill-opacity":0,stroke:function(t,e){return d.stroke(r,i,a)},"stroke-width":function(t,e){return d["stroke-width"](r,i,a)},"stroke-dasharray":function(t,e){return d["stroke-dasharray"](r,i,a)},opacity:function(t,e){return d.opacity(r,i,a)},display:function(t,e){return d.display(r,i,a)}})}};var f=e.angularScale.range(),h=Math.abs(f[1]-f[0])/o[0].length*Math.PI/180,p=n.svg.arc().startAngle(function(t){return-h/2}).endAngle(function(t){return h/2}).innerRadius(function(t){return e.radialScale(l+(t[2]||0))}).outerRadius(function(t){return e.radialScale(l+(t[2]||0))+e.radialScale(t[1])});c.arc=function(t,r,i){n.select(this).attr({class:"mark arc",d:p,transform:function(t,r){return"rotate("+(e.orientation+s(t[0])+90)+")"}})};var d={fill:function(e,r,n){return t[n].data.color},stroke:function(e,r,n){return t[n].data.strokeColor},"stroke-width":function(e,r,n){return t[n].data.strokeSize+"px"},"stroke-dasharray":function(e,n,i){return r[t[i].data.strokeDash]},opacity:function(e,r,n){return t[n].data.opacity},display:function(e,r,n){return void 0===t[n].data.visible||t[n].data.visible?"block":"none"}},g=n.select(this).selectAll("g.layer").data(o);g.enter().append("g").attr({class:"layer"});var m=g.selectAll("path.mark").data(function(t,e){return t});m.enter().append("path").attr({class:"mark"}),m.style(d).each(c[e.geometryType]),m.exit().remove(),g.exit().remove()})}return a.config=function(e){return arguments.length?(e.forEach(function(e,r){t[r]||(t[r]={}),i(t[r],o.PolyChart.defaultConfig()),i(t[r],e)}),this):t},a.getColorScale=function(){},n.rebind(a,e,"on"),a},o.PolyChart.defaultConfig=function(){return{data:{name:"geom1",t:[[1,2,3,4]],r:[[1,2,3,4]],dotType:"circle",dotSize:64,dotVisible:!1,barWidth:20,color:"#ffa500",strokeSize:1,strokeColor:"silver",strokeDash:"solid",opacity:1,index:0,visible:!0,visibleInLegend:!0},geometryConfig:{geometry:"LinePlot",geometryType:"arc",direction:"clockwise",orientation:0,container:"body",radialScale:null,angularScale:null,colorScale:n.scale.category20()}}},o.BarChart=function(){return o.PolyChart()},o.BarChart.defaultConfig=function(){return{geometryConfig:{geometryType:"bar"}}},o.AreaChart=function(){return o.PolyChart()},o.AreaChart.defaultConfig=function(){return{geometryConfig:{geometryType:"arc"}}},o.DotPlot=function(){return o.PolyChart()},o.DotPlot.defaultConfig=function(){return{geometryConfig:{geometryType:"dot",dotType:"circle"}}},o.LinePlot=function(){return o.PolyChart()},o.LinePlot.defaultConfig=function(){return{geometryConfig:{geometryType:"line"}}},o.Legend=function(){var t=o.Legend.defaultConfig(),e=n.dispatch("hover");function r(){var e=t.legendConfig,a=t.data.map(function(t,r){return[].concat(t).map(function(t,n){var a=i({},e.elements[r]);return a.name=t,a.color=[].concat(e.elements[r].color)[n],a})}),o=n.merge(a);o=o.filter(function(t,r){return e.elements[r]&&(e.elements[r].visibleInLegend||void 0===e.elements[r].visibleInLegend)}),e.reverseOrder&&(o=o.reverse());var s=e.container;("string"==typeof s||s.nodeName)&&(s=n.select(s));var l=o.map(function(t,e){return t.color}),c=e.fontSize,u=null==e.isContinuous?"number"==typeof o[0]:e.isContinuous,f=u?e.height:c*o.length,h=s.classed("legend-group",!0).selectAll("svg").data([0]),p=h.enter().append("svg").attr({width:300,height:f+c,xmlns:"http://www.w3.org/2000/svg","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1"});p.append("g").classed("legend-axis",!0),p.append("g").classed("legend-marks",!0);var d=n.range(o.length),g=n.scale[u?"linear":"ordinal"]().domain(d).range(l),m=n.scale[u?"linear":"ordinal"]().domain(d)[u?"range":"rangePoints"]([0,f]);if(u){var v=h.select(".legend-marks").append("defs").append("linearGradient").attr({id:"grad1",x1:"0%",y1:"0%",x2:"0%",y2:"100%"}).selectAll("stop").data(l);v.enter().append("stop"),v.attr({offset:function(t,e){return e/(l.length-1)*100+"%"}}).style({"stop-color":function(t,e){return t}}),h.append("rect").classed("legend-mark",!0).attr({height:e.height,width:e.colorBandWidth,fill:"url(#grad1)"})}else{var y=h.select(".legend-marks").selectAll("path.legend-mark").data(o);y.enter().append("path").classed("legend-mark",!0),y.attr({transform:function(t,e){return"translate("+[c/2,m(e)+c/2]+")"},d:function(t,e){var r,i,a,o=t.symbol;return a=3*(i=c),"line"===(r=o)?"M"+[[-i/2,-i/12],[i/2,-i/12],[i/2,i/12],[-i/2,i/12]]+"Z":-1!=n.svg.symbolTypes.indexOf(r)?n.svg.symbol().type(r).size(a)():n.svg.symbol().type("square").size(a)()},fill:function(t,e){return g(e)}}),y.exit().remove()}var x=n.svg.axis().scale(m).orient("right"),b=h.select("g.legend-axis").attr({transform:"translate("+[u?e.colorBandWidth:c,c/2]+")"}).call(x);return b.selectAll(".domain").style({fill:"none",stroke:"none"}),b.selectAll("line").style({fill:"none",stroke:u?e.textColor:"none"}),b.selectAll("text").style({fill:e.textColor,"font-size":e.fontSize}).text(function(t,e){return o[e].name}),r}return r.config=function(e){return arguments.length?(i(t,e),this):t},n.rebind(r,e,"on"),r},o.Legend.defaultConfig=function(t,e){return{data:["a","b","c"],legendConfig:{elements:[{symbol:"line",color:"red"},{symbol:"square",color:"yellow"},{symbol:"diamond",color:"limegreen"}],height:150,colorBandWidth:30,fontSize:12,container:"body",isContinuous:null,textColor:"grey",reverseOrder:!1}}},o.tooltipPanel=function(){var t,e,r,a={container:null,hasTick:!1,fontSize:12,color:"white",padding:5},s="tooltip-"+o.tooltipPanel.uid++,l=10,c=function(){var n=(t=a.container.selectAll("g."+s).data([0])).enter().append("g").classed(s,!0).style({"pointer-events":"none",display:"none"});return r=n.append("path").style({fill:"white","fill-opacity":.9}).attr({d:"M0 0"}),e=n.append("text").attr({dx:a.padding+l,dy:.3*+a.fontSize}),c};return c.text=function(i){var o=n.hsl(a.color).l,s=o>=.5?"#aaa":"white",u=o>=.5?"black":"white",f=i||"";e.style({fill:u,"font-size":a.fontSize+"px"}).text(f);var h=a.padding,p=e.node().getBBox(),d={fill:a.color,stroke:s,"stroke-width":"2px"},g=p.width+2*h+l,m=p.height+2*h;return r.attr({d:"M"+[[l,-m/2],[l,-m/4],[a.hasTick?0:l,0],[l,m/4],[l,m/2],[g,m/2],[g,-m/2]].join("L")+"Z"}).style(d),t.attr({transform:"translate("+[l,-m/2+2*h]+")"}),t.style({display:"block"}),c},c.move=function(e){if(t)return t.attr({transform:"translate("+[e[0],e[1]]+")"}).style({display:"block"}),c},c.hide=function(){if(t)return t.style({display:"none"}),c},c.show=function(){if(t)return t.style({display:"block"}),c},c.config=function(t){return i(a,t),c},c},o.tooltipPanel.uid=1,o.adapter={},o.adapter.plotly=function(){var t={convert:function(t,e){var r={};if(t.data&&(r.data=t.data.map(function(t,r){var n=i({},t);return[[n,["marker","color"],["color"]],[n,["marker","opacity"],["opacity"]],[n,["marker","line","color"],["strokeColor"]],[n,["marker","line","dash"],["strokeDash"]],[n,["marker","line","width"],["strokeSize"]],[n,["marker","symbol"],["dotType"]],[n,["marker","size"],["dotSize"]],[n,["marker","barWidth"],["barWidth"]],[n,["line","interpolation"],["lineInterpolation"]],[n,["showlegend"],["visibleInLegend"]]].forEach(function(t,r){o.util.translator.apply(null,t.concat(e))}),e||delete n.marker,e&&delete n.groupId,e?("LinePlot"===n.geometry?(n.type="scatter",!0===n.dotVisible?(delete n.dotVisible,n.mode="lines+markers"):n.mode="lines"):"DotPlot"===n.geometry?(n.type="scatter",n.mode="markers"):"AreaChart"===n.geometry?n.type="area":"BarChart"===n.geometry&&(n.type="bar"),delete n.geometry):("scatter"===n.type?"lines"===n.mode?n.geometry="LinePlot":"markers"===n.mode?n.geometry="DotPlot":"lines+markers"===n.mode&&(n.geometry="LinePlot",n.dotVisible=!0):"area"===n.type?n.geometry="AreaChart":"bar"===n.type&&(n.geometry="BarChart"),delete n.mode,delete n.type),n}),!e&&t.layout&&"stack"===t.layout.barmode)){var a=o.util.duplicates(r.data.map(function(t,e){return t.geometry}));r.data.forEach(function(t,e){var n=a.indexOf(t.geometry);-1!=n&&(r.data[e].groupId=n)})}if(t.layout){var s=i({},t.layout);if([[s,["plot_bgcolor"],["backgroundColor"]],[s,["showlegend"],["showLegend"]],[s,["radialaxis"],["radialAxis"]],[s,["angularaxis"],["angularAxis"]],[s.angularaxis,["showline"],["gridLinesVisible"]],[s.angularaxis,["showticklabels"],["labelsVisible"]],[s.angularaxis,["nticks"],["ticksCount"]],[s.angularaxis,["tickorientation"],["tickOrientation"]],[s.angularaxis,["ticksuffix"],["ticksSuffix"]],[s.angularaxis,["range"],["domain"]],[s.angularaxis,["endpadding"],["endPadding"]],[s.radialaxis,["showline"],["gridLinesVisible"]],[s.radialaxis,["tickorientation"],["tickOrientation"]],[s.radialaxis,["ticksuffix"],["ticksSuffix"]],[s.radialaxis,["range"],["domain"]],[s.angularAxis,["showline"],["gridLinesVisible"]],[s.angularAxis,["showticklabels"],["labelsVisible"]],[s.angularAxis,["nticks"],["ticksCount"]],[s.angularAxis,["tickorientation"],["tickOrientation"]],[s.angularAxis,["ticksuffix"],["ticksSuffix"]],[s.angularAxis,["range"],["domain"]],[s.angularAxis,["endpadding"],["endPadding"]],[s.radialAxis,["showline"],["gridLinesVisible"]],[s.radialAxis,["tickorientation"],["tickOrientation"]],[s.radialAxis,["ticksuffix"],["ticksSuffix"]],[s.radialAxis,["range"],["domain"]],[s.font,["outlinecolor"],["outlineColor"]],[s.legend,["traceorder"],["reverseOrder"]],[s,["labeloffset"],["labelOffset"]],[s,["defaultcolorrange"],["defaultColorRange"]]].forEach(function(t,r){o.util.translator.apply(null,t.concat(e))}),e?(void 0!==s.tickLength&&(s.angularaxis.ticklen=s.tickLength,delete s.tickLength),s.tickColor&&(s.angularaxis.tickcolor=s.tickColor,delete s.tickColor)):(s.angularAxis&&void 0!==s.angularAxis.ticklen&&(s.tickLength=s.angularAxis.ticklen),s.angularAxis&&void 0!==s.angularAxis.tickcolor&&(s.tickColor=s.angularAxis.tickcolor)),s.legend&&"boolean"!=typeof s.legend.reverseOrder&&(s.legend.reverseOrder="normal"!=s.legend.reverseOrder),s.legend&&"boolean"==typeof s.legend.traceorder&&(s.legend.traceorder=s.legend.traceorder?"reversed":"normal",delete s.legend.reverseOrder),s.margin&&void 0!==s.margin.t){var l=["t","r","b","l","pad"],c=["top","right","bottom","left","pad"],u={};n.entries(s.margin).forEach(function(t,e){u[c[l.indexOf(t.key)]]=t.value}),s.margin=u}e&&(delete s.needsEndSpacing,delete s.minorTickColor,delete s.minorTicks,delete s.angularaxis.ticksCount,delete s.angularaxis.ticksCount,delete s.angularaxis.ticksStep,delete s.angularaxis.rewriteTicks,delete s.angularaxis.nticks,delete s.radialaxis.ticksCount,delete s.radialaxis.ticksCount,delete s.radialaxis.ticksStep,delete s.radialaxis.rewriteTicks,delete s.radialaxis.nticks),r.layout=s}return r}};return t}},{"../../../constants/alignment":632,"../../../lib":660,d3:131}],778:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../../lib"),a=t("../../../components/color"),o=t("./micropolar"),s=t("./undo_manager"),l=i.extendDeepAll,c=e.exports={};c.framework=function(t){var e,r,i,a,u,f=new s;function h(r,s){return s&&(u=s),n.select(n.select(u).node().parentNode).selectAll(".svg-container>*:not(.chart-root)").remove(),e=e?l(e,r):r,i||(i=o.Axis()),a=o.adapter.plotly().convert(e),i.config(a).render(u),t.data=e.data,t.layout=e.layout,c.fillLayout(t),e}return h.isPolar=!0,h.svg=function(){return i.svg()},h.getConfig=function(){return e},h.getLiveConfig=function(){return o.adapter.plotly().convert(i.getLiveConfig(),!0)},h.getLiveScales=function(){return{t:i.angularScale(),r:i.radialScale()}},h.setUndoPoint=function(){var t,n,i=this,a=o.util.cloneJson(e);t=a,n=r,f.add({undo:function(){n&&i(n)},redo:function(){i(t)}}),r=o.util.cloneJson(a)},h.undo=function(){f.undo()},h.redo=function(){f.redo()},h},c.fillLayout=function(t){var e=n.select(t).selectAll(".plot-container"),r=e.selectAll(".svg-container"),i=t.framework&&t.framework.svg&&t.framework.svg(),o={width:800,height:600,paper_bgcolor:a.background,_container:e,_paperdiv:r,_paper:i};t._fullLayout=l(o,t.layout)}},{"../../../components/color":532,"../../../lib":660,"./micropolar":777,"./undo_manager":779,d3:131}],779:[function(t,e,r){"use strict";e.exports=function(){var t,e=[],r=-1,n=!1;function i(t,e){return t?(n=!0,t[e](),n=!1,this):this}return{add:function(t){return n?this:(e.splice(r+1,e.length-r),e.push(t),r=e.length-1,this)},setCallback:function(e){t=e},undo:function(){var n=e[r];return n?(i(n,"undo"),r-=1,t&&t(n.undo),this):this},redo:function(){var n=e[r+1];return n?(i(n,"redo"),r+=1,t&&t(n.redo),this):this},clear:function(){e=[],r=-1},hasUndo:function(){return-1!==r},hasRedo:function(){return r0?1:-1}function F(t){return B(Math.cos(t))}function N(t){return B(Math.sin(t))}e.exports=function(t,e){return new S(t,e)},C.plot=function(t,e){var r=e[this.id];this._hasClipOnAxisFalse=!1;for(var n=0;n=90||s>90&&l>=450?1:u<=0&&h<=0?0:Math.max(u,h);e=s<=180&&l>=180||s>180&&l>=540?-1:c>=0&&f>=0?0:Math.min(c,f);r=s<=270&&l>=270||s>270&&l>=630?-1:u>=0&&h>=0?0:Math.min(u,h);n=l>=360?1:c<=0&&f<=0?0:Math.max(c,f);return[e,r,n,i]}(v),x=y[2]-y[0],b=y[3]-y[1],w=m/g,M=Math.abs(b/x);w>M?(c=g,d=(m-(f=g*M))/i.h/2,h=[a[0],a[1]],p=[o[0]+d,o[1]-d]):(f=m,d=(g-(c=m/M))/i.w/2,h=[a[0]+d,a[1]-d],p=[o[0],o[1]]),r.xLength2=c,r.yLength2=f,r.xDomain2=h,r.yDomain2=p;var A=r.xOffset2=i.l+i.w*h[0],T=r.yOffset2=i.t+i.h*(1-p[1]),S=r.radius=c/x,C=r.cx=A-S*y[0],E=r.cy=T+S*y[3],L=r.cxx=C-A,z=r.cyy=E-T;r.updateRadialAxis(t,e),r.updateRadialAxisTitle(t,e),r.updateAngularAxis(t,e);var D=r.radialAxis.range,O=D[1]-D[0],R=r.xaxis={type:"linear",_id:"x",range:[y[0]*O,y[2]*O],domain:h};u.setConvert(R,t),R.setScale();var B=r.yaxis={type:"linear",_id:"y",range:[y[1]*O,y[3]*O],domain:p};u.setConvert(B,t),B.setScale(),R.isPtWithinRange=function(t){return r.isPtWithinSector(t)},B.isPtWithinRange=function(){return!0},n.frontplot.attr("transform",I(A,T)).call(l.setClipUrl,r._hasClipOnAxisFalse?null:r.clipIds.circle),n.bgcircle.attr({d:P(S,v),transform:I(C,E)}).call(s.fill,e.bgcolor),r.clipPaths.circle.select("path").attr("d",P(S,v)).attr("transform",I(L,z)),r.framework.selectAll(".crisp").classed("crisp",0)},C.updateRadialAxis=function(t,e){var r=this.gd,n=this.layers,i=this.radius,a=this.cx,l=this.cy,c=t._size,h=e.radialaxis,p=e.sector,d=k(p[0]);this.fillViewInitialKey("radialaxis.angle",h.angle);var g=this.radialAxis=o.extendFlat({},h,{_axislayer:n["radial-axis"],_gridlayer:n["radial-grid"],_id:"x",_pos:0,side:{counterclockwise:"top",clockwise:"bottom"}[h.side],domain:[0,i/c.w],anchor:"free",position:0,_counteraxis:!0,automargin:!1});E(g,h,t),f(g),h.range=g.range.slice(),h._input.range=g.range.slice(),this.fillViewInitialKey("radialaxis.range",g.range.slice()),"auto"===g.tickangle&&d>90&&d<=270&&(g.tickangle=180),g._transfn=function(t){return"translate("+g.l2p(t.x)+",0)"},g._gridpath=function(t){return z(g.r2p(t.x),p)};var m=L(h);this.radialTickLayout!==m&&(n["radial-axis"].selectAll(".xtick").remove(),this.radialTickLayout=m),u.doTicksSingle(r,g,!0),O(n["radial-axis"],h.showticklabels||h.ticks,{transform:I(a,l)+R(-h.angle)}),O(n["radial-grid"],h.showgrid,{transform:I(a,l)}).selectAll("path").attr("transform",null),O(n["radial-line"].select("line"),h.showline,{x1:0,y1:0,x2:i,y2:0,transform:I(a,l)+R(-h.angle)}).attr("stroke-width",h.linewidth).call(s.stroke,h.linecolor)},C.updateRadialAxisTitle=function(t,e,r){var n=this.gd,i=this.radius,a=this.cx,o=this.cy,s=e.radialaxis,c=this.id+"title",u=void 0!==r?r:s.angle,f=_(u),h=Math.cos(f),p=Math.sin(f),d=0;if(s.title){var m=l.bBox(this.layers["radial-axis"].node()).height,v=s.titlefont.size;d="counterclockwise"===s.side?-m-.4*v:m+.8*v}this.layers["radial-axis-title"]=g.draw(n,c,{propContainer:s,propName:this.id+".radialaxis.title",placeholder:b(n,"Click to enter radial axis title"),attributes:{x:a+i/2*h+d*p,y:o-i/2*p+d*h,"text-anchor":"middle"},transform:{rotate:-u}})},C.updateAngularAxis=function(t,e){var r=this,i=r.gd,a=r.layers,l=r.radius,c=r.cx,f=r.cy,h=e.angularaxis,p=e.sector,d=p.map(_);r.fillViewInitialKey("angularaxis.rotation",h.rotation);var g=r.angularAxis=o.extendFlat({},h,{_axislayer:a["angular-axis"],_gridlayer:a["angular-grid"],_id:"angular",_pos:0,side:"right",domain:[0,Math.PI],anchor:"free",position:0,_counteraxis:!0,automargin:!1,autorange:!1});if("linear"===g.type)D(p)?g.range=p.slice():g.range=d.map(g.unTransformRad).map(w),"radians"===g.thetaunit&&(g.tick0=w(g.tick0),g.dtick=w(g.dtick));else if("category"===g.type){var m=h.period?Math.max(h.period,h._categories.length):h._categories.length;g.range=[0,m],g._tickFilter=function(t){return r.isPtWithinSector({r:r.radialAxis.range[1],rad:g.c2rad(t.x)})}}function v(t){return g.c2rad(t.x,"degrees")}function y(t){return[l*Math.cos(t),l*Math.sin(t)]}E(g,h,t),g._transfn=function(t){var e=v(t),r=y(e),i=I(c+r[0],f-r[1]),a=n.select(this);return a&&a.node()&&a.classed("ticks")&&(i+=R(-w(e))),i},g._gridpath=function(t){var e=y(v(t));return"M0,0L"+-e[0]+","+e[1]};var b="outside"!==h.ticks?.7:.5;g._labelx=function(t){var e=v(t),r=g._labelStandoff,n=g._pad;return(0===N(e)?0:Math.cos(e)*(r+n+b*t.fontSize))+F(e)*(t.dx+r+n)},g._labely=function(t){var e=v(t),r=g._labelStandoff,n=g._labelShift,i=g._pad;return t.dy+t.fontSize*x-n+-Math.sin(e)*(r+i+b*t.fontSize)},g._labelanchor=function(t,e){var r=v(e);return 0===N(r)?F(r)>0?"start":"end":"middle"};var k=L(h);r.angularTickLayout!==k&&(a["angular-axis"].selectAll(".angulartick").remove(),r.angularTickLayout=k),u.doTicksSingle(i,g,!0),O(a["angular-line"].select("path"),h.showline,{d:P(l,p),transform:I(c,f)}).attr("stroke-width",h.linewidth).call(s.stroke,h.linecolor)},C.updateFx=function(t,e){this.gd._context.staticPlot||(this.updateAngularDrag(t,e),this.updateRadialDrag(t,e),this.updateMainDrag(t,e))},C.updateMainDrag=function(t,e){var r=this,o=r.gd,s=r.layers,l=t._zoomlayer,c=T.MINZOOM,u=T.OFFEDGE,f=r.radius,g=r.cx,y=r.cy,x=r.cxx,b=r.cyy,_=e.sector,w=p.makeDragger(s,"path","maindrag","crosshair");n.select(w).attr("d",P(f,_)).attr("transform",I(g,y));var k,M,A,S,C,E,L,z,D,O={element:w,gd:o,subplot:r.id,plotinfo:{xaxis:r.xaxis,yaxis:r.yaxis},xaxes:[r.xaxis],yaxes:[r.yaxis]};function R(t,e){var r=t-x,n=e-b;return Math.sqrt(r*r+n*n)}function B(t,e){return Math.atan2(b-e,t-x)}function F(t,e){return[t*Math.cos(e),t*Math.sin(-e)]}function N(t,e){var r=T.cornerLen,n=T.cornerHalfWidth;if(0===t)return P(2*n,_);var i=r/t/2,a=e-i,o=e+i,s=Math.max(0,Math.min(t,f)),l=s-n,c=s+n;return"M"+F(l,a)+"A"+[l,l]+" 0,0,0 "+F(l,o)+"L"+F(c,o)+"A"+[c,c]+" 0,0,1 "+F(c,a)+"Z"}function j(t,e){var r,n,i=k+t,a=M+e,o=R(k,M),s=Math.min(R(i,a),f),l=B(k,M),h=B(i,a);oc?(o0==h>y[0]){S=d.range[1]=h,u.doTicksSingle(i,r.radialAxis,!0),s["radial-grid"].attr("transform",I(c,f)).selectAll("path").attr("transform",null);var p=S-y[0],g=r.sectorBBox;for(var v in r.xaxis.range=[g[0]*p,g[2]*p],r.yaxis.range=[g[1]*p,g[3]*p],r.xaxis.setScale(),r.yaxis.setScale(),r.traceHash){var b=r.traceHash[v],_=o.filterVisible(b),w=b[0][0].trace._module,k=i._fullLayout[r.id];if(w.plot(i,r,_,k),!a.traceIs(v,"gl"))for(var M=0;M<_.length;M++)w.style(i,_[M])}}}},C.updateAngularDrag=function(t,e){var r=this,i=r.gd,s=r.layers,c=r.radius,f=r.cx,d=r.cy,g=r.cxx,m=r.cyy,x=e.sector,b=T.angularDragBoxSize,k=p.makeDragger(s,"path","angulardrag","move"),S={element:k,gd:i};function C(t,e){return Math.atan2(m+b-e,t-g-b)}n.select(k).attr("d",function(t,e,r){var n,i,a,o=Math.abs(r[1]-r[0])<=180?0:1;function s(t,e){return[t*Math.cos(e),-t*Math.sin(e)]}function l(t,e,r){return"A"+[t,t]+" "+[0,o,r]+" "+s(t,e)}return D(r)?(n=0,a=2*Math.PI,i=Math.PI,"M"+s(t,n)+l(t,i,0)+l(t,a,0)+"ZM"+s(e,n)+l(e,i,1)+l(e,a,1)+"Z"):(n=_(r[0]),a=_(r[1]),"M"+s(t,n)+"L"+s(e,n)+l(e,a,0)+"L"+s(t,a)+l(t,n,1)+"Z")}(c,c+b,x)).attr("transform",I(f,d)).call(y,"move");var E,L,z,P,O,B,F=s.frontplot.select(".scatterlayer").selectAll(".trace"),N=F.selectAll(".point"),j=F.selectAll(".textpoint");function V(t,e){var c=C(E+t,L+e),f=w(c-B);P=z+f,s.frontplot.attr("transform",I(r.xOffset2,r.yOffset2)+R([-f,g,m])),r.clipPaths.circle.select("path").attr("transform",I(g,m)+R(f)),N.each(function(){var t=n.select(this),e=l.getTranslate(t);t.attr("transform",I(e.x,e.y)+R([f]))}),j.each(function(){var t=n.select(this),e=t.select("text"),r=l.getTranslate(t);t.attr("transform",R([f,e.attr("x"),e.attr("y")])+I(r.x,r.y))});var h=r.angularAxis;for(var p in h.rotation=M(P),"linear"!==h.type||D(x)||(h.range=O.map(_).map(h.unTransformRad).map(w)),A(h),u.doTicksSingle(i,h,!0),r._hasClipOnAxisFalse&&!D(x)&&(r.sector=[O[0]-f,O[1]-f],F.call(l.hideOutsideRangePoints,r)),r.traceHash)if(a.traceIs(p,"gl")){var d=r.traceHash[p],v=o.filterVisible(d),y=d[0][0].trace._module,b=i._fullLayout[r.id];y.plot(i,r,v,b)}}function U(){j.select("text").attr("transform",null);var t={};t[r.id+".angularaxis.rotation"]=P,a.call("relayout",i,t)}S.prepFn=function(e,n,i){var a=t[r.id];O=a.sector.slice(),z=a.angularaxis.rotation;var o=k.getBoundingClientRect();E=n-o.left,L=i-o.top,B=C(E,L),S.moveFn=V,S.doneFn=U,v(t._zoomlayer)},h.init(S)},C.isPtWithinSector=function(t){var e=this.sector,r=this.radialAxis,n=r.range,i=r.c2r(t.r),a=k(e[0]),o=k(e[1]);a>o&&(o+=360);var s,l,c=k(w(t.rad)),u=c+360;return n[1]>=n[0]?(s=n[0],l=n[1]):(s=n[1],l=n[0]),i>=s&&i<=l&&(D(e)||c>=a&&c<=o||u>=a&&u<=o)},C.fillViewInitialKey=function(t,e){t in this.viewInitial||(this.viewInitial[t]=e)}},{"../../components/color":532,"../../components/dragelement":554,"../../components/drawing":557,"../../components/fx":574,"../../components/titles":625,"../../constants/alignment":632,"../../lib":660,"../../lib/setcursor":680,"../../registry":790,"../cartesian/autorange":705,"../cartesian/axes":706,"../cartesian/dragbox":714,"../cartesian/select":723,"../plots":768,"./constants":769,"./helpers":770,d3:131,tinycolor2:473}],781:[function(t,e,r){"use strict";function n(t,e){return"splom"===t?-1:"splom"===e?1:0}e.exports={sortBasePlotModules:function(t,e){return n(t.name,e.name)},sortModules:n}},{}],782:[function(t,e,r){"use strict";var n=t("../lib"),i=t("./domain").defaults;e.exports=function(t,e,r,a){var o,s,l=a.type,c=a.attributes,u=a.handleDefaults,f=a.partition||"x",h=e._subplots[l],p=h.length;function d(t,e){return n.coerce(o,s,c,t,e)}for(var g=0;g=f&&(p.min=0,d.min=0,g.min=0,t.aaxis&&delete t.aaxis.min,t.baxis&&delete t.baxis.min,t.caxis&&delete t.caxis.min)}e.exports=function(t,e,r){i(t,e,r,{type:"ternary",attributes:a,handleDefaults:l,font:e.font,paper_bgcolor:e.paper_bgcolor})}},{"../../../components/color":532,"../../subplot_defaults":782,"./axis_defaults":786,"./layout_attributes":788}],788:[function(t,e,r){"use strict";var n=t("../../../components/color/attributes"),i=t("../../domain").attributes,a=t("./axis_attributes"),o=t("../../../plot_api/edit_types").overrideAll;e.exports=o({domain:i({name:"ternary"}),bgcolor:{valType:"color",dflt:n.background},sum:{valType:"number",dflt:1,min:0},aaxis:a,baxis:a,caxis:a},"plot","from-root")},{"../../../components/color/attributes":531,"../../../plot_api/edit_types":691,"../../domain":731,"./axis_attributes":785}],789:[function(t,e,r){"use strict";var n=t("d3"),i=t("tinycolor2"),a=t("../../registry"),o=t("../../lib"),s=o._,l=t("../../components/color"),c=t("../../components/drawing"),u=t("../cartesian/set_convert"),f=t("../../lib/extend").extendFlat,h=t("../plots"),p=t("../cartesian/axes"),d=t("../../components/dragelement"),g=t("../../components/fx"),m=t("../../components/titles"),v=t("../cartesian/select").prepSelect,y=t("../cartesian/select").clearSelect,x=t("../cartesian/constants");function b(t,e){this.id=t.id,this.graphDiv=t.graphDiv,this.init(e),this.makeFramework(e)}e.exports=b;var _=b.prototype;_.init=function(t){this.container=t._ternarylayer,this.defs=t._defs,this.layoutId=t._uid,this.traceHash={},this.layers={}},_.plot=function(t,e){var r=e[this.id],n=e._size;this._hasClipOnAxisFalse=!1;for(var i=0;iw*x?i=(a=x)*w:a=(i=y)/w,o=m*i/y,s=v*a/x,r=e.l+e.w*d-i/2,n=e.t+e.h*(1-g)-a/2,h.x0=r,h.y0=n,h.w=i,h.h=a,h.sum=b,h.xaxis={type:"linear",range:[_+2*M-b,b-_-2*k],domain:[d-o/2,d+o/2],_id:"x"},u(h.xaxis,h.graphDiv._fullLayout),h.xaxis.setScale(),h.xaxis.isPtWithinRange=function(t){return t.a>=h.aaxis.range[0]&&t.a<=h.aaxis.range[1]&&t.b>=h.baxis.range[1]&&t.b<=h.baxis.range[0]&&t.c>=h.caxis.range[1]&&t.c<=h.caxis.range[0]},h.yaxis={type:"linear",range:[_,b-k-M],domain:[g-s/2,g+s/2],_id:"y"},u(h.yaxis,h.graphDiv._fullLayout),h.yaxis.setScale(),h.yaxis.isPtWithinRange=function(){return!0};var A=h.yaxis.domain[0],T=h.aaxis=f({},t.aaxis,{visible:!0,range:[_,b-k-M],side:"left",_counterangle:30,tickangle:(+t.aaxis.tickangle||0)-30,domain:[A,A+s*w],_axislayer:h.layers.aaxis,_gridlayer:h.layers.agrid,_pos:0,_id:"y",_length:i,_gridpath:"M0,0l"+a+",-"+i/2,automargin:!1});u(T,h.graphDiv._fullLayout),T.setScale();var S=h.baxis=f({},t.baxis,{visible:!0,range:[b-_-M,k],side:"bottom",_counterangle:30,domain:h.xaxis.domain,_axislayer:h.layers.baxis,_gridlayer:h.layers.bgrid,_counteraxis:h.aaxis,_pos:0,_id:"x",_length:i,_gridpath:"M0,0l-"+i/2+",-"+a,automargin:!1});u(S,h.graphDiv._fullLayout),S.setScale(),T._counteraxis=S;var C=h.caxis=f({},t.caxis,{visible:!0,range:[b-_-k,M],side:"right",_counterangle:30,tickangle:(+t.caxis.tickangle||0)+30,domain:[A,A+s*w],_axislayer:h.layers.caxis,_gridlayer:h.layers.cgrid,_counteraxis:h.baxis,_pos:0,_id:"y",_length:i,_gridpath:"M0,0l-"+a+","+i/2,automargin:!1});u(C,h.graphDiv._fullLayout),C.setScale();var E="M"+r+","+(n+a)+"h"+i+"l-"+i/2+",-"+a+"Z";h.clipDef.select("path").attr("d",E),h.layers.plotbg.select("path").attr("d",E);var L="M0,"+a+"h"+i+"l-"+i/2+",-"+a+"Z";h.clipDefRelative.select("path").attr("d",L);var z="translate("+r+","+n+")";h.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform",z),h.clipDefRelative.select("path").attr("transform",null);var P="translate("+(r-S._offset)+","+(n+a)+")";h.layers.baxis.attr("transform",P),h.layers.bgrid.attr("transform",P);var D="translate("+(r+i/2)+","+n+")rotate(30)translate(0,"+-T._offset+")";h.layers.aaxis.attr("transform",D),h.layers.agrid.attr("transform",D);var O="translate("+(r+i/2)+","+n+")rotate(-30)translate(0,"+-C._offset+")";h.layers.caxis.attr("transform",O),h.layers.cgrid.attr("transform",O),h.drawAxes(!0),h.plotContainer.selectAll(".crisp").classed("crisp",!1),h.layers.aline.select("path").attr("d",T.showline?"M"+r+","+(n+a)+"l"+i/2+",-"+a:"M0,0").call(l.stroke,T.linecolor||"#000").style("stroke-width",(T.linewidth||0)+"px"),h.layers.bline.select("path").attr("d",S.showline?"M"+r+","+(n+a)+"h"+i:"M0,0").call(l.stroke,S.linecolor||"#000").style("stroke-width",(S.linewidth||0)+"px"),h.layers.cline.select("path").attr("d",C.showline?"M"+(r+i/2)+","+n+"l"+i/2+","+a:"M0,0").call(l.stroke,C.linecolor||"#000").style("stroke-width",(C.linewidth||0)+"px"),h.graphDiv._context.staticPlot||h.initInteractions(),c.setClipUrl(h.layers.frontplot,h._hasClipOnAxisFalse?null:h.clipId)},_.drawAxes=function(t){var e=this.graphDiv,r=this.id.substr(7)+"title",n=this.aaxis,i=this.baxis,a=this.caxis;if(p.doTicksSingle(e,n,!0),p.doTicksSingle(e,i,!0),p.doTicksSingle(e,a,!0),t){var o=Math.max(n.showticklabels?n.tickfont.size/2:0,(a.showticklabels?.75*a.tickfont.size:0)+("outside"===a.ticks?.87*a.ticklen:0));this.layers["a-title"]=m.draw(e,"a"+r,{propContainer:n,propName:this.id+".aaxis.title",placeholder:s(e,"Click to enter Component A title"),attributes:{x:this.x0+this.w/2,y:this.y0-n.titlefont.size/3-o,"text-anchor":"middle"}});var l=(i.showticklabels?i.tickfont.size:0)+("outside"===i.ticks?i.ticklen:0)+3;this.layers["b-title"]=m.draw(e,"b"+r,{propContainer:i,propName:this.id+".baxis.title",placeholder:s(e,"Click to enter Component B title"),attributes:{x:this.x0-l,y:this.y0+this.h+.83*i.titlefont.size+l,"text-anchor":"middle"}}),this.layers["c-title"]=m.draw(e,"c"+r,{propContainer:a,propName:this.id+".caxis.title",placeholder:s(e,"Click to enter Component C title"),attributes:{x:this.x0+this.w+l,y:this.y0+this.h+.83*a.titlefont.size+l,"text-anchor":"middle"}})}};var k=x.MINZOOM/2+.87,M="m-0.87,.5h"+k+"v3h-"+(k+5.2)+"l"+(k/2+2.6)+",-"+(.87*k+4.5)+"l2.6,1.5l-"+k/2+","+.87*k+"Z",A="m0.87,.5h-"+k+"v3h"+(k+5.2)+"l-"+(k/2+2.6)+",-"+(.87*k+4.5)+"l-2.6,1.5l"+k/2+","+.87*k+"Z",T="m0,1l"+k/2+","+.87*k+"l2.6,-1.5l-"+(k/2+2.6)+",-"+(.87*k+4.5)+"l-"+(k/2+2.6)+","+(.87*k+4.5)+"l2.6,1.5l"+k/2+",-"+.87*k+"Z",S="m0.5,0.5h5v-2h-5v-5h-2v5h-5v2h5v5h2Z",C=!0;function E(t){n.select(t).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove()}_.initInteractions=function(){var t,e,r,n,u,f,h,p,m,b,_=this,k=_.layers.plotbg.select("path").node(),L=_.graphDiv,z=L._fullLayout._zoomlayer,P={element:k,gd:L,plotinfo:{xaxis:_.xaxis,yaxis:_.yaxis},subplot:_.id,prepFn:function(a,o,s){P.xaxes=[_.xaxis],P.yaxes=[_.yaxis];var c=L._fullLayout.dragmode;a.shiftKey&&(c="pan"===c?"zoom":"pan"),P.minDrag="lasso"===c?1:void 0,"zoom"===c?(P.moveFn=R,P.doneFn=B,function(a,o,s){var c=k.getBoundingClientRect();t=o-c.left,e=s-c.top,r={a:_.aaxis.range[0],b:_.baxis.range[1],c:_.caxis.range[1]},u=r,n=_.aaxis.range[1]-r.a,f=i(_.graphDiv._fullLayout[_.id].bgcolor).getLuminance(),h="M0,"+_.h+"L"+_.w/2+", 0L"+_.w+","+_.h+"Z",p=!1,m=z.append("path").attr("class","zoombox").attr("transform","translate("+_.x0+", "+_.y0+")").style({fill:f>.2?"rgba(0,0,0,0)":"rgba(255,255,255,0)","stroke-width":0}).attr("d",h),b=z.append("path").attr("class","zoombox-corners").attr("transform","translate("+_.x0+", "+_.y0+")").style({fill:l.background,stroke:l.defaultLine,"stroke-width":1,opacity:0}).attr("d","M0,0Z"),y(z)}(0,o,s)):"pan"===c?(P.moveFn=F,P.doneFn=N,r={a:_.aaxis.range[0],b:_.baxis.range[1],c:_.caxis.range[1]},u=r,y(z)):"select"!==c&&"lasso"!==c||v(a,o,s,P,c)},clickFn:function(t,e){if(E(L),2===t){var r={};r[_.id+".aaxis.min"]=0,r[_.id+".baxis.min"]=0,r[_.id+".caxis.min"]=0,L.emit("plotly_doubleclick",null),a.call("relayout",L,r)}g.click(L,e,_.id)}};function D(t,e){return 1-e/_.h}function O(t,e){return 1-(t+(_.h-e)/Math.sqrt(3))/_.w}function I(t,e){return(t-(_.h-e)/Math.sqrt(3))/_.w}function R(i,a){var o=t+i,s=e+a,l=Math.max(0,Math.min(1,D(0,e),D(0,s))),c=Math.max(0,Math.min(1,O(t,e),O(o,s))),d=Math.max(0,Math.min(1,I(t,e),I(o,s))),g=(l/2+d)*_.w,v=(1-l/2-c)*_.w,y=(g+v)/2,k=v-g,C=(1-l)*_.h,E=C-k/w;k.2?"rgba(0,0,0,0.4)":"rgba(255,255,255,0.3)").duration(200),b.transition().style("opacity",1).duration(200),p=!0)}function B(){if(E(L),u!==r){var t={};t[_.id+".aaxis.min"]=u.a,t[_.id+".baxis.min"]=u.b,t[_.id+".caxis.min"]=u.c,a.call("relayout",L,t),C&&L.data&&L._context.showTips&&(o.notifier(s(L,"Double-click to zoom back out"),"long"),C=!1)}}function F(t,e){var n=t/_.xaxis._m,i=e/_.yaxis._m,a=[(u={a:r.a-i,b:r.b+(n+i)/2,c:r.c-(n-i)/2}).a,u.b,u.c].sort(),o=a.indexOf(u.a),s=a.indexOf(u.b),l=a.indexOf(u.c);a[0]<0&&(a[1]+a[0]/2<0?(a[2]+=a[0]+a[1],a[0]=a[1]=0):(a[2]+=a[0]/2,a[1]+=a[0]/2,a[0]=0),u={a:a[o],b:a[s],c:a[l]},e=(r.a-u.a)*_.yaxis._m,t=(r.c-u.c-r.b+u.b)*_.xaxis._m);var f="translate("+(_.x0+t)+","+(_.y0+e)+")";_.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform",f);var h="translate("+-t+","+-e+")";_.clipDefRelative.select("path").attr("transform",h),_.aaxis.range=[u.a,_.sum-u.b-u.c],_.baxis.range=[_.sum-u.a-u.c,u.b],_.caxis.range=[_.sum-u.a-u.b,u.c],_.drawAxes(!1),_.plotContainer.selectAll(".crisp").classed("crisp",!1),_._hasClipOnAxisFalse&&_.plotContainer.select(".scatterlayer").selectAll(".trace").call(c.hideOutsideRangePoints,_)}function N(){var t={};t[_.id+".aaxis.min"]=u.a,t[_.id+".baxis.min"]=u.b,t[_.id+".caxis.min"]=u.c,a.call("relayout",L,t)}k.onmousemove=function(t){g.hover(L,t,_.id),L._fullLayout._lasthover=k,L._fullLayout._hoversubplot=_.id},k.onmouseout=function(t){L._dragging||d.unhover(L,t)},d.init(P)}},{"../../components/color":532,"../../components/dragelement":554,"../../components/drawing":557,"../../components/fx":574,"../../components/titles":625,"../../lib":660,"../../lib/extend":649,"../../registry":790,"../cartesian/axes":706,"../cartesian/constants":711,"../cartesian/select":723,"../cartesian/set_convert":724,"../plots":768,d3:131,tinycolor2:473}],790:[function(t,e,r){"use strict";var n=t("./lib/loggers"),i=t("./lib/noop"),a=t("./lib/push_unique"),o=t("./lib/is_plain_object"),s=t("./lib/extend"),l=t("./plots/attributes"),c=t("./plots/layout_attributes"),u=s.extendFlat,f=s.extendDeepAll;function h(t){var e=t.name,i=t.categories,a=t.meta;if(r.modules[e])n.log("Type "+e+" already registered");else{r.subplotsRegistry[t.basePlotModule.name]||function(t){var e=t.name;if(r.subplotsRegistry[e])return void n.log("Plot type "+e+" already registered.");for(var i in m(t),r.subplotsRegistry[e]=t,r.componentsRegistry)x(i,t.name)}(t.basePlotModule);for(var o={},s=0;s-1&&(u[h[r]].title="");for(r=0;r")?"":e.html(t).text()});return e.remove(),r}(_),_=(_=_.replace(/&(?!\w+;|\#[0-9]+;| \#x[0-9A-F]+;)/g,"&")).replace(c,"'"),i.isIE()&&(_=(_=(_=_.replace(/"/gi,"'")).replace(/(\('#)([^']*)('\))/gi,'("#$2")')).replace(/(\\')/gi,'"')),_}},{"../components/color":532,"../components/drawing":557,"../constants/xmlns_namespaces":639,"../lib":660,d3:131}],799:[function(t,e,r){"use strict";var n=t("../../lib").mergeArray;e.exports=function(t,e){for(var r=0;ra;if(!o)return e}return void 0!==r?r:t.dflt}(t.size,s,n.size),color:function(t,e,r){return a(e).isValid()?e:void 0!==r?r:t.dflt}(t.color,l,n.color)}}function b(t,e){var r;return Array.isArray(t)?e.01?N:function(t,e){return Math.abs(t-e)>=2?N(t):t>e?Math.ceil(t):Math.floor(t)};C=F(C,A=F(A,C)),L=F(L,E=F(E,L))}o.ensureSingle(z,"path").style("vector-effect","non-scaling-stroke").attr("d","M"+A+","+E+"V"+L+"H"+C+"V"+E+"Z").call(c.setClipUrl,e.layerClipId),function(t,e,r,n,i,a,l,u){var f;function w(e,r,n){var i=o.ensureSingle(e,"text").text(r).attr({class:"bartext bartext-"+f,transform:"","text-anchor":"middle","data-notex":1}).call(c.font,n).call(s.convertToTspans,t);return i}var k=r[0].trace,M=k.orientation,A=function(t,e){var r=b(t.text,e);return _(h,r)}(k,n);if(!A)return;if("none"===(f=function(t,e){var r=b(t.textposition,e);return function(t,e,r){return t.coerceNumber&&(e=+e),-1!==t.values.indexOf(e)?e:void 0!==r?r:t.dflt}(p,r)}(k,n)))return;var T,S,C,E,L,z,P=function(t,e,r){return x(d,t.textfont,e,r)}(k,n,t._fullLayout.font),D=function(t,e,r){return x(g,t.insidetextfont,e,r)}(k,n,P),O=function(t,e,r){return x(m,t.outsidetextfont,e,r)}(k,n,P),I=t._fullLayout.barmode,R="stack"===I||"relative"===I,B=r[n],F=!R||B._outmost,N=Math.abs(a-i)-2*v,j=Math.abs(u-l)-2*v;"outside"===f&&(F||(f="inside"));if("auto"===f)if(F){f="inside",T=w(e,A,D),S=c.bBox(T.node()),C=S.width,E=S.height;var V=C>0&&E>0,U=C<=N&&E<=j,q=C<=j&&E<=N,H="h"===M?N>=C*(j/E):j>=E*(N/C);V&&(U||q||H)?f="inside":(f="outside",T.remove(),T=null)}else f="inside";if(!T&&(T=w(e,A,"outside"===f?O:D),S=c.bBox(T.node()),C=S.width,E=S.height,C<=0||E<=0))return void T.remove();"outside"===f?(z="both"===k.constraintext||"outside"===k.constraintext,L=function(t,e,r,n,i,a,o){var s,l="h"===a?Math.abs(n-r):Math.abs(e-t);l>2*v&&(s=v);var c=1;o&&(c="h"===a?Math.min(1,l/i.height):Math.min(1,l/i.width));var u,f,h,p,d=(i.left+i.right)/2,g=(i.top+i.bottom)/2;u=c*i.width,f=c*i.height,"h"===a?er?(h=(t+e)/2,p=n+s+f/2):(h=(t+e)/2,p=n-s-f/2);return y(d,g,h,p,c,!1)}(i,a,l,u,S,M,z)):(z="both"===k.constraintext||"inside"===k.constraintext,L=function(t,e,r,n,i,a,o){var s,l,c,u,f,h,p,d=i.width,g=i.height,m=(i.left+i.right)/2,x=(i.top+i.bottom)/2,b=Math.abs(e-t),_=Math.abs(n-r);b>2*v&&_>2*v?(b-=2*(f=v),_-=2*f):f=0;d<=b&&g<=_?(h=!1,p=1):d<=_&&g<=b?(h=!0,p=1):dr?(c=(t+e)/2,u=n-f-l/2):(c=(t+e)/2,u=n+f+l/2);return y(m,x,c,u,p,h)}(i,a,l,u,S,M,z));T.attr("transform",L)}(t,z,r,u,A,C,E,L),e.layerClipId&&c.hideOutsideRangePoint(r[u],z.select("text"),f,w,M.xcalendar,M.ycalendar)}else z.remove();function N(t){return 0===k.bargap&&0===k.bargroupgap?n.round(Math.round(t)-B,2):t}});var E=!1===r[0].trace.cliponaxis;c.setClipUrl(A,E?null:e.layerClipId)}),u.getComponentMethod("errorbars","plot")(M,e)}},{"../../components/color":532,"../../components/drawing":557,"../../lib":660,"../../lib/svg_text_utils":684,"../../registry":790,"./attributes":800,d3:131,"fast-isnumeric":197,tinycolor2:473}],808:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n=t.cd,i=t.xaxis,a=t.yaxis,o=[];if(!1===e)for(r=0;rf+c||!n(u))&&(p=!0,g(h,t))}for(var m=0;m1||0===s.bargap&&0===s.bargroupgap&&!t[0].trace.marker.line.width)&&n.select(this).attr("shape-rendering","crispEdges")}),r.selectAll("g.points").each(function(e){o(n.select(this),e[0].trace,t)}),a.getComponentMethod("errorbars","style")(r)},styleOnSelect:function(t,e){var r=e[0].node3,n=e[0].trace;n.selectedpoints?(i.selectedPointStyle(r.selectAll("path"),n),i.selectedTextStyle(r.selectAll("text"),n)):o(r,n,t)}}},{"../../components/drawing":557,"../../registry":790,d3:131}],812:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults");e.exports=function(t,e,r,o,s){r("marker.color",o),i(t,"marker")&&a(t,e,s,r,{prefix:"marker.",cLetter:"c"}),r("marker.line.color",n.defaultLine),i(t,"marker.line")&&a(t,e,s,r,{prefix:"marker.line.",cLetter:"c"}),r("marker.line.width"),r("marker.opacity"),r("selected.marker.color"),r("unselected.marker.color")}},{"../../components/color":532,"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546}],813:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../components/color/attributes"),a=t("../../lib/extend").extendFlat,o=n.marker,s=o.line;e.exports={y:{valType:"data_array",editType:"calc+clearAxisTypes"},x:{valType:"data_array",editType:"calc+clearAxisTypes"},x0:{valType:"any",editType:"calc+clearAxisTypes"},y0:{valType:"any",editType:"calc+clearAxisTypes"},name:{valType:"string",editType:"calc+clearAxisTypes"},text:a({},n.text,{}),whiskerwidth:{valType:"number",min:0,max:1,dflt:.5,editType:"calcIfAutorange"},notched:{valType:"boolean",editType:"calcIfAutorange"},notchwidth:{valType:"number",min:0,max:.5,dflt:.25,editType:"calcIfAutorange"},boxpoints:{valType:"enumerated",values:["all","outliers","suspectedoutliers",!1],dflt:"outliers",editType:"calcIfAutorange"},boxmean:{valType:"enumerated",values:[!0,"sd",!1],dflt:!1,editType:"calcIfAutorange"},jitter:{valType:"number",min:0,max:1,editType:"calcIfAutorange"},pointpos:{valType:"number",min:-2,max:2,editType:"calcIfAutorange"},orientation:{valType:"enumerated",values:["v","h"],editType:"calc+clearAxisTypes"},marker:{outliercolor:{valType:"color",dflt:"rgba(0, 0, 0, 0)",editType:"style"},symbol:a({},o.symbol,{arrayOk:!1,editType:"plot"}),opacity:a({},o.opacity,{arrayOk:!1,dflt:1,editType:"style"}),size:a({},o.size,{arrayOk:!1,editType:"calcIfAutorange"}),color:a({},o.color,{arrayOk:!1,editType:"style"}),line:{color:a({},s.color,{arrayOk:!1,dflt:i.defaultLine,editType:"style"}),width:a({},s.width,{arrayOk:!1,dflt:0,editType:"style"}),outliercolor:{valType:"color",editType:"style"},outlierwidth:{valType:"number",min:0,dflt:1,editType:"style"},editType:"style"},editType:"plot"},line:{color:{valType:"color",editType:"style"},width:{valType:"number",min:0,dflt:2,editType:"style"},editType:"plot"},fillcolor:n.fillcolor,selected:{marker:n.selected.marker,editType:"style"},unselected:{marker:n.unselected.marker,editType:"style"},hoveron:{valType:"flaglist",flags:["boxes","points"],dflt:"boxes+points",editType:"style"}}},{"../../components/color/attributes":531,"../../lib/extend":649,"../scatter/attributes":990}],814:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=i._,o=t("../../plots/cartesian/axes");function s(t,e,r){var n={text:"tx"};for(var i in n)Array.isArray(e[i])&&(t[n[i]]=e[i][r])}function l(t,e){return t.v-e.v}function c(t){return t.v}e.exports=function(t,e){var r,u,f,h,p,d=t._fullLayout,g=o.getFromId(t,e.xaxis||"x"),m=o.getFromId(t,e.yaxis||"y"),v=[],y="violin"===e.type?"_numViolins":"_numBoxes";"h"===e.orientation?(u=g,f="x",h=m,p="y"):(u=m,f="y",h=g,p="x");var x=u.makeCalcdata(e,f),b=function(t,e,r,a,o){if(e in t)return r.makeCalcdata(t,e);var s;s=e+"0"in t?t[e+"0"]:"name"in t&&("category"===r.type||n(t.name)&&-1!==["linear","log"].indexOf(r.type)||i.isDateTime(t.name)&&"date"===r.type)?t.name:o;var l=r.d2c(s,0,t[e+"calendar"]);return a.map(function(){return l})}(e,p,h,x,d[y]),_=i.distinctVals(b),w=_.vals,k=_.minDiff/2,M=function(t,e){for(var r=t.length,n=new Array(r+1),i=0;i=0&&C0){var L=T[r].sort(l),z=L.map(c),P=z.length,D={pos:w[r],pts:L};D.min=z[0],D.max=z[P-1],D.mean=i.mean(z,P),D.sd=i.stdev(z,P,D.mean),D.q1=i.interp(z,.25),D.med=i.interp(z,.5),D.q3=i.interp(z,.75),D.lf=Math.min(D.q1,z[Math.min(i.findBin(2.5*D.q1-1.5*D.q3,z,!0)+1,P-1)]),D.uf=Math.max(D.q3,z[Math.max(i.findBin(2.5*D.q3-1.5*D.q1,z),0)]),D.lo=4*D.q1-3*D.q3,D.uo=4*D.q3-3*D.q1;var O=1.57*(D.q3-D.q1)/Math.sqrt(P);D.ln=D.med-O,D.un=D.med+O,v.push(D)}return function(t,e){if(i.isArrayOrTypedArray(e.selectedpoints))for(var r=0;r0?(v[0].t={num:d[y],dPos:k,posLetter:p,valLetter:f,labels:{med:a(t,"median:"),min:a(t,"min:"),q1:a(t,"q1:"),q3:a(t,"q3:"),max:a(t,"max:"),mean:"sd"===e.boxmean?a(t,"mean \xb1 \u03c3:"):a(t,"mean:"),lf:a(t,"lower fence:"),uf:a(t,"upper fence:")}},d[y]++,v):[{t:{empty:!0}}]}},{"../../lib":660,"../../plots/cartesian/axes":706,"fast-isnumeric":197}],815:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry"),a=t("../../components/color"),o=t("./attributes");function s(t,e,r,n){var a,o,s=r("y"),l=r("x"),c=l&&l.length;if(s&&s.length)a="v",c?o=Math.min(l.length,s.length):(r("x0"),o=s.length);else{if(!c)return void(e.visible=!1);a="h",r("y0"),o=l.length}e._length=o,i.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x","y"],n),r("orientation",a)}function l(t,e,r,i){var a=i.prefix,s=n.coerce2(t,e,o,"marker.outliercolor"),l=r("marker.line.outliercolor"),c=r(a+"points",s||l?"suspectedoutliers":void 0);c?(r("jitter","all"===c?.3:0),r("pointpos","all"===c?-1.5:0),r("marker.symbol"),r("marker.opacity"),r("marker.size"),r("marker.color",e.line.color),r("marker.line.color"),r("marker.line.width"),"suspectedoutliers"===c&&(r("marker.line.outliercolor",e.marker.color),r("marker.line.outlierwidth")),r("selected.marker.color"),r("unselected.marker.color"),r("selected.marker.size"),r("unselected.marker.size"),r("text")):delete e.marker,r("hoveron"),n.coerceSelectionMarkerOpacity(e,r)}e.exports={supplyDefaults:function(t,e,r,i){function c(r,i){return n.coerce(t,e,o,r,i)}s(t,e,c,i),!1!==e.visible&&(c("line.color",(t.marker||{}).color||r),c("line.width"),c("fillcolor",a.addOpacity(e.line.color,.5)),c("whiskerwidth"),c("boxmean"),c("notched",void 0!==t.notchwidth)&&c("notchwidth"),l(t,e,c,{prefix:"box"}))},handleSampleDefaults:s,handlePointsDefaults:l}},{"../../components/color":532,"../../lib":660,"../../registry":790,"./attributes":813}],816:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib"),a=t("../../components/fx"),o=t("../../components/color"),s=t("../scatter/fill_hover_text");function l(t,e,r,s){var l,c,u,f,h,p,d,g,m,v,y,x,b=t.cd,_=t.xa,w=t.ya,k=b[0].trace,M=b[0].t,A="violin"===k.type,T=[],S=M.bdPos,C=M.wHover,E=function(t){return t.pos+M.bPos-p};A&&"both"!==k.side?("positive"===k.side&&(m=function(t){var e=E(t);return a.inbox(e,e+C,v)}),"negative"===k.side&&(m=function(t){var e=E(t);return a.inbox(e-C,e,v)})):m=function(t){var e=E(t);return a.inbox(e-C,e+C,v)},x=A?function(t){return a.inbox(t.span[0]-h,t.span[1]-h,v)}:function(t){return a.inbox(t.min-h,t.max-h,v)},"h"===k.orientation?(h=e,p=r,d=x,g=m,l="y",u=w,c="x",f=_):(h=r,p=e,d=m,g=x,l="x",u=_,c="y",f=w);var L=Math.min(1,S/Math.abs(u.r2c(u.range[1])-u.r2c(u.range[0])));function z(t){return(d(t)+g(t))/2}v=t.maxHoverDistance-L,y=t.maxSpikeDistance-L;var P=a.getDistanceFunction(s,d,g,z);if(a.getClosest(b,P,t),!1===t.index)return[];var D=b[t.index],O=k.line.color,I=(k.marker||{}).color;o.opacity(O)&&k.line.width?t.color=O:o.opacity(I)&&k.boxpoints?t.color=I:t.color=k.fillcolor,t[l+"0"]=u.c2p(D.pos+M.bPos-S,!0),t[l+"1"]=u.c2p(D.pos+M.bPos+S,!0),t[l+"LabelVal"]=D.pos;var R=l+"Spike";t.spikeDistance=z(D)*y/v,t[R]=u.c2p(D.pos,!0);var B={},F=["med","min","q1","q3","max"];(k.boxmean||(k.meanline||{}).visible)&&F.push("mean"),(k.boxpoints||k.points)&&F.push("lf","uf");for(var N=0;Nt.uf}),l=Math.max((t.max-t.min)/10,t.q3-t.q1),c=1e-9*l,p=l*s,d=[],g=0;if(r.jitter){if(0===l)for(g=1,d=new Array(a.length),e=0;et.lo&&(_.so=!0)}return a});d.enter().append("path").classed("point",!0),d.exit().remove(),d.call(a.translatePoints,l,c)}function u(t,e,r,a){var o,s,l=e.pos,c=e.val,u=a.bPos,f=a.bPosPxOffset||0;Array.isArray(a.bdPos)?(o=a.bdPos[0],s=a.bdPos[1]):(o=a.bdPos,s=a.bdPos);var h=t.selectAll("path.mean").data(i.identity);h.enter().append("path").attr("class","mean").style({fill:"none","vector-effect":"non-scaling-stroke"}),h.exit().remove(),h.each(function(t){var e=l.c2p(t.pos+u,!0)+f,i=l.c2p(t.pos+u-o,!0)+f,a=l.c2p(t.pos+u+s,!0)+f,h=c.c2p(t.mean,!0),p=c.c2p(t.mean-t.sd,!0),d=c.c2p(t.mean+t.sd,!0);"h"===r.orientation?n.select(this).attr("d","M"+h+","+i+"V"+a+("sd"===r.boxmean?"m0,0L"+p+","+e+"L"+h+","+i+"L"+d+","+e+"Z":"")):n.select(this).attr("d","M"+i+","+h+"H"+a+("sd"===r.boxmean?"m0,0L"+e+","+p+"L"+i+","+h+"L"+e+","+d+"Z":""))})}e.exports={plot:function(t,e,r,i){var a=t._fullLayout,o=e.xaxis,s=e.yaxis,f=i.selectAll("g.trace.boxes").data(r,function(t){return t[0].trace.uid});f.enter().append("g").attr("class","trace boxes"),f.exit().remove(),f.order(),f.each(function(t){var r=t[0],i=r.t,f=r.trace,h=n.select(this);e.isRangePlot||(r.node3=h);var p,d,g=a._numBoxes,m=1-a.boxgap,v="group"===a.boxmode&&g>1,y=i.dPos*m*(1-a.boxgroupgap)/(v?g:1),x=v?2*i.dPos*((i.num+.5)/g-.5)*m:0,b=y*f.whiskerwidth;!0!==f.visible||i.empty?h.remove():("h"===f.orientation?(p=s,d=o):(p=o,d=s),i.bPos=x,i.bdPos=y,i.wdPos=b,i.wHover=i.dPos*(v?m/g:1),l(h,{pos:p,val:d},f,i),f.boxpoints&&c(h,{x:o,y:s},f,i),f.boxmean&&u(h,{pos:p,val:d},f,i))})},plotBoxAndWhiskers:l,plotPoints:c,plotBoxMean:u}},{"../../components/drawing":557,"../../lib":660,d3:131}],821:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n,i=t.cd,a=t.xaxis,o=t.yaxis,s=[];if(!1===e)for(r=0;r=10)return null;var i=1/0;var a=-1/0;var o=e.length;for(var s=0;s0?Math.floor:Math.ceil,P=E>0?Math.ceil:Math.floor,D=E>0?Math.min:Math.max,O=E>0?Math.max:Math.min,I=z(S+L),R=P(C-L),B=[[f=T(S)]];for(a=I;a*E=0;i--)a[u-i]=t[f][i],o[u-i]=e[f][i];for(s.push({x:a,y:o,bicubic:l}),i=f,a=[],o=[];i>=0;i--)a[f-i]=t[i][0],o[f-i]=e[i][0];return s.push({x:a,y:o,bicubic:c}),s}},{}],836:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib/extend").extendFlat;e.exports=function(t,e,r){var a,o,s,l,c,u,f,h,p,d,g,m,v,y,x=t["_"+e],b=t[e+"axis"],_=b._gridlines=[],w=b._minorgridlines=[],k=b._boundarylines=[],M=t["_"+r],A=t[r+"axis"];"array"===b.tickmode&&(b.tickvals=x.slice());var T=t._xctrl,S=t._yctrl,C=T[0].length,E=T.length,L=t._a.length,z=t._b.length;n.prepTicks(b),"array"===b.tickmode&&delete b.tickvals;var P=b.smoothing?3:1;function D(n){var i,a,o,s,l,c,u,f,p,d,g,m,v=[],y=[],x={};if("b"===e)for(a=t.b2j(n),o=Math.floor(Math.max(0,Math.min(z-2,a))),s=a-o,x.length=z,x.crossLength=L,x.xy=function(e){return t.evalxy([],e,a)},x.dxy=function(e,r){return t.dxydi([],e,o,r,s)},i=0;i0&&(p=t.dxydi([],i-1,o,0,s),v.push(l[0]+p[0]/3),y.push(l[1]+p[1]/3),d=t.dxydi([],i-1,o,1,s),v.push(f[0]-d[0]/3),y.push(f[1]-d[1]/3)),v.push(f[0]),y.push(f[1]),l=f;else for(i=t.a2i(n),c=Math.floor(Math.max(0,Math.min(L-2,i))),u=i-c,x.length=L,x.crossLength=z,x.xy=function(e){return t.evalxy([],i,e)},x.dxy=function(e,r){return t.dxydj([],c,e,u,r)},a=0;a0&&(g=t.dxydj([],c,a-1,u,0),v.push(l[0]+g[0]/3),y.push(l[1]+g[1]/3),m=t.dxydj([],c,a-1,u,1),v.push(f[0]-m[0]/3),y.push(f[1]-m[1]/3)),v.push(f[0]),y.push(f[1]),l=f;return x.axisLetter=e,x.axis=b,x.crossAxis=A,x.value=n,x.constvar=r,x.index=h,x.x=v,x.y=y,x.smoothing=A.smoothing,x}function O(n){var i,a,o,s,l,c=[],u=[],f={};if(f.length=x.length,f.crossLength=M.length,"b"===e)for(o=Math.max(0,Math.min(z-2,n)),l=Math.min(1,Math.max(0,n-o)),f.xy=function(e){return t.evalxy([],e,n)},f.dxy=function(e,r){return t.dxydi([],e,o,r,l)},i=0;ix.length-1||_.push(i(O(o),{color:b.gridcolor,width:b.gridwidth}));for(h=u;hx.length-1||g<0||g>x.length-1))for(m=x[s],v=x[g],a=0;ax[x.length-1]||w.push(i(D(d),{color:b.minorgridcolor,width:b.minorgridwidth}));b.startline&&k.push(i(O(0),{color:b.startlinecolor,width:b.startlinewidth})),b.endline&&k.push(i(O(x.length-1),{color:b.endlinecolor,width:b.endlinewidth}))}else{for(l=5e-15,u=(c=[Math.floor((x[x.length-1]-b.tick0)/b.dtick*(1+l)),Math.ceil((x[0]-b.tick0)/b.dtick/(1+l))].sort(function(t,e){return t-e}))[0],f=c[1],h=u;h<=f;h++)p=b.tick0+b.dtick*h,_.push(i(D(p),{color:b.gridcolor,width:b.gridwidth}));for(h=u-1;hx[x.length-1]||w.push(i(D(d),{color:b.minorgridcolor,width:b.minorgridwidth}));b.startline&&k.push(i(D(x[0]),{color:b.startlinecolor,width:b.startlinewidth})),b.endline&&k.push(i(D(x[x.length-1]),{color:b.endlinecolor,width:b.endlinewidth}))}}},{"../../lib/extend":649,"../../plots/cartesian/axes":706}],837:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib/extend").extendFlat;e.exports=function(t,e){var r,a,o,s=e._labels=[],l=e._gridlines;for(r=0;re.length&&(t=t.slice(0,e.length)):t=[],i=0;i90&&(p-=180,l=-l),{angle:p,flip:l,p:t.c2p(n,e,r),offsetMultplier:c}}},{}],851:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../components/drawing"),a=t("./map_1d_array"),o=t("./makepath"),s=t("./orient_text"),l=t("../../lib/svg_text_utils"),c=t("../../lib"),u=t("../../constants/alignment"),f=t("../../plots/get_data").getUidsFromCalcData;function h(t,e,r,n){var i=r[0],l=r[0].trace,u=e.xaxis,f=e.yaxis,h=l.aaxis,g=l.baxis,m=t._fullLayout._clips,y=c.ensureSingle(n,"g","carpet"+l.uid).classed("trace",!0),x=c.ensureSingle(y,"g","minorlayer"),b=c.ensureSingle(y,"g","majorlayer"),_=c.ensureSingle(y,"g","boundarylayer"),w=c.ensureSingle(y,"g","labellayer");y.style("opacity",l.opacity),p(u,f,b,h,"a",h._gridlines),p(u,f,b,g,"b",g._gridlines),p(u,f,x,h,"a",h._minorgridlines),p(u,f,x,g,"b",g._minorgridlines),p(u,f,_,h,"a-boundary",h._boundarylines),p(u,f,_,g,"b-boundary",g._boundarylines),function(t,e,r,n,i,a,o,l){var u,f,h,p;u=.5*(r.a[0]+r.a[r.a.length-1]),f=r.b[0],h=r.ab2xy(u,f,!0),p=r.dxyda_rough(u,f),void 0===o.angle&&c.extendFlat(o,s(r,i,a,h,r.dxydb_rough(u,f)));v(t,e,r,n,h,p,r.aaxis,i,a,o,"a-title"),u=r.a[0],f=.5*(r.b[0]+r.b[r.b.length-1]),h=r.ab2xy(u,f,!0),p=r.dxydb_rough(u,f),void 0===l.angle&&c.extendFlat(l,s(r,i,a,h,r.dxyda_rough(u,f)));v(t,e,r,n,h,p,r.baxis,i,a,l,"b-title")}(t,w,l,i,u,f,d(t,u,f,l,i,w,h._labels,"a-label"),d(t,u,f,l,i,w,g._labels,"b-label")),function(t,e,r,n,i){var s,l,u,f,h=r.select("#"+t._clipPathId);h.size()||(h=r.append("clipPath").classed("carpetclip",!0));var p=c.ensureSingle(h,"path","carpetboundary"),d=e.clipsegments,g=[];for(f=0;f0?"start":"end","data-notex":1}).call(i.font,o.font).text(o.text).call(l.convertToTspans,t),m=i.bBox(this);g.attr("transform","translate("+u.p[0]+","+u.p[1]+") rotate("+u.angle+")translate("+o.axis.labelpadding*h+","+.3*m.height+")"),p=Math.max(p,m.width+o.axis.labelpadding)}),h.exit().remove(),d.maxExtent=p,d}e.exports=function(t,e,r,i){var a=f(r);i.selectAll("g.trace").each(function(){var t=n.select(this).attr("class").split("carpet")[1].split(/\s/)[0];a[t]||n.select(this).remove()});for(var o=0;o90&&d<270,y=n.select(this);y.text(u.title||"").call(l.convertToTspans,t),v&&(x=(-l.lineCount(y)+m)*g*a-x),y.attr("transform","translate("+e.p[0]+","+e.p[1]+") rotate("+e.angle+") translate(0,"+x+")").classed("user-select-none",!0).attr("text-anchor","middle").call(i.font,u.titlefont)}),y.exit().remove()}},{"../../components/drawing":557,"../../constants/alignment":632,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/get_data":742,"./makepath":848,"./map_1d_array":849,"./orient_text":850,d3:131}],852:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../lib/search").findBin,a=t("./compute_control_points"),o=t("./create_spline_evaluator"),s=t("./create_i_derivative_evaluator"),l=t("./create_j_derivative_evaluator");e.exports=function(t){var e=t._a,r=t._b,c=e.length,u=r.length,f=t.aaxis,h=t.baxis,p=e[0],d=e[c-1],g=r[0],m=r[u-1],v=e[e.length-1]-e[0],y=r[r.length-1]-r[0],x=v*n.RELATIVE_CULL_TOLERANCE,b=y*n.RELATIVE_CULL_TOLERANCE;p-=x,d+=x,g-=b,m+=b,t.isVisible=function(t,e){return t>p&&tg&&ed||em},t.setScale=function(){var e=t._x,r=t._y,n=a(t._xctrl,t._yctrl,e,r,f.smoothing,h.smoothing);t._xctrl=n[0],t._yctrl=n[1],t.evalxy=o([t._xctrl,t._yctrl],c,u,f.smoothing,h.smoothing),t.dxydi=s([t._xctrl,t._yctrl],f.smoothing,h.smoothing),t.dxydj=l([t._xctrl,t._yctrl],f.smoothing,h.smoothing)},t.i2a=function(t){var r=Math.max(0,Math.floor(t[0]),c-2),n=t[0]-r;return(1-n)*e[r]+n*e[r+1]},t.j2b=function(t){var e=Math.max(0,Math.floor(t[1]),c-2),n=t[1]-e;return(1-n)*r[e]+n*r[e+1]},t.ij2ab=function(e){return[t.i2a(e[0]),t.j2b(e[1])]},t.a2i=function(t){var r=Math.max(0,Math.min(i(t,e),c-2)),n=e[r],a=e[r+1];return Math.max(0,Math.min(c-1,r+(t-n)/(a-n)))},t.b2j=function(t){var e=Math.max(0,Math.min(i(t,r),u-2)),n=r[e],a=r[e+1];return Math.max(0,Math.min(u-1,e+(t-n)/(a-n)))},t.ab2ij=function(e){return[t.a2i(e[0]),t.b2j(e[1])]},t.i2c=function(e,r){return t.evalxy([],e,r)},t.ab2xy=function(n,i,a){if(!a&&(ne[c-1]|ir[u-1]))return[!1,!1];var o=t.a2i(n),s=t.b2j(i),l=t.evalxy([],o,s);if(a){var f,h,p,d,g=0,m=0,v=[];ne[c-1]?(f=c-2,h=1,g=(n-e[c-1])/(e[c-1]-e[c-2])):h=o-(f=Math.max(0,Math.min(c-2,Math.floor(o)))),ir[u-1]?(p=u-2,d=1,m=(i-r[u-1])/(r[u-1]-r[u-2])):d=s-(p=Math.max(0,Math.min(u-2,Math.floor(s)))),g&&(t.dxydi(v,f,p,h,d),l[0]+=v[0]*g,l[1]+=v[1]*g),m&&(t.dxydj(v,f,p,h,d),l[0]+=v[0]*m,l[1]+=v[1]*m)}return l},t.c2p=function(t,e,r){return[e.c2p(t[0]),r.c2p(t[1])]},t.p2x=function(t,e,r){return[e.p2c(t[0]),r.p2c(t[1])]},t.dadi=function(t){var r=Math.max(0,Math.min(e.length-2,t));return e[r+1]-e[r]},t.dbdj=function(t){var e=Math.max(0,Math.min(r.length-2,t));return r[e+1]-r[e]},t.dxyda=function(e,r,n,i){var a=t.dxydi(null,e,r,n,i),o=t.dadi(e,n);return[a[0]/o,a[1]/o]},t.dxydb=function(e,r,n,i){var a=t.dxydj(null,e,r,n,i),o=t.dbdj(r,i);return[a[0]/o,a[1]/o]},t.dxyda_rough=function(e,r,n){var i=v*(n||.1),a=t.ab2xy(e+i,r,!0),o=t.ab2xy(e-i,r,!0);return[.5*(a[0]-o[0])/i,.5*(a[1]-o[1])/i]},t.dxydb_rough=function(e,r,n){var i=y*(n||.1),a=t.ab2xy(e,r+i,!0),o=t.ab2xy(e,r-i,!0);return[.5*(a[0]-o[0])/i,.5*(a[1]-o[1])/i]},t.dpdx=function(t){return t._m},t.dpdy=function(t){return t._m}}},{"../../lib/search":679,"./compute_control_points":840,"./constants":841,"./create_i_derivative_evaluator":842,"./create_j_derivative_evaluator":843,"./create_spline_evaluator":844}],853:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e,r){var i,a,o,s=[],l=[],c=t[0].length,u=t.length;function f(e,r){var n,i=0,a=0;return e>0&&void 0!==(n=t[r][e-1])&&(a++,i+=n),e0&&void 0!==(n=t[r-1][e])&&(a++,i+=n),r0&&a0&&i1e-5);return n.log("Smoother converged to",M,"after",A,"iterations"),t}},{"../../lib":660}],854:[function(t,e,r){"use strict";var n=t("../../lib").isArray1D;e.exports=function(t,e,r){var i=r("x"),a=i&&i.length,o=r("y"),s=o&&o.length;if(!a&&!s)return!1;if(e._cheater=!i,a&&!n(i)||s&&!n(o))e._length=null;else{var l=a?i.length:1/0;s&&(l=Math.min(l,o.length)),e.a&&e.a.length&&(l=Math.min(l,e.a.length)),e.b&&e.b.length&&(l=Math.min(l,e.b.length)),e._length=l}return!0}},{"../../lib":660}],855:[function(t,e,r){"use strict";var n=t("../scattergeo/attributes"),i=t("../../components/colorscale/attributes"),a=t("../../components/colorbar/attributes"),o=t("../../plots/attributes"),s=t("../../lib/extend"),l=s.extendFlat,c=s.extendDeepAll,u=n.marker.line;e.exports=l({locations:{valType:"data_array",editType:"calc"},locationmode:n.locationmode,z:{valType:"data_array",editType:"calc"},text:l({},n.text,{}),marker:{line:{color:u.color,width:l({},u.width,{dflt:1}),editType:"calc"},opacity:{valType:"number",arrayOk:!0,min:0,max:1,dflt:1,editType:"style"},editType:"calc"},selected:{marker:{opacity:n.selected.marker.opacity,editType:"plot"},editType:"plot"},unselected:{marker:{opacity:n.unselected.marker.opacity,editType:"plot"},editType:"plot"},hoverinfo:l({},o.hoverinfo,{editType:"calc",flags:["location","z","text","name"]})},c({},i,{zmax:{editType:"calc"},zmin:{editType:"calc"}}),{colorbar:a})},{"../../components/colorbar/attributes":533,"../../components/colorscale/attributes":538,"../../lib/extend":649,"../../plots/attributes":703,"../scattergeo/attributes":1028}],856:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../constants/numerical").BADNUM,a=t("../../components/colorscale/calc"),o=t("../scatter/arrays_to_calcdata"),s=t("../scatter/calc_selection");e.exports=function(t,e){for(var r=e._length,l=new Array(r),c=0;c")}(t,f,o,h.mockAxis),[t]}},{"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998,"./attributes":855}],860:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../heatmap/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("./style").style,n.styleOnSelect=t("./style").styleOnSelect,n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.moduleType="trace",n.name="choropleth",n.basePlotModule=t("../../plots/geo"),n.categories=["geo","noOpacity"],n.meta={},e.exports=n},{"../../plots/geo":736,"../heatmap/colorbar":902,"./attributes":855,"./calc":856,"./defaults":857,"./event_data":858,"./hover":859,"./plot":861,"./select":862,"./style":863}],861:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../lib/polygon"),o=t("../../lib/topojson_utils").getTopojsonFeatures,s=t("../../lib/geo_location_utils").locationToFeature,l=t("./style").style;function c(t,e){for(var r=t[0].trace,n=t.length,i=o(r,e),a=0;a0&&t[e+1][0]<0)return e;return null}switch(e="RUS"===l||"FJI"===l?function(t){var e;if(null===u(t))e=t;else for(e=new Array(t.length),i=0;ie?r[n++]=[t[i][0]+360,t[i][1]]:i===e?(r[n++]=t[i],r[n++]=[t[i][0],-90]):r[n++]=t[i];var o=a.tester(r);o.pts.pop(),c.push(o)}:function(t){c.push(a.tester(t))},o.type){case"MultiPolygon":for(r=0;r":f.value>h&&(s.prefixBoundary=!0);break;case"<":f.valueh)&&(s.prefixBoundary=!0);break;case"][":a=Math.min.apply(null,f.value),o=Math.max.apply(null,f.value),ah&&(s.prefixBoundary=!0)}}},{}],873:[function(t,e,r){"use strict";var n=t("../../plots/plots"),i=t("../../components/colorbar/draw"),a=t("./make_color_map"),o=t("./end_plus");e.exports=function(t,e){var r=e[0].trace,s="cb"+r.uid;if(t._fullLayout._infolayer.selectAll("."+s).remove(),r.showscale){var l=i(t,s);e[0].t.cb=l;var c=r.contours,u=r.line,f=c.size||1,h=c.coloring,p=a(r,{isColorbar:!0});"heatmap"===h&&l.filllevels({start:r.zmin,end:r.zmax,size:(r.zmax-r.zmin)/254}),l.fillcolor("fill"===h||"heatmap"===h?p:"").line({color:"lines"===h?p:u.color,width:!1!==c.showlines?u.width:0,dash:u.dash}).levels({start:c.start,end:o(c),size:f}).options(r.colorbar)()}else n.autoMargin(t,s)}},{"../../components/colorbar/draw":536,"../../plots/plots":768,"./end_plus":881,"./make_color_map":886}],874:[function(t,e,r){"use strict";e.exports={BOTTOMSTART:[1,9,13,104,713],TOPSTART:[4,6,7,104,713],LEFTSTART:[8,12,14,208,1114],RIGHTSTART:[2,3,11,208,1114],NEWDELTA:[null,[-1,0],[0,-1],[-1,0],[1,0],null,[0,-1],[-1,0],[0,1],[0,1],null,[0,1],[1,0],[1,0],[0,-1]],CHOOSESADDLE:{104:[4,1],208:[2,8],713:[7,13],1114:[11,14]},SADDLEREMAINDER:{1:4,2:8,4:1,7:13,8:2,11:14,13:7,14:11},LABELDISTANCE:2,LABELINCREASE:10,LABELMIN:3,LABELMAX:10,LABELOPTIMIZER:{EDGECOST:1,ANGLECOST:1,NEIGHBORCOST:5,SAMELEVELFACTOR:10,SAMELEVELDISTANCE:5,MAXCOST:100,INITIALSEARCHPOINTS:10,ITERATIONS:5}}},{}],875:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("./label_defaults"),a=t("../../components/color"),o=a.addOpacity,s=a.opacity,l=t("../../constants/filter_ops"),c=l.CONSTRAINT_REDUCTION,u=l.COMPARISON_OPS2;e.exports=function(t,e,r,a,l,f){var h,p,d,g=e.contours,m=r("contours.operation");(g._operation=c[m],function(t,e){var r;-1===u.indexOf(e.operation)?(t("contours.value",[0,1]),Array.isArray(e.value)?e.value.length>2?e.value=e.value.slice(2):0===e.length?e.value=[0,1]:e.length<2?(r=parseFloat(e.value[0]),e.value=[r,r+1]):e.value=[parseFloat(e.value[0]),parseFloat(e.value[1])]:n(e.value)&&(r=parseFloat(e.value),e.value=[r,r+1])):(t("contours.value",0),n(e.value)||(Array.isArray(e.value)?e.value=parseFloat(e.value[0]):e.value=0))}(r,g),"="===m?h=g.showlines=!0:(h=r("contours.showlines"),d=r("fillcolor",o((t.line||{}).color||l,.5))),h)&&(p=r("line.color",d&&s(d)?o(e.fillcolor,1):l),r("line.width",2),r("line.dash"));r("line.smoothing"),i(r,a,p,f)}},{"../../components/color":532,"../../constants/filter_ops":633,"./label_defaults":885,"fast-isnumeric":197}],876:[function(t,e,r){"use strict";var n=t("../../constants/filter_ops"),i=t("fast-isnumeric");function a(t,e){var r,a=Array.isArray(e);function o(t){return i(t)?+t:null}return-1!==n.COMPARISON_OPS2.indexOf(t)?r=o(a?e[0]:e):-1!==n.INTERVAL_OPS.indexOf(t)?r=a?[o(e[0]),o(e[1])]:[o(e),o(e)]:-1!==n.SET_OPS.indexOf(t)&&(r=a?e.map(o):[o(e)]),r}function o(t){return function(e){e=a(t,e);var r=Math.min(e[0],e[1]),n=Math.max(e[0],e[1]);return{start:r,end:n,size:n-r}}}function s(t){return function(e){return{start:e=a(t,e),end:1/0,size:1/0}}}e.exports={"[]":o("[]"),"][":o("]["),">":s(">"),"<":s("<"),"=":s("=")}},{"../../constants/filter_ops":633,"fast-isnumeric":197}],877:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var i=n("contours.start"),a=n("contours.end"),o=!1===i||!1===a,s=r("contours.size");!(o?e.autocontour=!0:r("autocontour",!1))&&s||r("ncontours")}},{}],878:[function(t,e,r){"use strict";var n=t("../../lib");function i(t){return n.extendFlat({},t,{edgepaths:n.extendDeep([],t.edgepaths),paths:n.extendDeep([],t.paths)})}e.exports=function(t,e){var r,a,o,s=function(t){return t.reverse()},l=function(t){return t};switch(e){case"=":case"<":return t;case">":for(1!==t.length&&n.warn("Contour data invalid for the specified inequality operation."),a=t[0],r=0;r1e3){n.warn("Too many contours, clipping at 1000",t);break}return l}},{"../../lib":660,"./constraint_mapping":876,"./end_plus":881}],881:[function(t,e,r){"use strict";e.exports=function(t){return t.end+t.size/1e6}},{}],882:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./constants");function a(t,e,r,n){return Math.abs(t[0]-e[0])20&&e?208===t||1114===t?n=0===r[0]?1:-1:a=0===r[1]?1:-1:-1!==i.BOTTOMSTART.indexOf(t)?a=1:-1!==i.LEFTSTART.indexOf(t)?n=1:-1!==i.TOPSTART.indexOf(t)?a=-1:n=-1;return[n,a]}(h,r,e),d=[s(t,e,[-p[0],-p[1]])],g=p.join(","),m=t.z.length,v=t.z[0].length;for(c=0;c<1e4;c++){if(h>20?(h=i.CHOOSESADDLE[h][(p[0]||p[1])<0?0:1],t.crossings[f]=i.SADDLEREMAINDER[h]):delete t.crossings[f],!(p=i.NEWDELTA[h])){n.log("Found bad marching index:",h,e,t.level);break}d.push(s(t,e,p)),e[0]+=p[0],e[1]+=p[1],a(d[d.length-1],d[d.length-2],o,l)&&d.pop(),f=e.join(",");var y=p[0]&&(e[0]<0||e[0]>v-2)||p[1]&&(e[1]<0||e[1]>m-2);if(f===u&&p.join(",")===g||r&&y)break;h=t.crossings[f]}1e4===c&&n.log("Infinite loop in contour?");var x,b,_,w,k,M,A,T,S,C,E,L,z,P,D,O=a(d[0],d[d.length-1],o,l),I=0,R=.2*t.smoothing,B=[],F=0;for(c=1;c=F;c--)if((x=B[c])=F&&x+B[b]T&&S--,t.edgepaths[S]=E.concat(d,C));break}U||(t.edgepaths[T]=d.concat(C))}for(T=0;Tt?0:1)+(e[0][1]>t?0:2)+(e[1][1]>t?0:4)+(e[1][0]>t?0:8);return 5===r||10===r?t>(e[0][0]+e[0][1]+e[1][0]+e[1][1])/4?5===r?713:1114:5===r?104:208:15===r?0:r}e.exports=function(t){var e,r,a,o,s,l,c,u,f,h=t[0].z,p=h.length,d=h[0].length,g=2===p||2===d;for(r=0;rt.level}return r?"M"+e.join("L")+"Z":""}(t,e),h=0,p=t.edgepaths.map(function(t,e){return e}),d=!0;function g(t){return Math.abs(t[1]-e[2][1])<.01}function m(t){return Math.abs(t[0]-e[0][0])<.01}function v(t){return Math.abs(t[0]-e[2][0])<.01}for(;p.length;){for(c=a.smoothopen(t.edgepaths[h],t.smoothing),f+=d?c:c.replace(/^M/,"L"),p.splice(p.indexOf(h),1),r=t.edgepaths[h][t.edgepaths[h].length-1],s=-1,o=0;o<4;o++){if(!r){i.log("Missing end?",h,t);break}for(u=r,Math.abs(u[1]-e[0][1])<.01&&!v(r)?n=e[1]:m(r)?n=e[0]:g(r)?n=e[3]:v(r)&&(n=e[2]),l=0;l=0&&(n=y,s=l):Math.abs(r[1]-n[1])<.01?Math.abs(r[1]-y[1])<.01&&(y[0]-r[0])*(n[0]-y[0])>=0&&(n=y,s=l):i.log("endpt to newendpt is not vert. or horz.",r,n,y)}if(r=n,s>=0)break;f+="L"+n}if(s===t.edgepaths.length){i.log("unclosed perimeter path");break}h=s,(d=-1===p.indexOf(h))&&(h=p[0],f+="Z")}for(h=0;hn.center?n.right-s:s-n.left)/(u+Math.abs(Math.sin(c)*o)),p=(l>n.middle?n.bottom-l:l-n.top)/(Math.abs(f)+Math.cos(c)*o);if(h<1||p<1)return 1/0;var d=v.EDGECOST*(1/(h-1)+1/(p-1));d+=v.ANGLECOST*c*c;for(var g=s-u,m=l-f,y=s+u,x=l+f,b=0;b2*v.MAXCOST)break;p&&(s/=2),l=(o=c-s/2)+1.5*s}if(h<=v.MAXCOST)return u},r.addLabelData=function(t,e,r,n){var i=e.width/2,a=e.height/2,o=t.x,s=t.y,l=t.theta,c=Math.sin(l),u=Math.cos(l),f=i*u,h=a*c,p=i*c,d=-a*u,g=[[o-f-h,s-p-d],[o+f-h,s+p-d],[o+f+h,s+p+d],[o-f+h,s-p+d]];r.push({text:e.text,x:o,y:s,dy:e.dy,theta:l,level:e.level,width:e.width,height:e.height}),n.push(g)},r.drawLabels=function(t,e,r,a,s){var l=t.selectAll("text").data(e,function(t){return t.text+","+t.x+","+t.y+","+t.theta});if(l.exit().remove(),l.enter().append("text").attr({"data-notex":1,"text-anchor":"middle"}).each(function(t){var e=t.x+Math.sin(t.theta)*t.dy,i=t.y-Math.cos(t.theta)*t.dy;n.select(this).text(t.text).attr({x:e,y:i,transform:"rotate("+180*t.theta/Math.PI+" "+e+" "+i+")"}).call(o.convertToTspans,r)}),s){for(var c="",u=0;ue.end&&(e.start=e.end=(e.start+e.end)/2),t._input.contours||(t._input.contours={}),i.extendFlat(t._input.contours,{start:e.start,end:e.end,size:e.size}),t._input.autocontour=!0}else if("constraint"!==e.type){var l,c=e.start,u=e.end,f=t._input.contours;if(c>u&&(e.start=f.start=u,u=e.end=f.end=c,c=e.start),!(e.size>0))l=c===u?1:a(c,u,t.ncontours).dtick,f.size=e.size=l}}},{"../../lib":660,"../../plots/cartesian/axes":706}],890:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../components/drawing"),a=t("../heatmap/style"),o=t("./make_color_map");e.exports=function(t){var e=n.select(t).selectAll("g.contour");e.style("opacity",function(t){return t.trace.opacity}),e.each(function(t){var e=n.select(this),r=t.trace,a=r.contours,s=r.line,l=a.size||1,c=a.start,u="constraint"===a.type,f=!u&&"lines"===a.coloring,h=!u&&"fill"===a.coloring,p=f||h?o(r):null;e.selectAll("g.contourlevel").each(function(t){n.select(this).selectAll("path").call(i.lineGroupStyle,s.width,f?p(t.level):s.color,s.dash)});var d=a.labelfont;if(e.selectAll("g.contourlabels text").each(function(t){i.font(n.select(this),{family:d.family,size:d.size,color:d.color||(f?p(t.level):s.color)})}),u)e.selectAll("g.contourfill path").style("fill",r.fillcolor);else if(h){var g;e.selectAll("g.contourfill path").style("fill",function(t){return void 0===g&&(g=t.level),p(t.level+.5*l)}),void 0===g&&(g=c),e.selectAll("g.contourbg path").style("fill",p(g-.5*l))}}),a(t)}},{"../../components/drawing":557,"../heatmap/style":912,"./make_color_map":886,d3:131}],891:[function(t,e,r){"use strict";var n=t("../../components/colorscale/defaults"),i=t("./label_defaults");e.exports=function(t,e,r,a,o){var s,l=r("contours.coloring"),c="";"fill"===l&&(s=r("contours.showlines")),!1!==s&&("lines"!==l&&(c=r("line.color","#000")),r("line.width",.5),r("line.dash")),"none"!==l&&n(t,e,a,r,{prefix:"",cLetter:"z"}),r("line.smoothing"),i(r,a,c,o)}},{"../../components/colorscale/defaults":542,"./label_defaults":885}],892:[function(t,e,r){"use strict";var n=t("../heatmap/attributes"),i=t("../contour/attributes"),a=i.contours,o=t("../scatter/attributes"),s=t("../../components/colorscale/attributes"),l=t("../../components/colorbar/attributes"),c=t("../../lib/extend").extendFlat,u=o.line;e.exports=c({},{carpet:{valType:"string",editType:"calc"},z:n.z,a:n.x,a0:n.x0,da:n.dx,b:n.y,b0:n.y0,db:n.dy,text:n.text,transpose:n.transpose,atype:n.xtype,btype:n.ytype,fillcolor:i.fillcolor,autocontour:i.autocontour,ncontours:i.ncontours,contours:{type:a.type,start:a.start,end:a.end,size:a.size,coloring:{valType:"enumerated",values:["fill","lines","none"],dflt:"fill",editType:"calc"},showlines:a.showlines,showlabels:a.showlabels,labelfont:a.labelfont,labelformat:a.labelformat,operation:a.operation,value:a.value,editType:"calc",impliedEdits:{autocontour:!1}},line:{color:c({},u.color,{}),width:u.width,dash:u.dash,smoothing:c({},u.smoothing,{}),editType:"plot"}},s,{autocolorscale:c({},s.autocolorscale,{dflt:!1})},{colorbar:l})},{"../../components/colorbar/attributes":533,"../../components/colorscale/attributes":538,"../../lib/extend":649,"../contour/attributes":870,"../heatmap/attributes":899,"../scatter/attributes":990}],893:[function(t,e,r){"use strict";var n=t("../../components/colorscale/calc"),i=t("../../lib").isArray1D,a=t("../heatmap/convert_column_xyz"),o=t("../heatmap/clean_2d_array"),s=t("../heatmap/max_row_length"),l=t("../heatmap/interp2d"),c=t("../heatmap/find_empties"),u=t("../heatmap/make_bound_array"),f=t("./defaults"),h=t("../carpet/lookup_carpetid"),p=t("../contour/set_contours");e.exports=function(t,e){var r=e._carpetTrace=h(t,e);if(r&&r.visible&&"legendonly"!==r.visible){if(!e.a||!e.b){var d=t.data[r.index],g=t.data[e.index];g.a||(g.a=d.a),g.b||(g.b=d.b),f(g,e,e._defaultColor,t._fullLayout)}var m=function(t,e){var r,f,h,p,d,g,m,v=e._carpetTrace,y=v.aaxis,x=v.baxis;y._minDtick=0,x._minDtick=0,i(e.z)&&a(e,y,x,"a","b",["z"]);r=e._a=e._a||e.a,p=e._b=e._b||e.b,r=r?y.makeCalcdata(e,"_a"):[],p=p?x.makeCalcdata(e,"_b"):[],f=e.a0||0,h=e.da||1,d=e.b0||0,g=e.db||1,m=e._z=o(e._z||e.z,e.transpose),e._emptypoints=c(m),e._interpz=l(m,e._emptypoints,e._interpz);var b=s(m),_="scaled"===e.xtype?"":r,w=u(e,_,f,h,b,y),k="scaled"===e.ytype?"":p,M=u(e,k,d,g,m.length,x),A={a:w,b:M,z:m};"levels"===e.contours.type&&"none"!==e.contours.coloring&&n(e,m,"","z");return[A]}(0,e);return p(e),m}}},{"../../components/colorscale/calc":539,"../../lib":660,"../carpet/lookup_carpetid":847,"../contour/set_contours":889,"../heatmap/clean_2d_array":901,"../heatmap/convert_column_xyz":903,"../heatmap/find_empties":905,"../heatmap/interp2d":908,"../heatmap/make_bound_array":909,"../heatmap/max_row_length":910,"./defaults":894}],894:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../heatmap/xyz_defaults"),a=t("./attributes"),o=t("../contour/constraint_defaults"),s=t("../contour/contours_defaults"),l=t("../contour/style_defaults");e.exports=function(t,e,r,c){function u(r,i){return n.coerce(t,e,a,r,i)}if(u("carpet"),t.a&&t.b){if(!i(t,e,u,c,"a","b"))return void(e.visible=!1);u("text");var f="constraint"===u("contours.type");f||delete e.showlegend,f?o(t,e,u,c,r,{hasHover:!1}):(s(t,e,u,function(r){return n.coerce2(t,e,a,r)}),l(t,e,u,c,{hasHover:!1}))}else e._defaultColor=r,e._length=null}},{"../../lib":660,"../contour/constraint_defaults":875,"../contour/contours_defaults":877,"../contour/style_defaults":891,"../heatmap/xyz_defaults":914,"./attributes":892}],895:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../contour/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../contour/style"),n.moduleType="trace",n.name="contourcarpet",n.basePlotModule=t("../../plots/cartesian"),n.categories=["cartesian","svg","carpet","contour","symbols","showLegend","hasLines","carpetDependent"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"../contour/colorbar":873,"../contour/style":890,"./attributes":892,"./calc":893,"./defaults":894,"./plot":898}],896:[function(t,e,r){"use strict";var n=t("../../components/drawing"),i=t("../carpet/axis_aligned_line"),a=t("../../lib");e.exports=function(t,e,r,o,s,l,c,u){var f,h,p,d,g,m,v,y="",x=e.edgepaths.map(function(t,e){return e}),b=!0,_=1e-4*Math.abs(r[0][0]-r[2][0]),w=1e-4*Math.abs(r[0][1]-r[2][1]);function k(t){return Math.abs(t[1]-r[0][1])=0&&(p=E,g=m):Math.abs(h[1]-p[1])=0&&(p=E,g=m):a.log("endpt to newendpt is not vert. or horz.",h,p,E)}if(g>=0)break;y+=S(h,p),h=p}if(g===e.edgepaths.length){a.log("unclosed perimeter path");break}f=g,(b=-1===x.indexOf(f))&&(f=x[0],y+=S(h,p)+"Z",h=null)}for(f=0;f=0;q--)j=M.clipsegments[q],V=i([],j.x,E.c2p),U=i([],j.y,L.c2p),V.reverse(),U.reverse(),G.push(a(V,U,j.bicubic));var W="M"+G.join("L")+"Z";!function(t,e,r,n,o,l){var c,u,f,h,p=s.ensureSingle(t,"g","contourbg").selectAll("path").data("fill"!==l||o?[]:[0]);p.enter().append("path"),p.exit().remove();var d=[];for(h=0;hm&&(n.max=m);n.len=n.max-n.min}(this,r,t,n,c,e.height),!(n.len<(e.width+e.height)*h.LABELMIN)))for(var i=Math.min(Math.ceil(n.len/P),h.LABELMAX),a=0;az){E("x scale is not linear");break}}if(m.length&&"fast"===S){var P=(m[m.length-1]-m[0])/(m.length-1),D=Math.abs(P/100);for(b=0;bD){E("y scale is not linear");break}}}var O=c(x),I="scaled"===e.xtype?"":r,R=p(e,I,d,g,O,w),B="scaled"===e.ytype?"":m,F=p(e,B,v,y,x.length,k);T||(a.expand(w,R),a.expand(k,F));var N={x:R,y:F,z:x,text:e._text||e.text};if(I&&I.length===R.length-1&&(N.xCenter=I),B&&B.length===F.length-1&&(N.yCenter=B),A&&(N.xRanges=_.xRanges,N.yRanges=_.yRanges,N.pts=_.pts),M&&"constraint"===e.contours.type||s(e,x,"","z"),M&&e.contours&&"heatmap"===e.contours.coloring){var j={type:"contour"===e.type?"heatmap":"histogram2d",xcalendar:e.xcalendar,ycalendar:e.ycalendar};N.xfill=p(j,I,d,g,O,w),N.yfill=p(j,B,v,y,x.length,k)}return[N]}},{"../../components/colorscale/calc":539,"../../lib":660,"../../plots/cartesian/axes":706,"../../registry":790,"../histogram2d/calc":931,"./clean_2d_array":901,"./convert_column_xyz":903,"./find_empties":905,"./interp2d":908,"./make_bound_array":909,"./max_row_length":910}],901:[function(t,e,r){"use strict";var n=t("fast-isnumeric");e.exports=function(t,e){var r,i,a,o,s,l;function c(t){if(n(t))return+t}if(e){for(r=0,s=0;s=0;o--)(s=((f[[(r=(a=h[o])[0])-1,i=a[1]]]||g)[2]+(f[[r+1,i]]||g)[2]+(f[[r,i-1]]||g)[2]+(f[[r,i+1]]||g)[2])/20)&&(l[a]=[r,i,s],h.splice(o,1),c=!0);if(!c)throw"findEmpties iterated with no new neighbors";for(a in l)f[a]=l[a],u.push(l[a])}return u.sort(function(t,e){return e[2]-t[2]})}},{"./max_row_length":910}],906:[function(t,e,r){"use strict";var n=t("../../components/fx"),i=t("../../lib"),a=t("../../plots/cartesian/axes");e.exports=function(t,e,r,o,s,l){var c,u,f,h,p=t.cd[0],d=p.trace,g=t.xa,m=t.ya,v=p.x,y=p.y,x=p.z,b=p.xCenter,_=p.yCenter,w=p.zmask,k=[d.zmin,d.zmax],M=d.zhoverformat,A=v,T=y;if(!1!==t.index){try{f=Math.round(t.index[1]),h=Math.round(t.index[0])}catch(e){return void i.error("Error hovering on heatmap, pointNumber must be [row,col], found:",t.index)}if(f<0||f>=x[0].length||h<0||h>x.length)return}else{if(n.inbox(e-v[0],e-v[v.length-1],0)>0||n.inbox(r-y[0],r-y[y.length-1],0)>0)return;if(l){var S;for(A=[2*v[0]-v[1]],S=1;Sg&&(v=Math.max(v,Math.abs(t[a][o]-d)/(m-g))))}return v}e.exports=function(t,e,r){var i,s,l=1;if(Array.isArray(r))for(i=0;i.01;i++)l=o(t,e,a(l));return l>.01&&n.log("interp2d didn't converge quickly",l),t}},{"../../lib":660}],909:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib").isArrayOrTypedArray;e.exports=function(t,e,r,a,o,s){var l,c,u,f=[],h=n.traceIs(t,"contour"),p=n.traceIs(t,"histogram"),d=n.traceIs(t,"gl2d");if(i(e)&&e.length>1&&!p&&"category"!==s.type){var g=e.length;if(!(g<=o))return h?e.slice(0,o):e.slice(0,o+1);if(h||d)f=e.slice(0,o);else if(1===o)f=[e[0]-.5,e[0]+.5];else{for(f=[1.5*e[0]-.5*e[1]],u=1;u0;)f=_.c2p(A[y]),y--;for(f0;)v=w.c2p(T[y]),y--;if(v image").each(function(t){var e=t.trace||{};a[e.uid]||n.select(this.parentNode).remove()});for(var o=0;o0&&(a=!0);for(var l=0;la){var o=a-r[t];return r[t]=a,o}}return 0},max:function(t,e,r,i){var a=i[e];if(n(a)){if(a=Number(a),!n(r[t]))return r[t]=a,a;if(r[t]c?t>o?t>1.1*i?i:t>1.1*a?a:o:t>s?s:t>l?l:c:Math.pow(10,Math.floor(Math.log(t)/Math.LN10))}function p(t,e,r,n,a,s){if(n&&t>o){var l=d(e,a,s),c=d(r,a,s),u=t===i?0:1;return l[u]!==c[u]}return Math.floor(r/t)-Math.floor(e/t)>.1}function d(t,e,r){var n=e.c2d(t,i,r).split("-");return""===n[0]&&(n.unshift(),n[0]="-"+n[0]),n}e.exports=function(t,e,r,n,a){var s,l,c=-1.1*e,h=-.1*e,p=t-h,d=r[0],g=r[1],m=Math.min(f(d+h,d+p,n,a),f(g+h,g+p,n,a)),v=Math.min(f(d+c,d+h,n,a),f(g+c,g+h,n,a));if(m>v&&vo){var y=s===i?1:6,x=s===i?"M12":"M1";return function(e,r){var o=n.c2d(e,i,a),s=o.indexOf("-",y);s>0&&(o=o.substr(0,s));var c=n.d2c(o,0,a);if(cu.size/1.9?u.size:u.size/Math.ceil(u.size/x);var A=u.start+(u.size-x)/2;b=A-x*Math.ceil((A-b)/x)}for(s=0;s=0&&w=0;n--)s(n);else if("increasing"===e){for(n=1;n=0;n--)t[n]+=t[n+1];"exclude"===r&&(t.push(0),t.shift())}}(d,x.direction,x.currentbin);var Z=Math.min(f.length,d.length),J=[],K=0,Q=Z-1;for(r=0;r=K;r--)if(d[r]){Q=r;break}for(r=K;r<=Q;r++)if(n(f[r])&&n(d[r])){var $={p:f[r],s:d[r],b:0};x.enabled||($.pts=z[r],H?$.p0=$.p1=z[r].length?A[z[r][0]]:f[r]:($.p0=U(S[r]),$.p1=U(S[r+1],!0))),J.push($)}return 1===J.length&&(J[0].width1=a.tickIncrement(J[0].p,M.size,!1,y)-J[0].p),o(J,e),i.isArrayOrTypedArray(e.selectedpoints)&&i.tagSelected(J,e,Y),J}}},{"../../constants/numerical":637,"../../lib":660,"../../plots/cartesian/axes":706,"../bar/arrays_to_calcdata":799,"./average":919,"./bin_functions":921,"./bin_label_vals":922,"./clean_bins":924,"./norm_functions":929,"fast-isnumeric":197}],924:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib").cleanDate,a=t("../../constants/numerical"),o=a.ONEDAY,s=a.BADNUM;e.exports=function(t,e,r){var a=e.type,l=r+"bins",c=t[l];c||(c=t[l]={});var u="date"===a?function(t){return t||0===t?i(t,s,c.calendar):null}:function(t){return n(t)?Number(t):null};c.start=u(c.start),c.end=u(c.end);var f="date"===a?o:1,h=c.size;if(n(h))c.size=h>0?Number(h):f;else if("string"!=typeof h)c.size=f;else{var p=h.charAt(0),d=h.substr(1);((d=n(d)?Number(d):0)<=0||"date"!==a||"M"!==p||d!==Math.round(d))&&(c.size=f)}var g="autobin"+r;"boolean"!=typeof t[g]&&(t[g]=t._fullInput[g]=t._input[g]=!((c.start||0===c.start)&&(c.end||0===c.end))),t[g]||(delete t["nbins"+r],delete t._fullInput["nbins"+r])}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],925:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("../../components/color"),o=t("./bin_defaults"),s=t("../bar/style_defaults"),l=t("./attributes");e.exports=function(t,e,r,c){function u(r,n){return i.coerce(t,e,l,r,n)}var f=u("x"),h=u("y");u("cumulative.enabled")&&(u("cumulative.direction"),u("cumulative.currentbin")),u("text");var p=u("orientation",h&&!f?"h":"v"),d="v"===p?"x":"y",g="v"===p?"y":"x",m=f&&h?Math.min(f.length&&h.length):(e[d]||[]).length;if(m){e._length=m,n.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x","y"],c),e[g]&&u("histfunc"),o(t,e,u,[d]),s(t,e,u,r,c);var v=n.getComponentMethod("errorbars","supplyDefaults");v(t,e,a.defaultLine,{axis:"y"}),v(t,e,a.defaultLine,{axis:"x",inherit:"y"}),i.coerceSelectionMarkerOpacity(e,u)}else e.visible=!1}},{"../../components/color":532,"../../lib":660,"../../registry":790,"../bar/style_defaults":812,"./attributes":918,"./bin_defaults":920}],926:[function(t,e,r){"use strict";e.exports=function(t,e,r,n,i){if(t.x="xVal"in e?e.xVal:e.x,t.y="yVal"in e?e.yVal:e.y,e.xa&&(t.xaxis=e.xa),e.ya&&(t.yaxis=e.ya),!(r.cumulative||{}).enabled){var a,o=Array.isArray(i)?n[0].pts[i[0]][i[1]]:n[i].pts;if(t.pointNumbers=o,t.binNumber=t.pointNumber,delete t.pointNumber,delete t.pointIndex,r._indexToPoints){a=[];for(var s=0;sA&&m.splice(A,m.length-A),y.length>A&&y.splice(A,y.length-A),u(e,"x",m,g,_,k,x),u(e,"y",y,v,w,M,b);var T=[],S=[],C=[],E="string"==typeof e.xbins.size,L="string"==typeof e.ybins.size,z=[],P=[],D=E?z:e.xbins,O=L?P:e.ybins,I=0,R=[],B=[],F=e.histnorm,N=e.histfunc,j=-1!==F.indexOf("density"),V="max"===N||"min"===N?null:0,U=a.count,q=o[F],H=!1,G=[],W=[],Y="z"in e?e.z:"marker"in e&&Array.isArray(e.marker.color)?e.marker.color:"";Y&&"count"!==N&&(H="avg"===N,U=a[N]);var X=e.xbins,Z=_(X.start),J=_(X.end)+(Z-i.tickIncrement(Z,X.size,!1,x))/1e6;for(r=Z;r=0&&c=0&&d0)c=a(t.alphahull,u);else{var p=["x","y","z"].indexOf(t.delaunayaxis);c=i(u.map(function(t){return[t[(p+1)%3],t[(p+2)%3]]}))}var d={positions:u,cells:c,lightPosition:[t.lightposition.x,t.lightposition.y,t.lightposition.z],ambient:t.lighting.ambient,diffuse:t.lighting.diffuse,specular:t.lighting.specular,roughness:t.lighting.roughness,fresnel:t.lighting.fresnel,vertexNormalsEpsilon:t.lighting.vertexnormalsepsilon,faceNormalsEpsilon:t.lighting.facenormalsepsilon,opacity:t.opacity,contourEnable:t.contour.show,contourColor:l(t.contour.color).slice(0,3),contourWidth:t.contour.width,useFacetNormals:t.flatshading};t.intensity?(this.color="#fff",d.vertexIntensity=t.intensity,d.vertexIntensityBounds=[t.cmin,t.cmax],d.colormap=s(t.colorscale)):t.vertexcolor?(this.color=t.vertexcolor[0],d.vertexColors=f(t.vertexcolor)):t.facecolor?(this.color=t.facecolor[0],d.cellColors=f(t.facecolor)):(this.color=t.color,d.meshColor=l(t.color)),this.mesh.update(d)},u.dispose=function(){this.scene.glplot.remove(this.mesh),this.mesh.dispose()},e.exports=function(t,e){var r=t.glplot.gl,i=n({gl:r}),a=new c(t,i,e.uid);return i._trace=a,a.update(e),t.glplot.add(i),a}},{"../../lib/gl_format_color":656,"../../lib/str2rgbarray":683,"alpha-shape":49,"convex-hull":111,"delaunay-triangulate":133,"gl-mesh3d":249}],943:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("../../components/colorscale/defaults"),o=t("./attributes");e.exports=function(t,e,r,s){function l(r,n){return i.coerce(t,e,o,r,n)}function c(t){var e=t.map(function(t){var e=l(t);return e&&i.isArrayOrTypedArray(e)?e:null});return e.every(function(t){return t&&t.length===e[0].length})&&e}var u=c(["x","y","z"]),f=c(["i","j","k"]);u?(f&&f.forEach(function(t){for(var e=0;ed):p=_>y,d=_;var w=s(y,x,b,_);w.pos=v,w.yc=(y+_)/2,w.i=m,w.dir=p?"increasing":"decreasing",h&&(w.tx=e.text[m]),g.push(w)}}return a.expand(n,u.concat(c),{padded:!0}),g.length&&(g[0].t={labels:{open:i(t,"open:")+" ",high:i(t,"high:")+" ",low:i(t,"low:")+" ",close:i(t,"close:")+" "}}),g}e.exports={calc:function(t,e){var r=a.getFromId(t,e.xaxis),i=a.getFromId(t,e.yaxis),o=function(t,e,r){var i=r._minDiff;if(!i){var a,o=t._fullData,s=[];for(i=1/0,a=0;a"),t.y0=t.y1=f.c2p(C.yc,!0),[t]}},{"../../components/color":532,"../../components/fx":574,"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998}],949:[function(t,e,r){"use strict";e.exports={moduleType:"trace",name:"ohlc",basePlotModule:t("../../plots/cartesian"),categories:["cartesian","svg","showLegend"],meta:{},attributes:t("./attributes"),supplyDefaults:t("./defaults"),calc:t("./calc").calc,plot:t("./plot"),style:t("./style"),hoverPoints:t("./hover"),selectPoints:t("./select")}},{"../../plots/cartesian":717,"./attributes":945,"./calc":946,"./defaults":947,"./hover":948,"./plot":951,"./select":952,"./style":953}],950:[function(t,e,r){"use strict";var n=t("../../registry");e.exports=function(t,e,r,i){var a=r("x"),o=r("open"),s=r("high"),l=r("low"),c=r("close");if(n.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x"],i),o&&s&&l&&c){var u=Math.min(o.length,s.length,l.length,c.length);return a&&(u=Math.min(u,a.length)),e._length=u,u}}},{"../../registry":790}],951:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib");e.exports=function(t,e,r,a){var o=e.xaxis,s=e.yaxis,l=a.selectAll("g.trace").data(r,function(t){return t[0].trace.uid});l.enter().append("g").attr("class","trace ohlc"),l.exit().remove(),l.order(),l.each(function(t){var r=t[0],a=r.t,l=r.trace,c=n.select(this);if(e.isRangePlot||(r.node3=c),!0!==l.visible||a.empty)c.remove();else{var u=a.tickLen,f=c.selectAll("path").data(i.identity);f.enter().append("path"),f.exit().remove(),f.attr("d",function(t){var e=o.c2p(t.pos,!0),r=o.c2p(t.pos-u,!0),n=o.c2p(t.pos+u,!0);return"M"+r+","+s.c2p(t.o,!0)+"H"+e+"M"+e+","+s.c2p(t.h,!0)+"V"+s.c2p(t.l,!0)+"M"+n+","+s.c2p(t.c,!0)+"H"+e})}})}},{"../../lib":660,d3:131}],952:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n=t.cd,i=t.xaxis,a=t.yaxis,o=[],s=n[0].t.bPos||0;if(!1===e)for(r=0;r=0;a--){var o=t[a];if(e>f(n,o))return c(n,i);if(e>o||a===t.length-1)return c(o,n);i=n,n=o}}function d(t,e){for(var r=0;r=e[r][0]&&t<=e[r][1])return!0;return!1}function g(t){t.attr("x",-n.bar.captureWidth/2).attr("width",n.bar.captureWidth)}function m(t){t.attr("visibility","visible").style("visibility","visible").attr("fill","yellow").attr("opacity",0)}function v(t){if(!t.brush.filterSpecified)return"0,"+t.height;for(var e,r,n,i=y(t.brush.filter.getConsolidated(),t.height),a=[0],o=i.length?i[0][0]:null,s=0;se){h=r;break}}if(a=u,isNaN(a)&&(a=isNaN(f)||isNaN(h)?isNaN(f)?h:f:e-c[f][1]t[1]+r||e=.9*t[1]+.1*t[0]?"n":e<=.9*t[0]+.1*t[1]?"s":"ns"}(d,e);g&&(o.interval=l[a],o.intervalPix=d,o.region=g)}}if(t.ordinal&&!o.region){var m=t.unitTickvals,v=t.unitToPaddedPx.invert(e);for(r=0;r=x[0]&&v<=x[1]){o.clickableOrdinalRange=x;break}}}return o}function k(t){t.on("mousemove",function(t){if(i.event.preventDefault(),!t.parent.inBrushDrag){var e=w(t,t.height-i.mouse(this)[1]-2*n.verticalPadding),r="crosshair";e.clickableOrdinalRange?r="pointer":e.region&&(r=e.region+"-resize"),i.select(document.body).style("cursor",r)}}).on("mouseleave",function(t){t.parent.inBrushDrag||x()}).call(i.behavior.drag().on("dragstart",function(t){i.event.sourceEvent.stopPropagation();var e=t.height-i.mouse(this)[1]-2*n.verticalPadding,r=t.unitToPaddedPx.invert(e),a=t.brush,o=w(t,e),s=o.interval,l=a.svgBrush;if(l.wasDragged=!1,l.grabbingBar="ns"===o.region,l.grabbingBar){var c=s.map(t.unitToPaddedPx);l.grabPoint=e-c[0]-n.verticalPadding,l.barLength=c[1]-c[0]}l.clickableOrdinalRange=o.clickableOrdinalRange,l.stayingIntervals=t.multiselect&&a.filterSpecified?a.filter.getConsolidated():[],s&&(l.stayingIntervals=l.stayingIntervals.filter(function(t){return t[0]!==s[0]&&t[1]!==s[1]})),l.startExtent=o.region?s["s"===o.region?1:0]:r,t.parent.inBrushDrag=!0,l.brushStartCallback()}).on("drag",function(t){i.event.sourceEvent.stopPropagation();var e=t.height-i.mouse(this)[1]-2*n.verticalPadding,r=t.brush.svgBrush;r.wasDragged=!0,r.grabbingBar?r.newExtent=[e-r.grabPoint,e+r.barLength-r.grabPoint].map(t.unitToPaddedPx.invert):r.newExtent=[r.startExtent,t.unitToPaddedPx.invert(e)].sort(s);var a=Math.max(0,-r.newExtent[0]),o=Math.max(0,r.newExtent[1]-1);r.newExtent[0]+=a,r.newExtent[1]-=o,r.grabbingBar&&(r.newExtent[1]+=a,r.newExtent[0]-=o),t.brush.filterSpecified=!0,r.extent=r.stayingIntervals.concat([r.newExtent]),r.brushCallback(t),_(this.parentNode)}).on("dragend",function(t){i.event.sourceEvent.stopPropagation();var e=t.brush,r=e.filter,n=e.svgBrush,a=n.grabbingBar;if(n.grabbingBar=!1,n.grabLocation=void 0,t.parent.inBrushDrag=!1,x(),!n.wasDragged)return n.wasDragged=void 0,n.clickableOrdinalRange?e.filterSpecified&&t.multiselect?n.extent.push(n.clickableOrdinalRange):(n.extent=[n.clickableOrdinalRange],e.filterSpecified=!0):a?(n.extent=n.stayingIntervals,0===n.extent.length&&A(e)):A(e),n.brushCallback(t),_(this.parentNode),void n.brushEndCallback(e.filterSpecified?r.getConsolidated():[]);var o=function(){r.set(r.getConsolidated())};if(t.ordinal){var s=t.unitTickvals;s[s.length-1]n.newExtent[0];n.extent=n.stayingIntervals.concat(l?[n.newExtent]:[]),n.extent.length||A(e),n.brushCallback(t),l?_(this.parentNode,o):(o(),_(this.parentNode))}else o();n.brushEndCallback(e.filterSpecified?r.getConsolidated():[])}))}function M(t,e){return t[0]-e[0]}function A(t){t.filterSpecified=!1,t.svgBrush.extent=[[0,1]]}function T(t){for(var e,r=t.slice(),n=[],i=r.shift();i;){for(e=i.slice();(i=r.shift())&&i[0]<=e[1];)e[1]=Math.max(e[1],i[1]);n.push(e)}return n}e.exports={makeBrush:function(t,e,r,n,i,a){var o,l=function(){var t,e,r=[];return{set:function(n){r=n.map(function(t){return t.slice().sort(s)}).sort(M),t=T(r),e=r.reduce(function(t,e){return[Math.min(t[0],e[0]),Math.max(t[1],e[1])]},[1/0,-1/0])},get:function(){return r.slice()},getConsolidated:function(){return t},getBounds:function(){return e}}}();return l.set(r),{filter:l,filterSpecified:e,svgBrush:{extent:[],brushStartCallback:n,brushCallback:(o=i,function(t){var e=t.brush,r=function(t){return t.svgBrush.extent.map(function(t){return t.slice()})}(e).slice();e.filter.set(r),o()}),brushEndCallback:a}}},ensureAxisBrush:function(t){var e=t.selectAll("."+n.cn.axisBrush).data(o,a);e.enter().append("g").classed(n.cn.axisBrush,!0),function(t){var e=t.selectAll(".background").data(o);e.enter().append("rect").classed("background",!0).call(g).call(m).style("pointer-events","auto").attr("transform","translate(0 "+n.verticalPadding+")"),e.call(k).attr("height",function(t){return t.height-n.verticalPadding});var r=t.selectAll(".highlight-shadow").data(o);r.enter().append("line").classed("highlight-shadow",!0).attr("x",-n.bar.width/2).attr("stroke-width",n.bar.width+n.bar.strokeWidth).attr("stroke",n.bar.strokeColor).attr("opacity",n.bar.strokeOpacity).attr("stroke-linecap","butt"),r.attr("y1",function(t){return t.height}).call(b);var i=t.selectAll(".highlight").data(o);i.enter().append("line").classed("highlight",!0).attr("x",-n.bar.width/2).attr("stroke-width",n.bar.width-n.bar.strokeWidth).attr("stroke",n.bar.fillColor).attr("opacity",n.bar.fillOpacity).attr("stroke-linecap","butt"),i.attr("y1",function(t){return t.height}).call(b)}(e)},cleanRanges:function(t,e){if(Array.isArray(t[0])?(t=t.map(function(t){return t.sort(s)}),t=e.multiselect?T(t.sort(M)):[t[0]]):t=[t.sort(s)],e.tickvals){var r=e.tickvals.slice().sort(s);if(!(t=t.map(function(t){var e=[h(r,t[0],[]),p(r,t[1],[])];if(e[1]>e[0])return e}).filter(function(t){return t})).length)return}return t.length>1?t:t[0]}}},{"../../lib":660,"../../lib/gup":657,"./constants":959,d3:131}],956:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/get_data").getModuleCalcData,a=t("./plot"),o=t("../../constants/xmlns_namespaces");r.name="parcoords",r.plot=function(t){var e=i(t.calcdata,"parcoords")[0];e.length&&a(t,e)},r.clean=function(t,e,r,n){var i=n._has&&n._has("parcoords"),a=e._has&&e._has("parcoords");i&&!a&&(n._paperdiv.selectAll(".parcoords").remove(),n._glimages.selectAll("*").remove())},r.toSVG=function(t){var e=t._fullLayout._glimages,r=n.select(t).selectAll(".svg-container");r.filter(function(t,e){return e===r.size()-1}).selectAll(".gl-canvas-context, .gl-canvas-focus").each(function(){var t=this.toDataURL("image/png");e.append("svg:image").attr({xmlns:o.svg,"xlink:href":t,preserveAspectRatio:"none",x:0,y:0,width:this.width,height:this.height})}),window.setTimeout(function(){n.selectAll("#filterBarPattern").attr("id","filterBarPattern")},60)}},{"../../constants/xmlns_namespaces":639,"../../plots/get_data":742,"./plot":964,d3:131}],957:[function(t,e,r){"use strict";var n=t("../../components/colorscale/has_colorscale"),i=t("../../components/colorscale/calc"),a=t("../../lib"),o=t("../../lib/gup").wrap;e.exports=function(t,e){var r=!!e.line.colorscale&&a.isArrayOrTypedArray(e.line.color),s=r?e.line.color:function(t){for(var e=new Array(t),r=0;rs&&(n.log("parcoords traces support up to "+s+" dimensions at the moment"),l.splice(s)),o=0;o>>8*e)%256/255}function M(t,e,r){var n,i,a,o=[];for(i=0;i=h-4?k(o,h-2-s):.5);return a}(d,p,i);!function(t,e,r){for(var n=0;n<16;n++)t["p"+n.toString(16)](M(e,r,n))}(E,d,o),L=S.texture(l.extendFlat({data:function(t,e,r){for(var n=[],i=0;i<256;i++){var a=t(i/255);n.push((e?v:a).concat(r))}return n}(r.unitToColor,A,Math.round(255*(A?a:1)))},b))}var D=[0,1];var O=[];function I(t,e,n,i,a,o,s,c,u,f,h){var p,d,g,m,v=[t,e],y=[0,1].map(function(){return[0,1,2,3].map(function(){return new Float32Array(16)})});for(p=0;p<2;p++)for(m=v[p],d=0;d<4;d++)for(g=0;g<16;g++)y[p][d][g]=g+16*d===m?1:0;var x=r.lines.canvasOverdrag,b=r.domain,_=r.canvasWidth,w=r.canvasHeight;return l.extendFlat({key:s,resolution:[_,w],viewBoxPosition:[n+x,i],viewBoxSize:[a,o],i:t,ii:e,dim1A:y[0][0],dim1B:y[0][1],dim1C:y[0][2],dim1D:y[0][3],dim2A:y[1][0],dim2B:y[1][1],dim2C:y[1][2],dim2D:y[1][3],colorClamp:D,scissorX:(c===u?0:n+x)+(r.pad.l-x)+r.layoutWidth*b.x[0],scissorWidth:(c===f?_-n+x:a+.5)+(c===u?n+x:0),scissorY:i+r.pad.b+r.layoutHeight*b.y[0],scissorHeight:o,viewportX:r.pad.l-x+r.layoutWidth*b.x[0],viewportY:r.pad.b+r.layoutHeight*b.y[0],viewportWidth:_,viewportHeight:w},h)}return{setColorDomain:function(t){D[0]=t[0],D[1]=t[1]},render:function(t,e,n){var i,a,o,s=t.length,l=1/0,c=-1/0;for(i=0;ic&&(c=t[i].dim2.canvasX,o=i),t[i].dim1.canvasXn._length&&(M=M.slice(0,n._length));var A,T=n.tickvals;function S(t,e){return{val:t,text:A[e]}}function C(t,e){return t.val-e.val}if(Array.isArray(T)&&T.length){A=n.ticktext,Array.isArray(A)&&A.length?A.length>T.length?A=A.slice(0,T.length):T.length>A.length&&(T=T.slice(0,A.length)):A=T.map(o.format(n.tickformat));for(var E=1;E=r||s>=n)return;var l=t.lineLayer.readPixel(a,n-1-s),c=0!==l[3],u=c?l[2]+256*(l[1]+256*l[0]):null,f={x:a,y:s,clientX:e.clientX,clientY:e.clientY,dataIndex:t.model.key,curveNumber:u};u!==M&&(c?d.hover(f):d.unhover&&d.unhover(f),M=u)}}),k.style("opacity",function(t){return t.pick?.01:1}),e.style("background","rgba(255, 255, 255, 0)");var A=e.selectAll("."+i.cn.parcoords).data(w,c);A.exit().remove(),A.enter().append("g").classed(i.cn.parcoords,!0).style("shape-rendering","crispEdges").style("pointer-events","none"),A.attr("transform",function(t){return"translate("+t.model.translateX+","+t.model.translateY+")"});var T=A.selectAll("."+i.cn.parcoordsControlView).data(u,c);T.enter().append("g").classed(i.cn.parcoordsControlView,!0),T.attr("transform",function(t){return"translate("+t.model.pad.l+","+t.model.pad.t+")"});var S=T.selectAll("."+i.cn.yAxis).data(function(t){return t.dimensions},c);function C(t,e){for(var r=e.panels||(e.panels=[]),n=t.data(),i=n.length-1,a=0;aline").attr("fill","none").attr("stroke","black").attr("stroke-opacity",.25).attr("stroke-width","1px"),L.selectAll("text").style("text-shadow","1px 1px 1px #fff, -1px -1px 1px #fff, 1px -1px 1px #fff, -1px 1px 1px #fff").style("cursor","default").style("user-select","none");var z=E.selectAll("."+i.cn.axisHeading).data(u,c);z.enter().append("g").classed(i.cn.axisHeading,!0);var P=z.selectAll("."+i.cn.axisTitle).data(u,c);P.enter().append("text").classed(i.cn.axisTitle,!0).attr("text-anchor","middle").style("cursor","ew-resize").style("user-select","none").style("pointer-events","auto"),P.attr("transform","translate(0,"+-i.axisTitleOffset+")").text(function(t){return t.label}).each(function(t){s.font(o.select(this),t.model.labelFont)});var D=E.selectAll("."+i.cn.axisExtent).data(u,c);D.enter().append("g").classed(i.cn.axisExtent,!0);var O=D.selectAll("."+i.cn.axisExtentTop).data(u,c);O.enter().append("g").classed(i.cn.axisExtentTop,!0),O.attr("transform","translate(0,"+-i.axisExtentOffset+")");var I=O.selectAll("."+i.cn.axisExtentTopText).data(u,c);function R(t,e){if(t.ordinal)return"";var r=t.domainScale.domain();return o.format(t.tickFormat)(r[e?r.length-1:0])}I.enter().append("text").classed(i.cn.axisExtentTopText,!0).call(y),I.text(function(t){return R(t,!0)}).each(function(t){s.font(o.select(this),t.model.rangeFont)});var B=D.selectAll("."+i.cn.axisExtentBottom).data(u,c);B.enter().append("g").classed(i.cn.axisExtentBottom,!0),B.attr("transform",function(t){return"translate(0,"+(t.model.height+i.axisExtentOffset)+")"});var F=B.selectAll("."+i.cn.axisExtentBottomText).data(u,c);F.enter().append("text").classed(i.cn.axisExtentBottomText,!0).attr("dy","0.75em").call(y),F.text(function(t){return R(t)}).each(function(t){s.font(o.select(this),t.model.rangeFont)}),h.ensureAxisBrush(E)}},{"../../components/drawing":557,"../../lib":660,"../../lib/gup":657,"./axisbrush":955,"./constants":959,"./lines":962,d3:131}],964:[function(t,e,r){"use strict";var n=t("./parcoords"),i=t("../../lib/prepare_regl");e.exports=function(t,e){var r=t._fullLayout,a=r._toppaper,o=r._paperdiv,s=r._glcontainer;i(t);var l={},c={},u=r._size;e.forEach(function(e,r){l[r]=t.data[r].dimensions,c[r]=t.data[r].dimensions.slice()});n(o,a,s,e,{width:u.w,height:u.h,margin:{t:u.t,r:u.r,b:u.b,l:u.l}},{filterChanged:function(e,r,n){var i=c[e][r],a=n.map(function(t){return t.slice()});a.length?(1===a.length&&(a=a[0]),i.constraintrange=a,a=[a]):(delete i.constraintrange,a=null);var o={};o["dimensions["+r+"].constraintrange"]=a,t.emit("plotly_restyle",[o,[e]])},hover:function(e){t.emit("plotly_hover",e)},unhover:function(e){t.emit("plotly_unhover",e)},axesMoved:function(e,r){function n(t){return!("visible"in t)||t.visible}function i(t,e,r){var n=e.indexOf(r),i=t.indexOf(n);return-1===i&&(i+=e.length),i}var a=function(t){return function(e,n){return i(r,t,e)-i(r,t,n)}}(c[e].filter(n));l[e].sort(a),c[e].filter(function(t){return!n(t)}).sort(function(t){return c[e].indexOf(t)}).forEach(function(t){l[e].splice(l[e].indexOf(t),1),l[e].splice(c[e].indexOf(t),0,t)}),t.emit("plotly_restyle")}})}},{"../../lib/prepare_regl":673,"./parcoords":963}],965:[function(t,e,r){"use strict";var n=t("../../components/color/attributes"),i=t("../../plots/font_attributes"),a=t("../../plots/attributes"),o=t("../../plots/domain").attributes,s=t("../../lib/extend").extendFlat,l=i({editType:"calc",colorEditType:"style"});e.exports={labels:{valType:"data_array",editType:"calc"},label0:{valType:"number",dflt:0,editType:"calc"},dlabel:{valType:"number",dflt:1,editType:"calc"},values:{valType:"data_array",editType:"calc"},marker:{colors:{valType:"data_array",editType:"calc"},line:{color:{valType:"color",dflt:n.defaultLine,arrayOk:!0,editType:"style"},width:{valType:"number",min:0,dflt:0,arrayOk:!0,editType:"style"},editType:"calc"},editType:"calc"},text:{valType:"data_array",editType:"calc"},hovertext:{valType:"string",dflt:"",arrayOk:!0,editType:"style"},scalegroup:{valType:"string",dflt:"",editType:"calc"},textinfo:{valType:"flaglist",flags:["label","text","value","percent"],extras:["none"],editType:"calc"},hoverinfo:s({},a.hoverinfo,{flags:["label","text","value","percent","name"]}),textposition:{valType:"enumerated",values:["inside","outside","auto","none"],dflt:"auto",arrayOk:!0,editType:"calc"},textfont:s({},l,{}),insidetextfont:s({},l,{}),outsidetextfont:s({},l,{}),domain:o({name:"pie",trace:!0,editType:"calc"}),hole:{valType:"number",min:0,max:1,dflt:0,editType:"calc"},sort:{valType:"boolean",dflt:!0,editType:"calc"},direction:{valType:"enumerated",values:["clockwise","counterclockwise"],dflt:"counterclockwise",editType:"calc"},rotation:{valType:"number",min:-360,max:360,dflt:0,editType:"calc"},pull:{valType:"number",min:0,max:1,dflt:0,arrayOk:!0,editType:"calc"}}},{"../../components/color/attributes":531,"../../lib/extend":649,"../../plots/attributes":703,"../../plots/domain":731,"../../plots/font_attributes":732}],966:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../plots/get_data").getModuleCalcData;r.name="pie",r.plot=function(t){var e=n.getModule("pie"),r=i(t.calcdata,e)[0];r.length&&e.plot(t,r)},r.clean=function(t,e,r,n){var i=n._has&&n._has("pie"),a=e._has&&e._has("pie");i&&!a&&n._pielayer.selectAll("g.trace").remove()}},{"../../plots/get_data":742,"../../registry":790}],967:[function(t,e,r){"use strict";var n,i=t("fast-isnumeric"),a=t("../../lib").isArrayOrTypedArray,o=t("tinycolor2"),s=t("../../components/color"),l=t("./helpers");function c(t,e){if(!n){var r=s.defaults;n=u(r)}var i=e||n;return i[t%i.length]}function u(t){var e,r=t.slice();for(e=0;e")}}return y}},{"../../components/color":532,"../../lib":660,"./helpers":970,"fast-isnumeric":197,tinycolor2:473}],968:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../plots/domain").defaults;e.exports=function(t,e,r,o){function s(r,a){return n.coerce(t,e,i,r,a)}var l,c=n.coerceFont,u=s("values"),f=n.isArrayOrTypedArray(u),h=s("labels");if(Array.isArray(h)&&(l=h.length,f&&(l=Math.min(l,u.length))),!Array.isArray(h)){if(!f)return void(e.visible=!1);l=u.length,s("label0"),s("dlabel")}if(l){e._length=l,s("marker.line.width")&&s("marker.line.color"),s("marker.colors"),s("scalegroup");var p=s("text"),d=s("textinfo",Array.isArray(p)?"text+percent":"percent");if(s("hovertext"),d&&"none"!==d){var g=s("textposition"),m=Array.isArray(g)||"auto"===g,v=m||"inside"===g,y=m||"outside"===g;if(v||y){var x=c(s,"textfont",o.font);v&&c(s,"insidetextfont",x),y&&c(s,"outsidetextfont",x)}}a(e,o,s),s("hole"),s("sort"),s("direction"),s("rotation"),s("pull")}else e.visible=!1}},{"../../lib":660,"../../plots/domain":731,"./attributes":965}],969:[function(t,e,r){"use strict";var n=t("../../components/fx/helpers").appendArrayMultiPointValues;e.exports=function(t,e){var r={curveNumber:e.index,pointNumbers:t.pts,data:e._input,fullData:e,label:t.label,color:t.color,value:t.v,v:t.v};return 1===t.pts.length&&(r.pointNumber=r.i=t.pts[0]),n(r,e,t.pts),r}},{"../../components/fx/helpers":571}],970:[function(t,e,r){"use strict";var n=t("../../lib");r.formatPiePercent=function(t,e){var r=(100*t).toPrecision(3);return-1!==r.lastIndexOf(".")&&(r=r.replace(/[.]?0+$/,"")),n.numSeparate(r,e)+"%"},r.formatPieValue=function(t,e){var r=t.toPrecision(10);return-1!==r.lastIndexOf(".")&&(r=r.replace(/[.]?0+$/,"")),n.numSeparate(r,e)},r.getFirstFilled=function(t,e){if(Array.isArray(t))for(var r=0;r0?1:-1)/2,y:a/(1+r*r/(n*n)),outside:!0}}e.exports=function(t,e){var r=t._fullLayout;!function(t,e){var r,n,i,a,o,s,l,c,u,f=[];for(i=0;il&&(l=s.pull[a]);o.r=Math.min(r,n)/(2+2*l),o.cx=e.l+e.w*(s.domain.x[1]+s.domain.x[0])/2,o.cy=e.t+e.h*(2-s.domain.y[1]-s.domain.y[0])/2,s.scalegroup&&-1===f.indexOf(s.scalegroup)&&f.push(s.scalegroup)}for(a=0;ai.vTotal/2?1:0)}(e),p.each(function(){var p=n.select(this).selectAll("g.slice").data(e);p.enter().append("g").classed("slice",!0),p.exit().remove();var m=[[[],[]],[[],[]]],v=!1;p.each(function(e){if(e.hidden)n.select(this).selectAll("path,g").remove();else{e.pointNumber=e.i,e.curveNumber=g.index,m[e.pxmid[1]<0?0:1][e.pxmid[0]<0?0:1].push(e);var a=d.cx,p=d.cy,y=n.select(this),x=y.selectAll("path.surface").data([e]),b=!1,_=!1;if(x.enter().append("path").classed("surface",!0).style({"pointer-events":"all"}),y.select("path.textline").remove(),y.on("mouseover",function(){var o=t._fullLayout,s=t._fullData[g.index];if(!t._dragging&&!1!==o.hovermode){var l=s.hoverinfo;if(Array.isArray(l)&&(l=i.castHoverinfo({hoverinfo:[c.castOption(l,e.pts)],_module:g._module},o,0)),"all"===l&&(l="label+text+value+percent+name"),"none"!==l&&"skip"!==l&&l){var h=f(e,d),m=a+e.pxmid[0]*(1-h),v=p+e.pxmid[1]*(1-h),y=r.separators,x=[];if(-1!==l.indexOf("label")&&x.push(e.label),-1!==l.indexOf("text")){var w=c.castOption(s.hovertext||s.text,e.pts);w&&x.push(w)}-1!==l.indexOf("value")&&x.push(c.formatPieValue(e.v,y)),-1!==l.indexOf("percent")&&x.push(c.formatPiePercent(e.v/d.vTotal,y));var k=g.hoverlabel,M=k.font;i.loneHover({x0:m-h*d.r,x1:m+h*d.r,y:v,text:x.join("
"),name:-1!==l.indexOf("name")?s.name:void 0,idealAlign:e.pxmid[0]<0?"left":"right",color:c.castOption(k.bgcolor,e.pts)||e.color,borderColor:c.castOption(k.bordercolor,e.pts),fontFamily:c.castOption(M.family,e.pts),fontSize:c.castOption(M.size,e.pts),fontColor:c.castOption(M.color,e.pts)},{container:o._hoverlayer.node(),outerContainer:o._paper.node(),gd:t}),b=!0}t.emit("plotly_hover",{points:[u(e,s)],event:n.event}),_=!0}}).on("mouseout",function(r){var a=t._fullLayout,o=t._fullData[g.index];_&&(r.originalEvent=n.event,t.emit("plotly_unhover",{points:[u(e,o)],event:n.event}),_=!1),b&&(i.loneUnhover(a._hoverlayer.node()),b=!1)}).on("click",function(){var r=t._fullLayout,a=t._fullData[g.index];t._dragging||!1===r.hovermode||(t._hoverdata=[u(e,a)],i.click(t,n.event))}),g.pull){var w=+c.castOption(g.pull,e.pts)||0;w>0&&(a+=w*e.pxmid[0],p+=w*e.pxmid[1])}e.cxFinal=a,e.cyFinal=p;var k=g.hole;if(e.v===d.vTotal){var M="M"+(a+e.px0[0])+","+(p+e.px0[1])+E(e.px0,e.pxmid,!0,1)+E(e.pxmid,e.px0,!0,1)+"Z";k?x.attr("d","M"+(a+k*e.px0[0])+","+(p+k*e.px0[1])+E(e.px0,e.pxmid,!1,k)+E(e.pxmid,e.px0,!1,k)+"Z"+M):x.attr("d",M)}else{var A=E(e.px0,e.px1,!0,1);if(k){var T=1-k;x.attr("d","M"+(a+k*e.px1[0])+","+(p+k*e.px1[1])+E(e.px1,e.px0,!1,k)+"l"+T*e.px0[0]+","+T*e.px0[1]+A+"Z")}else x.attr("d","M"+a+","+p+"l"+e.px0[0]+","+e.px0[1]+A+"Z")}var S=c.castOption(g.textposition,e.pts),C=y.selectAll("g.slicetext").data(e.text&&"none"!==S?[0]:[]);C.enter().append("g").classed("slicetext",!0),C.exit().remove(),C.each(function(){var r=s.ensureSingle(n.select(this),"text","",function(t){t.attr("data-notex",1)});r.text(e.text).attr({class:"slicetext",transform:"","text-anchor":"middle"}).call(o.font,"outside"===S?g.outsidetextfont:g.insidetextfont).call(l.convertToTspans,t);var i,c=o.bBox(r.node());"outside"===S?i=h(c,e):(i=function(t,e,r){var n=Math.sqrt(t.width*t.width+t.height*t.height),i=t.width/t.height,a=Math.PI*Math.min(e.v/r.vTotal,.5),o=1-r.trace.hole,s=f(e,r),l={scale:s*r.r*2/n,rCenter:1-s,rotate:0};if(l.scale>=1)return l;var c=i+1/(2*Math.tan(a)),u=r.r*Math.min(1/(Math.sqrt(c*c+.5)+c),o/(Math.sqrt(i*i+o/2)+i)),h={scale:2*u/t.height,rCenter:Math.cos(u/r.r)-u*i/r.r,rotate:(180/Math.PI*e.midangle+720)%180-90},p=1/i,d=p+1/(2*Math.tan(a)),g=r.r*Math.min(1/(Math.sqrt(d*d+.5)+d),o/(Math.sqrt(p*p+o/2)+p)),m={scale:2*g/t.width,rCenter:Math.cos(g/r.r)-g/i/r.r,rotate:(180/Math.PI*e.midangle+810)%180-90},v=m.scale>h.scale?m:h;return l.scale<1&&v.scale>l.scale?v:l}(c,e,d),"auto"===S&&i.scale<1&&(r.call(o.font,g.outsidetextfont),g.outsidetextfont.family===g.insidetextfont.family&&g.outsidetextfont.size===g.insidetextfont.size||(c=o.bBox(r.node())),i=h(c,e)));var u=a+e.pxmid[0]*i.rCenter+(i.x||0),m=p+e.pxmid[1]*i.rCenter+(i.y||0);i.outside&&(e.yLabelMin=m-c.height/2,e.yLabelMid=m,e.yLabelMax=m+c.height/2,e.labelExtraX=0,e.labelExtraY=0,v=!0),r.attr("transform","translate("+u+","+m+")"+(i.scale<1?"scale("+i.scale+")":"")+(i.rotate?"rotate("+i.rotate+")":"")+"translate("+-(c.left+c.right)/2+","+-(c.top+c.bottom)/2+")")})}function E(t,r,n,i){return"a"+i*d.r+","+i*d.r+" 0 "+e.largeArc+(n?" 1 ":" 0 ")+i*(r[0]-t[0])+","+i*(r[1]-t[1])}}),v&&function(t,e){var r,n,i,a,o,s,l,u,f,h,p,d,g;function m(t,e){return t.pxmid[1]-e.pxmid[1]}function v(t,e){return e.pxmid[1]-t.pxmid[1]}function y(t,r){r||(r={});var i,u,f,p,d,g,m=r.labelExtraY+(n?r.yLabelMax:r.yLabelMin),v=n?t.yLabelMin:t.yLabelMax,y=n?t.yLabelMax:t.yLabelMin,x=t.cyFinal+o(t.px0[1],t.px1[1]),b=m-v;if(b*l>0&&(t.labelExtraY=b),Array.isArray(e.pull))for(u=0;u=(c.castOption(e.pull,f.pts)||0)||((t.pxmid[1]-f.pxmid[1])*l>0?(p=f.cyFinal+o(f.px0[1],f.px1[1]),(b=p-v-t.labelExtraY)*l>0&&(t.labelExtraY+=b)):(y+t.labelExtraY-x)*l>0&&(i=3*s*Math.abs(u-h.indexOf(t)),d=f.cxFinal+a(f.px0[0],f.px1[0]),(g=d+i-(t.cxFinal+t.pxmid[0])-t.labelExtraX)*s>0&&(t.labelExtraX+=g)))}for(n=0;n<2;n++)for(i=n?m:v,o=n?Math.max:Math.min,l=n?1:-1,r=0;r<2;r++){for(a=r?Math.max:Math.min,s=r?1:-1,(u=t[n][r]).sort(i),f=t[1-n][r],h=f.concat(u),d=[],p=0;pMath.abs(c)?o+="l"+c*t.pxmid[0]/t.pxmid[1]+","+c+"H"+(i+t.labelExtraX+s):o+="l"+t.labelExtraX+","+l+"v"+(c-l)+"h"+s}else o+="V"+(t.yLabelMid+t.labelExtraY)+"h"+s;e.append("path").classed("textline",!0).call(a.stroke,g.outsidetextfont.color).attr({"stroke-width":Math.min(2,g.outsidetextfont.size/8),d:o,fill:"none"})}})})}),setTimeout(function(){p.selectAll("tspan").each(function(){var t=n.select(this);t.attr("dy")&&t.attr("dy",t.attr("dy"))})},0)}},{"../../components/color":532,"../../components/drawing":557,"../../components/fx":574,"../../lib":660,"../../lib/svg_text_utils":684,"./event_data":969,"./helpers":970,d3:131}],975:[function(t,e,r){"use strict";var n=t("d3"),i=t("./style_one");e.exports=function(t){t._fullLayout._pielayer.selectAll(".trace").each(function(t){var e=t[0].trace,r=n.select(this);r.style({opacity:e.opacity}),r.selectAll("path.surface").each(function(t){n.select(this).call(i,t,e)})})}},{"./style_one":976,d3:131}],976:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("./helpers").castOption;e.exports=function(t,e,r){var a=r.marker.line,o=i(a.color,e.pts)||n.defaultLine,s=i(a.width,e.pts)||0;t.style({"stroke-width":s}).call(n.fill,e.color).call(n.stroke,o)}},{"../../components/color":532,"./helpers":970}],977:[function(t,e,r){"use strict";var n=t("../scatter/attributes");e.exports={x:n.x,y:n.y,xy:{valType:"data_array",editType:"calc"},indices:{valType:"data_array",editType:"calc"},xbounds:{valType:"data_array",editType:"calc"},ybounds:{valType:"data_array",editType:"calc"},text:n.text,marker:{color:{valType:"color",arrayOk:!1,editType:"calc"},opacity:{valType:"number",min:0,max:1,dflt:1,arrayOk:!1,editType:"calc"},blend:{valType:"boolean",dflt:null,editType:"calc"},sizemin:{valType:"number",min:.1,max:2,dflt:.5,editType:"calc"},sizemax:{valType:"number",min:.1,dflt:20,editType:"calc"},border:{color:{valType:"color",arrayOk:!1,editType:"calc"},arearatio:{valType:"number",min:0,max:1,dflt:0,editType:"calc"},editType:"calc"},editType:"calc"}}},{"../scatter/attributes":990}],978:[function(t,e,r){"use strict";var n=t("gl-pointcloud2d"),i=t("../../lib/str2rgbarray"),a=t("../../plots/cartesian/autorange").expand,o=t("../scatter/get_trace_color");function s(t,e){this.scene=t,this.uid=e,this.type="pointcloud",this.pickXData=[],this.pickYData=[],this.xData=[],this.yData=[],this.textLabels=[],this.color="rgb(0, 0, 0)",this.name="",this.hoverinfo="all",this.idToIndex=new Int32Array(0),this.bounds=[0,0,0,0],this.pointcloudOptions={positions:new Float32Array(0),idToIndex:this.idToIndex,sizemin:.5,sizemax:12,color:[0,0,0,1],areaRatio:1,borderColor:[0,0,0,1]},this.pointcloud=n(t.glplot,this.pointcloudOptions),this.pointcloud._trace=this}var l=s.prototype;l.handlePick=function(t){var e=this.idToIndex[t.pointId];return{trace:this,dataCoord:t.dataCoord,traceCoord:this.pickXYData?[this.pickXYData[2*e],this.pickXYData[2*e+1]]:[this.pickXData[e],this.pickYData[e]],textLabel:Array.isArray(this.textLabels)?this.textLabels[e]:this.textLabels,color:this.color,name:this.name,pointIndex:e,hoverinfo:this.hoverinfo}},l.update=function(t){this.index=t.index,this.textLabels=t.text,this.name=t.name,this.hoverinfo=t.hoverinfo,this.bounds=[1/0,1/0,-1/0,-1/0],this.updateFast(t),this.color=o(t,{})},l.updateFast=function(t){var e,r,n,a,o,s,l=this.xData=this.pickXData=t.x,c=this.yData=this.pickYData=t.y,u=this.pickXYData=t.xy,f=t.xbounds&&t.ybounds,h=t.indices,p=this.bounds;if(u){if(n=u,e=u.length>>>1,f)p[0]=t.xbounds[0],p[2]=t.xbounds[1],p[1]=t.ybounds[0],p[3]=t.ybounds[1];else for(s=0;sp[2]&&(p[2]=a),op[3]&&(p[3]=o);if(h)r=h;else for(r=new Int32Array(e),s=0;sp[2]&&(p[2]=a),op[3]&&(p[3]=o);this.idToIndex=r,this.pointcloudOptions.idToIndex=r,this.pointcloudOptions.positions=n;var d=i(t.marker.color),g=i(t.marker.border.color),m=t.opacity*t.marker.opacity;d[3]*=m,this.pointcloudOptions.color=d;var v=t.marker.blend;if(null===v){v=l.length<100||c.length<100}this.pointcloudOptions.blend=v,g[3]*=m,this.pointcloudOptions.borderColor=g;var y=t.marker.sizemin,x=Math.max(t.marker.sizemax,t.marker.sizemin);this.pointcloudOptions.sizeMin=y,this.pointcloudOptions.sizeMax=x,this.pointcloudOptions.areaRatio=t.marker.border.arearatio,this.pointcloud.update(this.pointcloudOptions),this.expandAxesFast(p,x/2)},l.expandAxesFast=function(t,e){var r=e||.5;a(this.scene.xaxis,[t[0],t[2]],{ppad:r}),a(this.scene.yaxis,[t[1],t[3]],{ppad:r})},l.dispose=function(){this.pointcloud.dispose()},e.exports=function(t,e){var r=new s(t,e.uid);return r.update(e),r}},{"../../lib/str2rgbarray":683,"../../plots/cartesian/autorange":705,"../scatter/get_trace_color":1e3,"gl-pointcloud2d":260}],979:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes");e.exports=function(t,e,r){function a(r,a){return n.coerce(t,e,i,r,a)}a("x"),a("y"),a("xbounds"),a("ybounds"),t.xy&&t.xy instanceof Float32Array&&(e.xy=t.xy),t.indices&&t.indices instanceof Int32Array&&(e.indices=t.indices),a("text"),a("marker.color",r),a("marker.opacity"),a("marker.blend"),a("marker.sizemin"),a("marker.sizemax"),a("marker.border.color",r),a("marker.border.arearatio"),e._length=null}},{"../../lib":660,"./attributes":977}],980:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.calc=t("../scatter3d/calc"),n.plot=t("./convert"),n.moduleType="trace",n.name="pointcloud",n.basePlotModule=t("../../plots/gl2d"),n.categories=["gl","gl2d","showLegend"],n.meta={},e.exports=n},{"../../plots/gl2d":745,"../scatter3d/calc":1016,"./attributes":977,"./convert":978,"./defaults":979}],981:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../../plots/attributes"),a=t("../../components/color/attributes"),o=t("../../components/fx/attributes"),s=t("../../plots/domain").attributes,l=t("../../lib/extend").extendFlat,c=t("../../plot_api/edit_types").overrideAll;e.exports=c({hoverinfo:l({},i.hoverinfo,{flags:["label","text","value","percent","name"]}),hoverlabel:o.hoverlabel,domain:s({name:"sankey",trace:!0}),orientation:{valType:"enumerated",values:["v","h"],dflt:"h"},valueformat:{valType:"string",dflt:".3s"},valuesuffix:{valType:"string",dflt:""},arrangement:{valType:"enumerated",values:["snap","perpendicular","freeform","fixed"],dflt:"snap"},textfont:n({}),node:{label:{valType:"data_array",dflt:[]},color:{valType:"color",arrayOk:!0},line:{color:{valType:"color",dflt:a.defaultLine,arrayOk:!0},width:{valType:"number",min:0,dflt:.5,arrayOk:!0}},pad:{valType:"number",arrayOk:!1,min:0,dflt:20},thickness:{valType:"number",arrayOk:!1,min:1,dflt:20}},link:{label:{valType:"data_array",dflt:[]},color:{valType:"color",arrayOk:!0},line:{color:{valType:"color",dflt:a.defaultLine,arrayOk:!0},width:{valType:"number",min:0,dflt:0,arrayOk:!0}},source:{valType:"data_array",dflt:[]},target:{valType:"data_array",dflt:[]},value:{valType:"data_array",dflt:[]}}},"calc","nested")},{"../../components/color/attributes":531,"../../components/fx/attributes":566,"../../lib/extend":649,"../../plot_api/edit_types":691,"../../plots/attributes":703,"../../plots/domain":731,"../../plots/font_attributes":732}],982:[function(t,e,r){"use strict";var n=t("../../plot_api/edit_types").overrideAll,i=t("../../plots/get_data").getModuleCalcData,a=t("./plot"),o=t("../../components/fx/layout_attributes");r.name="sankey",r.baseLayoutAttrOverrides=n({hoverlabel:o.hoverlabel},"plot","nested"),r.plot=function(t){var e=i(t.calcdata,"sankey")[0];a(t,e)},r.clean=function(t,e,r,n){var i=n._has&&n._has("sankey"),a=e._has&&e._has("sankey");i&&!a&&n._paperdiv.selectAll(".sankey").remove()}},{"../../components/fx/layout_attributes":575,"../../plot_api/edit_types":691,"../../plots/get_data":742,"./plot":987}],983:[function(t,e,r){"use strict";var n=t("strongly-connected-components"),i=t("../../lib"),a=t("../../lib/gup").wrap;e.exports=function(t,e){return function(t,e,r){for(var a=t.length,o=i.init2dArray(a,0),s=0;s1})}(e.node.label,e.link.source,e.link.target)&&(i.error("Circularity is present in the Sankey data. Removing all nodes and links."),e.link.label=[],e.link.source=[],e.link.target=[],e.link.value=[],e.link.color=[],e.node.label=[],e.node.color=[]),a({link:e.link,node:e.node})}},{"../../lib":660,"../../lib/gup":657,"strongly-connected-components":465}],984:[function(t,e,r){"use strict";e.exports={nodeTextOffsetHorizontal:4,nodeTextOffsetVertical:3,nodePadAcross:10,sankeyIterations:50,forceIterations:5,forceTicksPerFrame:10,duration:500,ease:"cubic-in-out",cn:{sankey:"sankey",sankeyLinks:"sankey-links",sankeyLink:"sankey-link",sankeyNodeSet:"sankey-node-set",sankeyNode:"sankey-node",nodeRect:"node-rect",nodeCapture:"node-capture",nodeCentered:"node-entered",nodeLabelGuide:"node-label-guide",nodeLabel:"node-label",nodeLabelTextPath:"node-label-text-path"}}},{}],985:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../components/color"),o=t("tinycolor2"),s=t("../../plots/domain").defaults;e.exports=function(t,e,r,l){function c(r,a){return n.coerce(t,e,i,r,a)}c("node.label"),c("node.pad"),c("node.thickness"),c("node.line.color"),c("node.line.width");var u=l.colorway;c("node.color",e.node.label.map(function(t,e){return a.addOpacity(function(t){return u[t%u.length]}(e),.8)})),c("link.label"),c("link.source"),c("link.target"),c("link.value"),c("link.line.color"),c("link.line.width"),c("link.color",e.link.value.map(function(){return o(l.paper_bgcolor).getLuminance()<.333?"rgba(255, 255, 255, 0.6)":"rgba(0, 0, 0, 0.2)"})),s(e,l,c),c("orientation"),c("valueformat"),c("valuesuffix"),c("arrangement"),n.coerceFont(c,"textfont",n.extendFlat({},l.font)),e._length=null}},{"../../components/color":532,"../../lib":660,"../../plots/domain":731,"./attributes":981,tinycolor2:473}],986:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.calc=t("./calc"),n.plot=t("./plot"),n.moduleType="trace",n.name="sankey",n.basePlotModule=t("./base_plot"),n.categories=["noOpacity"],n.meta={},e.exports=n},{"./attributes":981,"./base_plot":982,"./calc":983,"./defaults":985,"./plot":987}],987:[function(t,e,r){"use strict";var n=t("d3"),i=t("./render"),a=t("../../components/fx"),o=t("../../components/color"),s=t("../../lib"),l=t("./constants").cn,c=s._;function u(t){return""!==t}function f(t,e){return t.filter(function(t){return t.key===e.traceId})}function h(t,e){n.select(t).select("path").style("fill-opacity",e),n.select(t).select("rect").style("fill-opacity",e)}function p(t){n.select(t).select("text.name").style("fill","black")}function d(t){return function(e){return-1!==t.node.sourceLinks.indexOf(e.link)||-1!==t.node.targetLinks.indexOf(e.link)}}function g(t){return function(e){return-1!==e.node.sourceLinks.indexOf(t.link)||-1!==e.node.targetLinks.indexOf(t.link)}}function m(t,e,r){e&&r&&f(r,e).selectAll("."+l.sankeyLink).filter(d(e)).call(y.bind(0,e,r,!1))}function v(t,e,r){e&&r&&f(r,e).selectAll("."+l.sankeyLink).filter(d(e)).call(x.bind(0,e,r,!1))}function y(t,e,r,n){var i=n.datum().link.label;n.style("fill-opacity",.4),i&&f(e,t).selectAll("."+l.sankeyLink).filter(function(t){return t.link.label===i}).style("fill-opacity",.4),r&&f(e,t).selectAll("."+l.sankeyNode).filter(g(t)).call(m)}function x(t,e,r,n){var i=n.datum().link.label;n.style("fill-opacity",function(t){return t.tinyColorAlpha}),i&&f(e,t).selectAll("."+l.sankeyLink).filter(function(t){return t.link.label===i}).style("fill-opacity",function(t){return t.tinyColorAlpha}),r&&f(e,t).selectAll(l.sankeyNode).filter(g(t)).call(v)}function b(t,e){var r=t.hoverlabel||{},n=s.nestedProperty(r,e).get();return!Array.isArray(n)&&n}e.exports=function(t,e){var r=t._fullLayout,s=r._paper,f=r._size,d=c(t,"source:")+" ",g=c(t,"target:")+" ",_=c(t,"incoming flow count:")+" ",w=c(t,"outgoing flow count:")+" ";i(s,e,{width:f.w,height:f.h,margin:{t:f.t,r:f.r,b:f.b,l:f.l}},{linkEvents:{hover:function(e,r,i){n.select(e).call(y.bind(0,r,i,!0)),t.emit("plotly_hover",{event:n.event,points:[r.link]})},follow:function(e,i){var s=i.link.trace,l=t._fullLayout._paperdiv.node().getBoundingClientRect(),c=e.getBoundingClientRect(),f=c.left+c.width/2,m=c.top+c.height/2,v=a.loneHover({x:f-l.left,y:m-l.top,name:n.format(i.valueFormat)(i.link.value)+i.valueSuffix,text:[i.link.label||"",d+i.link.source.label,g+i.link.target.label].filter(u).join("
"),color:b(s,"bgcolor")||o.addOpacity(i.tinyColorHue,1),borderColor:b(s,"bordercolor"),fontFamily:b(s,"font.family"),fontSize:b(s,"font.size"),fontColor:b(s,"font.color"),idealAlign:n.event.x"),color:b(o,"bgcolor")||i.tinyColorHue,borderColor:b(o,"bordercolor"),fontFamily:b(o,"font.family"),fontSize:b(o,"font.size"),fontColor:b(o,"font.color"),idealAlign:"left"},{container:r._hoverlayer.node(),outerContainer:r._paper.node(),gd:t});h(v,.85),p(v)},unhover:function(e,i,o){n.select(e).call(v,i,o),t.emit("plotly_unhover",{event:n.event,points:[i.node]}),a.loneUnhover(r._hoverlayer.node())},select:function(e,r,i){var o=r.node;o.originalEvent=n.event,t._hoverdata=[o],n.select(e).call(v,r,i),a.click(t,{target:!0})}}})}},{"../../components/color":532,"../../components/fx":574,"../../lib":660,"./constants":984,"./render":988,d3:131}],988:[function(t,e,r){"use strict";var n=t("./constants"),i=t("d3"),a=t("tinycolor2"),o=t("../../components/color"),s=t("../../components/drawing"),l=t("@plotly/d3-sankey").sankey,c=t("d3-force"),u=t("../../lib"),f=u.isArrayOrTypedArray,h=u.isIndex,p=t("../../lib/gup"),d=p.keyFun,g=p.repeat,m=p.unwrap;function v(t){t.lastDraggedX=t.x,t.lastDraggedY=t.y}function y(t){return function(e){return e.node.originalX===t.node.originalX}}function x(t){for(var e=0;e1||t.linkLineWidth>0}function T(t){return"translate("+t.translateX+","+t.translateY+")"+(t.horizontal?"matrix(1 0 0 1 0 0)":"matrix(0 1 1 0 0 0)")}function S(t){return"translate("+(t.horizontal?0:t.labelY)+" "+(t.horizontal?t.labelY:0)+")"}function C(t){return i.svg.line()([[t.horizontal?t.left?-t.sizeAcross:t.visibleWidth+n.nodeTextOffsetHorizontal:n.nodeTextOffsetHorizontal,0],[t.horizontal?t.left?-n.nodeTextOffsetHorizontal:t.sizeAcross:t.visibleHeight-n.nodeTextOffsetHorizontal,0]])}function E(t){return t.horizontal?"matrix(1 0 0 1 0 0)":"matrix(0 1 1 0 0 0)"}function L(t){return t.horizontal?"scale(1 1)":"scale(-1 1)"}function z(t){return t.darkBackground&&!t.horizontal?"rgb(255,255,255)":"rgb(0,0,0)"}function P(t){return t.horizontal&&t.left?"100%":"0%"}function D(t,e,r){t.on(".basic",null).on("mouseover.basic",function(t){t.interactionState.dragInProgress||(r.hover(this,t,e),t.interactionState.hovered=[this,t])}).on("mousemove.basic",function(t){t.interactionState.dragInProgress||(r.follow(this,t),t.interactionState.hovered=[this,t])}).on("mouseout.basic",function(t){t.interactionState.dragInProgress||(r.unhover(this,t,e),t.interactionState.hovered=!1)}).on("click.basic",function(t){t.interactionState.hovered&&(r.unhover(this,t,e),t.interactionState.hovered=!1),t.interactionState.dragInProgress||r.select(this,t,e)})}function O(t,e,r){var a=i.behavior.drag().origin(function(t){return t.node}).on("dragstart",function(i){if("fixed"!==i.arrangement&&(u.raiseToTop(this),i.interactionState.dragInProgress=i.node,v(i.node),i.interactionState.hovered&&(r.nodeEvents.unhover.apply(0,i.interactionState.hovered),i.interactionState.hovered=!1),"snap"===i.arrangement)){var a=i.traceId+"|"+Math.floor(i.node.originalX);i.forceLayouts[a]?i.forceLayouts[a].alpha(1):function(t,e,r){var i=r.sankey.nodes().filter(function(t){return t.originalX===r.node.originalX});r.forceLayouts[e]=c.forceSimulation(i).alphaDecay(0).force("collide",c.forceCollide().radius(function(t){return t.dy/2+r.nodePad/2}).strength(1).iterations(n.forceIterations)).force("constrain",function(t,e,r,i){return function(){for(var t=0,a=0;a0&&i.forceLayouts[e].alpha(0)}}(0,e,i,r)).stop()}(0,a,i),function(t,e,r,i){window.requestAnimationFrame(function a(){for(var o=0;o0&&window.requestAnimationFrame(a)})}(t,e,i,a)}}).on("drag",function(r){if("fixed"!==r.arrangement){var n=i.event.x,a=i.event.y;"snap"===r.arrangement?(r.node.x=n,r.node.y=a):("freeform"===r.arrangement&&(r.node.x=n),r.node.y=Math.max(r.node.dy/2,Math.min(r.size-r.node.dy/2,a))),v(r.node),"snap"!==r.arrangement&&(r.sankey.relayout(),k(t.filter(y(r)),e))}}).on("dragend",function(t){t.interactionState.dragInProgress=!1});t.on(".drag",null).call(a)}e.exports=function(t,e,r,i){var c=t.selectAll("."+n.cn.sankey).data(e.filter(function(t){return m(t).trace.visible}).map(function(t,e,r){var i,a=m(e).trace,o=a.domain,s=a.node,c=a.link,u=a.arrangement,p="h"===a.orientation,d=a.node.pad,g=a.node.thickness,v=a.node.line.color,y=a.node.line.width,b=a.link.line.color,_=a.link.line.width,w=a.valueformat,k=a.valuesuffix,M=a.textfont,A=t.width*(o.x[1]-o.x[0]),T=t.height*(o.y[1]-o.y[0]),S=[],C=f(c.color),E={},L=s.label.length;for(i=0;i0&&h(P,L)&&h(D,L)&&(D=+D,E[P=+P]=E[D]=!0,S.push({pointNumber:i,label:c.label[i],color:C?c.color[i]:c.color,source:P,target:D,value:+z}))}var O=f(s.color),I=[],R=!1,B={};for(i=0;i5?t.node.label:""}).attr("text-anchor",function(t){return t.horizontal&&t.left?"end":"start"}),F.transition().ease(n.ease).duration(n.duration).attr("startOffset",P).style("fill",z)}},{"../../components/color":532,"../../components/drawing":557,"../../lib":660,"../../lib/gup":657,"./constants":984,"@plotly/d3-sankey":43,d3:131,"d3-force":127,tinycolor2:473}],989:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e){for(var r=0;r=0;i--){var a=t[i];if("scatter"===a.type&&a.xaxis===r.xaxis&&a.yaxis===r.yaxis){a.opacity=void 0;break}}}}}},{}],994:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("../../plots/plots"),o=t("../../components/colorscale"),s=t("../../components/colorbar/draw");e.exports=function(t,e){var r=e[0].trace,l=r.marker,c="cb"+r.uid;if(t._fullLayout._infolayer.selectAll("."+c).remove(),void 0!==l&&l.showscale){var u=l.color,f=l.cmin,h=l.cmax;n(f)||(f=i.aggNums(Math.min,null,u)),n(h)||(h=i.aggNums(Math.max,null,u));var p=e[0].t.cb=s(t,c),d=o.makeColorScaleFunc(o.extractScale(l.colorscale,f,h),{noNumericCheck:!0});p.fillcolor(d).filllevels({start:f,end:h,size:(h-f)/254}).options(l.colorbar)()}else a.autoMargin(t,c)}},{"../../components/colorbar/draw":536,"../../components/colorscale":547,"../../lib":660,"../../plots/plots":768,"fast-isnumeric":197}],995:[function(t,e,r){"use strict";var n=t("../../components/colorscale/has_colorscale"),i=t("../../components/colorscale/calc"),a=t("./subtypes");e.exports=function(t){a.hasLines(t)&&n(t,"line")&&i(t,t.line.color,"line","c"),a.hasMarkers(t)&&(n(t,"marker")&&i(t,t.marker.color,"marker","c"),n(t,"marker.line")&&i(t,t.marker.line.color,"marker.line","c"))}},{"../../components/colorscale/calc":539,"../../components/colorscale/has_colorscale":546,"./subtypes":1012}],996:[function(t,e,r){"use strict";e.exports={PTS_LINESONLY:20,minTolerance:.2,toleranceGrowth:10,maxScreensAway:20}},{}],997:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry"),a=t("./attributes"),o=t("./constants"),s=t("./subtypes"),l=t("./xy_defaults"),c=t("./marker_defaults"),u=t("./line_defaults"),f=t("./line_shape_defaults"),h=t("./text_defaults"),p=t("./fillcolor_defaults");e.exports=function(t,e,r,d){function g(r,i){return n.coerce(t,e,a,r,i)}var m=l(t,e,d,g),v=mV!=(D=C[T][1])>=V&&(L=C[T-1][0],z=C[T][0],D-P&&(E=L+(z-L)*(V-P)/(D-P),B=Math.min(B,E),F=Math.max(F,E)));B=Math.max(B,0),F=Math.min(F,h._length);var U=s.defaultLine;return s.opacity(f.fillcolor)?U=f.fillcolor:s.opacity((f.line||{}).color)&&(U=f.line.color),n.extendFlat(t,{distance:t.maxHoverDistance,x0:B,x1:F,y0:V,y1:V,color:U}),delete t.index,f.text&&!Array.isArray(f.text)?t.text=String(f.text):t.text=f.name,[t]}}}},{"../../components/color":532,"../../components/fx":574,"../../lib":660,"../../registry":790,"./fill_hover_text":998,"./get_trace_color":1e3}],1002:[function(t,e,r){"use strict";var n={},i=t("./subtypes");n.hasLines=i.hasLines,n.hasMarkers=i.hasMarkers,n.hasText=i.hasText,n.isBubble=i.isBubble,n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.cleanData=t("./clean_data"),n.calc=t("./calc").calc,n.arraysToCalcdata=t("./arrays_to_calcdata"),n.plot=t("./plot"),n.colorbar=t("./colorbar"),n.style=t("./style").style,n.styleOnSelect=t("./style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("./select"),n.animatable=!0,n.moduleType="trace",n.name="scatter",n.basePlotModule=t("../../plots/cartesian"),n.categories=["cartesian","svg","symbols","markerColorscale","errorBarsOK","showLegend","scatter-like","zoomScale"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"./arrays_to_calcdata":989,"./attributes":990,"./calc":991,"./clean_data":993,"./colorbar":994,"./defaults":997,"./hover":1001,"./plot":1009,"./select":1010,"./style":1011,"./subtypes":1012}],1003:[function(t,e,r){"use strict";var n=t("../../lib").isArrayOrTypedArray,i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults");e.exports=function(t,e,r,o,s,l){var c=(t.marker||{}).color;(s("line.color",r),i(t,"line"))?a(t,e,o,s,{prefix:"line.",cLetter:"c"}):s("line.color",!n(c)&&c||r);s("line.width"),(l||{}).noDash||s("line.dash")}},{"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546,"../../lib":660}],1004:[function(t,e,r){"use strict";var n=t("../../constants/numerical").BADNUM,i=t("../../lib"),a=i.segmentsIntersect,o=i.constrain,s=t("./constants");e.exports=function(t,e){var r,l,c,u,f,h,p,d,g,m,v,y,x,b,_,w,k=e.xaxis,M=e.yaxis,A=e.simplify,T=e.connectGaps,S=e.baseTolerance,C=e.shape,E="linear"===C,L=[],z=s.minTolerance,P=new Array(t.length),D=0;function O(e){var r=t[e],i=k.c2p(r.x),a=M.c2p(r.y);return i===n||a===n?r.intoCenter||!1:[i,a]}function I(t){var e=t[0]/k._length,r=t[1]/M._length;return(1+s.toleranceGrowth*Math.max(0,-e,e-1,-r,r-1))*S}function R(t,e){var r=t[0]-e[0],n=t[1]-e[1];return Math.sqrt(r*r+n*n)}A||(S=z=-1);var B,F,N,j,V,U,q,H=s.maxScreensAway,G=-k._length*H,W=k._length*(1+H),Y=-M._length*H,X=M._length*(1+H),Z=[[G,Y,W,Y],[W,Y,W,X],[W,X,G,X],[G,X,G,Y]];function J(t){if(t[0]W||t[1]X)return[o(t[0],G,W),o(t[1],Y,X)]}function K(t,e){return t[0]===e[0]&&(t[0]===G||t[0]===W)||(t[1]===e[1]&&(t[1]===Y||t[1]===X)||void 0)}function Q(t,e,r){return function(n,a){var o=J(n),s=J(a),l=[];if(o&&s&&K(o,s))return l;o&&l.push(o),s&&l.push(s);var c=2*i.constrain((n[t]+a[t])/2,e,r)-((o||n)[t]+(s||a)[t]);c&&((o&&s?c>0==o[t]>s[t]?o:s:o||s)[t]+=c);return l}}function $(t){var e=t[0],r=t[1],n=e===P[D-1][0],i=r===P[D-1][1];if(!n||!i)if(D>1){var a=e===P[D-2][0],o=r===P[D-2][1];n&&(e===G||e===W)&&a?o?D--:P[D-1]=t:i&&(r===Y||r===X)&&o?a?D--:P[D-1]=t:P[D++]=t}else P[D++]=t}function tt(t){P[D-1][0]!==t[0]&&P[D-1][1]!==t[1]&&$([N,j]),$(t),V=null,N=j=0}function et(t){if(B=t[0]W?W:0,F=t[1]X?X:0,B||F){if(D)if(V){var e=q(V,t);e.length>1&&(tt(e[0]),P[D++]=e[1])}else U=q(P[D-1],t)[0],P[D++]=U;else P[D++]=[B||t[0],F||t[1]];var r=P[D-1];B&&F&&(r[0]!==B||r[1]!==F)?(V&&(N!==B&&j!==F?$(N&&j?(n=V,a=(i=t)[0]-n[0],o=(i[1]-n[1])/a,(n[1]*i[0]-i[1]*n[0])/a>0?[o>0?G:W,X]:[o>0?W:G,Y]):[N||B,j||F]):N&&j&&$([N,j])),$([B,F])):N-B&&j-F&&$([B||N,F||j]),V=t,N=B,j=F}else V&&tt(q(V,t)[0]),P[D++]=t;var n,i,a,o}for("linear"===C||"spline"===C?q=function(t,e){for(var r=[],n=0,i=0;i<4;i++){var o=Z[i],s=a(t[0],t[1],e[0],e[1],o[0],o[1],o[2],o[3]);s&&(!n||Math.abs(s.x-r[0][0])>1||Math.abs(s.y-r[0][1])>1)&&(s=[s.x,s.y],n&&R(s,t)I(h))break;c=h,(x=g[0]*d[0]+g[1]*d[1])>v?(v=x,u=h,p=!1):x=t.length||!h)break;et(h),l=h}}else et(u)}V&&$([N||V[0],j||V[1]]),L.push(P.slice(0,D))}return L}},{"../../constants/numerical":637,"../../lib":660,"./constants":996}],1005:[function(t,e,r){"use strict";e.exports=function(t,e,r){"spline"===r("line.shape")&&r("line.smoothing")}},{}],1006:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n,i,a=null;for(i=0;i0?Math.max(e,i):0}}},{"fast-isnumeric":197}],1008:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults"),o=t("./subtypes");e.exports=function(t,e,r,s,l,c){var u=o.isBubble(t),f=(t.line||{}).color;(c=c||{},f&&(r=f),l("marker.symbol"),l("marker.opacity",u?.7:1),l("marker.size"),l("marker.color",r),i(t,"marker")&&a(t,e,s,l,{prefix:"marker.",cLetter:"c"}),c.noSelect||(l("selected.marker.color"),l("unselected.marker.color"),l("selected.marker.size"),l("unselected.marker.size")),c.noLine||(l("marker.line.color",f&&!Array.isArray(f)&&e.marker.color!==f?f:u?n.background:n.defaultLine),i(t,"marker.line")&&a(t,e,s,l,{prefix:"marker.line.",cLetter:"c"}),l("marker.line.width",u?1:0)),u&&(l("marker.sizeref"),l("marker.sizemin"),l("marker.sizemode")),c.gradient)&&("none"!==l("marker.gradient.type")&&l("marker.gradient.color"))}},{"../../components/color":532,"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546,"./subtypes":1012}],1009:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../registry"),a=t("../../lib"),o=t("../../components/drawing"),s=t("./subtypes"),l=t("./line_points"),c=t("./link_traces"),u=t("../../lib/polygon").tester;function f(t,e,r,c,f,h,p){var d,g;!function(t,e,r,i,o){var l=r.xaxis,c=r.yaxis,u=n.extent(a.simpleMap(l.range,l.r2c)),f=n.extent(a.simpleMap(c.range,c.r2c)),h=i[0].trace;if(!s.hasMarkers(h))return;var p=h.marker.maxdisplayed;if(0===p)return;var d=i.filter(function(t){return t.x>=u[0]&&t.x<=u[1]&&t.y>=f[0]&&t.y<=f[1]}),g=Math.ceil(d.length/p),m=0;o.forEach(function(t,r){var n=t[0].trace;s.hasMarkers(n)&&n.marker.maxdisplayed>0&&r0;function v(t){return m?t.transition():t}var y=r.xaxis,x=r.yaxis,b=c[0].trace,_=b.line,w=n.select(h);if(i.getComponentMethod("errorbars","plot")(w,r,p),!0===b.visible){var k,M;v(w).style("opacity",b.opacity);var A=b.fill.charAt(b.fill.length-1);"x"!==A&&"y"!==A&&(A=""),r.isRangePlot||(c[0].node3=w);var T="",S=[],C=b._prevtrace;C&&(T=C._prevRevpath||"",M=C._nextFill,S=C._polygons);var E,L,z,P,D,O,I,R,B,F="",N="",j=[],V=a.noop;if(k=b._ownFill,s.hasLines(b)||"none"!==b.fill){for(M&&M.datum(c),-1!==["hv","vh","hvh","vhv"].indexOf(_.shape)?(z=o.steps(_.shape),P=o.steps(_.shape.split("").reverse().join(""))):z=P="spline"===_.shape?function(t){var e=t[t.length-1];return t.length>1&&t[0][0]===e[0]&&t[0][1]===e[1]?o.smoothclosed(t.slice(1),_.smoothing):o.smoothopen(t,_.smoothing)}:function(t){return"M"+t.join("L")},D=function(t){return P(t.reverse())},j=l(c,{xaxis:y,yaxis:x,connectGaps:b.connectgaps,baseTolerance:Math.max(_.width||1,3)/4,shape:_.shape,simplify:_.simplify}),B=b._polygons=new Array(j.length),g=0;g1){var r=n.select(this);if(r.datum(c),t)v(r.style("opacity",0).attr("d",E).call(o.lineGroupStyle)).style("opacity",1);else{var i=v(r);i.attr("d",E),o.singleLineStyle(c,i)}}}}}var U=w.selectAll(".js-line").data(j);v(U.exit()).style("opacity",0).remove(),U.each(V(!1)),U.enter().append("path").classed("js-line",!0).style("vector-effect","non-scaling-stroke").call(o.lineGroupStyle).each(V(!0)),o.setClipUrl(U,r.layerClipId),j.length?(k?O&&R&&(A?("y"===A?O[1]=R[1]=x.c2p(0,!0):"x"===A&&(O[0]=R[0]=y.c2p(0,!0)),v(k).attr("d","M"+R+"L"+O+"L"+F.substr(1)).call(o.singleFillStyle)):v(k).attr("d",F+"Z").call(o.singleFillStyle)):M&&("tonext"===b.fill.substr(0,6)&&F&&T?("tonext"===b.fill?v(M).attr("d",F+"Z"+T+"Z").call(o.singleFillStyle):v(M).attr("d",F+"L"+T.substr(1)+"Z").call(o.singleFillStyle),b._polygons=b._polygons.concat(S)):(H(M),b._polygons=null)),b._prevRevpath=N,b._prevPolygons=B):(k?H(k):M&&H(M),b._polygons=b._prevRevpath=b._prevPolygons=null);var q=w.selectAll(".points");d=q.data([c]),q.each(Z),d.enter().append("g").classed("points",!0).each(Z),d.exit().remove(),d.each(function(t){var e=!1===t[0].trace.cliponaxis;o.setClipUrl(n.select(this),e?null:r.layerClipId)})}function H(t){v(t).attr("d","M0,0Z")}function G(t){return t.filter(function(t){return t.vis})}function W(t){return t.id}function Y(t){if(t.ids)return W}function X(){return!1}function Z(e){var i,l=e[0].trace,c=n.select(this),u=s.hasMarkers(l),f=s.hasText(l),h=Y(l),p=X,d=X;u&&(p=l.marker.maxdisplayed||l._needsCull?G:a.identity),f&&(d=l.marker.maxdisplayed||l._needsCull?G:a.identity);var g,b=(i=c.selectAll("path.point").data(p,h)).enter().append("path").classed("point",!0);m&&b.call(o.pointStyle,l,t).call(o.translatePoints,y,x).style("opacity",0).transition().style("opacity",1),i.order(),u&&(g=o.makePointStyleFns(l)),i.each(function(e){var i=n.select(this),a=v(i);o.translatePoint(e,a,y,x)?(o.singlePointStyle(e,a,l,g,t),r.layerClipId&&o.hideOutsideRangePoint(e,a,y,x,l.xcalendar,l.ycalendar),l.customdata&&i.classed("plotly-customdata",null!==e.data&&void 0!==e.data)):a.remove()}),m?i.exit().transition().style("opacity",0).remove():i.exit().remove(),(i=c.selectAll("g").data(d,h)).enter().append("g").classed("textpoint",!0).append("text"),i.order(),i.each(function(t){var e=n.select(this),i=v(e.select("text"));o.translatePoint(t,i,y,x)?r.layerClipId&&o.hideOutsideRangePoint(t,e,y,x,l.xcalendar,l.ycalendar):e.remove()}),i.selectAll("text").call(o.textPointStyle,l,t).each(function(t){var e=y.c2p(t.x),r=x.c2p(t.y);n.select(this).selectAll("tspan.line").each(function(){v(n.select(this)).attr({x:e,y:r})})}),i.exit().remove()}}e.exports=function(t,e,r,i,a,s){var l,u,h,p,d=!a,g=!!a&&a.duration>0;for((h=i.selectAll("g.trace").data(r,function(t){return t[0].trace.uid})).enter().append("g").attr("class",function(t){return"trace scatter trace"+t[0].trace.uid}).style("stroke-miterlimit",2),c(t,e,r),function(t,e,r){var i;e.selectAll("g.trace").each(function(t){var e=n.select(this);if((i=t[0].trace)._nexttrace){if(i._nextFill=e.select(".js-fill.js-tonext"),!i._nextFill.size()){var a=":first-child";e.select(".js-fill.js-tozero").size()&&(a+=" + *"),i._nextFill=e.insert("path",a).attr("class","js-fill js-tonext")}}else e.selectAll(".js-fill.js-tonext").remove(),i._nextFill=null;i.fill&&("tozero"===i.fill.substr(0,6)||"toself"===i.fill||"to"===i.fill.substr(0,2)&&!i._prevtrace)?(i._ownFill=e.select(".js-fill.js-tozero"),i._ownFill.size()||(i._ownFill=e.insert("path",":first-child").attr("class","js-fill js-tozero"))):(e.selectAll(".js-fill.js-tozero").remove(),i._ownFill=null),e.selectAll(".js-fill").call(o.setClipUrl,r.layerClipId)})}(0,i,e),l=0,u={};lu[e[0].trace.uid]?1:-1}),g)?(s&&(p=s()),n.transition().duration(a.duration).ease(a.easing).each("end",function(){p&&p()}).each("interrupt",function(){p&&p()}).each(function(){i.selectAll("g.trace").each(function(n,i){f(t,i,e,n,r,this,a)})})):i.selectAll("g.trace").each(function(n,i){f(t,i,e,n,r,this,a)});d&&h.exit().remove(),i.selectAll("path:not([d])").remove()}},{"../../components/drawing":557,"../../lib":660,"../../lib/polygon":672,"../../registry":790,"./line_points":1004,"./link_traces":1006,"./subtypes":1012,d3:131}],1010:[function(t,e,r){"use strict";var n=t("./subtypes");e.exports=function(t,e){var r,i,a,o,s=t.cd,l=t.xaxis,c=t.yaxis,u=[],f=s[0].trace;if(!n.hasMarkers(f)&&!n.hasText(f))return[];if(!1===e)for(r=0;r=0&&(p[1]+=1),h.indexOf("top")>=0&&(p[1]-=1),h.indexOf("left")>=0&&(p[0]-=1),h.indexOf("right")>=0&&(p[0]+=1),p)),r.textColor=u(e.textfont,1,E),r.textSize=x(e.textfont.size,E,l.identity,12),r.textFont=e.textfont.family,r.textAngle=0);var O=["x","y","z"];for(r.project=[!1,!1,!1],r.projectScale=[1,1,1],r.projectOpacity=[1,1,1],n=0;n<3;++n){var I=e.projection[O[n]];(r.project[n]=I.show)&&(r.projectOpacity[n]=I.opacity,r.projectScale[n]=I.scale)}r.errorBounds=d(e,b);var R=function(t){for(var e=[0,0,0],r=[[0,0,0],[0,0,0],[0,0,0]],n=[0,0,0],i=0;i<3;i++){var a=t[i];a&&!1!==a.copy_zstyle&&(a=t[2]),a&&(e[i]=a.width/2,r[i]=c(a.color),n=a.thickness)}return{capSize:e,color:r,lineWidth:n}}([e.error_x,e.error_y,e.error_z]);return r.errorColor=R.color,r.errorLineWidth=R.lineWidth,r.errorCapSize=R.capSize,r.delaunayAxis=e.surfaceaxis,r.delaunayColor=c(e.surfacecolor),r}function _(t){if(Array.isArray(t)){var e=t[0];return Array.isArray(e)&&(t=e),"rgb("+t.slice(0,3).map(function(t){return Math.round(255*t)})+")"}return null}m.handlePick=function(t){if(t.object&&(t.object===this.linePlot||t.object===this.delaunayMesh||t.object===this.textMarkers||t.object===this.scatterPlot)){t.object.highlight&&t.object.highlight(null),this.scatterPlot&&(t.object=this.scatterPlot,this.scatterPlot.highlight(t.data)),this.textLabels?void 0!==this.textLabels[t.data.index]?t.textLabel=this.textLabels[t.data.index]:t.textLabel=this.textLabels:t.textLabel="";var e=t.index=t.data.index;return t.traceCoordinate=[this.data.x[e],this.data.y[e],this.data.z[e]],!0}},m.update=function(t){var e,r,l,c,u=this.scene.glplot.gl,f=h.solid;this.data=t;var p=b(this.scene,t);"mode"in p&&(this.mode=p.mode),"lineDashes"in p&&p.lineDashes in h&&(f=h[p.lineDashes]),this.color=_(p.scatterColor)||_(p.lineColor),this.dataPoints=p.position,e={gl:u,position:p.position,color:p.lineColor,lineWidth:p.lineWidth||1,dashes:f[0],dashScale:f[1],opacity:t.opacity,connectGaps:t.connectgaps},-1!==this.mode.indexOf("lines")?this.linePlot?this.linePlot.update(e):(this.linePlot=n(e),this.linePlot._trace=this,this.scene.glplot.add(this.linePlot)):this.linePlot&&(this.scene.glplot.remove(this.linePlot),this.linePlot.dispose(),this.linePlot=null);var d=t.opacity;if(t.marker&&t.marker.opacity&&(d*=t.marker.opacity),r={gl:u,position:p.position,color:p.scatterColor,size:p.scatterSize,glyph:p.scatterMarker,opacity:d,orthographic:!0,lineWidth:p.scatterLineWidth,lineColor:p.scatterLineColor,project:p.project,projectScale:p.projectScale,projectOpacity:p.projectOpacity},-1!==this.mode.indexOf("markers")?this.scatterPlot?this.scatterPlot.update(r):(this.scatterPlot=i(r),this.scatterPlot._trace=this,this.scatterPlot.highlightScale=1,this.scene.glplot.add(this.scatterPlot)):this.scatterPlot&&(this.scene.glplot.remove(this.scatterPlot),this.scatterPlot.dispose(),this.scatterPlot=null),c={gl:u,position:p.position,glyph:p.text,color:p.textColor,size:p.textSize,angle:p.textAngle,alignment:p.textOffset,font:p.textFont,orthographic:!0,lineWidth:0,project:!1,opacity:t.opacity},this.textLabels=t.hovertext||t.text,-1!==this.mode.indexOf("text")?this.textMarkers?this.textMarkers.update(c):(this.textMarkers=i(c),this.textMarkers._trace=this,this.textMarkers.highlightScale=1,this.scene.glplot.add(this.textMarkers)):this.textMarkers&&(this.scene.glplot.remove(this.textMarkers),this.textMarkers.dispose(),this.textMarkers=null),l={gl:u,position:p.position,color:p.errorColor,error:p.errorBounds,lineWidth:p.errorLineWidth,capSize:p.errorCapSize,opacity:t.opacity},this.errorBars?p.errorBounds?this.errorBars.update(l):(this.scene.glplot.remove(this.errorBars),this.errorBars.dispose(),this.errorBars=null):p.errorBounds&&(this.errorBars=a(l),this.errorBars._trace=this,this.scene.glplot.add(this.errorBars)),p.delaunayAxis>=0){var g=function(t,e,r){var n,i=(r+1)%3,a=(r+2)%3,o=[],l=[];for(n=0;n=0&&f("surfacecolor",h||p);for(var d=["x","y","z"],g=0;g<3;++g){var m="projection."+d[g];f(m+".show")&&(f(m+".opacity"),f(m+".scale"))}var v=n.getComponentMethod("errorbars","supplyDefaults");v(t,e,r,{axis:"z"}),v(t,e,r,{axis:"y",inherit:"z"}),v(t,e,r,{axis:"x",inherit:"z"})}else e.visible=!1}},{"../../lib":660,"../../registry":790,"../scatter/line_defaults":1003,"../scatter/marker_defaults":1008,"../scatter/subtypes":1012,"../scatter/text_defaults":1013,"./attributes":1015}],1020:[function(t,e,r){"use strict";var n={};n.plot=t("./convert"),n.attributes=t("./attributes"),n.markerSymbols=t("../../constants/gl3d_markers"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.moduleType="trace",n.name="scatter3d",n.basePlotModule=t("../../plots/gl3d"),n.categories=["gl3d","symbols","markerColorscale","showLegend"],n.meta={},e.exports=n},{"../../constants/gl3d_markers":635,"../../plots/gl3d":748,"../scatter/colorbar":994,"./attributes":1015,"./calc":1016,"./convert":1018,"./defaults":1019}],1021:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../plots/attributes"),a=t("../../components/colorscale/color_attributes"),o=t("../../components/colorbar/attributes"),s=t("../../lib/extend").extendFlat,l=n.marker,c=n.line,u=l.line;e.exports={carpet:{valType:"string",editType:"calc"},a:{valType:"data_array",editType:"calc"},b:{valType:"data_array",editType:"calc"},mode:s({},n.mode,{dflt:"markers"}),text:s({},n.text,{}),line:{color:c.color,width:c.width,dash:c.dash,shape:s({},c.shape,{values:["linear","spline"]}),smoothing:c.smoothing,editType:"calc"},connectgaps:n.connectgaps,fill:s({},n.fill,{values:["none","toself","tonext"]}),fillcolor:n.fillcolor,marker:s({symbol:l.symbol,opacity:l.opacity,maxdisplayed:l.maxdisplayed,size:l.size,sizeref:l.sizeref,sizemin:l.sizemin,sizemode:l.sizemode,line:s({width:u.width,editType:"calc"},a("marker".line)),gradient:l.gradient,editType:"calc"},a("marker"),{showscale:l.showscale,colorbar:o}),textfont:n.textfont,textposition:n.textposition,selected:n.selected,unselected:n.unselected,hoverinfo:s({},i.hoverinfo,{flags:["a","b","text","name"]}),hoveron:n.hoveron}},{"../../components/colorbar/attributes":533,"../../components/colorscale/color_attributes":540,"../../lib/extend":649,"../../plots/attributes":703,"../scatter/attributes":990}],1022:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../scatter/colorscale_calc"),a=t("../scatter/arrays_to_calcdata"),o=t("../scatter/calc_selection"),s=t("../scatter/calc").calcMarkerSize,l=t("../carpet/lookup_carpetid");e.exports=function(t,e){var r=e._carpetTrace=l(t,e);if(r&&r.visible&&"legendonly"!==r.visible){var c;e.xaxis=r.xaxis,e.yaxis=r.yaxis;var u,f,h=e._length,p=new Array(h),d=!1;for(c=0;c"),a}function w(t,e){var r;r=t.labelprefix&&t.labelprefix.length>0?t.labelprefix.replace(/ = $/,""):t._hovertitle,g.push(r+": "+e.toFixed(3)+t.labelsuffix)}}},{"../scatter/hover":1001}],1026:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../scatter/style").style,n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("../scatter/select"),n.eventData=t("./event_data"),n.moduleType="trace",n.name="scattercarpet",n.basePlotModule=t("../../plots/cartesian"),n.categories=["svg","carpet","symbols","markerColorscale","showLegend","carpetDependent","zoomScale"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"../scatter/colorbar":994,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1021,"./calc":1022,"./defaults":1023,"./event_data":1024,"./hover":1025,"./plot":1027}],1027:[function(t,e,r){"use strict";var n=t("../scatter/plot"),i=t("../../plots/cartesian/axes"),a=t("../../components/drawing");e.exports=function(t,e,r,o){var s,l,c,u=r[0][0].carpet,f={xaxis:i.getFromId(t,u.xaxis||"x"),yaxis:i.getFromId(t,u.yaxis||"y"),plot:e.plot};for(n(t,f,r,o),s=0;s")}(u,m,p.mockAxis,c[0].t.labels),[t]}}},{"../../components/fx":574,"../../constants/numerical":637,"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998,"../scatter/get_trace_color":1e3,"./attributes":1028}],1033:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("./style"),n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.moduleType="trace",n.name="scattergeo",n.basePlotModule=t("../../plots/geo"),n.categories=["geo","symbols","markerColorscale","showLegend","scatter-like"],n.meta={},e.exports=n},{"../../plots/geo":736,"../scatter/colorbar":994,"../scatter/style":1011,"./attributes":1028,"./calc":1029,"./defaults":1030,"./event_data":1031,"./hover":1032,"./plot":1034,"./select":1035,"./style":1036}],1034:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../constants/numerical").BADNUM,o=t("../../lib/topojson_utils").getTopojsonFeatures,s=t("../../lib/geo_location_utils").locationToFeature,l=t("../../lib/geojson_utils"),c=t("../scatter/subtypes"),u=t("./style");function f(t,e){var r=t[0].trace;if(Array.isArray(r.locations))for(var n=o(r,e),i=r.locationmode,l=0;ld.TOO_MANY_POINTS?"rect":h.hasMarkers(e)?"rect":"round";if(o&&e.connectgaps){var l=n[0],c=n[1];for(i=0;i1&&c.extendFlat(o.line,b(t,r,n)),o.errorX||o.errorY){var s=_(t,r,n,i,a);o.errorX&&c.extendFlat(o.errorX,s.x),o.errorY&&c.extendFlat(o.errorY,s.y)}return o}function A(t,e){var r=e._scene,n=t._fullLayout,i={count:0,dirty:!0,lineOptions:[],fillOptions:[],markerOptions:[],selectedOptions:[],unselectedOptions:[],errorXOptions:[],errorYOptions:[]};return e._scene||((r=e._scene=c.extendFlat({},i,{selectBatch:null,unselectBatch:null,fill2d:!1,scatter2d:!1,error2d:!1,line2d:!1,select2d:null})).update=function(t){for(var e=new Array(r.count),n=0;n=k&&(T.marker.cluster=m.tree),S.lineOptions.push(T.line),S.errorXOptions.push(T.errorX),S.errorYOptions.push(T.errorY),S.fillOptions.push(T.fill),S.markerOptions.push(T.marker),S.selectedOptions.push(T.selected),S.unselectedOptions.push(T.unselected),S.count++,m._scene=S,m.index=S.count-1,m.x=v,m.y=y,m.positions=x,m.count=u,t.firstscatter=!1,[{x:!1,y:!1,t:m,trace:e}]},plot:function(t,e,r){if(r.length){var o=t._fullLayout,s=r[0][0].t._scene,l=o.dragmode;if(s){var c=o._size,h=o.width,p=o.height;u(t,["ANGLE_instanced_arrays","OES_element_index_uint"]);var d=o._glcanvas.data()[0].regl;if(m(t,e,r),s.dirty){if(!0===s.error2d&&(s.error2d=a(d)),!0===s.line2d&&(s.line2d=i(d)),!0===s.scatter2d&&(s.scatter2d=n(d)),!0===s.fill2d&&(s.fill2d=i(d)),s.line2d&&s.line2d.update(s.lineOptions),s.error2d){var g=(s.errorXOptions||[]).concat(s.errorYOptions||[]);s.error2d.update(g)}s.scatter2d&&s.scatter2d.update(s.markerOptions),s.fill2d&&(s.fillOptions=s.fillOptions.map(function(t,e){var n=r[e];if(!(t&&n&&n[0]&&n[0].trace))return null;var i,a,o=n[0],l=o.trace,c=o.t,u=s.lineOptions[e],f=[],h=u&&u.positions||c.positions;if("tozeroy"===l.fill)(f=(f=[h[0],0]).concat(h)).push(h[h.length-2]),f.push(0);else if("tozerox"===l.fill)(f=(f=[0,h[1]]).concat(h)).push(0),f.push(h[h.length-1]);else if("toself"===l.fill||"tonext"===l.fill){for(f=[],i=0,a=0;a=0?Math.floor((e+180)/360):Math.ceil((e-180)/360)),d=e-p;if(n.getClosest(l,function(t){var e=t.lonlat;if(e[0]===s)return 1/0;var n=i.wrap180(e[0]),a=e[1],o=h.project([n,a]),l=o.x-u.c2p([d,a]),c=o.y-f.c2p([n,r]),p=Math.max(3,t.mrc||0);return Math.max(Math.sqrt(l*l+c*c)-p,1-3/p)},t),!1!==t.index){var g=l[t.index],m=g.lonlat,v=[i.wrap180(m[0])+p,m[1]],y=u.c2p(v),x=f.c2p(v),b=g.mrc||1;return t.x0=y-b,t.x1=y+b,t.y0=x-b,t.y1=x+b,t.color=a(c,g),t.extraText=function(t,e,r){var n=(e.hi||t.hoverinfo).split("+"),i=-1!==n.indexOf("all"),a=-1!==n.indexOf("lon"),s=-1!==n.indexOf("lat"),l=e.lonlat,c=[];function u(t){return t+"\xb0"}i||a&&s?c.push("("+u(l[0])+", "+u(l[1])+")"):a?c.push(r.lon+u(l[0])):s&&c.push(r.lat+u(l[1]));(i||-1!==n.indexOf("text"))&&o(e,t,c);return c.join("
")}(c,g,l[0].t.labels),[t]}}},{"../../components/fx":574,"../../constants/numerical":637,"../../lib":660,"../scatter/fill_hover_text":998,"../scatter/get_trace_color":1e3}],1047:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("../scattergeo/calc"),n.plot=t("./plot"),n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.style=function(t,e){e&&e[0].trace._glTrace.update(e)},n.moduleType="trace",n.name="scattermapbox",n.basePlotModule=t("../../plots/mapbox"),n.categories=["mapbox","gl","symbols","markerColorscale","showLegend","scatterlike"],n.meta={},e.exports=n},{"../../plots/mapbox":762,"../scatter/colorbar":994,"../scattergeo/calc":1029,"./attributes":1042,"./defaults":1044,"./event_data":1045,"./hover":1046,"./plot":1048,"./select":1049}],1048:[function(t,e,r){"use strict";var n=t("./convert");function i(t,e){this.subplot=t,this.uid=e,this.sourceIds={fill:e+"-source-fill",line:e+"-source-line",circle:e+"-source-circle",symbol:e+"-source-symbol"},this.layerIds={fill:e+"-layer-fill",line:e+"-layer-line",circle:e+"-layer-circle",symbol:e+"-layer-symbol"},this.order=["fill","line","circle","symbol"]}var a=i.prototype;a.addSource=function(t,e){this.subplot.map.addSource(this.sourceIds[t],{type:"geojson",data:e.geojson})},a.setSourceData=function(t,e){this.subplot.map.getSource(this.sourceIds[t]).setData(e.geojson)},a.addLayer=function(t,e){this.subplot.map.addLayer({type:t,id:this.layerIds[t],source:this.sourceIds[t],layout:e.layout,paint:e.paint})},a.update=function(t){for(var e=this.subplot,r=n(t),i=0;i")}e.exports={hoverPoints:function(t,e,r,i){var a=n(t,e,r,i);if(a&&!1!==a[0].index){var s=a[0];if(void 0===s.index)return a;var l=t.subplot,c=s.cd[s.index],u=s.trace;if(l.isPtWithinSector(c))return s.xLabelVal=void 0,s.yLabelVal=void 0,s.extraText=o(c,u,l),a}},makeHoverPointText:o}},{"../../lib":660,"../../plots/cartesian/axes":706,"../scatter/hover":1001}],1054:[function(t,e,r){"use strict";e.exports={moduleType:"trace",name:"scatterpolar",basePlotModule:t("../../plots/polar"),categories:["polar","symbols","markerColorscale","showLegend","scatter-like"],attributes:t("./attributes"),supplyDefaults:t("./defaults"),calc:t("./calc"),plot:t("./plot"),style:t("../scatter/style").style,hoverPoints:t("./hover").hoverPoints,selectPoints:t("../scatter/select"),meta:{}}},{"../../plots/polar":771,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1050,"./calc":1051,"./defaults":1052,"./hover":1053,"./plot":1055}],1055:[function(t,e,r){"use strict";var n=t("../scatter/plot"),i=t("../../constants/numerical").BADNUM;e.exports=function(t,e,r){var a,o,s,l={xaxis:e.xaxis,yaxis:e.yaxis,plot:e.framework,layerClipId:e._hasClipOnAxisFalse?e.clipIds.circle:null},c=e.radialAxis,u=c.range;for(s=u[0]>u[1]?function(t){return t<=0}:function(t){return t>=0},a=0;a=0?(m=o.c2r(g)-l[0],T=v,y=s.c2rad(T,b.thetaunit),E[d]=C[2*d]=m*Math.cos(y),L[d]=C[2*d+1]=m*Math.sin(y)):E[d]=L[d]=C[2*d]=C[2*d+1]=NaN;var z=a.sceneOptions(t,e,b,C);z.fill&&!f.fill2d&&(f.fill2d=!0),z.marker&&!f.scatter2d&&(f.scatter2d=!0),z.line&&!f.line2d&&(f.line2d=!0),!z.errorX&&!z.errorY||f.error2d||(f.error2d=!0),_.tree=n(C),z.marker&&S>=u&&(z.marker.cluster=_.tree),c.hasMarkers(b)&&(z.selected.positions=z.unselected.positions=z.marker.positions),f.lineOptions.push(z.line),f.errorXOptions.push(z.errorX),f.errorYOptions.push(z.errorY),f.fillOptions.push(z.fill),f.markerOptions.push(z.marker),f.selectedOptions.push(z.selected),f.unselectedOptions.push(z.unselected),f.count=r.length,_._scene=f,_.index=p,_.x=E,_.y=L,_.rawx=E,_.rawy=L,_.r=w,_.theta=k,_.positions=C,_.count=S}}),a.plot(t,e,r)},hoverPoints:function(t,e,r,n){var i=t.cd[0].t,o=i.r,s=i.theta,c=a.hoverPoints(t,e,r,n);if(c&&!1!==c[0].index){var u=c[0];if(void 0===u.index)return c;var f=t.subplot,h=f.angularAxis,p=u.cd[u.index],d=u.trace;if(p.r=o[u.index],p.theta=s[u.index],p.rad=h.c2rad(p.theta,d.thetaunit),f.isPtWithinSector(p))return u.xLabelVal=void 0,u.yLabelVal=void 0,u.extraText=l(p,d,f),c}},style:a.style,selectPoints:a.selectPoints,meta:{}}},{"../../plots/cartesian/axes":706,"../../plots/polar":771,"../scatter/colorscale_calc":995,"../scatter/subtypes":1012,"../scattergl":1041,"../scattergl/constants":1038,"../scatterpolar/hover":1053,"./attributes":1056,"./defaults":1057,"fast-isnumeric":197,"point-cluster":411}],1059:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../plots/attributes"),a=t("../../components/colorscale/color_attributes"),o=t("../../components/colorbar/attributes"),s=t("../../components/drawing/attributes").dash,l=t("../../lib/extend").extendFlat,c=n.marker,u=n.line,f=c.line;e.exports={a:{valType:"data_array",editType:"calc"},b:{valType:"data_array",editType:"calc"},c:{valType:"data_array",editType:"calc"},sum:{valType:"number",dflt:0,min:0,editType:"calc"},mode:l({},n.mode,{dflt:"markers"}),text:l({},n.text,{}),hovertext:l({},n.hovertext,{}),line:{color:u.color,width:u.width,dash:s,shape:l({},u.shape,{values:["linear","spline"]}),smoothing:u.smoothing,editType:"calc"},connectgaps:n.connectgaps,cliponaxis:n.cliponaxis,fill:l({},n.fill,{values:["none","toself","tonext"]}),fillcolor:n.fillcolor,marker:l({symbol:c.symbol,opacity:c.opacity,maxdisplayed:c.maxdisplayed,size:c.size,sizeref:c.sizeref,sizemin:c.sizemin,sizemode:c.sizemode,line:l({width:f.width,editType:"calc"},a("marker.line")),gradient:c.gradient,editType:"calc"},a("marker"),{showscale:c.showscale,colorbar:o}),textfont:n.textfont,textposition:n.textposition,selected:n.selected,unselected:n.unselected,hoverinfo:l({},i.hoverinfo,{flags:["a","b","c","text","name"]}),hoveron:n.hoveron}},{"../../components/colorbar/attributes":533,"../../components/colorscale/color_attributes":540,"../../components/drawing/attributes":556,"../../lib/extend":649,"../../plots/attributes":703,"../scatter/attributes":990}],1060:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../scatter/colorscale_calc"),a=t("../scatter/arrays_to_calcdata"),o=t("../scatter/calc_selection"),s=t("../scatter/calc").calcMarkerSize,l=["a","b","c"],c={a:["b","c"],b:["a","c"],c:["a","b"]};e.exports=function(t,e){var r,u,f,h,p,d,g=t._fullLayout[e.subplot].sum,m=e.sum||g,v={a:e.a,b:e.b,c:e.c};for(r=0;r"),o}function v(t,e){m.push(t._hovertitle+": "+i.tickText(t,e,"hover").text)}}},{"../../plots/cartesian/axes":706,"../scatter/hover":1001}],1064:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../scatter/style").style,n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("../scatter/select"),n.eventData=t("./event_data"),n.moduleType="trace",n.name="scatterternary",n.basePlotModule=t("../../plots/ternary"),n.categories=["ternary","symbols","markerColorscale","showLegend","scatter-like"],n.meta={},e.exports=n},{"../../plots/ternary":783,"../scatter/colorbar":994,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1059,"./calc":1060,"./defaults":1061,"./event_data":1062,"./hover":1063,"./plot":1065}],1065:[function(t,e,r){"use strict";var n=t("../scatter/plot");e.exports=function(t,e,r){var i=e.plotContainer;i.select(".scatterlayer").selectAll("*").remove();var a={xaxis:e.xaxis,yaxis:e.yaxis,plot:i,layerClipId:e._hasClipOnAxisFalse?e.clipIdRelative:null},o=e.layers.frontplot.select("g.scatterlayer");n(t,a,r,o)}},{"../scatter/plot":1009}],1066:[function(t,e,r){"use strict";var n=t("../scattergl/attributes"),i=t("../../plots/cartesian/constants").idRegex;function a(t){return{valType:"info_array",freeLength:!0,editType:"calc",items:{valType:"subplotid",regex:i[t],editType:"plot"}}}e.exports={dimensions:{_isLinkedToArray:"dimension",visible:{valType:"boolean",dflt:!0,editType:"calc"},label:{valType:"string",editType:"calc"},values:{valType:"data_array",editType:"calc+clearAxisTypes"},editType:"calc+clearAxisTypes"},text:n.text,marker:n.marker,xaxes:a("x"),yaxes:a("y"),diagonal:{visible:{valType:"boolean",dflt:!0,editType:"calc"},editType:"calc"},showupperhalf:{valType:"boolean",dflt:!0,editType:"calc"},showlowerhalf:{valType:"boolean",dflt:!0,editType:"calc"},selected:{marker:n.selected.marker,editType:"calc"},unselected:{marker:n.unselected.marker,editType:"calc"},opacity:n.opacity}},{"../../plots/cartesian/constants":711,"../scattergl/attributes":1037}],1067:[function(t,e,r){"use strict";var n=t("regl-line2d"),i=t("../../registry"),a=t("../../lib"),o=t("../../lib/prepare_regl"),s=t("../../plots/get_data").getModuleCalcData,l=t("../../plots/cartesian"),c=t("../../plots/cartesian/axis_ids"),u="splom";function f(t,e,r){for(var n=e.dimensions,i=r.matrixOptions.data.length,a=new Array(i),o=0,s=0;o1&&ra&&f?r._splomSubplots[y]=1:iv;for(r=0,n=0;r",maxDimensionCount:60,overdrag:45,releaseTransitionDuration:120,releaseTransitionEase:"cubic-out",scrollbarCaptureWidth:18,scrollbarHideDelay:1e3,scrollbarHideDuration:1e3,scrollbarOffset:5,scrollbarWidth:8,transitionDuration:100,transitionEase:"cubic-out",uplift:5,wrapSpacer:" ",wrapSplitCharacter:" ",cn:{table:"table",tableControlView:"table-control-view",scrollBackground:"scroll-background",yColumn:"y-column",columnBlock:"column-block",scrollAreaClip:"scroll-area-clip",scrollAreaClipRect:"scroll-area-clip-rect",columnBoundary:"column-boundary",columnBoundaryClippath:"column-boundary-clippath",columnBoundaryRect:"column-boundary-rect",columnCells:"column-cells",columnCell:"column-cell",cellRect:"cell-rect",cellText:"cell-text",cellTextHolder:"cell-text-holder",scrollbarKit:"scrollbar-kit",scrollbar:"scrollbar",scrollbarSlider:"scrollbar-slider",scrollbarGlyph:"scrollbar-glyph",scrollbarCaptureZone:"scrollbar-capture-zone"}}},{}],1080:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../lib/extend").extendFlat,a=t("fast-isnumeric");function o(t){if(Array.isArray(t)){for(var e=0,r=0;r=e||c===t.length-1)&&(n[i]=o,o.key=l++,o.firstRowIndex=s,o.lastRowIndex=c,o={firstRowIndex:null,lastRowIndex:null,rows:[]},i+=a,s=c+1,a=0);return n}e.exports=function(t,e){var r=l(e.cells.values),p=function(t){return t.slice(e.header.values.length,t.length)},d=l(e.header.values);d.length&&!d[0].length&&(d[0]=[""],d=l(d));var g=d.concat(p(r).map(function(){return c((d[0]||[""]).length)})),m=e.domain,v=Math.floor(t._fullLayout._size.w*(m.x[1]-m.x[0])),y=Math.floor(t._fullLayout._size.h*(m.y[1]-m.y[0])),x=e.header.values.length?g[0].map(function(){return e.header.height}):[n.emptyHeaderHeight],b=r.length?r[0].map(function(){return e.cells.height}):[],_=x.reduce(s,0),w=h(b,y-_+n.uplift),k=f(h(x,_),[]),M=f(w,k),A={},T=e._fullInput.columnorder.concat(p(r.map(function(t,e){return e}))),S=g.map(function(t,r){var n=Array.isArray(e.columnwidth)?e.columnwidth[Math.min(r,e.columnwidth.length-1)]:e.columnwidth;return a(n)?Number(n):1}),C=S.reduce(s,0);S=S.map(function(t){return t/C*v});var E=Math.max(o(e.header.line.width),o(e.cells.line.width)),L={key:e.index,translateX:m.x[0]*t._fullLayout._size.w,translateY:t._fullLayout._size.h*(1-m.y[1]),size:t._fullLayout._size,width:v,maxLineWidth:E,height:y,columnOrder:T,groupHeight:y,rowBlocks:M,headerRowBlocks:k,scrollY:0,cells:i({},e.cells,{values:r}),headerCells:i({},e.header,{values:g}),gdColumns:g.map(function(t){return t[0]}),gdColumnsOriginalOrder:g.map(function(t){return t[0]}),prevPages:[0,0],scrollbarState:{scrollbarScrollInProgress:!1},columns:g.map(function(t,e){var r=A[t];return A[t]=(r||0)+1,{key:t+"__"+A[t],label:t,specIndex:e,xIndex:T[e],xScale:u,x:void 0,calcdata:void 0,columnWidth:S[e]}})};return L.columns.forEach(function(t){t.calcdata=L,t.x=u(t)}),L}},{"../../lib/extend":649,"./constants":1079,"fast-isnumeric":197}],1081:[function(t,e,r){"use strict";var n=t("../../lib/extend").extendFlat;r.splitToPanels=function(t){var e=[0,0],r=n({},t,{key:"header",type:"header",page:0,prevPages:e,currentRepaint:[null,null],dragHandle:!0,values:t.calcdata.headerCells.values[t.specIndex],rowBlocks:t.calcdata.headerRowBlocks,calcdata:n({},t.calcdata,{cells:t.calcdata.headerCells})});return[n({},t,{key:"cells1",type:"cells",page:0,prevPages:e,currentRepaint:[null,null],dragHandle:!1,values:t.calcdata.cells.values[t.specIndex],rowBlocks:t.calcdata.rowBlocks}),n({},t,{key:"cells2",type:"cells",page:1,prevPages:e,currentRepaint:[null,null],dragHandle:!1,values:t.calcdata.cells.values[t.specIndex],rowBlocks:t.calcdata.rowBlocks}),r]},r.splitToCells=function(t){var e=function(t){var e=t.rowBlocks[t.page],r=e?e.rows[0].rowIndex:0,n=e?r+e.rows.length:0;return[r,n]}(t);return(t.values||[]).slice(e[0],e[1]).map(function(r,n){return{keyWithinBlock:n+("string"==typeof r&&r.match(/[<$&> ]/)?"_keybuster_"+Math.random():""),key:e[0]+n,column:t,calcdata:t.calcdata,page:t.page,rowBlocks:t.rowBlocks,value:r}})}},{"../../lib/extend":649}],1082:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../plots/domain").defaults;e.exports=function(t,e,r,o){function s(r,a){return n.coerce(t,e,i,r,a)}a(e,o,s),s("columnwidth"),s("header.values"),s("header.format"),s("header.align"),s("header.prefix"),s("header.suffix"),s("header.height"),s("header.line.width"),s("header.line.color"),s("header.fill.color"),n.coerceFont(s,"header.font",n.extendFlat({},o.font)),function(t,e){for(var r=t.columnorder||[],n=t.header.values.length,i=r.slice(0,n),a=i.slice().sort(function(t,e){return t-e}),o=i.map(function(t){return a.indexOf(t)}),s=o.length;s/i),l=!o||s;t.mayHaveMarkup=o&&a.match(/[<&>]/);var c,u="string"==typeof(c=a)&&c.match(n.latexCheck);t.latex=u;var f,h,p=u?"":_(t.calcdata.cells.prefix,e,r)||"",d=u?"":_(t.calcdata.cells.suffix,e,r)||"",g=u?null:_(t.calcdata.cells.format,e,r)||null,m=p+(g?i.format(g)(t.value):t.value)+d;if(t.wrappingNeeded=!t.wrapped&&!l&&!u&&(f=b(m)),t.cellHeightMayIncrease=s||u||t.mayHaveMarkup||(void 0===f?b(m):f),t.needsConvertToTspans=t.mayHaveMarkup||t.wrappingNeeded||t.latex,t.wrappingNeeded){var v=(" "===n.wrapSplitCharacter?m.replace(/i&&n.push(a),i+=l}return n}(i,l,s);1===c.length&&(c[0]===i.length-1?c.unshift(c[0]-1):c.push(c[0]+1)),c[0]%2&&c.reverse(),e.each(function(t,e){t.page=c[e],t.scrollY=l}),e.attr("transform",function(t){return"translate(0 "+(D(t.rowBlocks,t.page)-t.scrollY)+")"}),t&&(C(t,r,e,c,n.prevPages,n,0),C(t,r,e,c,n.prevPages,n,1),v(r,t))}}function S(t,e,r,a){return function(o){var s=o.calcdata?o.calcdata:o,l=e.filter(function(t){return s.key===t.key}),c=r||s.scrollbarState.dragMultiplier;s.scrollY=void 0===a?s.scrollY+c*i.event.dy:a;var u=l.selectAll("."+n.cn.yColumn).selectAll("."+n.cn.columnBlock).filter(k);T(t,u,l)}}function C(t,e,r,n,i,a,o){n[o]!==i[o]&&(clearTimeout(a.currentRepaint[o]),a.currentRepaint[o]=setTimeout(function(){var a=r.filter(function(t,e){return e===o&&n[e]!==i[e]});y(t,e,a,r),i[o]=n[o]}))}function E(t,e,r){return function(){var a=i.select(e.parentNode);a.each(function(t){var e=t.fragments;a.selectAll("tspan.line").each(function(t,r){e[r].width=this.getComputedTextLength()});var r,i,o=e[e.length-1].width,s=e.slice(0,-1),l=[],c=0,u=t.column.columnWidth-2*n.cellPad;for(t.value="";s.length;)c+(i=(r=s.shift()).width+o)>u&&(t.value+=l.join(n.wrapSpacer)+n.lineBreaker,l=[],c=0),l.push(r.text),c+=i;c&&(t.value+=l.join(n.wrapSpacer)),t.wrapped=!0}),a.selectAll("tspan.line").remove(),x(a.select("."+n.cn.cellText),r,t),i.select(e.parentNode.parentNode).call(P)}}function L(t,e,r,a,o){return function(){if(!o.settledY){var s=i.select(e.parentNode),l=R(o),c=o.key-l.firstRowIndex,u=l.rows[c].rowHeight,f=o.cellHeightMayIncrease?e.parentNode.getBoundingClientRect().height+2*n.cellPad:u,h=Math.max(f,u);h-l.rows[c].rowHeight&&(l.rows[c].rowHeight=h,t.selectAll("."+n.cn.columnCell).call(P),T(null,t.filter(k),0),v(r,a,!0)),s.attr("transform",function(){var t=this.parentNode.getBoundingClientRect(),e=i.select(this.parentNode).select("."+n.cn.cellRect).node().getBoundingClientRect(),r=this.transform.baseVal.consolidate(),a=e.top-t.top+(r?r.matrix.f:n.cellPad);return"translate("+z(o,i.select(this.parentNode).select("."+n.cn.cellTextHolder).node().getBoundingClientRect().width)+" "+a+")"}),o.settledY=!0}}}function z(t,e){switch(t.align){case"left":return n.cellPad;case"right":return t.column.columnWidth-(e||0)-n.cellPad;case"center":return(t.column.columnWidth-(e||0))/2;default:return n.cellPad}}function P(t){t.attr("transform",function(t){var e=t.rowBlocks[0].auxiliaryBlocks.reduce(function(t,e){return t+O(e,1/0)},0);return"translate(0 "+(O(R(t),t.key)+e)+")"}).selectAll("."+n.cn.cellRect).attr("height",function(t){return(e=R(t),r=t.key,e.rows[r-e.firstRowIndex]).rowHeight;var e,r})}function D(t,e){for(var r=0,n=e-1;n>=0;n--)r+=I(t[n]);return r}function O(t,e){for(var r=0,n=0;n0){var y,x,b,_,w,k=t.xa,M=t.ya;"h"===h.orientation?(w=e,y="y",b=M,x="x",_=k):(w=r,y="x",b=k,x="y",_=M);var A=f[t.index];if(w>=A.span[0]&&w<=A.span[1]){var T=n.extendFlat({},t),S=_.c2p(w,!0),C=o.getKdeValue(A,h,w),E=o.getPositionOnKdePath(A,h,S),L=b._offset,z=b._length;T[y+"0"]=E[0],T[y+"1"]=E[1],T[x+"0"]=T[x+"1"]=S,T[x+"Label"]=x+": "+i.hoverLabelText(_,w)+", "+f[0].t.labels.kde+" "+C.toFixed(3),T.spikeDistance=v[0].spikeDistance;var P=y+"Spike";T[P]=v[0][P],v[0].spikeDistance=void 0,v[0][P]=void 0,m.push(T),(u={stroke:t.color})[y+"1"]=n.constrain(L+E[0],L,L+z),u[y+"2"]=n.constrain(L+E[1],L,L+z),u[x+"1"]=u[x+"2"]=_._offset+S}}}-1!==p.indexOf("points")&&(c=a.hoverOnPoints(t,e,r));var D=l.selectAll(".violinline-"+h.uid).data(u?[0]:[]);return D.enter().append("line").classed("violinline-"+h.uid,!0).attr("stroke-width",1.5),D.exit().remove(),D.attr(u),"closest"===s?c?[c]:m:c?(m.push(c),m):m}},{"../../lib":660,"../../plots/cartesian/axes":706,"../box/hover":816,"./helpers":1088}],1090:[function(t,e,r){"use strict";e.exports={attributes:t("./attributes"),layoutAttributes:t("./layout_attributes"),supplyDefaults:t("./defaults"),supplyLayoutDefaults:t("./layout_defaults"),calc:t("./calc"),setPositions:t("./set_positions"),plot:t("./plot"),style:t("./style"),styleOnSelect:t("../scatter/style").styleOnSelect,hoverPoints:t("./hover"),selectPoints:t("../box/select"),moduleType:"trace",name:"violin",basePlotModule:t("../../plots/cartesian"),categories:["cartesian","svg","symbols","oriented","box-violin","showLegend","violinLayout","zoomScale"],meta:{}}},{"../../plots/cartesian":717,"../box/select":821,"../scatter/style":1011,"./attributes":1085,"./calc":1086,"./defaults":1087,"./hover":1089,"./layout_attributes":1091,"./layout_defaults":1092,"./plot":1093,"./set_positions":1094,"./style":1095}],1091:[function(t,e,r){"use strict";var n=t("../box/layout_attributes"),i=t("../../lib").extendFlat;e.exports={violinmode:i({},n.boxmode,{}),violingap:i({},n.boxgap,{}),violingroupgap:i({},n.boxgroupgap,{})}},{"../../lib":660,"../box/layout_attributes":818}],1092:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./layout_attributes"),a=t("../box/layout_defaults");e.exports=function(t,e,r){a._supply(t,e,r,function(r,a){return n.coerce(t,e,i,r,a)},"violin")}},{"../../lib":660,"../box/layout_defaults":819,"./layout_attributes":1091}],1093:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../components/drawing"),o=t("../box/plot"),s=t("../scatter/line_points"),l=t("./helpers");e.exports=function(t,e,r,c){var u=t._fullLayout,f=e.xaxis,h=e.yaxis;function p(t){var e=s(t,{xaxis:f,yaxis:h,connectGaps:!0,baseTolerance:.75,shape:"spline",simplify:!0});return a.smoothopen(e[0],1)}var d=c.selectAll("g.trace.violins").data(r,function(t){return t[0].trace.uid});d.enter().append("g").attr("class","trace violins"),d.exit().remove(),d.order(),d.each(function(t){var r=t[0],a=r.t,s=r.trace,c=n.select(this);e.isRangePlot||(r.node3=c);var d=u._numViolins,g="group"===u.violinmode&&d>1,m=1-u.violingap,v=a.bdPos=a.dPos*m*(1-u.violingroupgap)/(g?d:1),y=a.bPos=g?2*a.dPos*((a.num+.5)/d-.5)*m:0;if(a.wHover=a.dPos*(g?m/d:1),!0!==s.visible||a.empty)n.select(this).remove();else{var x=e[a.valLetter+"axis"],b=e[a.posLetter+"axis"],_="both"===s.side,w=_||"positive"===s.side,k=_||"negative"===s.side,M=s.box&&s.box.visible,A=s.meanline&&s.meanline.visible,T=u._violinScaleGroupStats[s.scalegroup],S=c.selectAll("path.violin").data(i.identity);if(S.enter().append("path").style("vector-effect","non-scaling-stroke").attr("class","violin"),S.exit().remove(),S.each(function(t){var e,r,i,o,l,c,u,f,h=n.select(this),d=t.density,g=d.length,m=t.pos+y,M=b.c2p(m);switch(s.scalemode){case"width":e=T.maxWidth/v;break;case"count":e=T.maxWidth/v*(T.maxCount/t.pts.length)}if(w){for(u=new Array(g),l=0;la&&(a=u,o=c)}}return a?i(o):s};case"rms":return function(t,e){for(var r=0,a=0,o=0;o":return function(t){return h(t)>s};case">=":return function(t){return h(t)>=s};case"[]":return function(t){var e=h(t);return e>=s[0]&&e<=s[1]};case"()":return function(t){var e=h(t);return e>s[0]&&e=s[0]&&es[0]&&e<=s[1]};case"][":return function(t){var e=h(t);return e<=s[0]||e>=s[1]};case")(":return function(t){var e=h(t);return es[1]};case"](":return function(t){var e=h(t);return e<=s[0]||e>s[1]};case")[":return function(t){var e=h(t);return e=s[1]};case"{}":return function(t){return-1!==s.indexOf(h(t))};case"}{":return function(t){return-1===s.indexOf(h(t))}}}(r,a.getDataToCoordFunc(t,e,s,i),h),x={},b={},_=0;d?(m=function(t){x[t.astr]=n.extendDeep([],t.get()),t.set(new Array(f))},v=function(t,e){var r=x[t.astr][e];t.get()[e]=r}):(m=function(t){x[t.astr]=n.extendDeep([],t.get()),t.set([])},v=function(t,e){var r=x[t.astr][e];t.get().push(r)}),M(m);for(var w=o(e.transforms,r),k=0;k1?"%{group} (%{trace})":"%{group}");var l=t.styles,c=o.styles=[];if(l)for(a=0;aMath.abs(e))c.rotate(o,0,0,-t*i*Math.PI*d.rotateSpeed/window.innerWidth);else{var s=d.zoomSpeed*a*e/window.innerHeight*(o-c.lastT())/100;c.pan(o,0,0,f*(Math.exp(s)-1))}},!0),d};var n=t("right-now"),i=t("3d-view"),a=t("mouse-change"),o=t("mouse-wheel"),s=t("mouse-event-offset"),l=t("has-passive-events")},{"3d-view":42,"has-passive-events":355,"mouse-change":378,"mouse-event-offset":379,"mouse-wheel":381,"right-now":440}],42:[function(t,e,r){"use strict";e.exports=function(t){var e=(t=t||{}).eye||[0,0,1],r=t.center||[0,0,0],s=t.up||[0,1,0],l=t.distanceLimits||[0,1/0],c=t.mode||"turntable",u=n(),f=i(),h=a();return u.setDistanceLimits(l[0],l[1]),u.lookAt(0,e,r,s),f.setDistanceLimits(l[0],l[1]),f.lookAt(0,e,r,s),h.setDistanceLimits(l[0],l[1]),h.lookAt(0,e,r,s),new o({turntable:u,orbit:f,matrix:h},c)};var n=t("turntable-camera-controller"),i=t("orbit-camera-controller"),a=t("matrix-camera-controller");function o(t,e){this._controllerNames=Object.keys(t),this._controllerList=this._controllerNames.map(function(e){return t[e]}),this._mode=e,this._active=t[e],this._active||(this._mode="turntable",this._active=t.turntable),this.modes=this._controllerNames,this.computedMatrix=this._active.computedMatrix,this.computedEye=this._active.computedEye,this.computedUp=this._active.computedUp,this.computedCenter=this._active.computedCenter,this.computedRadius=this._active.computedRadius}var s=o.prototype;[["flush",1],["idle",1],["lookAt",4],["rotate",4],["pan",4],["translate",4],["setMatrix",2],["setDistanceLimits",2],["setDistance",2]].forEach(function(t){for(var e=t[0],r=[],n=0;n0;--t)p(c*=.99),d(),h(c),d();function h(t){function r(t){return u(t.source)*t.value}i.forEach(function(n){n.forEach(function(n){if(n.targetLinks.length){var i=e.sum(n.targetLinks,r)/e.sum(n.targetLinks,f);n.y+=(i-u(n))*t}})})}function p(t){function r(t){return u(t.target)*t.value}i.slice().reverse().forEach(function(n){n.forEach(function(n){if(n.sourceLinks.length){var i=e.sum(n.sourceLinks,r)/e.sum(n.sourceLinks,f);n.y+=(i-u(n))*t}})})}function d(){i.forEach(function(t){var e,r,n,i=0,s=t.length;for(t.sort(g),n=0;n0&&(e.y+=r),i=e.y+e.dy+a;if((r=i-a-o[1])>0)for(i=e.y-=r,n=s-2;n>=0;--n)e=t[n],(r=e.y+e.dy+a-i)>0&&(e.y-=r),i=e.y})}function g(t,e){return t.y-e.y}}(n),c(),t},t.relayout=function(){return c(),t},t.link=function(){var t=.5;function e(e){var r=e.source.x+e.source.dx,i=e.target.x,a=n.interpolateNumber(r,i),o=a(t),s=a(1-t),l=e.source.y+e.sy,c=l+e.dy,u=e.target.y+e.ty,f=u+e.dy;return"M"+r+","+l+"C"+o+","+l+" "+s+","+u+" "+i+","+u+"L"+i+","+f+"C"+s+","+f+" "+o+","+c+" "+r+","+c+"Z"}return e.curvature=function(r){return arguments.length?(t=+r,e):t},e},t},Object.defineProperty(t,"__esModule",{value:!0})},"object"==typeof r&&void 0!==e?i(r,t("d3-array"),t("d3-collection"),t("d3-interpolate")):i(n.d3=n.d3||{},n.d3,n.d3,n.d3)},{"d3-array":123,"d3-collection":124,"d3-interpolate":128}],44:[function(t,e,r){"use strict";var n="undefined"==typeof WeakMap?t("weak-map"):WeakMap,i=t("gl-buffer"),a=t("gl-vao"),o=new n;e.exports=function(t){var e=o.get(t),r=e&&(e._triangleBuffer.handle||e._triangleBuffer.buffer);if(!r||!t.isBuffer(r)){var n=i(t,new Float32Array([-1,-1,-1,4,4,-1]));(e=a(t,[{buffer:n,type:t.FLOAT,size:2}]))._triangleBuffer=n,o.set(t,e)}e.bind(),t.drawArrays(t.TRIANGLES,0,3),e.unbind()}},{"gl-buffer":211,"gl-vao":284,"weak-map":490}],45:[function(t,e,r){e.exports=function(t){var e=0,r=0,n=0,i=0;return t.map(function(t){var a=(t=t.slice())[0],o=a.toUpperCase();if(a!=o)switch(t[0]=o,a){case"a":t[6]+=n,t[7]+=i;break;case"v":t[1]+=i;break;case"h":t[1]+=n;break;default:for(var s=1;si&&(i=t[o]),t[o]=0;c--)if(u[c]!==f[c])return!1;for(c=u.length-1;c>=0;c--)if(l=u[c],!y(t[l],e[l],r,n))return!1;return!0}(t,e,r,o))}return r?t===e:t==e}function x(t){return"[object Arguments]"==Object.prototype.toString.call(t)}function b(t,e){if(!t||!e)return!1;if("[object RegExp]"==Object.prototype.toString.call(e))return e.test(t);try{if(t instanceof e)return!0}catch(t){}return!Error.isPrototypeOf(e)&&!0===e.call({},t)}function _(t,e,r,n){var i;if("function"!=typeof e)throw new TypeError('"block" argument must be a function');"string"==typeof r&&(n=r,r=null),i=function(t){var e;try{t()}catch(t){e=t}return e}(e),n=(r&&r.name?" ("+r.name+").":".")+(n?" "+n:"."),t&&!i&&m(i,r,"Missing expected exception"+n);var o="string"==typeof n,s=!t&&i&&!r;if((!t&&a.isError(i)&&o&&b(i,r)||s)&&m(i,r,"Got unwanted exception"+n),t&&i&&r&&!b(i,r)||!t&&i)throw i}f.AssertionError=function(t){var e;this.name="AssertionError",this.actual=t.actual,this.expected=t.expected,this.operator=t.operator,t.message?(this.message=t.message,this.generatedMessage=!1):(this.message=d(g((e=this).actual),128)+" "+e.operator+" "+d(g(e.expected),128),this.generatedMessage=!0);var r=t.stackStartFunction||m;if(Error.captureStackTrace)Error.captureStackTrace(this,r);else{var n=new Error;if(n.stack){var i=n.stack,a=p(r),o=i.indexOf("\n"+a);if(o>=0){var s=i.indexOf("\n",o+1);i=i.substring(s+1)}this.stack=i}}},a.inherits(f.AssertionError,Error),f.fail=m,f.ok=v,f.equal=function(t,e,r){t!=e&&m(t,e,r,"==",f.equal)},f.notEqual=function(t,e,r){t==e&&m(t,e,r,"!=",f.notEqual)},f.deepEqual=function(t,e,r){y(t,e,!1)||m(t,e,r,"deepEqual",f.deepEqual)},f.deepStrictEqual=function(t,e,r){y(t,e,!0)||m(t,e,r,"deepStrictEqual",f.deepStrictEqual)},f.notDeepEqual=function(t,e,r){y(t,e,!1)&&m(t,e,r,"notDeepEqual",f.notDeepEqual)},f.notDeepStrictEqual=function t(e,r,n){y(e,r,!0)&&m(e,r,n,"notDeepStrictEqual",t)},f.strictEqual=function(t,e,r){t!==e&&m(t,e,r,"===",f.strictEqual)},f.notStrictEqual=function(t,e,r){t===e&&m(t,e,r,"!==",f.notStrictEqual)},f.throws=function(t,e,r){_(!0,t,e,r)},f.doesNotThrow=function(t,e,r){_(!1,t,e,r)},f.ifError=function(t){if(t)throw t};var w=Object.keys||function(t){var e=[];for(var r in t)o.call(t,r)&&e.push(r);return e}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"util/":487}],54:[function(t,e,r){e.exports=function(t){return atob(t)}},{}],55:[function(t,e,r){"use strict";e.exports=function(t,e){for(var r=e.length,a=new Array(r+1),o=0;o0?l-4:l;var u=0;for(e=0;e>16&255,s[u++]=n>>8&255,s[u++]=255&n;2===o?(n=i[t.charCodeAt(e)]<<2|i[t.charCodeAt(e+1)]>>4,s[u++]=255&n):1===o&&(n=i[t.charCodeAt(e)]<<10|i[t.charCodeAt(e+1)]<<4|i[t.charCodeAt(e+2)]>>2,s[u++]=n>>8&255,s[u++]=255&n);return s},r.fromByteArray=function(t){for(var e,r=t.length,i=r%3,a="",o=[],s=0,l=r-i;sl?l:s+16383));1===i?(e=t[r-1],a+=n[e>>2],a+=n[e<<4&63],a+="=="):2===i&&(e=(t[r-2]<<8)+t[r-1],a+=n[e>>10],a+=n[e>>4&63],a+=n[e<<2&63],a+="=");return o.push(a),o.join("")};for(var n=[],i=[],a="undefined"!=typeof Uint8Array?Uint8Array:Array,o="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",s=0,l=o.length;s0)throw new Error("Invalid string. Length must be a multiple of 4");return"="===t[e-2]?2:"="===t[e-1]?1:0}function u(t,e,r){for(var i,a,o=[],s=e;s>18&63]+n[a>>12&63]+n[a>>6&63]+n[63&a]);return o.join("")}i["-".charCodeAt(0)]=62,i["_".charCodeAt(0)]=63},{}],57:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]).add(e[0].mul(t[1])),t[1].mul(e[1]))}},{"./lib/rationalize":67}],58:[function(t,e,r){"use strict";e.exports=function(t,e){return t[0].mul(e[1]).cmp(e[0].mul(t[1]))}},{}],59:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]),t[1].mul(e[0]))}},{"./lib/rationalize":67}],60:[function(t,e,r){"use strict";var n=t("./is-rat"),i=t("./lib/is-bn"),a=t("./lib/num-to-bn"),o=t("./lib/str-to-bn"),s=t("./lib/rationalize"),l=t("./div");e.exports=function t(e,r){if(n(e))return r?l(e,t(r)):[e[0].clone(),e[1].clone()];var c=0;var u,f;if(i(e))u=e.clone();else if("string"==typeof e)u=o(e);else{if(0===e)return[a(0),a(1)];if(e===Math.floor(e))u=a(e);else{for(;e!==Math.floor(e);)e*=Math.pow(2,256),c-=256;u=a(e)}}if(n(r))u.mul(r[1]),f=r[0].clone();else if(i(r))f=r.clone();else if("string"==typeof r)f=o(r);else if(r)if(r===Math.floor(r))f=a(r);else{for(;r!==Math.floor(r);)r*=Math.pow(2,256),c+=256;f=a(r)}else f=a(1);c>0?u=u.ushln(c):c<0&&(f=f.ushln(-c));return s(u,f)}},{"./div":59,"./is-rat":61,"./lib/is-bn":65,"./lib/num-to-bn":66,"./lib/rationalize":67,"./lib/str-to-bn":68}],61:[function(t,e,r){"use strict";var n=t("./lib/is-bn");e.exports=function(t){return Array.isArray(t)&&2===t.length&&n(t[0])&&n(t[1])}},{"./lib/is-bn":65}],62:[function(t,e,r){"use strict";var n=t("bn.js");e.exports=function(t){return t.cmp(new n(0))}},{"bn.js":76}],63:[function(t,e,r){"use strict";var n=t("./bn-sign");e.exports=function(t){var e=t.length,r=t.words,i=0;if(1===e)i=r[0];else if(2===e)i=r[0]+67108864*r[1];else for(var a=0;a20)return 52;return r+32}},{"bit-twiddle":74,"double-bits":134}],65:[function(t,e,r){"use strict";t("bn.js");e.exports=function(t){return t&&"object"==typeof t&&Boolean(t.words)}},{"bn.js":76}],66:[function(t,e,r){"use strict";var n=t("bn.js"),i=t("double-bits");e.exports=function(t){var e=i.exponent(t);return e<52?new n(t):new n(t*Math.pow(2,52-e)).ushln(e-52)}},{"bn.js":76,"double-bits":134}],67:[function(t,e,r){"use strict";var n=t("./num-to-bn"),i=t("./bn-sign");e.exports=function(t,e){var r=i(t),a=i(e);if(0===r)return[n(0),n(1)];if(0===a)return[n(0),n(0)];a<0&&(t=t.neg(),e=e.neg());var o=t.gcd(e);if(o.cmpn(1))return[t.div(o),e.div(o)];return[t,e]}},{"./bn-sign":62,"./num-to-bn":66}],68:[function(t,e,r){"use strict";var n=t("bn.js");e.exports=function(t){return new n(t)}},{"bn.js":76}],69:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[0]),t[1].mul(e[1]))}},{"./lib/rationalize":67}],70:[function(t,e,r){"use strict";var n=t("./lib/bn-sign");e.exports=function(t){return n(t[0])*n(t[1])}},{"./lib/bn-sign":62}],71:[function(t,e,r){"use strict";var n=t("./lib/rationalize");e.exports=function(t,e){return n(t[0].mul(e[1]).sub(t[1].mul(e[0])),t[1].mul(e[1]))}},{"./lib/rationalize":67}],72:[function(t,e,r){"use strict";var n=t("./lib/bn-to-num"),i=t("./lib/ctz");e.exports=function(t){var e=t[0],r=t[1];if(0===e.cmpn(0))return 0;var a=e.abs().divmod(r.abs()),o=a.div,s=n(o),l=a.mod,c=e.negative!==r.negative?-1:1;if(0===l.cmpn(0))return c*s;if(s){var u=i(s)+4,f=n(l.ushln(u).divRound(r));return c*(s+f*Math.pow(2,-u))}var h=r.bitLength()-l.bitLength()+53,f=n(l.ushln(h).divRound(r));return h<1023?c*f*Math.pow(2,-h):(f*=Math.pow(2,-1023),c*f*Math.pow(2,1023-h))}},{"./lib/bn-to-num":63,"./lib/ctz":64}],73:[function(t,e,r){"use strict";function n(t,e,r,n,i,a){var o=["function ",t,"(a,l,h,",n.join(","),"){",a?"":"var i=",r?"l-1":"h+1",";while(l<=h){var m=(l+h)>>>1,x=a",i?".get(m)":"[m]"];return a?e.indexOf("c")<0?o.push(";if(x===y){return m}else if(x<=y){"):o.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){"):o.push(";if(",e,"){i=m;"),r?o.push("l=m+1}else{h=m-1}"):o.push("h=m-1}else{l=m+1}"),o.push("}"),a?o.push("return -1};"):o.push("return i};"),o.join("")}function i(t,e,r,i){return new Function([n("A","x"+t+"y",e,["y"],!1,i),n("B","x"+t+"y",e,["y"],!0,i),n("P","c(x,y)"+t+"0",e,["y","c"],!1,i),n("Q","c(x,y)"+t+"0",e,["y","c"],!0,i),"function dispatchBsearch",r,"(a,y,c,l,h){if(a.shape){if(typeof(c)==='function'){return Q(a,(l===undefined)?0:l|0,(h===undefined)?a.shape[0]-1:h|0,y,c)}else{return B(a,(c===undefined)?0:c|0,(l===undefined)?a.shape[0]-1:l|0,y)}}else{if(typeof(c)==='function'){return P(a,(l===undefined)?0:l|0,(h===undefined)?a.length-1:h|0,y,c)}else{return A(a,(c===undefined)?0:c|0,(l===undefined)?a.length-1:l|0,y)}}}return dispatchBsearch",r].join(""))()}e.exports={ge:i(">=",!1,"GE"),gt:i(">",!1,"GT"),lt:i("<",!0,"LT"),le:i("<=",!0,"LE"),eq:i("-",!0,"EQ",!0)}},{}],74:[function(t,e,r){"use strict";"use restrict";function n(t){var e=32;return(t&=-t)&&e--,65535&t&&(e-=16),16711935&t&&(e-=8),252645135&t&&(e-=4),858993459&t&&(e-=2),1431655765&t&&(e-=1),e}r.INT_BITS=32,r.INT_MAX=2147483647,r.INT_MIN=-1<<31,r.sign=function(t){return(t>0)-(t<0)},r.abs=function(t){var e=t>>31;return(t^e)-e},r.min=function(t,e){return e^(t^e)&-(t65535)<<4,e|=r=((t>>>=e)>255)<<3,e|=r=((t>>>=r)>15)<<2,(e|=r=((t>>>=r)>3)<<1)|(t>>>=r)>>1},r.log10=function(t){return t>=1e9?9:t>=1e8?8:t>=1e7?7:t>=1e6?6:t>=1e5?5:t>=1e4?4:t>=1e3?3:t>=100?2:t>=10?1:0},r.popCount=function(t){return 16843009*((t=(858993459&(t-=t>>>1&1431655765))+(t>>>2&858993459))+(t>>>4)&252645135)>>>24},r.countTrailingZeros=n,r.nextPow2=function(t){return t+=0===t,--t,t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)+1},r.prevPow2=function(t){return t|=t>>>1,t|=t>>>2,t|=t>>>4,t|=t>>>8,(t|=t>>>16)-(t>>>1)},r.parity=function(t){return t^=t>>>16,t^=t>>>8,t^=t>>>4,27030>>>(t&=15)&1};var i=new Array(256);!function(t){for(var e=0;e<256;++e){var r=e,n=e,i=7;for(r>>>=1;r;r>>>=1)n<<=1,n|=1&r,--i;t[e]=n<>>8&255]<<16|i[t>>>16&255]<<8|i[t>>>24&255]},r.interleave2=function(t,e){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t&=65535)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e&=65535)|e<<8))|e<<4))|e<<2))|e<<1))<<1},r.deinterleave2=function(t,e){return(t=65535&((t=16711935&((t=252645135&((t=858993459&((t=t>>>e&1431655765)|t>>>1))|t>>>2))|t>>>4))|t>>>16))<<16>>16},r.interleave3=function(t,e,r){return t=1227133513&((t=3272356035&((t=251719695&((t=4278190335&((t&=1023)|t<<16))|t<<8))|t<<4))|t<<2),(t|=(e=1227133513&((e=3272356035&((e=251719695&((e=4278190335&((e&=1023)|e<<16))|e<<8))|e<<4))|e<<2))<<1)|(r=1227133513&((r=3272356035&((r=251719695&((r=4278190335&((r&=1023)|r<<16))|r<<8))|r<<4))|r<<2))<<2},r.deinterleave3=function(t,e){return(t=1023&((t=4278190335&((t=251719695&((t=3272356035&((t=t>>>e&1227133513)|t>>>2))|t>>>4))|t>>>8))|t>>>16))<<22>>22},r.nextCombination=function(t){var e=t|t-1;return e+1|(~e&-~e)-1>>>n(t)+1}},{}],75:[function(t,e,r){"use strict";var n=t("clamp");e.exports=function(t,e){e||(e={});var r,o,s,l,c,u,f,h,p,d,g,m=null==e.cutoff?.25:e.cutoff,v=null==e.radius?8:e.radius,y=e.channel||0;if(ArrayBuffer.isView(t)||Array.isArray(t)){if(!e.width||!e.height)throw Error("For raw data width and height should be provided by options");r=e.width,o=e.height,l=t,u=e.stride?e.stride:Math.floor(t.length/r/o)}else window.HTMLCanvasElement&&t instanceof window.HTMLCanvasElement?(f=(h=t).getContext("2d"),r=h.width,o=h.height,p=f.getImageData(0,0,r,o),l=p.data,u=4):window.CanvasRenderingContext2D&&t instanceof window.CanvasRenderingContext2D?(h=t.canvas,f=t,r=h.width,o=h.height,p=f.getImageData(0,0,r,o),l=p.data,u=4):window.ImageData&&t instanceof window.ImageData&&(p=t,r=t.width,o=t.height,l=p.data,u=4);if(s=Math.max(r,o),window.Uint8ClampedArray&&l instanceof window.Uint8ClampedArray||window.Uint8Array&&l instanceof window.Uint8Array)for(c=l,l=Array(r*o),d=0,g=c.length;d=49&&o<=54?o-49+10:o>=17&&o<=22?o-17+10:15&o}return n}function l(t,e,r,n){for(var i=0,a=Math.min(t.length,r),o=e;o=49?s-49+10:s>=17?s-17+10:s}return i}a.isBN=function(t){return t instanceof a||null!==t&&"object"==typeof t&&t.constructor.wordSize===a.wordSize&&Array.isArray(t.words)},a.max=function(t,e){return t.cmp(e)>0?t:e},a.min=function(t,e){return t.cmp(e)<0?t:e},a.prototype._init=function(t,e,r){if("number"==typeof t)return this._initNumber(t,e,r);if("object"==typeof t)return this._initArray(t,e,r);"hex"===e&&(e=16),n(e===(0|e)&&e>=2&&e<=36);var i=0;"-"===(t=t.toString().replace(/\s+/g,""))[0]&&i++,16===e?this._parseHex(t,i):this._parseBase(t,e,i),"-"===t[0]&&(this.negative=1),this.strip(),"le"===r&&this._initArray(this.toArray(),e,r)},a.prototype._initNumber=function(t,e,r){t<0&&(this.negative=1,t=-t),t<67108864?(this.words=[67108863&t],this.length=1):t<4503599627370496?(this.words=[67108863&t,t/67108864&67108863],this.length=2):(n(t<9007199254740992),this.words=[67108863&t,t/67108864&67108863,1],this.length=3),"le"===r&&this._initArray(this.toArray(),e,r)},a.prototype._initArray=function(t,e,r){if(n("number"==typeof t.length),t.length<=0)return this.words=[0],this.length=1,this;this.length=Math.ceil(t.length/3),this.words=new Array(this.length);for(var i=0;i=0;i-=3)o=t[i]|t[i-1]<<8|t[i-2]<<16,this.words[a]|=o<>>26-s&67108863,(s+=24)>=26&&(s-=26,a++);else if("le"===r)for(i=0,a=0;i>>26-s&67108863,(s+=24)>=26&&(s-=26,a++);return this.strip()},a.prototype._parseHex=function(t,e){this.length=Math.ceil((t.length-e)/6),this.words=new Array(this.length);for(var r=0;r=e;r-=6)i=s(t,r,r+6),this.words[n]|=i<>>26-a&4194303,(a+=24)>=26&&(a-=26,n++);r+6!==e&&(i=s(t,e,r+6),this.words[n]|=i<>>26-a&4194303),this.strip()},a.prototype._parseBase=function(t,e,r){this.words=[0],this.length=1;for(var n=0,i=1;i<=67108863;i*=e)n++;n--,i=i/e|0;for(var a=t.length-r,o=a%n,s=Math.min(a,a-o)+r,c=0,u=r;u1&&0===this.words[this.length-1];)this.length--;return this._normSign()},a.prototype._normSign=function(){return 1===this.length&&0===this.words[0]&&(this.negative=0),this},a.prototype.inspect=function(){return(this.red?""};var c=["","0","00","000","0000","00000","000000","0000000","00000000","000000000","0000000000","00000000000","000000000000","0000000000000","00000000000000","000000000000000","0000000000000000","00000000000000000","000000000000000000","0000000000000000000","00000000000000000000","000000000000000000000","0000000000000000000000","00000000000000000000000","000000000000000000000000","0000000000000000000000000"],u=[0,0,25,16,12,11,10,9,8,8,7,7,7,7,6,6,6,6,6,6,6,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5],f=[0,0,33554432,43046721,16777216,48828125,60466176,40353607,16777216,43046721,1e7,19487171,35831808,62748517,7529536,11390625,16777216,24137569,34012224,47045881,64e6,4084101,5153632,6436343,7962624,9765625,11881376,14348907,17210368,20511149,243e5,28629151,33554432,39135393,45435424,52521875,60466176];function h(t,e,r){r.negative=e.negative^t.negative;var n=t.length+e.length|0;r.length=n,n=n-1|0;var i=0|t.words[0],a=0|e.words[0],o=i*a,s=67108863&o,l=o/67108864|0;r.words[0]=s;for(var c=1;c>>26,f=67108863&l,h=Math.min(c,e.length-1),p=Math.max(0,c-t.length+1);p<=h;p++){var d=c-p|0;u+=(o=(i=0|t.words[d])*(a=0|e.words[p])+f)/67108864|0,f=67108863&o}r.words[c]=0|f,l=0|u}return 0!==l?r.words[c]=0|l:r.length--,r.strip()}a.prototype.toString=function(t,e){var r;if(e=0|e||1,16===(t=t||10)||"hex"===t){r="";for(var i=0,a=0,o=0;o>>24-i&16777215)||o!==this.length-1?c[6-l.length]+l+r:l+r,(i+=2)>=26&&(i-=26,o--)}for(0!==a&&(r=a.toString(16)+r);r.length%e!=0;)r="0"+r;return 0!==this.negative&&(r="-"+r),r}if(t===(0|t)&&t>=2&&t<=36){var h=u[t],p=f[t];r="";var d=this.clone();for(d.negative=0;!d.isZero();){var g=d.modn(p).toString(t);r=(d=d.idivn(p)).isZero()?g+r:c[h-g.length]+g+r}for(this.isZero()&&(r="0"+r);r.length%e!=0;)r="0"+r;return 0!==this.negative&&(r="-"+r),r}n(!1,"Base should be between 2 and 36")},a.prototype.toNumber=function(){var t=this.words[0];return 2===this.length?t+=67108864*this.words[1]:3===this.length&&1===this.words[2]?t+=4503599627370496+67108864*this.words[1]:this.length>2&&n(!1,"Number can only safely store up to 53 bits"),0!==this.negative?-t:t},a.prototype.toJSON=function(){return this.toString(16)},a.prototype.toBuffer=function(t,e){return n(void 0!==o),this.toArrayLike(o,t,e)},a.prototype.toArray=function(t,e){return this.toArrayLike(Array,t,e)},a.prototype.toArrayLike=function(t,e,r){var i=this.byteLength(),a=r||Math.max(1,i);n(i<=a,"byte array longer than desired length"),n(a>0,"Requested array length <= 0"),this.strip();var o,s,l="le"===e,c=new t(a),u=this.clone();if(l){for(s=0;!u.isZero();s++)o=u.andln(255),u.iushrn(8),c[s]=o;for(;s=4096&&(r+=13,e>>>=13),e>=64&&(r+=7,e>>>=7),e>=8&&(r+=4,e>>>=4),e>=2&&(r+=2,e>>>=2),r+e},a.prototype._zeroBits=function(t){if(0===t)return 26;var e=t,r=0;return 0==(8191&e)&&(r+=13,e>>>=13),0==(127&e)&&(r+=7,e>>>=7),0==(15&e)&&(r+=4,e>>>=4),0==(3&e)&&(r+=2,e>>>=2),0==(1&e)&&r++,r},a.prototype.bitLength=function(){var t=this.words[this.length-1],e=this._countBits(t);return 26*(this.length-1)+e},a.prototype.zeroBits=function(){if(this.isZero())return 0;for(var t=0,e=0;et.length?this.clone().ior(t):t.clone().ior(this)},a.prototype.uor=function(t){return this.length>t.length?this.clone().iuor(t):t.clone().iuor(this)},a.prototype.iuand=function(t){var e;e=this.length>t.length?t:this;for(var r=0;rt.length?this.clone().iand(t):t.clone().iand(this)},a.prototype.uand=function(t){return this.length>t.length?this.clone().iuand(t):t.clone().iuand(this)},a.prototype.iuxor=function(t){var e,r;this.length>t.length?(e=this,r=t):(e=t,r=this);for(var n=0;nt.length?this.clone().ixor(t):t.clone().ixor(this)},a.prototype.uxor=function(t){return this.length>t.length?this.clone().iuxor(t):t.clone().iuxor(this)},a.prototype.inotn=function(t){n("number"==typeof t&&t>=0);var e=0|Math.ceil(t/26),r=t%26;this._expand(e),r>0&&e--;for(var i=0;i0&&(this.words[i]=~this.words[i]&67108863>>26-r),this.strip()},a.prototype.notn=function(t){return this.clone().inotn(t)},a.prototype.setn=function(t,e){n("number"==typeof t&&t>=0);var r=t/26|0,i=t%26;return this._expand(r+1),this.words[r]=e?this.words[r]|1<t.length?(r=this,n=t):(r=t,n=this);for(var i=0,a=0;a>>26;for(;0!==i&&a>>26;if(this.length=r.length,0!==i)this.words[this.length]=i,this.length++;else if(r!==this)for(;at.length?this.clone().iadd(t):t.clone().iadd(this)},a.prototype.isub=function(t){if(0!==t.negative){t.negative=0;var e=this.iadd(t);return t.negative=1,e._normSign()}if(0!==this.negative)return this.negative=0,this.iadd(t),this.negative=1,this._normSign();var r,n,i=this.cmp(t);if(0===i)return this.negative=0,this.length=1,this.words[0]=0,this;i>0?(r=this,n=t):(r=t,n=this);for(var a=0,o=0;o>26,this.words[o]=67108863&e;for(;0!==a&&o>26,this.words[o]=67108863&e;if(0===a&&o>>13,p=0|o[1],d=8191&p,g=p>>>13,m=0|o[2],v=8191&m,y=m>>>13,x=0|o[3],b=8191&x,_=x>>>13,w=0|o[4],k=8191&w,M=w>>>13,A=0|o[5],T=8191&A,S=A>>>13,C=0|o[6],E=8191&C,L=C>>>13,z=0|o[7],P=8191&z,D=z>>>13,O=0|o[8],I=8191&O,R=O>>>13,B=0|o[9],F=8191&B,N=B>>>13,j=0|s[0],V=8191&j,U=j>>>13,q=0|s[1],H=8191&q,G=q>>>13,W=0|s[2],Y=8191&W,X=W>>>13,Z=0|s[3],J=8191&Z,K=Z>>>13,Q=0|s[4],$=8191&Q,tt=Q>>>13,et=0|s[5],rt=8191&et,nt=et>>>13,it=0|s[6],at=8191&it,ot=it>>>13,st=0|s[7],lt=8191&st,ct=st>>>13,ut=0|s[8],ft=8191&ut,ht=ut>>>13,pt=0|s[9],dt=8191&pt,gt=pt>>>13;r.negative=t.negative^e.negative,r.length=19;var mt=(c+(n=Math.imul(f,V))|0)+((8191&(i=(i=Math.imul(f,U))+Math.imul(h,V)|0))<<13)|0;c=((a=Math.imul(h,U))+(i>>>13)|0)+(mt>>>26)|0,mt&=67108863,n=Math.imul(d,V),i=(i=Math.imul(d,U))+Math.imul(g,V)|0,a=Math.imul(g,U);var vt=(c+(n=n+Math.imul(f,H)|0)|0)+((8191&(i=(i=i+Math.imul(f,G)|0)+Math.imul(h,H)|0))<<13)|0;c=((a=a+Math.imul(h,G)|0)+(i>>>13)|0)+(vt>>>26)|0,vt&=67108863,n=Math.imul(v,V),i=(i=Math.imul(v,U))+Math.imul(y,V)|0,a=Math.imul(y,U),n=n+Math.imul(d,H)|0,i=(i=i+Math.imul(d,G)|0)+Math.imul(g,H)|0,a=a+Math.imul(g,G)|0;var yt=(c+(n=n+Math.imul(f,Y)|0)|0)+((8191&(i=(i=i+Math.imul(f,X)|0)+Math.imul(h,Y)|0))<<13)|0;c=((a=a+Math.imul(h,X)|0)+(i>>>13)|0)+(yt>>>26)|0,yt&=67108863,n=Math.imul(b,V),i=(i=Math.imul(b,U))+Math.imul(_,V)|0,a=Math.imul(_,U),n=n+Math.imul(v,H)|0,i=(i=i+Math.imul(v,G)|0)+Math.imul(y,H)|0,a=a+Math.imul(y,G)|0,n=n+Math.imul(d,Y)|0,i=(i=i+Math.imul(d,X)|0)+Math.imul(g,Y)|0,a=a+Math.imul(g,X)|0;var xt=(c+(n=n+Math.imul(f,J)|0)|0)+((8191&(i=(i=i+Math.imul(f,K)|0)+Math.imul(h,J)|0))<<13)|0;c=((a=a+Math.imul(h,K)|0)+(i>>>13)|0)+(xt>>>26)|0,xt&=67108863,n=Math.imul(k,V),i=(i=Math.imul(k,U))+Math.imul(M,V)|0,a=Math.imul(M,U),n=n+Math.imul(b,H)|0,i=(i=i+Math.imul(b,G)|0)+Math.imul(_,H)|0,a=a+Math.imul(_,G)|0,n=n+Math.imul(v,Y)|0,i=(i=i+Math.imul(v,X)|0)+Math.imul(y,Y)|0,a=a+Math.imul(y,X)|0,n=n+Math.imul(d,J)|0,i=(i=i+Math.imul(d,K)|0)+Math.imul(g,J)|0,a=a+Math.imul(g,K)|0;var bt=(c+(n=n+Math.imul(f,$)|0)|0)+((8191&(i=(i=i+Math.imul(f,tt)|0)+Math.imul(h,$)|0))<<13)|0;c=((a=a+Math.imul(h,tt)|0)+(i>>>13)|0)+(bt>>>26)|0,bt&=67108863,n=Math.imul(T,V),i=(i=Math.imul(T,U))+Math.imul(S,V)|0,a=Math.imul(S,U),n=n+Math.imul(k,H)|0,i=(i=i+Math.imul(k,G)|0)+Math.imul(M,H)|0,a=a+Math.imul(M,G)|0,n=n+Math.imul(b,Y)|0,i=(i=i+Math.imul(b,X)|0)+Math.imul(_,Y)|0,a=a+Math.imul(_,X)|0,n=n+Math.imul(v,J)|0,i=(i=i+Math.imul(v,K)|0)+Math.imul(y,J)|0,a=a+Math.imul(y,K)|0,n=n+Math.imul(d,$)|0,i=(i=i+Math.imul(d,tt)|0)+Math.imul(g,$)|0,a=a+Math.imul(g,tt)|0;var _t=(c+(n=n+Math.imul(f,rt)|0)|0)+((8191&(i=(i=i+Math.imul(f,nt)|0)+Math.imul(h,rt)|0))<<13)|0;c=((a=a+Math.imul(h,nt)|0)+(i>>>13)|0)+(_t>>>26)|0,_t&=67108863,n=Math.imul(E,V),i=(i=Math.imul(E,U))+Math.imul(L,V)|0,a=Math.imul(L,U),n=n+Math.imul(T,H)|0,i=(i=i+Math.imul(T,G)|0)+Math.imul(S,H)|0,a=a+Math.imul(S,G)|0,n=n+Math.imul(k,Y)|0,i=(i=i+Math.imul(k,X)|0)+Math.imul(M,Y)|0,a=a+Math.imul(M,X)|0,n=n+Math.imul(b,J)|0,i=(i=i+Math.imul(b,K)|0)+Math.imul(_,J)|0,a=a+Math.imul(_,K)|0,n=n+Math.imul(v,$)|0,i=(i=i+Math.imul(v,tt)|0)+Math.imul(y,$)|0,a=a+Math.imul(y,tt)|0,n=n+Math.imul(d,rt)|0,i=(i=i+Math.imul(d,nt)|0)+Math.imul(g,rt)|0,a=a+Math.imul(g,nt)|0;var wt=(c+(n=n+Math.imul(f,at)|0)|0)+((8191&(i=(i=i+Math.imul(f,ot)|0)+Math.imul(h,at)|0))<<13)|0;c=((a=a+Math.imul(h,ot)|0)+(i>>>13)|0)+(wt>>>26)|0,wt&=67108863,n=Math.imul(P,V),i=(i=Math.imul(P,U))+Math.imul(D,V)|0,a=Math.imul(D,U),n=n+Math.imul(E,H)|0,i=(i=i+Math.imul(E,G)|0)+Math.imul(L,H)|0,a=a+Math.imul(L,G)|0,n=n+Math.imul(T,Y)|0,i=(i=i+Math.imul(T,X)|0)+Math.imul(S,Y)|0,a=a+Math.imul(S,X)|0,n=n+Math.imul(k,J)|0,i=(i=i+Math.imul(k,K)|0)+Math.imul(M,J)|0,a=a+Math.imul(M,K)|0,n=n+Math.imul(b,$)|0,i=(i=i+Math.imul(b,tt)|0)+Math.imul(_,$)|0,a=a+Math.imul(_,tt)|0,n=n+Math.imul(v,rt)|0,i=(i=i+Math.imul(v,nt)|0)+Math.imul(y,rt)|0,a=a+Math.imul(y,nt)|0,n=n+Math.imul(d,at)|0,i=(i=i+Math.imul(d,ot)|0)+Math.imul(g,at)|0,a=a+Math.imul(g,ot)|0;var kt=(c+(n=n+Math.imul(f,lt)|0)|0)+((8191&(i=(i=i+Math.imul(f,ct)|0)+Math.imul(h,lt)|0))<<13)|0;c=((a=a+Math.imul(h,ct)|0)+(i>>>13)|0)+(kt>>>26)|0,kt&=67108863,n=Math.imul(I,V),i=(i=Math.imul(I,U))+Math.imul(R,V)|0,a=Math.imul(R,U),n=n+Math.imul(P,H)|0,i=(i=i+Math.imul(P,G)|0)+Math.imul(D,H)|0,a=a+Math.imul(D,G)|0,n=n+Math.imul(E,Y)|0,i=(i=i+Math.imul(E,X)|0)+Math.imul(L,Y)|0,a=a+Math.imul(L,X)|0,n=n+Math.imul(T,J)|0,i=(i=i+Math.imul(T,K)|0)+Math.imul(S,J)|0,a=a+Math.imul(S,K)|0,n=n+Math.imul(k,$)|0,i=(i=i+Math.imul(k,tt)|0)+Math.imul(M,$)|0,a=a+Math.imul(M,tt)|0,n=n+Math.imul(b,rt)|0,i=(i=i+Math.imul(b,nt)|0)+Math.imul(_,rt)|0,a=a+Math.imul(_,nt)|0,n=n+Math.imul(v,at)|0,i=(i=i+Math.imul(v,ot)|0)+Math.imul(y,at)|0,a=a+Math.imul(y,ot)|0,n=n+Math.imul(d,lt)|0,i=(i=i+Math.imul(d,ct)|0)+Math.imul(g,lt)|0,a=a+Math.imul(g,ct)|0;var Mt=(c+(n=n+Math.imul(f,ft)|0)|0)+((8191&(i=(i=i+Math.imul(f,ht)|0)+Math.imul(h,ft)|0))<<13)|0;c=((a=a+Math.imul(h,ht)|0)+(i>>>13)|0)+(Mt>>>26)|0,Mt&=67108863,n=Math.imul(F,V),i=(i=Math.imul(F,U))+Math.imul(N,V)|0,a=Math.imul(N,U),n=n+Math.imul(I,H)|0,i=(i=i+Math.imul(I,G)|0)+Math.imul(R,H)|0,a=a+Math.imul(R,G)|0,n=n+Math.imul(P,Y)|0,i=(i=i+Math.imul(P,X)|0)+Math.imul(D,Y)|0,a=a+Math.imul(D,X)|0,n=n+Math.imul(E,J)|0,i=(i=i+Math.imul(E,K)|0)+Math.imul(L,J)|0,a=a+Math.imul(L,K)|0,n=n+Math.imul(T,$)|0,i=(i=i+Math.imul(T,tt)|0)+Math.imul(S,$)|0,a=a+Math.imul(S,tt)|0,n=n+Math.imul(k,rt)|0,i=(i=i+Math.imul(k,nt)|0)+Math.imul(M,rt)|0,a=a+Math.imul(M,nt)|0,n=n+Math.imul(b,at)|0,i=(i=i+Math.imul(b,ot)|0)+Math.imul(_,at)|0,a=a+Math.imul(_,ot)|0,n=n+Math.imul(v,lt)|0,i=(i=i+Math.imul(v,ct)|0)+Math.imul(y,lt)|0,a=a+Math.imul(y,ct)|0,n=n+Math.imul(d,ft)|0,i=(i=i+Math.imul(d,ht)|0)+Math.imul(g,ft)|0,a=a+Math.imul(g,ht)|0;var At=(c+(n=n+Math.imul(f,dt)|0)|0)+((8191&(i=(i=i+Math.imul(f,gt)|0)+Math.imul(h,dt)|0))<<13)|0;c=((a=a+Math.imul(h,gt)|0)+(i>>>13)|0)+(At>>>26)|0,At&=67108863,n=Math.imul(F,H),i=(i=Math.imul(F,G))+Math.imul(N,H)|0,a=Math.imul(N,G),n=n+Math.imul(I,Y)|0,i=(i=i+Math.imul(I,X)|0)+Math.imul(R,Y)|0,a=a+Math.imul(R,X)|0,n=n+Math.imul(P,J)|0,i=(i=i+Math.imul(P,K)|0)+Math.imul(D,J)|0,a=a+Math.imul(D,K)|0,n=n+Math.imul(E,$)|0,i=(i=i+Math.imul(E,tt)|0)+Math.imul(L,$)|0,a=a+Math.imul(L,tt)|0,n=n+Math.imul(T,rt)|0,i=(i=i+Math.imul(T,nt)|0)+Math.imul(S,rt)|0,a=a+Math.imul(S,nt)|0,n=n+Math.imul(k,at)|0,i=(i=i+Math.imul(k,ot)|0)+Math.imul(M,at)|0,a=a+Math.imul(M,ot)|0,n=n+Math.imul(b,lt)|0,i=(i=i+Math.imul(b,ct)|0)+Math.imul(_,lt)|0,a=a+Math.imul(_,ct)|0,n=n+Math.imul(v,ft)|0,i=(i=i+Math.imul(v,ht)|0)+Math.imul(y,ft)|0,a=a+Math.imul(y,ht)|0;var Tt=(c+(n=n+Math.imul(d,dt)|0)|0)+((8191&(i=(i=i+Math.imul(d,gt)|0)+Math.imul(g,dt)|0))<<13)|0;c=((a=a+Math.imul(g,gt)|0)+(i>>>13)|0)+(Tt>>>26)|0,Tt&=67108863,n=Math.imul(F,Y),i=(i=Math.imul(F,X))+Math.imul(N,Y)|0,a=Math.imul(N,X),n=n+Math.imul(I,J)|0,i=(i=i+Math.imul(I,K)|0)+Math.imul(R,J)|0,a=a+Math.imul(R,K)|0,n=n+Math.imul(P,$)|0,i=(i=i+Math.imul(P,tt)|0)+Math.imul(D,$)|0,a=a+Math.imul(D,tt)|0,n=n+Math.imul(E,rt)|0,i=(i=i+Math.imul(E,nt)|0)+Math.imul(L,rt)|0,a=a+Math.imul(L,nt)|0,n=n+Math.imul(T,at)|0,i=(i=i+Math.imul(T,ot)|0)+Math.imul(S,at)|0,a=a+Math.imul(S,ot)|0,n=n+Math.imul(k,lt)|0,i=(i=i+Math.imul(k,ct)|0)+Math.imul(M,lt)|0,a=a+Math.imul(M,ct)|0,n=n+Math.imul(b,ft)|0,i=(i=i+Math.imul(b,ht)|0)+Math.imul(_,ft)|0,a=a+Math.imul(_,ht)|0;var St=(c+(n=n+Math.imul(v,dt)|0)|0)+((8191&(i=(i=i+Math.imul(v,gt)|0)+Math.imul(y,dt)|0))<<13)|0;c=((a=a+Math.imul(y,gt)|0)+(i>>>13)|0)+(St>>>26)|0,St&=67108863,n=Math.imul(F,J),i=(i=Math.imul(F,K))+Math.imul(N,J)|0,a=Math.imul(N,K),n=n+Math.imul(I,$)|0,i=(i=i+Math.imul(I,tt)|0)+Math.imul(R,$)|0,a=a+Math.imul(R,tt)|0,n=n+Math.imul(P,rt)|0,i=(i=i+Math.imul(P,nt)|0)+Math.imul(D,rt)|0,a=a+Math.imul(D,nt)|0,n=n+Math.imul(E,at)|0,i=(i=i+Math.imul(E,ot)|0)+Math.imul(L,at)|0,a=a+Math.imul(L,ot)|0,n=n+Math.imul(T,lt)|0,i=(i=i+Math.imul(T,ct)|0)+Math.imul(S,lt)|0,a=a+Math.imul(S,ct)|0,n=n+Math.imul(k,ft)|0,i=(i=i+Math.imul(k,ht)|0)+Math.imul(M,ft)|0,a=a+Math.imul(M,ht)|0;var Ct=(c+(n=n+Math.imul(b,dt)|0)|0)+((8191&(i=(i=i+Math.imul(b,gt)|0)+Math.imul(_,dt)|0))<<13)|0;c=((a=a+Math.imul(_,gt)|0)+(i>>>13)|0)+(Ct>>>26)|0,Ct&=67108863,n=Math.imul(F,$),i=(i=Math.imul(F,tt))+Math.imul(N,$)|0,a=Math.imul(N,tt),n=n+Math.imul(I,rt)|0,i=(i=i+Math.imul(I,nt)|0)+Math.imul(R,rt)|0,a=a+Math.imul(R,nt)|0,n=n+Math.imul(P,at)|0,i=(i=i+Math.imul(P,ot)|0)+Math.imul(D,at)|0,a=a+Math.imul(D,ot)|0,n=n+Math.imul(E,lt)|0,i=(i=i+Math.imul(E,ct)|0)+Math.imul(L,lt)|0,a=a+Math.imul(L,ct)|0,n=n+Math.imul(T,ft)|0,i=(i=i+Math.imul(T,ht)|0)+Math.imul(S,ft)|0,a=a+Math.imul(S,ht)|0;var Et=(c+(n=n+Math.imul(k,dt)|0)|0)+((8191&(i=(i=i+Math.imul(k,gt)|0)+Math.imul(M,dt)|0))<<13)|0;c=((a=a+Math.imul(M,gt)|0)+(i>>>13)|0)+(Et>>>26)|0,Et&=67108863,n=Math.imul(F,rt),i=(i=Math.imul(F,nt))+Math.imul(N,rt)|0,a=Math.imul(N,nt),n=n+Math.imul(I,at)|0,i=(i=i+Math.imul(I,ot)|0)+Math.imul(R,at)|0,a=a+Math.imul(R,ot)|0,n=n+Math.imul(P,lt)|0,i=(i=i+Math.imul(P,ct)|0)+Math.imul(D,lt)|0,a=a+Math.imul(D,ct)|0,n=n+Math.imul(E,ft)|0,i=(i=i+Math.imul(E,ht)|0)+Math.imul(L,ft)|0,a=a+Math.imul(L,ht)|0;var Lt=(c+(n=n+Math.imul(T,dt)|0)|0)+((8191&(i=(i=i+Math.imul(T,gt)|0)+Math.imul(S,dt)|0))<<13)|0;c=((a=a+Math.imul(S,gt)|0)+(i>>>13)|0)+(Lt>>>26)|0,Lt&=67108863,n=Math.imul(F,at),i=(i=Math.imul(F,ot))+Math.imul(N,at)|0,a=Math.imul(N,ot),n=n+Math.imul(I,lt)|0,i=(i=i+Math.imul(I,ct)|0)+Math.imul(R,lt)|0,a=a+Math.imul(R,ct)|0,n=n+Math.imul(P,ft)|0,i=(i=i+Math.imul(P,ht)|0)+Math.imul(D,ft)|0,a=a+Math.imul(D,ht)|0;var zt=(c+(n=n+Math.imul(E,dt)|0)|0)+((8191&(i=(i=i+Math.imul(E,gt)|0)+Math.imul(L,dt)|0))<<13)|0;c=((a=a+Math.imul(L,gt)|0)+(i>>>13)|0)+(zt>>>26)|0,zt&=67108863,n=Math.imul(F,lt),i=(i=Math.imul(F,ct))+Math.imul(N,lt)|0,a=Math.imul(N,ct),n=n+Math.imul(I,ft)|0,i=(i=i+Math.imul(I,ht)|0)+Math.imul(R,ft)|0,a=a+Math.imul(R,ht)|0;var Pt=(c+(n=n+Math.imul(P,dt)|0)|0)+((8191&(i=(i=i+Math.imul(P,gt)|0)+Math.imul(D,dt)|0))<<13)|0;c=((a=a+Math.imul(D,gt)|0)+(i>>>13)|0)+(Pt>>>26)|0,Pt&=67108863,n=Math.imul(F,ft),i=(i=Math.imul(F,ht))+Math.imul(N,ft)|0,a=Math.imul(N,ht);var Dt=(c+(n=n+Math.imul(I,dt)|0)|0)+((8191&(i=(i=i+Math.imul(I,gt)|0)+Math.imul(R,dt)|0))<<13)|0;c=((a=a+Math.imul(R,gt)|0)+(i>>>13)|0)+(Dt>>>26)|0,Dt&=67108863;var Ot=(c+(n=Math.imul(F,dt))|0)+((8191&(i=(i=Math.imul(F,gt))+Math.imul(N,dt)|0))<<13)|0;return c=((a=Math.imul(N,gt))+(i>>>13)|0)+(Ot>>>26)|0,Ot&=67108863,l[0]=mt,l[1]=vt,l[2]=yt,l[3]=xt,l[4]=bt,l[5]=_t,l[6]=wt,l[7]=kt,l[8]=Mt,l[9]=At,l[10]=Tt,l[11]=St,l[12]=Ct,l[13]=Et,l[14]=Lt,l[15]=zt,l[16]=Pt,l[17]=Dt,l[18]=Ot,0!==c&&(l[19]=c,r.length++),r};function d(t,e,r){return(new g).mulp(t,e,r)}function g(t,e){this.x=t,this.y=e}Math.imul||(p=h),a.prototype.mulTo=function(t,e){var r=this.length+t.length;return 10===this.length&&10===t.length?p(this,t,e):r<63?h(this,t,e):r<1024?function(t,e,r){r.negative=e.negative^t.negative,r.length=t.length+e.length;for(var n=0,i=0,a=0;a>>26)|0)>>>26,o&=67108863}r.words[a]=s,n=o,o=i}return 0!==n?r.words[a]=n:r.length--,r.strip()}(this,t,e):d(this,t,e)},g.prototype.makeRBT=function(t){for(var e=new Array(t),r=a.prototype._countBits(t)-1,n=0;n>=1;return n},g.prototype.permute=function(t,e,r,n,i,a){for(var o=0;o>>=1)i++;return 1<>>=13,r[2*o+1]=8191&a,a>>>=13;for(o=2*e;o>=26,e+=i/67108864|0,e+=a>>>26,this.words[r]=67108863&a}return 0!==e&&(this.words[r]=e,this.length++),this},a.prototype.muln=function(t){return this.clone().imuln(t)},a.prototype.sqr=function(){return this.mul(this)},a.prototype.isqr=function(){return this.imul(this.clone())},a.prototype.pow=function(t){var e=function(t){for(var e=new Array(t.bitLength()),r=0;r>>i}return e}(t);if(0===e.length)return new a(1);for(var r=this,n=0;n=0);var e,r=t%26,i=(t-r)/26,a=67108863>>>26-r<<26-r;if(0!==r){var o=0;for(e=0;e>>26-r}o&&(this.words[e]=o,this.length++)}if(0!==i){for(e=this.length-1;e>=0;e--)this.words[e+i]=this.words[e];for(e=0;e=0),i=e?(e-e%26)/26:0;var a=t%26,o=Math.min((t-a)/26,this.length),s=67108863^67108863>>>a<o)for(this.length-=o,c=0;c=0&&(0!==u||c>=i);c--){var f=0|this.words[c];this.words[c]=u<<26-a|f>>>a,u=f&s}return l&&0!==u&&(l.words[l.length++]=u),0===this.length&&(this.words[0]=0,this.length=1),this.strip()},a.prototype.ishrn=function(t,e,r){return n(0===this.negative),this.iushrn(t,e,r)},a.prototype.shln=function(t){return this.clone().ishln(t)},a.prototype.ushln=function(t){return this.clone().iushln(t)},a.prototype.shrn=function(t){return this.clone().ishrn(t)},a.prototype.ushrn=function(t){return this.clone().iushrn(t)},a.prototype.testn=function(t){n("number"==typeof t&&t>=0);var e=t%26,r=(t-e)/26,i=1<=0);var e=t%26,r=(t-e)/26;if(n(0===this.negative,"imaskn works only with positive numbers"),this.length<=r)return this;if(0!==e&&r++,this.length=Math.min(r,this.length),0!==e){var i=67108863^67108863>>>e<=67108864;e++)this.words[e]-=67108864,e===this.length-1?this.words[e+1]=1:this.words[e+1]++;return this.length=Math.max(this.length,e+1),this},a.prototype.isubn=function(t){if(n("number"==typeof t),n(t<67108864),t<0)return this.iaddn(-t);if(0!==this.negative)return this.negative=0,this.iaddn(t),this.negative=1,this;if(this.words[0]-=t,1===this.length&&this.words[0]<0)this.words[0]=-this.words[0],this.negative=1;else for(var e=0;e>26)-(l/67108864|0),this.words[i+r]=67108863&a}for(;i>26,this.words[i+r]=67108863&a;if(0===s)return this.strip();for(n(-1===s),s=0,i=0;i>26,this.words[i]=67108863&a;return this.negative=1,this.strip()},a.prototype._wordDiv=function(t,e){var r=(this.length,t.length),n=this.clone(),i=t,o=0|i.words[i.length-1];0!==(r=26-this._countBits(o))&&(i=i.ushln(r),n.iushln(r),o=0|i.words[i.length-1]);var s,l=n.length-i.length;if("mod"!==e){(s=new a(null)).length=l+1,s.words=new Array(s.length);for(var c=0;c=0;f--){var h=67108864*(0|n.words[i.length+f])+(0|n.words[i.length+f-1]);for(h=Math.min(h/o|0,67108863),n._ishlnsubmul(i,h,f);0!==n.negative;)h--,n.negative=0,n._ishlnsubmul(i,1,f),n.isZero()||(n.negative^=1);s&&(s.words[f]=h)}return s&&s.strip(),n.strip(),"div"!==e&&0!==r&&n.iushrn(r),{div:s||null,mod:n}},a.prototype.divmod=function(t,e,r){return n(!t.isZero()),this.isZero()?{div:new a(0),mod:new a(0)}:0!==this.negative&&0===t.negative?(s=this.neg().divmod(t,e),"mod"!==e&&(i=s.div.neg()),"div"!==e&&(o=s.mod.neg(),r&&0!==o.negative&&o.iadd(t)),{div:i,mod:o}):0===this.negative&&0!==t.negative?(s=this.divmod(t.neg(),e),"mod"!==e&&(i=s.div.neg()),{div:i,mod:s.mod}):0!=(this.negative&t.negative)?(s=this.neg().divmod(t.neg(),e),"div"!==e&&(o=s.mod.neg(),r&&0!==o.negative&&o.isub(t)),{div:s.div,mod:o}):t.length>this.length||this.cmp(t)<0?{div:new a(0),mod:this}:1===t.length?"div"===e?{div:this.divn(t.words[0]),mod:null}:"mod"===e?{div:null,mod:new a(this.modn(t.words[0]))}:{div:this.divn(t.words[0]),mod:new a(this.modn(t.words[0]))}:this._wordDiv(t,e);var i,o,s},a.prototype.div=function(t){return this.divmod(t,"div",!1).div},a.prototype.mod=function(t){return this.divmod(t,"mod",!1).mod},a.prototype.umod=function(t){return this.divmod(t,"mod",!0).mod},a.prototype.divRound=function(t){var e=this.divmod(t);if(e.mod.isZero())return e.div;var r=0!==e.div.negative?e.mod.isub(t):e.mod,n=t.ushrn(1),i=t.andln(1),a=r.cmp(n);return a<0||1===i&&0===a?e.div:0!==e.div.negative?e.div.isubn(1):e.div.iaddn(1)},a.prototype.modn=function(t){n(t<=67108863);for(var e=(1<<26)%t,r=0,i=this.length-1;i>=0;i--)r=(e*r+(0|this.words[i]))%t;return r},a.prototype.idivn=function(t){n(t<=67108863);for(var e=0,r=this.length-1;r>=0;r--){var i=(0|this.words[r])+67108864*e;this.words[r]=i/t|0,e=i%t}return this.strip()},a.prototype.divn=function(t){return this.clone().idivn(t)},a.prototype.egcd=function(t){n(0===t.negative),n(!t.isZero());var e=this,r=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var i=new a(1),o=new a(0),s=new a(0),l=new a(1),c=0;e.isEven()&&r.isEven();)e.iushrn(1),r.iushrn(1),++c;for(var u=r.clone(),f=e.clone();!e.isZero();){for(var h=0,p=1;0==(e.words[0]&p)&&h<26;++h,p<<=1);if(h>0)for(e.iushrn(h);h-- >0;)(i.isOdd()||o.isOdd())&&(i.iadd(u),o.isub(f)),i.iushrn(1),o.iushrn(1);for(var d=0,g=1;0==(r.words[0]&g)&&d<26;++d,g<<=1);if(d>0)for(r.iushrn(d);d-- >0;)(s.isOdd()||l.isOdd())&&(s.iadd(u),l.isub(f)),s.iushrn(1),l.iushrn(1);e.cmp(r)>=0?(e.isub(r),i.isub(s),o.isub(l)):(r.isub(e),s.isub(i),l.isub(o))}return{a:s,b:l,gcd:r.iushln(c)}},a.prototype._invmp=function(t){n(0===t.negative),n(!t.isZero());var e=this,r=t.clone();e=0!==e.negative?e.umod(t):e.clone();for(var i,o=new a(1),s=new a(0),l=r.clone();e.cmpn(1)>0&&r.cmpn(1)>0;){for(var c=0,u=1;0==(e.words[0]&u)&&c<26;++c,u<<=1);if(c>0)for(e.iushrn(c);c-- >0;)o.isOdd()&&o.iadd(l),o.iushrn(1);for(var f=0,h=1;0==(r.words[0]&h)&&f<26;++f,h<<=1);if(f>0)for(r.iushrn(f);f-- >0;)s.isOdd()&&s.iadd(l),s.iushrn(1);e.cmp(r)>=0?(e.isub(r),o.isub(s)):(r.isub(e),s.isub(o))}return(i=0===e.cmpn(1)?o:s).cmpn(0)<0&&i.iadd(t),i},a.prototype.gcd=function(t){if(this.isZero())return t.abs();if(t.isZero())return this.abs();var e=this.clone(),r=t.clone();e.negative=0,r.negative=0;for(var n=0;e.isEven()&&r.isEven();n++)e.iushrn(1),r.iushrn(1);for(;;){for(;e.isEven();)e.iushrn(1);for(;r.isEven();)r.iushrn(1);var i=e.cmp(r);if(i<0){var a=e;e=r,r=a}else if(0===i||0===r.cmpn(1))break;e.isub(r)}return r.iushln(n)},a.prototype.invm=function(t){return this.egcd(t).a.umod(t)},a.prototype.isEven=function(){return 0==(1&this.words[0])},a.prototype.isOdd=function(){return 1==(1&this.words[0])},a.prototype.andln=function(t){return this.words[0]&t},a.prototype.bincn=function(t){n("number"==typeof t);var e=t%26,r=(t-e)/26,i=1<>>26,s&=67108863,this.words[o]=s}return 0!==a&&(this.words[o]=a,this.length++),this},a.prototype.isZero=function(){return 1===this.length&&0===this.words[0]},a.prototype.cmpn=function(t){var e,r=t<0;if(0!==this.negative&&!r)return-1;if(0===this.negative&&r)return 1;if(this.strip(),this.length>1)e=1;else{r&&(t=-t),n(t<=67108863,"Number is too big");var i=0|this.words[0];e=i===t?0:it.length)return 1;if(this.length=0;r--){var n=0|this.words[r],i=0|t.words[r];if(n!==i){ni&&(e=1);break}}return e},a.prototype.gtn=function(t){return 1===this.cmpn(t)},a.prototype.gt=function(t){return 1===this.cmp(t)},a.prototype.gten=function(t){return this.cmpn(t)>=0},a.prototype.gte=function(t){return this.cmp(t)>=0},a.prototype.ltn=function(t){return-1===this.cmpn(t)},a.prototype.lt=function(t){return-1===this.cmp(t)},a.prototype.lten=function(t){return this.cmpn(t)<=0},a.prototype.lte=function(t){return this.cmp(t)<=0},a.prototype.eqn=function(t){return 0===this.cmpn(t)},a.prototype.eq=function(t){return 0===this.cmp(t)},a.red=function(t){return new w(t)},a.prototype.toRed=function(t){return n(!this.red,"Already a number in reduction context"),n(0===this.negative,"red works only with positives"),t.convertTo(this)._forceRed(t)},a.prototype.fromRed=function(){return n(this.red,"fromRed works only with numbers in reduction context"),this.red.convertFrom(this)},a.prototype._forceRed=function(t){return this.red=t,this},a.prototype.forceRed=function(t){return n(!this.red,"Already a number in reduction context"),this._forceRed(t)},a.prototype.redAdd=function(t){return n(this.red,"redAdd works only with red numbers"),this.red.add(this,t)},a.prototype.redIAdd=function(t){return n(this.red,"redIAdd works only with red numbers"),this.red.iadd(this,t)},a.prototype.redSub=function(t){return n(this.red,"redSub works only with red numbers"),this.red.sub(this,t)},a.prototype.redISub=function(t){return n(this.red,"redISub works only with red numbers"),this.red.isub(this,t)},a.prototype.redShl=function(t){return n(this.red,"redShl works only with red numbers"),this.red.shl(this,t)},a.prototype.redMul=function(t){return n(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.mul(this,t)},a.prototype.redIMul=function(t){return n(this.red,"redMul works only with red numbers"),this.red._verify2(this,t),this.red.imul(this,t)},a.prototype.redSqr=function(){return n(this.red,"redSqr works only with red numbers"),this.red._verify1(this),this.red.sqr(this)},a.prototype.redISqr=function(){return n(this.red,"redISqr works only with red numbers"),this.red._verify1(this),this.red.isqr(this)},a.prototype.redSqrt=function(){return n(this.red,"redSqrt works only with red numbers"),this.red._verify1(this),this.red.sqrt(this)},a.prototype.redInvm=function(){return n(this.red,"redInvm works only with red numbers"),this.red._verify1(this),this.red.invm(this)},a.prototype.redNeg=function(){return n(this.red,"redNeg works only with red numbers"),this.red._verify1(this),this.red.neg(this)},a.prototype.redPow=function(t){return n(this.red&&!t.red,"redPow(normalNum)"),this.red._verify1(this),this.red.pow(this,t)};var m={k256:null,p224:null,p192:null,p25519:null};function v(t,e){this.name=t,this.p=new a(e,16),this.n=this.p.bitLength(),this.k=new a(1).iushln(this.n).isub(this.p),this.tmp=this._tmp()}function y(){v.call(this,"k256","ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f")}function x(){v.call(this,"p224","ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001")}function b(){v.call(this,"p192","ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff")}function _(){v.call(this,"25519","7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed")}function w(t){if("string"==typeof t){var e=a._prime(t);this.m=e.p,this.prime=e}else n(t.gtn(1),"modulus must be greater than 1"),this.m=t,this.prime=null}function k(t){w.call(this,t),this.shift=this.m.bitLength(),this.shift%26!=0&&(this.shift+=26-this.shift%26),this.r=new a(1).iushln(this.shift),this.r2=this.imod(this.r.sqr()),this.rinv=this.r._invmp(this.m),this.minv=this.rinv.mul(this.r).isubn(1).div(this.m),this.minv=this.minv.umod(this.r),this.minv=this.r.sub(this.minv)}v.prototype._tmp=function(){var t=new a(null);return t.words=new Array(Math.ceil(this.n/13)),t},v.prototype.ireduce=function(t){var e,r=t;do{this.split(r,this.tmp),e=(r=(r=this.imulK(r)).iadd(this.tmp)).bitLength()}while(e>this.n);var n=e0?r.isub(this.p):r.strip(),r},v.prototype.split=function(t,e){t.iushrn(this.n,0,e)},v.prototype.imulK=function(t){return t.imul(this.k)},i(y,v),y.prototype.split=function(t,e){for(var r=Math.min(t.length,9),n=0;n>>22,i=a}i>>>=22,t.words[n-10]=i,0===i&&t.length>10?t.length-=10:t.length-=9},y.prototype.imulK=function(t){t.words[t.length]=0,t.words[t.length+1]=0,t.length+=2;for(var e=0,r=0;r>>=26,t.words[r]=i,e=n}return 0!==e&&(t.words[t.length++]=e),t},a._prime=function(t){if(m[t])return m[t];var e;if("k256"===t)e=new y;else if("p224"===t)e=new x;else if("p192"===t)e=new b;else{if("p25519"!==t)throw new Error("Unknown prime "+t);e=new _}return m[t]=e,e},w.prototype._verify1=function(t){n(0===t.negative,"red works only with positives"),n(t.red,"red works only with red numbers")},w.prototype._verify2=function(t,e){n(0==(t.negative|e.negative),"red works only with positives"),n(t.red&&t.red===e.red,"red works only with red numbers")},w.prototype.imod=function(t){return this.prime?this.prime.ireduce(t)._forceRed(this):t.umod(this.m)._forceRed(this)},w.prototype.neg=function(t){return t.isZero()?t.clone():this.m.sub(t)._forceRed(this)},w.prototype.add=function(t,e){this._verify2(t,e);var r=t.add(e);return r.cmp(this.m)>=0&&r.isub(this.m),r._forceRed(this)},w.prototype.iadd=function(t,e){this._verify2(t,e);var r=t.iadd(e);return r.cmp(this.m)>=0&&r.isub(this.m),r},w.prototype.sub=function(t,e){this._verify2(t,e);var r=t.sub(e);return r.cmpn(0)<0&&r.iadd(this.m),r._forceRed(this)},w.prototype.isub=function(t,e){this._verify2(t,e);var r=t.isub(e);return r.cmpn(0)<0&&r.iadd(this.m),r},w.prototype.shl=function(t,e){return this._verify1(t),this.imod(t.ushln(e))},w.prototype.imul=function(t,e){return this._verify2(t,e),this.imod(t.imul(e))},w.prototype.mul=function(t,e){return this._verify2(t,e),this.imod(t.mul(e))},w.prototype.isqr=function(t){return this.imul(t,t.clone())},w.prototype.sqr=function(t){return this.mul(t,t)},w.prototype.sqrt=function(t){if(t.isZero())return t.clone();var e=this.m.andln(3);if(n(e%2==1),3===e){var r=this.m.add(new a(1)).iushrn(2);return this.pow(t,r)}for(var i=this.m.subn(1),o=0;!i.isZero()&&0===i.andln(1);)o++,i.iushrn(1);n(!i.isZero());var s=new a(1).toRed(this),l=s.redNeg(),c=this.m.subn(1).iushrn(1),u=this.m.bitLength();for(u=new a(2*u*u).toRed(this);0!==this.pow(u,c).cmp(l);)u.redIAdd(l);for(var f=this.pow(u,i),h=this.pow(t,i.addn(1).iushrn(1)),p=this.pow(t,i),d=o;0!==p.cmp(s);){for(var g=p,m=0;0!==g.cmp(s);m++)g=g.redSqr();n(m=0;n--){for(var c=e.words[n],u=l-1;u>=0;u--){var f=c>>u&1;i!==r[0]&&(i=this.sqr(i)),0!==f||0!==o?(o<<=1,o|=f,(4===++s||0===n&&0===u)&&(i=this.mul(i,r[o]),s=0,o=0)):s=0}l=26}return i},w.prototype.convertTo=function(t){var e=t.umod(this.m);return e===t?e.clone():e},w.prototype.convertFrom=function(t){var e=t.clone();return e.red=null,e},a.mont=function(t){return new k(t)},i(k,w),k.prototype.convertTo=function(t){return this.imod(t.ushln(this.shift))},k.prototype.convertFrom=function(t){var e=this.imod(t.mul(this.rinv));return e.red=null,e},k.prototype.imul=function(t,e){if(t.isZero()||e.isZero())return t.words[0]=0,t.length=1,t;var r=t.imul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=r.isub(n).iushrn(this.shift),a=i;return i.cmp(this.m)>=0?a=i.isub(this.m):i.cmpn(0)<0&&(a=i.iadd(this.m)),a._forceRed(this)},k.prototype.mul=function(t,e){if(t.isZero()||e.isZero())return new a(0)._forceRed(this);var r=t.mul(e),n=r.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m),i=r.isub(n).iushrn(this.shift),o=i;return i.cmp(this.m)>=0?o=i.isub(this.m):i.cmpn(0)<0&&(o=i.iadd(this.m)),o._forceRed(this)},k.prototype.invm=function(t){return this.imod(t._invmp(this.m).mul(this.r2))._forceRed(this)}}(void 0===e||e,this)},{buffer:85}],77:[function(t,e,r){"use strict";e.exports=function(t){var e,r,n,i=t.length,a=0;for(e=0;e>>1;if(!(u<=0)){var f,h=i.mallocDouble(2*u*s),p=i.mallocInt32(s);if((s=l(t,u,h,p))>0){if(1===u&&n)a.init(s),f=a.sweepComplete(u,r,0,s,h,p,0,s,h,p);else{var d=i.mallocDouble(2*u*c),g=i.mallocInt32(c);(c=l(e,u,d,g))>0&&(a.init(s+c),f=1===u?a.sweepBipartite(u,r,0,s,h,p,0,c,d,g):o(u,r,n,s,h,p,c,d,g),i.free(d),i.free(g))}i.free(h),i.free(p)}return f}}}function u(t,e){n.push([t,e])}},{"./lib/intersect":80,"./lib/sweep":84,"typedarray-pool":481}],79:[function(t,e,r){"use strict";var n="d",i="ax",a="vv",o="fp",s="es",l="rs",c="re",u="rb",f="ri",h="rp",p="bs",d="be",g="bb",m="bi",v="bp",y="rv",x="Q",b=[n,i,a,l,c,u,f,p,d,g,m];function _(t){var e="bruteForce"+(t?"Full":"Partial"),r=[],_=b.slice();t||_.splice(3,0,o);var w=["function "+e+"("+_.join()+"){"];function k(e,o){var _=function(t,e,r){var o="bruteForce"+(t?"Red":"Blue")+(e?"Flip":"")+(r?"Full":""),_=["function ",o,"(",b.join(),"){","var ",s,"=2*",n,";"],w="for(var i="+l+","+h+"="+s+"*"+l+";i<"+c+";++i,"+h+"+="+s+"){var x0="+u+"["+i+"+"+h+"],x1="+u+"["+i+"+"+h+"+"+n+"],xi="+f+"[i];",k="for(var j="+p+","+v+"="+s+"*"+p+";j<"+d+";++j,"+v+"+="+s+"){var y0="+g+"["+i+"+"+v+"],"+(r?"y1="+g+"["+i+"+"+v+"+"+n+"],":"")+"yi="+m+"[j];";return t?_.push(w,x,":",k):_.push(k,x,":",w),r?_.push("if(y1"+d+"-"+p+"){"),t?(k(!0,!1),w.push("}else{"),k(!1,!1)):(w.push("if("+o+"){"),k(!0,!0),w.push("}else{"),k(!0,!1),w.push("}}else{if("+o+"){"),k(!1,!0),w.push("}else{"),k(!1,!1),w.push("}")),w.push("}}return "+e);var M=r.join("")+w.join("");return new Function(M)()}r.partial=_(!1),r.full=_(!0)},{}],80:[function(t,e,r){"use strict";e.exports=function(t,e,r,a,u,S,C,E,L){!function(t,e){var r=8*i.log2(e+1)*(t+1)|0,a=i.nextPow2(b*r);w.length0;){var O=(P-=1)*b,I=w[O],R=w[O+1],B=w[O+2],F=w[O+3],N=w[O+4],j=w[O+5],V=P*_,U=k[V],q=k[V+1],H=1&j,G=!!(16&j),W=u,Y=S,X=E,Z=L;if(H&&(W=E,Y=L,X=u,Z=S),!(2&j&&(B=m(t,I,R,B,W,Y,q),R>=B)||4&j&&(R=v(t,I,R,B,W,Y,U))>=B)){var J=B-R,K=N-F;if(G){if(t*J*(J+K)=p0)&&!(p1>=hi)",["p0","p1"]),g=u("lo===p0",["p0"]),m=u("lo>>1,h=2*t,p=f,d=s[h*f+e];for(;c=x?(p=y,d=x):v>=_?(p=m,d=v):(p=b,d=_):x>=_?(p=y,d=x):_>=v?(p=m,d=v):(p=b,d=_);for(var w=h*(u-1),k=h*p,M=0;Mr&&i[f+e]>c;--u,f-=o){for(var h=f,p=f+o,d=0;d=0&&i.push("lo=e[k+n]");t.indexOf("hi")>=0&&i.push("hi=e[k+o]");return r.push(n.replace("_",i.join()).replace("$",t)),Function.apply(void 0,r)};var n="for(var j=2*a,k=j*c,l=k,m=c,n=b,o=a+b,p=c;d>p;++p,k+=j){var _;if($)if(m===p)m+=1,l+=j;else{for(var s=0;j>s;++s){var t=e[k+s];e[k+s]=e[l],e[l++]=t}var u=f[p];f[p]=f[m],f[m++]=u}}return m"},{}],83:[function(t,e,r){"use strict";e.exports=function(t,e){e<=4*n?i(0,e-1,t):function t(e,r,f){var h=(r-e+1)/6|0,p=e+h,d=r-h,g=e+r>>1,m=g-h,v=g+h,y=p,x=m,b=g,_=v,w=d,k=e+1,M=r-1,A=0;c(y,x,f)&&(A=y,y=x,x=A);c(_,w,f)&&(A=_,_=w,w=A);c(y,b,f)&&(A=y,y=b,b=A);c(x,b,f)&&(A=x,x=b,b=A);c(y,_,f)&&(A=y,y=_,_=A);c(b,_,f)&&(A=b,b=_,_=A);c(x,w,f)&&(A=x,x=w,w=A);c(x,b,f)&&(A=x,x=b,b=A);c(_,w,f)&&(A=_,_=w,w=A);var T=f[2*x];var S=f[2*x+1];var C=f[2*_];var E=f[2*_+1];var L=2*y;var z=2*b;var P=2*w;var D=2*p;var O=2*g;var I=2*d;for(var R=0;R<2;++R){var B=f[L+R],F=f[z+R],N=f[P+R];f[D+R]=B,f[O+R]=F,f[I+R]=N}o(m,e,f);o(v,r,f);for(var j=k;j<=M;++j)if(u(j,T,S,f))j!==k&&a(j,k,f),++k;else if(!u(j,C,E,f))for(;;){if(u(M,C,E,f)){u(M,T,S,f)?(s(j,k,M,f),++k,--M):(a(j,M,f),--M);break}if(--Mt;){var c=r[l-2],u=r[l-1];if(cr[e+1])}function u(t,e,r,n){var i=n[t*=2];return i>>1;a(p,S);for(var C=0,E=0,k=0;k=o)d(c,u,E--,L=L-o|0);else if(L>=0)d(s,l,C--,L);else if(L<=-o){L=-L-o|0;for(var z=0;z>>1;a(p,C);for(var E=0,L=0,z=0,M=0;M>1==p[2*M+3]>>1&&(D=2,M+=1),P<0){for(var O=-(P>>1)-1,I=0;I>1)-1;0===D?d(s,l,E--,O):1===D?d(c,u,L--,O):2===D&&d(f,h,z--,O)}}},scanBipartite:function(t,e,r,n,i,c,u,f,h,m,v,y){var x=0,b=2*t,_=e,w=e+t,k=1,M=1;n?M=o:k=o;for(var A=i;A>>1;a(p,E);for(var L=0,A=0;A=o?(P=!n,T-=o):(P=!!n,T-=1),P)g(s,l,L++,T);else{var D=y[T],O=b*T,I=v[O+e+1],R=v[O+e+1+t];t:for(var B=0;B>>1;a(p,k);for(var M=0,x=0;x=o)s[M++]=b-o;else{var T=d[b-=1],S=m*b,C=h[S+e+1],E=h[S+e+1+t];t:for(var L=0;L=0;--L)if(s[L]===b){for(var O=L+1;Oa)throw new RangeError("Invalid typed array length");var e=new Uint8Array(t);return e.__proto__=s.prototype,e}function s(t,e,r){if("number"==typeof t){if("string"==typeof e)throw new Error("If encoding is specified then the first argument must be a string");return u(t)}return l(t,e,r)}function l(t,e,r){if("number"==typeof t)throw new TypeError('"value" argument must not be a number');return j(t)||t&&j(t.buffer)?function(t,e,r){if(e<0||t.byteLength=a)throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x"+a.toString(16)+" bytes");return 0|t}function p(t,e){if(s.isBuffer(t))return t.length;if(ArrayBuffer.isView(t)||j(t))return t.byteLength;"string"!=typeof t&&(t=""+t);var r=t.length;if(0===r)return 0;for(var n=!1;;)switch(e){case"ascii":case"latin1":case"binary":return r;case"utf8":case"utf-8":case void 0:return B(t).length;case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return 2*r;case"hex":return r>>>1;case"base64":return F(t).length;default:if(n)return B(t).length;e=(""+e).toLowerCase(),n=!0}}function d(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function g(t,e,r,n,i){if(0===t.length)return-1;if("string"==typeof r?(n=r,r=0):r>2147483647?r=2147483647:r<-2147483648&&(r=-2147483648),V(r=+r)&&(r=i?0:t.length-1),r<0&&(r=t.length+r),r>=t.length){if(i)return-1;r=t.length-1}else if(r<0){if(!i)return-1;r=0}if("string"==typeof e&&(e=s.from(e,n)),s.isBuffer(e))return 0===e.length?-1:m(t,e,r,n,i);if("number"==typeof e)return e&=255,"function"==typeof Uint8Array.prototype.indexOf?i?Uint8Array.prototype.indexOf.call(t,e,r):Uint8Array.prototype.lastIndexOf.call(t,e,r):m(t,[e],r,n,i);throw new TypeError("val must be string, number or Buffer")}function m(t,e,r,n,i){var a,o=1,s=t.length,l=e.length;if(void 0!==n&&("ucs2"===(n=String(n).toLowerCase())||"ucs-2"===n||"utf16le"===n||"utf-16le"===n)){if(t.length<2||e.length<2)return-1;o=2,s/=2,l/=2,r/=2}function c(t,e){return 1===o?t[e]:t.readUInt16BE(e*o)}if(i){var u=-1;for(a=r;as&&(r=s-l),a=r;a>=0;a--){for(var f=!0,h=0;hi&&(n=i):n=i;var a=e.length;n>a/2&&(n=a/2);for(var o=0;o>8,i=r%256,a.push(i),a.push(n);return a}(e,t.length-r),t,r,n)}function k(t,e,r){return 0===e&&r===t.length?n.fromByteArray(t):n.fromByteArray(t.slice(e,r))}function M(t,e,r){r=Math.min(t.length,r);for(var n=[],i=e;i239?4:c>223?3:c>191?2:1;if(i+f<=r)switch(f){case 1:c<128&&(u=c);break;case 2:128==(192&(a=t[i+1]))&&(l=(31&c)<<6|63&a)>127&&(u=l);break;case 3:a=t[i+1],o=t[i+2],128==(192&a)&&128==(192&o)&&(l=(15&c)<<12|(63&a)<<6|63&o)>2047&&(l<55296||l>57343)&&(u=l);break;case 4:a=t[i+1],o=t[i+2],s=t[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&(l=(15&c)<<18|(63&a)<<12|(63&o)<<6|63&s)>65535&&l<1114112&&(u=l)}null===u?(u=65533,f=1):u>65535&&(u-=65536,n.push(u>>>10&1023|55296),u=56320|1023&u),n.push(u),i+=f}return function(t){var e=t.length;if(e<=A)return String.fromCharCode.apply(String,t);var r="",n=0;for(;nthis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(e>>>=0))return"";for(t||(t="utf8");;)switch(t){case"hex":return C(this,e,r);case"utf8":case"utf-8":return M(this,e,r);case"ascii":return T(this,e,r);case"latin1":case"binary":return S(this,e,r);case"base64":return k(this,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return E(this,e,r);default:if(n)throw new TypeError("Unknown encoding: "+t);t=(t+"").toLowerCase(),n=!0}}.apply(this,arguments)},s.prototype.toLocaleString=s.prototype.toString,s.prototype.equals=function(t){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");return this===t||0===s.compare(this,t)},s.prototype.inspect=function(){var t="",e=r.INSPECT_MAX_BYTES;return this.length>0&&(t=this.toString("hex",0,e).match(/.{2}/g).join(" "),this.length>e&&(t+=" ... ")),""},s.prototype.compare=function(t,e,r,n,i){if(!s.isBuffer(t))throw new TypeError("Argument must be a Buffer");if(void 0===e&&(e=0),void 0===r&&(r=t?t.length:0),void 0===n&&(n=0),void 0===i&&(i=this.length),e<0||r>t.length||n<0||i>this.length)throw new RangeError("out of range index");if(n>=i&&e>=r)return 0;if(n>=i)return-1;if(e>=r)return 1;if(this===t)return 0;for(var a=(i>>>=0)-(n>>>=0),o=(r>>>=0)-(e>>>=0),l=Math.min(a,o),c=this.slice(n,i),u=t.slice(e,r),f=0;f>>=0,isFinite(r)?(r>>>=0,void 0===n&&(n="utf8")):(n=r,r=void 0)}var i=this.length-e;if((void 0===r||r>i)&&(r=i),t.length>0&&(r<0||e<0)||e>this.length)throw new RangeError("Attempt to write outside buffer bounds");n||(n="utf8");for(var a=!1;;)switch(n){case"hex":return v(this,t,e,r);case"utf8":case"utf-8":return y(this,t,e,r);case"ascii":return x(this,t,e,r);case"latin1":case"binary":return b(this,t,e,r);case"base64":return _(this,t,e,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return w(this,t,e,r);default:if(a)throw new TypeError("Unknown encoding: "+n);n=(""+n).toLowerCase(),a=!0}},s.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var A=4096;function T(t,e,r){var n="";r=Math.min(t.length,r);for(var i=e;in)&&(r=n);for(var i="",a=e;ar)throw new RangeError("Trying to access beyond buffer length")}function z(t,e,r,n,i,a){if(!s.isBuffer(t))throw new TypeError('"buffer" argument must be a Buffer instance');if(e>i||et.length)throw new RangeError("Index out of range")}function P(t,e,r,n,i,a){if(r+n>t.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function D(t,e,r,n,a){return e=+e,r>>>=0,a||P(t,0,r,4),i.write(t,e,r,n,23,4),r+4}function O(t,e,r,n,a){return e=+e,r>>>=0,a||P(t,0,r,8),i.write(t,e,r,n,52,8),r+8}s.prototype.slice=function(t,e){var r=this.length;(t=~~t)<0?(t+=r)<0&&(t=0):t>r&&(t=r),(e=void 0===e?r:~~e)<0?(e+=r)<0&&(e=0):e>r&&(e=r),e>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t],i=1,a=0;++a>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t+--e],i=1;e>0&&(i*=256);)n+=this[t+--e]*i;return n},s.prototype.readUInt8=function(t,e){return t>>>=0,e||L(t,1,this.length),this[t]},s.prototype.readUInt16LE=function(t,e){return t>>>=0,e||L(t,2,this.length),this[t]|this[t+1]<<8},s.prototype.readUInt16BE=function(t,e){return t>>>=0,e||L(t,2,this.length),this[t]<<8|this[t+1]},s.prototype.readUInt32LE=function(t,e){return t>>>=0,e||L(t,4,this.length),(this[t]|this[t+1]<<8|this[t+2]<<16)+16777216*this[t+3]},s.prototype.readUInt32BE=function(t,e){return t>>>=0,e||L(t,4,this.length),16777216*this[t]+(this[t+1]<<16|this[t+2]<<8|this[t+3])},s.prototype.readIntLE=function(t,e,r){t>>>=0,e>>>=0,r||L(t,e,this.length);for(var n=this[t],i=1,a=0;++a=(i*=128)&&(n-=Math.pow(2,8*e)),n},s.prototype.readIntBE=function(t,e,r){t>>>=0,e>>>=0,r||L(t,e,this.length);for(var n=e,i=1,a=this[t+--n];n>0&&(i*=256);)a+=this[t+--n]*i;return a>=(i*=128)&&(a-=Math.pow(2,8*e)),a},s.prototype.readInt8=function(t,e){return t>>>=0,e||L(t,1,this.length),128&this[t]?-1*(255-this[t]+1):this[t]},s.prototype.readInt16LE=function(t,e){t>>>=0,e||L(t,2,this.length);var r=this[t]|this[t+1]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt16BE=function(t,e){t>>>=0,e||L(t,2,this.length);var r=this[t+1]|this[t]<<8;return 32768&r?4294901760|r:r},s.prototype.readInt32LE=function(t,e){return t>>>=0,e||L(t,4,this.length),this[t]|this[t+1]<<8|this[t+2]<<16|this[t+3]<<24},s.prototype.readInt32BE=function(t,e){return t>>>=0,e||L(t,4,this.length),this[t]<<24|this[t+1]<<16|this[t+2]<<8|this[t+3]},s.prototype.readFloatLE=function(t,e){return t>>>=0,e||L(t,4,this.length),i.read(this,t,!0,23,4)},s.prototype.readFloatBE=function(t,e){return t>>>=0,e||L(t,4,this.length),i.read(this,t,!1,23,4)},s.prototype.readDoubleLE=function(t,e){return t>>>=0,e||L(t,8,this.length),i.read(this,t,!0,52,8)},s.prototype.readDoubleBE=function(t,e){return t>>>=0,e||L(t,8,this.length),i.read(this,t,!1,52,8)},s.prototype.writeUIntLE=function(t,e,r,n){(t=+t,e>>>=0,r>>>=0,n)||z(this,t,e,r,Math.pow(2,8*r)-1,0);var i=1,a=0;for(this[e]=255&t;++a>>=0,r>>>=0,n)||z(this,t,e,r,Math.pow(2,8*r)-1,0);var i=r-1,a=1;for(this[e+i]=255&t;--i>=0&&(a*=256);)this[e+i]=t/a&255;return e+r},s.prototype.writeUInt8=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,1,255,0),this[e]=255&t,e+1},s.prototype.writeUInt16LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,65535,0),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeUInt16BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,65535,0),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeUInt32LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,4294967295,0),this[e+3]=t>>>24,this[e+2]=t>>>16,this[e+1]=t>>>8,this[e]=255&t,e+4},s.prototype.writeUInt32BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,4294967295,0),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeIntLE=function(t,e,r,n){if(t=+t,e>>>=0,!n){var i=Math.pow(2,8*r-1);z(this,t,e,r,i-1,-i)}var a=0,o=1,s=0;for(this[e]=255&t;++a>0)-s&255;return e+r},s.prototype.writeIntBE=function(t,e,r,n){if(t=+t,e>>>=0,!n){var i=Math.pow(2,8*r-1);z(this,t,e,r,i-1,-i)}var a=r-1,o=1,s=0;for(this[e+a]=255&t;--a>=0&&(o*=256);)t<0&&0===s&&0!==this[e+a+1]&&(s=1),this[e+a]=(t/o>>0)-s&255;return e+r},s.prototype.writeInt8=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,1,127,-128),t<0&&(t=255+t+1),this[e]=255&t,e+1},s.prototype.writeInt16LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,32767,-32768),this[e]=255&t,this[e+1]=t>>>8,e+2},s.prototype.writeInt16BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,2,32767,-32768),this[e]=t>>>8,this[e+1]=255&t,e+2},s.prototype.writeInt32LE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,2147483647,-2147483648),this[e]=255&t,this[e+1]=t>>>8,this[e+2]=t>>>16,this[e+3]=t>>>24,e+4},s.prototype.writeInt32BE=function(t,e,r){return t=+t,e>>>=0,r||z(this,t,e,4,2147483647,-2147483648),t<0&&(t=4294967295+t+1),this[e]=t>>>24,this[e+1]=t>>>16,this[e+2]=t>>>8,this[e+3]=255&t,e+4},s.prototype.writeFloatLE=function(t,e,r){return D(this,t,e,!0,r)},s.prototype.writeFloatBE=function(t,e,r){return D(this,t,e,!1,r)},s.prototype.writeDoubleLE=function(t,e,r){return O(this,t,e,!0,r)},s.prototype.writeDoubleBE=function(t,e,r){return O(this,t,e,!1,r)},s.prototype.copy=function(t,e,r,n){if(!s.isBuffer(t))throw new TypeError("argument should be a Buffer");if(r||(r=0),n||0===n||(n=this.length),e>=t.length&&(e=t.length),e||(e=0),n>0&&n=this.length)throw new RangeError("Index out of range");if(n<0)throw new RangeError("sourceEnd out of bounds");n>this.length&&(n=this.length),t.length-e=0;--a)t[a+e]=this[a+r];else Uint8Array.prototype.set.call(t,this.subarray(r,n),e);return i},s.prototype.fill=function(t,e,r,n){if("string"==typeof t){if("string"==typeof e?(n=e,e=0,r=this.length):"string"==typeof r&&(n=r,r=this.length),void 0!==n&&"string"!=typeof n)throw new TypeError("encoding must be a string");if("string"==typeof n&&!s.isEncoding(n))throw new TypeError("Unknown encoding: "+n);if(1===t.length){var i=t.charCodeAt(0);("utf8"===n&&i<128||"latin1"===n)&&(t=i)}}else"number"==typeof t&&(t&=255);if(e<0||this.length>>=0,r=void 0===r?this.length:r>>>0,t||(t=0),"number"==typeof t)for(a=e;a55295&&r<57344){if(!i){if(r>56319){(e-=3)>-1&&a.push(239,191,189);continue}if(o+1===n){(e-=3)>-1&&a.push(239,191,189);continue}i=r;continue}if(r<56320){(e-=3)>-1&&a.push(239,191,189),i=r;continue}r=65536+(i-55296<<10|r-56320)}else i&&(e-=3)>-1&&a.push(239,191,189);if(i=null,r<128){if((e-=1)<0)break;a.push(r)}else if(r<2048){if((e-=2)<0)break;a.push(r>>6|192,63&r|128)}else if(r<65536){if((e-=3)<0)break;a.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((e-=4)<0)break;a.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return a}function F(t){return n.toByteArray(function(t){if((t=(t=t.split("=")[0]).trim().replace(I,"")).length<2)return"";for(;t.length%4!=0;)t+="=";return t}(t))}function N(t,e,r,n){for(var i=0;i=e.length||i>=t.length);++i)e[i+r]=t[i];return i}function j(t){return t instanceof ArrayBuffer||null!=t&&null!=t.constructor&&"ArrayBuffer"===t.constructor.name&&"number"==typeof t.byteLength}function V(t){return t!=t}},{"base64-js":56,ieee754:356}],87:[function(t,e,r){"use strict";var n=t("./lib/monotone"),i=t("./lib/triangulation"),a=t("./lib/delaunay"),o=t("./lib/filter");function s(t){return[Math.min(t[0],t[1]),Math.max(t[0],t[1])]}function l(t,e){return t[0]-e[0]||t[1]-e[1]}function c(t,e,r){return e in t?t[e]:r}e.exports=function(t,e,r){Array.isArray(e)?(r=r||{},e=e||[]):(r=e||{},e=[]);var u=!!c(r,"delaunay",!0),f=!!c(r,"interior",!0),h=!!c(r,"exterior",!0),p=!!c(r,"infinity",!1);if(!f&&!h||0===t.length)return[];var d=n(t,e);if(u||f!==h||p){for(var g=i(t.length,function(t){return t.map(s).sort(l)}(e)),m=0;m0;){for(var u=r.pop(),s=r.pop(),f=-1,h=-1,l=o[s],d=1;d=0||(e.flip(s,u),i(t,e,r,f,s,h),i(t,e,r,s,h,f),i(t,e,r,h,u,f),i(t,e,r,u,f,h)))}}},{"binary-search-bounds":92,"robust-in-sphere":444}],89:[function(t,e,r){"use strict";var n,i=t("binary-search-bounds");function a(t,e,r,n,i,a,o){this.cells=t,this.neighbor=e,this.flags=n,this.constraint=r,this.active=i,this.next=a,this.boundary=o}function o(t,e){return t[0]-e[0]||t[1]-e[1]||t[2]-e[2]}e.exports=function(t,e,r){var n=function(t,e){for(var r=t.cells(),n=r.length,i=0;i0||l.length>0;){for(;s.length>0;){var p=s.pop();if(c[p]!==-i){c[p]=i;u[p];for(var d=0;d<3;++d){var g=h[3*p+d];g>=0&&0===c[g]&&(f[3*p+d]?l.push(g):(s.push(g),c[g]=i))}}}var m=l;l=s,s=m,l.length=0,i=-i}var v=function(t,e,r){for(var n=0,i=0;i1&&i(r[h[p-2]],r[h[p-1]],a)>0;)t.push([h[p-1],h[p-2],o]),p-=1;h.length=p,h.push(o);var d=u.upperIds;for(p=d.length;p>1&&i(r[d[p-2]],r[d[p-1]],a)<0;)t.push([d[p-2],d[p-1],o]),p-=1;d.length=p,d.push(o)}}function p(t,e){var r;return(r=t.a[0]v[0]&&i.push(new c(v,m,s,f),new c(m,v,o,f))}i.sort(u);for(var y=i[0].a[0]-(1+Math.abs(i[0].a[0]))*Math.pow(2,-52),x=[new l([y,1],[y,0],-1,[],[],[],[])],b=[],f=0,_=i.length;f<_;++f){var w=i[f],k=w.type;k===a?h(b,x,t,w.a,w.idx):k===s?d(x,t,w):g(x,t,w)}return b}},{"binary-search-bounds":92,"robust-orientation":446}],91:[function(t,e,r){"use strict";var n=t("binary-search-bounds");function i(t,e){this.stars=t,this.edges=e}e.exports=function(t,e){for(var r=new Array(t),n=0;n=0}}(),a.removeTriangle=function(t,e,r){var n=this.stars;o(n[t],e,r),o(n[e],r,t),o(n[r],t,e)},a.addTriangle=function(t,e,r){var n=this.stars;n[t].push(e,r),n[e].push(r,t),n[r].push(t,e)},a.opposite=function(t,e){for(var r=this.stars[e],n=1,i=r.length;n>>1,x=a[m]"];return i?e.indexOf("c")<0?a.push(";if(x===y){return m}else if(x<=y){"):a.push(";var p=c(x,y);if(p===0){return m}else if(p<=0){"):a.push(";if(",e,"){i=m;"),r?a.push("l=m+1}else{h=m-1}"):a.push("h=m-1}else{l=m+1}"),a.push("}"),i?a.push("return -1};"):a.push("return i};"),a.join("")}function i(t,e,r,i){return new Function([n("A","x"+t+"y",e,["y"],i),n("P","c(x,y)"+t+"0",e,["y","c"],i),"function dispatchBsearch",r,"(a,y,c,l,h){if(typeof(c)==='function'){return P(a,(l===void 0)?0:l|0,(h===void 0)?a.length-1:h|0,y,c)}else{return A(a,(c===void 0)?0:c|0,(l===void 0)?a.length-1:l|0,y)}}return dispatchBsearch",r].join(""))()}e.exports={ge:i(">=",!1,"GE"),gt:i(">",!1,"GT"),lt:i("<",!0,"LT"),le:i("<=",!0,"LE"),eq:i("-",!0,"EQ",!0)}},{}],93:[function(t,e,r){"use strict";e.exports=function(t){for(var e=1,r=1;rr?r:t:te?e:t}},{}],97:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n;if(r){n=e;for(var i=new Array(e.length),a=0;ae[2]?1:0)}function v(t,e,r){if(0!==t.length){if(e)for(var n=0;n=0;--a){var x=e[u=(S=n[a])[0]],b=x[0],_=x[1],w=t[b],k=t[_];if((w[0]-k[0]||w[1]-k[1])<0){var M=b;b=_,_=M}x[0]=b;var A,T=x[1]=S[1];for(i&&(A=x[2]);a>0&&n[a-1][0]===u;){var S,C=(S=n[--a])[1];i?e.push([T,C,A]):e.push([T,C]),T=C}i?e.push([T,_,A]):e.push([T,_])}return h}(t,e,h,m,r));return v(e,y,r),!!y||(h.length>0||m.length>0)}},{"./lib/rat-seg-intersect":98,"big-rat":60,"big-rat/cmp":58,"big-rat/to-float":72,"box-intersect":78,nextafter:394,"rat-vec":428,"robust-segment-intersect":449,"union-find":482}],98:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var a=s(e,t),f=s(n,r),h=u(a,f);if(0===o(h))return null;var p=s(t,r),d=u(f,p),g=i(d,h),m=c(a,g);return l(t,m)};var n=t("big-rat/mul"),i=t("big-rat/div"),a=t("big-rat/sub"),o=t("big-rat/sign"),s=t("rat-vec/sub"),l=t("rat-vec/add"),c=t("rat-vec/muls");function u(t,e){return a(n(t[0],e[1]),n(t[1],e[0]))}},{"big-rat/div":59,"big-rat/mul":69,"big-rat/sign":70,"big-rat/sub":71,"rat-vec/add":427,"rat-vec/muls":429,"rat-vec/sub":430}],99:[function(t,e,r){"use strict";var n=t("clamp");function i(t,e){null==e&&(e=!0);var r=t[0],i=t[1],a=t[2],o=t[3];return null==o&&(o=e?1:255),e&&(r*=255,i*=255,a*=255,o*=255),16777216*(r=255&n(r,0,255))+((i=255&n(i,0,255))<<16)+((a=255&n(a,0,255))<<8)+(o=255&n(o,0,255))}e.exports=i,e.exports.to=i,e.exports.from=function(t,e){var r=(t=+t)>>>24,n=(16711680&t)>>>16,i=(65280&t)>>>8,a=255&t;return!1===e?[r,n,i,a]:[r/255,n/255,i/255,a/255]}},{clamp:96}],100:[function(t,e,r){"use strict";e.exports={aliceblue:[240,248,255],antiquewhite:[250,235,215],aqua:[0,255,255],aquamarine:[127,255,212],azure:[240,255,255],beige:[245,245,220],bisque:[255,228,196],black:[0,0,0],blanchedalmond:[255,235,205],blue:[0,0,255],blueviolet:[138,43,226],brown:[165,42,42],burlywood:[222,184,135],cadetblue:[95,158,160],chartreuse:[127,255,0],chocolate:[210,105,30],coral:[255,127,80],cornflowerblue:[100,149,237],cornsilk:[255,248,220],crimson:[220,20,60],cyan:[0,255,255],darkblue:[0,0,139],darkcyan:[0,139,139],darkgoldenrod:[184,134,11],darkgray:[169,169,169],darkgreen:[0,100,0],darkgrey:[169,169,169],darkkhaki:[189,183,107],darkmagenta:[139,0,139],darkolivegreen:[85,107,47],darkorange:[255,140,0],darkorchid:[153,50,204],darkred:[139,0,0],darksalmon:[233,150,122],darkseagreen:[143,188,143],darkslateblue:[72,61,139],darkslategray:[47,79,79],darkslategrey:[47,79,79],darkturquoise:[0,206,209],darkviolet:[148,0,211],deeppink:[255,20,147],deepskyblue:[0,191,255],dimgray:[105,105,105],dimgrey:[105,105,105],dodgerblue:[30,144,255],firebrick:[178,34,34],floralwhite:[255,250,240],forestgreen:[34,139,34],fuchsia:[255,0,255],gainsboro:[220,220,220],ghostwhite:[248,248,255],gold:[255,215,0],goldenrod:[218,165,32],gray:[128,128,128],green:[0,128,0],greenyellow:[173,255,47],grey:[128,128,128],honeydew:[240,255,240],hotpink:[255,105,180],indianred:[205,92,92],indigo:[75,0,130],ivory:[255,255,240],khaki:[240,230,140],lavender:[230,230,250],lavenderblush:[255,240,245],lawngreen:[124,252,0],lemonchiffon:[255,250,205],lightblue:[173,216,230],lightcoral:[240,128,128],lightcyan:[224,255,255],lightgoldenrodyellow:[250,250,210],lightgray:[211,211,211],lightgreen:[144,238,144],lightgrey:[211,211,211],lightpink:[255,182,193],lightsalmon:[255,160,122],lightseagreen:[32,178,170],lightskyblue:[135,206,250],lightslategray:[119,136,153],lightslategrey:[119,136,153],lightsteelblue:[176,196,222],lightyellow:[255,255,224],lime:[0,255,0],limegreen:[50,205,50],linen:[250,240,230],magenta:[255,0,255],maroon:[128,0,0],mediumaquamarine:[102,205,170],mediumblue:[0,0,205],mediumorchid:[186,85,211],mediumpurple:[147,112,219],mediumseagreen:[60,179,113],mediumslateblue:[123,104,238],mediumspringgreen:[0,250,154],mediumturquoise:[72,209,204],mediumvioletred:[199,21,133],midnightblue:[25,25,112],mintcream:[245,255,250],mistyrose:[255,228,225],moccasin:[255,228,181],navajowhite:[255,222,173],navy:[0,0,128],oldlace:[253,245,230],olive:[128,128,0],olivedrab:[107,142,35],orange:[255,165,0],orangered:[255,69,0],orchid:[218,112,214],palegoldenrod:[238,232,170],palegreen:[152,251,152],paleturquoise:[175,238,238],palevioletred:[219,112,147],papayawhip:[255,239,213],peachpuff:[255,218,185],peru:[205,133,63],pink:[255,192,203],plum:[221,160,221],powderblue:[176,224,230],purple:[128,0,128],rebeccapurple:[102,51,153],red:[255,0,0],rosybrown:[188,143,143],royalblue:[65,105,225],saddlebrown:[139,69,19],salmon:[250,128,114],sandybrown:[244,164,96],seagreen:[46,139,87],seashell:[255,245,238],sienna:[160,82,45],silver:[192,192,192],skyblue:[135,206,235],slateblue:[106,90,205],slategray:[112,128,144],slategrey:[112,128,144],snow:[255,250,250],springgreen:[0,255,127],steelblue:[70,130,180],tan:[210,180,140],teal:[0,128,128],thistle:[216,191,216],tomato:[255,99,71],turquoise:[64,224,208],violet:[238,130,238],wheat:[245,222,179],white:[255,255,255],whitesmoke:[245,245,245],yellow:[255,255,0],yellowgreen:[154,205,50]}},{}],101:[function(t,e,r){"use strict";var n=t("color-rgba"),i=t("clamp"),a=t("dtype");e.exports=function(t,e){"float"!==e&&e||(e="array"),"uint"===e&&(e="uint8"),"uint_clamped"===e&&(e="uint8_clamped");var r=a(e),o=new r(4);if(t instanceof r)return Array.isArray(t)?t.slice():(o.set(t),o);var s="uint8"!==e&&"uint8_clamped"!==e;return t instanceof Uint8Array||t instanceof Uint8ClampedArray?(o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=null!=t[3]?t[3]:255,s&&(o[0]/=255,o[1]/=255,o[2]/=255,o[3]/=255),o):(t.length&&"string"!=typeof t||((t=n(t))[0]/=255,t[1]/=255,t[2]/=255),s?(o[0]=t[0],o[1]=t[1],o[2]=t[2],o[3]=null!=t[3]?t[3]:1):(o[0]=i(Math.round(255*t[0]),0,255),o[1]=i(Math.round(255*t[1]),0,255),o[2]=i(Math.round(255*t[2]),0,255),o[3]=null==t[3]?255:i(Math.floor(255*t[3]),0,255)),o)}},{clamp:96,"color-rgba":103,dtype:136}],102:[function(t,e,r){(function(r){"use strict";var n=t("color-name"),i=t("is-plain-obj"),a=t("defined");e.exports=function(t){var e,s,l=[],c=1;if("string"==typeof t)if(n[t])l=n[t].slice(),s="rgb";else if("transparent"===t)c=0,s="rgb",l=[0,0,0];else if(/^#[A-Fa-f0-9]+$/.test(t)){var u=t.slice(1),f=u.length,h=f<=4;c=1,h?(l=[parseInt(u[0]+u[0],16),parseInt(u[1]+u[1],16),parseInt(u[2]+u[2],16)],4===f&&(c=parseInt(u[3]+u[3],16)/255)):(l=[parseInt(u[0]+u[1],16),parseInt(u[2]+u[3],16),parseInt(u[4]+u[5],16)],8===f&&(c=parseInt(u[6]+u[7],16)/255)),l[0]||(l[0]=0),l[1]||(l[1]=0),l[2]||(l[2]=0),s="rgb"}else if(e=/^((?:rgb|hs[lvb]|hwb|cmyk?|xy[zy]|gray|lab|lchu?v?|[ly]uv|lms)a?)\s*\(([^\)]*)\)/.exec(t)){var p=e[1],u=p.replace(/a$/,"");s=u;var f="cmyk"===u?4:"gray"===u?1:3;l=e[2].trim().split(/\s*,\s*/).map(function(t,e){if(/%$/.test(t))return e===f?parseFloat(t)/100:"rgb"===u?255*parseFloat(t)/100:parseFloat(t);if("h"===u[e]){if(/deg$/.test(t))return parseFloat(t);if(void 0!==o[t])return o[t]}return parseFloat(t)}),p===u&&l.push(1),c=void 0===l[f]?1:l[f],l=l.slice(0,f)}else t.length>10&&/[0-9](?:\s|\/)/.test(t)&&(l=t.match(/([0-9]+)/g).map(function(t){return parseFloat(t)}),s=t.match(/([a-z])/ig).join("").toLowerCase());else if("number"==typeof t)s="rgb",l=[t>>>16,(65280&t)>>>8,255&t];else if(i(t)){var d=a(t.r,t.red,t.R,null);null!==d?(s="rgb",l=[d,a(t.g,t.green,t.G),a(t.b,t.blue,t.B)]):(s="hsl",l=[a(t.h,t.hue,t.H),a(t.s,t.saturation,t.S),a(t.l,t.lightness,t.L,t.b,t.brightness)]),c=a(t.a,t.alpha,t.opacity,1),null!=t.opacity&&(c/=100)}else(Array.isArray(t)||r.ArrayBuffer&&ArrayBuffer.isView&&ArrayBuffer.isView(t))&&(l=[t[0],t[1],t[2]],s="rgb",c=4===t.length?t[3]:1);return{space:s,values:l,alpha:c}};var o={red:0,orange:60,yellow:120,green:180,blue:240,purple:300}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"color-name":100,defined:132,"is-plain-obj":366}],103:[function(t,e,r){"use strict";var n=t("color-parse"),i=t("color-space/hsl"),a=t("clamp");e.exports=function(t){var e;if("string"!=typeof t)throw Error("Argument should be a string");var r=n(t);return r.space?((e=Array(3))[0]=a(r.values[0],0,255),e[1]=a(r.values[1],0,255),e[2]=a(r.values[2],0,255),"h"===r.space[0]&&(e=i.rgb(e)),e.push(a(r.alpha,0,1)),e):[]}},{clamp:96,"color-parse":102,"color-space/hsl":104}],104:[function(t,e,r){"use strict";var n=t("./rgb");e.exports={name:"hsl",min:[0,0,0],max:[360,100,100],channel:["hue","saturation","lightness"],alias:["HSL"],rgb:function(t){var e,r,n,i,a,o=t[0]/360,s=t[1]/100,l=t[2]/100;if(0===s)return[a=255*l,a,a];e=2*l-(r=l<.5?l*(1+s):l+s-l*s),i=[0,0,0];for(var c=0;c<3;c++)(n=o+1/3*-(c-1))<0?n++:n>1&&n--,a=6*n<1?e+6*(r-e)*n:2*n<1?r:3*n<2?e+(r-e)*(2/3-n)*6:e,i[c]=255*a;return i}},n.hsl=function(t){var e,r,n=t[0]/255,i=t[1]/255,a=t[2]/255,o=Math.min(n,i,a),s=Math.max(n,i,a),l=s-o;return s===o?e=0:n===s?e=(i-a)/l:i===s?e=2+(a-n)/l:a===s&&(e=4+(n-i)/l),(e=Math.min(60*e,360))<0&&(e+=360),r=(o+s)/2,[e,100*(s===o?0:r<=.5?l/(s+o):l/(2-s-o)),100*r]}},{"./rgb":105}],105:[function(t,e,r){"use strict";e.exports={name:"rgb",min:[0,0,0],max:[255,255,255],channel:["red","green","blue"],alias:["RGB"]}},{}],106:[function(t,e,r){e.exports={jet:[{index:0,rgb:[0,0,131]},{index:.125,rgb:[0,60,170]},{index:.375,rgb:[5,255,255]},{index:.625,rgb:[255,255,0]},{index:.875,rgb:[250,0,0]},{index:1,rgb:[128,0,0]}],hsv:[{index:0,rgb:[255,0,0]},{index:.169,rgb:[253,255,2]},{index:.173,rgb:[247,255,2]},{index:.337,rgb:[0,252,4]},{index:.341,rgb:[0,252,10]},{index:.506,rgb:[1,249,255]},{index:.671,rgb:[2,0,253]},{index:.675,rgb:[8,0,253]},{index:.839,rgb:[255,0,251]},{index:.843,rgb:[255,0,245]},{index:1,rgb:[255,0,6]}],hot:[{index:0,rgb:[0,0,0]},{index:.3,rgb:[230,0,0]},{index:.6,rgb:[255,210,0]},{index:1,rgb:[255,255,255]}],cool:[{index:0,rgb:[0,255,255]},{index:1,rgb:[255,0,255]}],spring:[{index:0,rgb:[255,0,255]},{index:1,rgb:[255,255,0]}],summer:[{index:0,rgb:[0,128,102]},{index:1,rgb:[255,255,102]}],autumn:[{index:0,rgb:[255,0,0]},{index:1,rgb:[255,255,0]}],winter:[{index:0,rgb:[0,0,255]},{index:1,rgb:[0,255,128]}],bone:[{index:0,rgb:[0,0,0]},{index:.376,rgb:[84,84,116]},{index:.753,rgb:[169,200,200]},{index:1,rgb:[255,255,255]}],copper:[{index:0,rgb:[0,0,0]},{index:.804,rgb:[255,160,102]},{index:1,rgb:[255,199,127]}],greys:[{index:0,rgb:[0,0,0]},{index:1,rgb:[255,255,255]}],yignbu:[{index:0,rgb:[8,29,88]},{index:.125,rgb:[37,52,148]},{index:.25,rgb:[34,94,168]},{index:.375,rgb:[29,145,192]},{index:.5,rgb:[65,182,196]},{index:.625,rgb:[127,205,187]},{index:.75,rgb:[199,233,180]},{index:.875,rgb:[237,248,217]},{index:1,rgb:[255,255,217]}],greens:[{index:0,rgb:[0,68,27]},{index:.125,rgb:[0,109,44]},{index:.25,rgb:[35,139,69]},{index:.375,rgb:[65,171,93]},{index:.5,rgb:[116,196,118]},{index:.625,rgb:[161,217,155]},{index:.75,rgb:[199,233,192]},{index:.875,rgb:[229,245,224]},{index:1,rgb:[247,252,245]}],yiorrd:[{index:0,rgb:[128,0,38]},{index:.125,rgb:[189,0,38]},{index:.25,rgb:[227,26,28]},{index:.375,rgb:[252,78,42]},{index:.5,rgb:[253,141,60]},{index:.625,rgb:[254,178,76]},{index:.75,rgb:[254,217,118]},{index:.875,rgb:[255,237,160]},{index:1,rgb:[255,255,204]}],bluered:[{index:0,rgb:[0,0,255]},{index:1,rgb:[255,0,0]}],rdbu:[{index:0,rgb:[5,10,172]},{index:.35,rgb:[106,137,247]},{index:.5,rgb:[190,190,190]},{index:.6,rgb:[220,170,132]},{index:.7,rgb:[230,145,90]},{index:1,rgb:[178,10,28]}],picnic:[{index:0,rgb:[0,0,255]},{index:.1,rgb:[51,153,255]},{index:.2,rgb:[102,204,255]},{index:.3,rgb:[153,204,255]},{index:.4,rgb:[204,204,255]},{index:.5,rgb:[255,255,255]},{index:.6,rgb:[255,204,255]},{index:.7,rgb:[255,153,255]},{index:.8,rgb:[255,102,204]},{index:.9,rgb:[255,102,102]},{index:1,rgb:[255,0,0]}],rainbow:[{index:0,rgb:[150,0,90]},{index:.125,rgb:[0,0,200]},{index:.25,rgb:[0,25,255]},{index:.375,rgb:[0,152,255]},{index:.5,rgb:[44,255,150]},{index:.625,rgb:[151,255,0]},{index:.75,rgb:[255,234,0]},{index:.875,rgb:[255,111,0]},{index:1,rgb:[255,0,0]}],portland:[{index:0,rgb:[12,51,131]},{index:.25,rgb:[10,136,186]},{index:.5,rgb:[242,211,56]},{index:.75,rgb:[242,143,56]},{index:1,rgb:[217,30,30]}],blackbody:[{index:0,rgb:[0,0,0]},{index:.2,rgb:[230,0,0]},{index:.4,rgb:[230,210,0]},{index:.7,rgb:[255,255,255]},{index:1,rgb:[160,200,255]}],earth:[{index:0,rgb:[0,0,130]},{index:.1,rgb:[0,180,180]},{index:.2,rgb:[40,210,40]},{index:.4,rgb:[230,230,50]},{index:.6,rgb:[120,70,20]},{index:1,rgb:[255,255,255]}],electric:[{index:0,rgb:[0,0,0]},{index:.15,rgb:[30,0,100]},{index:.4,rgb:[120,0,100]},{index:.6,rgb:[160,90,0]},{index:.8,rgb:[230,200,0]},{index:1,rgb:[255,250,220]}],alpha:[{index:0,rgb:[255,255,255,0]},{index:1,rgb:[255,255,255,1]}],viridis:[{index:0,rgb:[68,1,84]},{index:.13,rgb:[71,44,122]},{index:.25,rgb:[59,81,139]},{index:.38,rgb:[44,113,142]},{index:.5,rgb:[33,144,141]},{index:.63,rgb:[39,173,129]},{index:.75,rgb:[92,200,99]},{index:.88,rgb:[170,220,50]},{index:1,rgb:[253,231,37]}],inferno:[{index:0,rgb:[0,0,4]},{index:.13,rgb:[31,12,72]},{index:.25,rgb:[85,15,109]},{index:.38,rgb:[136,34,106]},{index:.5,rgb:[186,54,85]},{index:.63,rgb:[227,89,51]},{index:.75,rgb:[249,140,10]},{index:.88,rgb:[249,201,50]},{index:1,rgb:[252,255,164]}],magma:[{index:0,rgb:[0,0,4]},{index:.13,rgb:[28,16,68]},{index:.25,rgb:[79,18,123]},{index:.38,rgb:[129,37,129]},{index:.5,rgb:[181,54,122]},{index:.63,rgb:[229,80,100]},{index:.75,rgb:[251,135,97]},{index:.88,rgb:[254,194,135]},{index:1,rgb:[252,253,191]}],plasma:[{index:0,rgb:[13,8,135]},{index:.13,rgb:[75,3,161]},{index:.25,rgb:[125,3,168]},{index:.38,rgb:[168,34,150]},{index:.5,rgb:[203,70,121]},{index:.63,rgb:[229,107,93]},{index:.75,rgb:[248,148,65]},{index:.88,rgb:[253,195,40]},{index:1,rgb:[240,249,33]}],warm:[{index:0,rgb:[125,0,179]},{index:.13,rgb:[172,0,187]},{index:.25,rgb:[219,0,170]},{index:.38,rgb:[255,0,130]},{index:.5,rgb:[255,63,74]},{index:.63,rgb:[255,123,0]},{index:.75,rgb:[234,176,0]},{index:.88,rgb:[190,228,0]},{index:1,rgb:[147,255,0]}],cool:[{index:0,rgb:[125,0,179]},{index:.13,rgb:[116,0,218]},{index:.25,rgb:[98,74,237]},{index:.38,rgb:[68,146,231]},{index:.5,rgb:[0,204,197]},{index:.63,rgb:[0,247,146]},{index:.75,rgb:[0,255,88]},{index:.88,rgb:[40,255,8]},{index:1,rgb:[147,255,0]}],"rainbow-soft":[{index:0,rgb:[125,0,179]},{index:.1,rgb:[199,0,180]},{index:.2,rgb:[255,0,121]},{index:.3,rgb:[255,108,0]},{index:.4,rgb:[222,194,0]},{index:.5,rgb:[150,255,0]},{index:.6,rgb:[0,255,55]},{index:.7,rgb:[0,246,150]},{index:.8,rgb:[50,167,222]},{index:.9,rgb:[103,51,235]},{index:1,rgb:[124,0,186]}],bathymetry:[{index:0,rgb:[40,26,44]},{index:.13,rgb:[59,49,90]},{index:.25,rgb:[64,76,139]},{index:.38,rgb:[63,110,151]},{index:.5,rgb:[72,142,158]},{index:.63,rgb:[85,174,163]},{index:.75,rgb:[120,206,163]},{index:.88,rgb:[187,230,172]},{index:1,rgb:[253,254,204]}],cdom:[{index:0,rgb:[47,15,62]},{index:.13,rgb:[87,23,86]},{index:.25,rgb:[130,28,99]},{index:.38,rgb:[171,41,96]},{index:.5,rgb:[206,67,86]},{index:.63,rgb:[230,106,84]},{index:.75,rgb:[242,149,103]},{index:.88,rgb:[249,193,135]},{index:1,rgb:[254,237,176]}],chlorophyll:[{index:0,rgb:[18,36,20]},{index:.13,rgb:[25,63,41]},{index:.25,rgb:[24,91,59]},{index:.38,rgb:[13,119,72]},{index:.5,rgb:[18,148,80]},{index:.63,rgb:[80,173,89]},{index:.75,rgb:[132,196,122]},{index:.88,rgb:[175,221,162]},{index:1,rgb:[215,249,208]}],density:[{index:0,rgb:[54,14,36]},{index:.13,rgb:[89,23,80]},{index:.25,rgb:[110,45,132]},{index:.38,rgb:[120,77,178]},{index:.5,rgb:[120,113,213]},{index:.63,rgb:[115,151,228]},{index:.75,rgb:[134,185,227]},{index:.88,rgb:[177,214,227]},{index:1,rgb:[230,241,241]}],"freesurface-blue":[{index:0,rgb:[30,4,110]},{index:.13,rgb:[47,14,176]},{index:.25,rgb:[41,45,236]},{index:.38,rgb:[25,99,212]},{index:.5,rgb:[68,131,200]},{index:.63,rgb:[114,156,197]},{index:.75,rgb:[157,181,203]},{index:.88,rgb:[200,208,216]},{index:1,rgb:[241,237,236]}],"freesurface-red":[{index:0,rgb:[60,9,18]},{index:.13,rgb:[100,17,27]},{index:.25,rgb:[142,20,29]},{index:.38,rgb:[177,43,27]},{index:.5,rgb:[192,87,63]},{index:.63,rgb:[205,125,105]},{index:.75,rgb:[216,162,148]},{index:.88,rgb:[227,199,193]},{index:1,rgb:[241,237,236]}],oxygen:[{index:0,rgb:[64,5,5]},{index:.13,rgb:[106,6,15]},{index:.25,rgb:[144,26,7]},{index:.38,rgb:[168,64,3]},{index:.5,rgb:[188,100,4]},{index:.63,rgb:[206,136,11]},{index:.75,rgb:[220,174,25]},{index:.88,rgb:[231,215,44]},{index:1,rgb:[248,254,105]}],par:[{index:0,rgb:[51,20,24]},{index:.13,rgb:[90,32,35]},{index:.25,rgb:[129,44,34]},{index:.38,rgb:[159,68,25]},{index:.5,rgb:[182,99,19]},{index:.63,rgb:[199,134,22]},{index:.75,rgb:[212,171,35]},{index:.88,rgb:[221,210,54]},{index:1,rgb:[225,253,75]}],phase:[{index:0,rgb:[145,105,18]},{index:.13,rgb:[184,71,38]},{index:.25,rgb:[186,58,115]},{index:.38,rgb:[160,71,185]},{index:.5,rgb:[110,97,218]},{index:.63,rgb:[50,123,164]},{index:.75,rgb:[31,131,110]},{index:.88,rgb:[77,129,34]},{index:1,rgb:[145,105,18]}],salinity:[{index:0,rgb:[42,24,108]},{index:.13,rgb:[33,50,162]},{index:.25,rgb:[15,90,145]},{index:.38,rgb:[40,118,137]},{index:.5,rgb:[59,146,135]},{index:.63,rgb:[79,175,126]},{index:.75,rgb:[120,203,104]},{index:.88,rgb:[193,221,100]},{index:1,rgb:[253,239,154]}],temperature:[{index:0,rgb:[4,35,51]},{index:.13,rgb:[23,51,122]},{index:.25,rgb:[85,59,157]},{index:.38,rgb:[129,79,143]},{index:.5,rgb:[175,95,130]},{index:.63,rgb:[222,112,101]},{index:.75,rgb:[249,146,66]},{index:.88,rgb:[249,196,65]},{index:1,rgb:[232,250,91]}],turbidity:[{index:0,rgb:[34,31,27]},{index:.13,rgb:[65,50,41]},{index:.25,rgb:[98,69,52]},{index:.38,rgb:[131,89,57]},{index:.5,rgb:[161,112,59]},{index:.63,rgb:[185,140,66]},{index:.75,rgb:[202,174,88]},{index:.88,rgb:[216,209,126]},{index:1,rgb:[233,246,171]}],"velocity-blue":[{index:0,rgb:[17,32,64]},{index:.13,rgb:[35,52,116]},{index:.25,rgb:[29,81,156]},{index:.38,rgb:[31,113,162]},{index:.5,rgb:[50,144,169]},{index:.63,rgb:[87,173,176]},{index:.75,rgb:[149,196,189]},{index:.88,rgb:[203,221,211]},{index:1,rgb:[254,251,230]}],"velocity-green":[{index:0,rgb:[23,35,19]},{index:.13,rgb:[24,64,38]},{index:.25,rgb:[11,95,45]},{index:.38,rgb:[39,123,35]},{index:.5,rgb:[95,146,12]},{index:.63,rgb:[152,165,18]},{index:.75,rgb:[201,186,69]},{index:.88,rgb:[233,216,137]},{index:1,rgb:[255,253,205]}],cubehelix:[{index:0,rgb:[0,0,0]},{index:.07,rgb:[22,5,59]},{index:.13,rgb:[60,4,105]},{index:.2,rgb:[109,1,135]},{index:.27,rgb:[161,0,147]},{index:.33,rgb:[210,2,142]},{index:.4,rgb:[251,11,123]},{index:.47,rgb:[255,29,97]},{index:.53,rgb:[255,54,69]},{index:.6,rgb:[255,85,46]},{index:.67,rgb:[255,120,34]},{index:.73,rgb:[255,157,37]},{index:.8,rgb:[241,191,57]},{index:.87,rgb:[224,220,93]},{index:.93,rgb:[218,241,142]},{index:1,rgb:[227,253,198]}]}},{}],107:[function(t,e,r){"use strict";var n=t("./colorScale"),i=t("lerp");function a(t){return[t[0]/255,t[1]/255,t[2]/255,t[3]]}function o(t){for(var e,r="#",n=0;n<3;++n)r+=("00"+(e=(e=t[n]).toString(16))).substr(e.length);return r}function s(t){return"rgba("+t.join(",")+")"}e.exports=function(t){var e,r,l,c,u,f,h,p,d,g;t||(t={});p=(t.nshades||72)-1,h=t.format||"hex",(f=t.colormap)||(f="jet");if("string"==typeof f){if(f=f.toLowerCase(),!n[f])throw Error(f+" not a supported colorscale");u=n[f]}else{if(!Array.isArray(f))throw Error("unsupported colormap option",f);u=f.slice()}if(u.length>p)throw new Error(f+" map requires nshades to be at least size "+u.length);d=Array.isArray(t.alpha)?2!==t.alpha.length?[1,1]:t.alpha.slice():"number"==typeof t.alpha?[t.alpha,t.alpha]:[1,1];e=u.map(function(t){return Math.round(t.index*p)}),d[0]=Math.min(Math.max(d[0],0),1),d[1]=Math.min(Math.max(d[1],0),1);var m=u.map(function(t,e){var r=u[e].index,n=u[e].rgb.slice();return 4===n.length&&n[3]>=0&&n[3]<=1?n:(n[3]=d[0]+(d[1]-d[0])*r,n)}),v=[];for(g=0;g0?-1:l(t,e,a)?-1:1:0===s?c>0?1:l(t,e,r)?1:-1:i(c-s)}var h=n(t,e,r);if(h>0)return o>0&&n(t,e,a)>0?1:-1;if(h<0)return o>0||n(t,e,a)>0?1:-1;var p=n(t,e,a);return p>0?1:l(t,e,r)?1:-1};var n=t("robust-orientation"),i=t("signum"),a=t("two-sum"),o=t("robust-product"),s=t("robust-sum");function l(t,e,r){var n=a(t[0],-e[0]),i=a(t[1],-e[1]),l=a(r[0],-e[0]),c=a(r[1],-e[1]),u=s(o(n,l),o(i,c));return u[u.length-1]>=0}},{"robust-orientation":446,"robust-product":447,"robust-sum":451,signum:452,"two-sum":480}],109:[function(t,e,r){e.exports=function(t,e){var r=t.length,a=t.length-e.length;if(a)return a;switch(r){case 0:return 0;case 1:return t[0]-e[0];case 2:return t[0]+t[1]-e[0]-e[1]||n(t[0],t[1])-n(e[0],e[1]);case 3:var o=t[0]+t[1],s=e[0]+e[1];if(a=o+t[2]-(s+e[2]))return a;var l=n(t[0],t[1]),c=n(e[0],e[1]);return n(l,t[2])-n(c,e[2])||n(l+t[2],o)-n(c+e[2],s);case 4:var u=t[0],f=t[1],h=t[2],p=t[3],d=e[0],g=e[1],m=e[2],v=e[3];return u+f+h+p-(d+g+m+v)||n(u,f,h,p)-n(d,g,m,v,d)||n(u+f,u+h,u+p,f+h,f+p,h+p)-n(d+g,d+m,d+v,g+m,g+v,m+v)||n(u+f+h,u+f+p,u+h+p,f+h+p)-n(d+g+m,d+g+v,d+m+v,g+m+v);default:for(var y=t.slice().sort(i),x=e.slice().sort(i),b=0;bt[r][0]&&(r=n);return er?[[r],[e]]:[[e]]}},{}],113:[function(t,e,r){"use strict";e.exports=function(t){var e=n(t),r=e.length;if(r<=2)return[];for(var i=new Array(r),a=e[r-1],o=0;o=e[l]&&(s+=1);a[o]=s}}return t}(o,r)}};var n=t("incremental-convex-hull"),i=t("affine-hull")},{"affine-hull":47,"incremental-convex-hull":357}],115:[function(t,e,r){e.exports={AFG:"afghan",ALA:"\\b\\wland",ALB:"albania",DZA:"algeria",ASM:"^(?=.*americ).*samoa",AND:"andorra",AGO:"angola",AIA:"anguill?a",ATA:"antarctica",ATG:"antigua",ARG:"argentin",ARM:"armenia",ABW:"^(?!.*bonaire).*\\baruba",AUS:"australia",AUT:"^(?!.*hungary).*austria|\\baustri.*\\bemp",AZE:"azerbaijan",BHS:"bahamas",BHR:"bahrain",BGD:"bangladesh|^(?=.*east).*paki?stan",BRB:"barbados",BLR:"belarus|byelo",BEL:"^(?!.*luxem).*belgium",BLZ:"belize|^(?=.*british).*honduras",BEN:"benin|dahome",BMU:"bermuda",BTN:"bhutan",BOL:"bolivia",BES:"^(?=.*bonaire).*eustatius|^(?=.*carib).*netherlands|\\bbes.?islands",BIH:"herzegovina|bosnia",BWA:"botswana|bechuana",BVT:"bouvet",BRA:"brazil",IOT:"british.?indian.?ocean",BRN:"brunei",BGR:"bulgaria",BFA:"burkina|\\bfaso|upper.?volta",BDI:"burundi",CPV:"verde",KHM:"cambodia|kampuchea|khmer",CMR:"cameroon",CAN:"canada",CYM:"cayman",CAF:"\\bcentral.african.republic",TCD:"\\bchad",CHL:"\\bchile",CHN:"^(?!.*\\bmac)(?!.*\\bhong)(?!.*\\btai)(?!.*\\brep).*china|^(?=.*peo)(?=.*rep).*china",CXR:"christmas",CCK:"\\bcocos|keeling",COL:"colombia",COM:"comoro",COG:"^(?!.*\\bdem)(?!.*\\bd[\\.]?r)(?!.*kinshasa)(?!.*zaire)(?!.*belg)(?!.*l.opoldville)(?!.*free).*\\bcongo",COK:"\\bcook",CRI:"costa.?rica",CIV:"ivoire|ivory",HRV:"croatia",CUB:"\\bcuba",CUW:"^(?!.*bonaire).*\\bcura(c|\xe7)ao",CYP:"cyprus",CSK:"czechoslovakia",CZE:"^(?=.*rep).*czech|czechia|bohemia",COD:"\\bdem.*congo|congo.*\\bdem|congo.*\\bd[\\.]?r|\\bd[\\.]?r.*congo|belgian.?congo|congo.?free.?state|kinshasa|zaire|l.opoldville|drc|droc|rdc",DNK:"denmark",DJI:"djibouti",DMA:"dominica(?!n)",DOM:"dominican.rep",ECU:"ecuador",EGY:"egypt",SLV:"el.?salvador",GNQ:"guine.*eq|eq.*guine|^(?=.*span).*guinea",ERI:"eritrea",EST:"estonia",ETH:"ethiopia|abyssinia",FLK:"falkland|malvinas",FRO:"faroe|faeroe",FJI:"fiji",FIN:"finland",FRA:"^(?!.*\\bdep)(?!.*martinique).*france|french.?republic|\\bgaul",GUF:"^(?=.*french).*guiana",PYF:"french.?polynesia|tahiti",ATF:"french.?southern",GAB:"gabon",GMB:"gambia",GEO:"^(?!.*south).*georgia",DDR:"german.?democratic.?republic|democratic.?republic.*germany|east.germany",DEU:"^(?!.*east).*germany|^(?=.*\\bfed.*\\brep).*german",GHA:"ghana|gold.?coast",GIB:"gibraltar",GRC:"greece|hellenic|hellas",GRL:"greenland",GRD:"grenada",GLP:"guadeloupe",GUM:"\\bguam",GTM:"guatemala",GGY:"guernsey",GIN:"^(?!.*eq)(?!.*span)(?!.*bissau)(?!.*portu)(?!.*new).*guinea",GNB:"bissau|^(?=.*portu).*guinea",GUY:"guyana|british.?guiana",HTI:"haiti",HMD:"heard.*mcdonald",VAT:"holy.?see|vatican|papal.?st",HND:"^(?!.*brit).*honduras",HKG:"hong.?kong",HUN:"^(?!.*austr).*hungary",ISL:"iceland",IND:"india(?!.*ocea)",IDN:"indonesia",IRN:"\\biran|persia",IRQ:"\\biraq|mesopotamia",IRL:"(^ireland)|(^republic.*ireland)",IMN:"^(?=.*isle).*\\bman",ISR:"israel",ITA:"italy",JAM:"jamaica",JPN:"japan",JEY:"jersey",JOR:"jordan",KAZ:"kazak",KEN:"kenya|british.?east.?africa|east.?africa.?prot",KIR:"kiribati",PRK:"^(?=.*democrat|people|north|d.*p.*.r).*\\bkorea|dprk|korea.*(d.*p.*r)",KWT:"kuwait",KGZ:"kyrgyz|kirghiz",LAO:"\\blaos?\\b",LVA:"latvia",LBN:"lebanon",LSO:"lesotho|basuto",LBR:"liberia",LBY:"libya",LIE:"liechtenstein",LTU:"lithuania",LUX:"^(?!.*belg).*luxem",MAC:"maca(o|u)",MDG:"madagascar|malagasy",MWI:"malawi|nyasa",MYS:"malaysia",MDV:"maldive",MLI:"\\bmali\\b",MLT:"\\bmalta",MHL:"marshall",MTQ:"martinique",MRT:"mauritania",MUS:"mauritius",MYT:"\\bmayotte",MEX:"\\bmexic",FSM:"fed.*micronesia|micronesia.*fed",MCO:"monaco",MNG:"mongolia",MNE:"^(?!.*serbia).*montenegro",MSR:"montserrat",MAR:"morocco|\\bmaroc",MOZ:"mozambique",MMR:"myanmar|burma",NAM:"namibia",NRU:"nauru",NPL:"nepal",NLD:"^(?!.*\\bant)(?!.*\\bcarib).*netherlands",ANT:"^(?=.*\\bant).*(nether|dutch)",NCL:"new.?caledonia",NZL:"new.?zealand",NIC:"nicaragua",NER:"\\bniger(?!ia)",NGA:"nigeria",NIU:"niue",NFK:"norfolk",MNP:"mariana",NOR:"norway",OMN:"\\boman|trucial",PAK:"^(?!.*east).*paki?stan",PLW:"palau",PSE:"palestin|\\bgaza|west.?bank",PAN:"panama",PNG:"papua|new.?guinea",PRY:"paraguay",PER:"peru",PHL:"philippines",PCN:"pitcairn",POL:"poland",PRT:"portugal",PRI:"puerto.?rico",QAT:"qatar",KOR:"^(?!.*d.*p.*r)(?!.*democrat)(?!.*people)(?!.*north).*\\bkorea(?!.*d.*p.*r)",MDA:"moldov|b(a|e)ssarabia",REU:"r(e|\xe9)union",ROU:"r(o|u|ou)mania",RUS:"\\brussia|soviet.?union|u\\.?s\\.?s\\.?r|socialist.?republics",RWA:"rwanda",BLM:"barth(e|\xe9)lemy",SHN:"helena",KNA:"kitts|\\bnevis",LCA:"\\blucia",MAF:"^(?=.*collectivity).*martin|^(?=.*france).*martin(?!ique)|^(?=.*french).*martin(?!ique)",SPM:"miquelon",VCT:"vincent",WSM:"^(?!.*amer).*samoa",SMR:"san.?marino",STP:"\\bs(a|\xe3)o.?tom(e|\xe9)",SAU:"\\bsa\\w*.?arabia",SEN:"senegal",SRB:"^(?!.*monte).*serbia",SYC:"seychell",SLE:"sierra",SGP:"singapore",SXM:"^(?!.*martin)(?!.*saba).*maarten",SVK:"^(?!.*cze).*slovak",SVN:"slovenia",SLB:"solomon",SOM:"somali",ZAF:"south.africa|s\\\\..?africa",SGS:"south.?georgia|sandwich",SSD:"\\bs\\w*.?sudan",ESP:"spain",LKA:"sri.?lanka|ceylon",SDN:"^(?!.*\\bs(?!u)).*sudan",SUR:"surinam|dutch.?guiana",SJM:"svalbard",SWZ:"swaziland",SWE:"sweden",CHE:"switz|swiss",SYR:"syria",TWN:"taiwan|taipei|formosa|^(?!.*peo)(?=.*rep).*china",TJK:"tajik",THA:"thailand|\\bsiam",MKD:"macedonia|fyrom",TLS:"^(?=.*leste).*timor|^(?=.*east).*timor",TGO:"togo",TKL:"tokelau",TON:"tonga",TTO:"trinidad|tobago",TUN:"tunisia",TUR:"turkey",TKM:"turkmen",TCA:"turks",TUV:"tuvalu",UGA:"uganda",UKR:"ukrain",ARE:"emirates|^u\\.?a\\.?e\\.?$|united.?arab.?em",GBR:"united.?kingdom|britain|^u\\.?k\\.?$",TZA:"tanzania",USA:"united.?states\\b(?!.*islands)|\\bu\\.?s\\.?a\\.?\\b|^\\s*u\\.?s\\.?\\b(?!.*islands)",UMI:"minor.?outlying.?is",URY:"uruguay",UZB:"uzbek",VUT:"vanuatu|new.?hebrides",VEN:"venezuela",VNM:"^(?!.*republic).*viet.?nam|^(?=.*socialist).*viet.?nam",VGB:"^(?=.*\\bu\\.?\\s?k).*virgin|^(?=.*brit).*virgin|^(?=.*kingdom).*virgin",VIR:"^(?=.*\\bu\\.?\\s?s).*virgin|^(?=.*states).*virgin",WLF:"futuna|wallis",ESH:"western.sahara",YEM:"^(?!.*arab)(?!.*north)(?!.*sana)(?!.*peo)(?!.*dem)(?!.*south)(?!.*aden)(?!.*\\bp\\.?d\\.?r).*yemen",YMD:"^(?=.*peo).*yemen|^(?!.*rep)(?=.*dem).*yemen|^(?=.*south).*yemen|^(?=.*aden).*yemen|^(?=.*\\bp\\.?d\\.?r).*yemen",YUG:"yugoslavia",ZMB:"zambia|northern.?rhodesia",EAZ:"zanzibar",ZWE:"zimbabwe|^(?!.*northern).*rhodesia"}},{}],116:[function(t,e,r){"use strict";e.exports=function(t,e,r,n,i,a){var o=i-1,s=i*i,l=o*o,c=(1+2*i)*l,u=i*l,f=s*(3-2*i),h=s*o;if(t.length){a||(a=new Array(t.length));for(var p=t.length-1;p>=0;--p)a[p]=c*t[p]+u*e[p]+f*r[p]+h*n[p];return a}return c*t+u*e+f*r+h*n},e.exports.derivative=function(t,e,r,n,i,a){var o=6*i*i-6*i,s=3*i*i-4*i+1,l=-6*i*i+6*i,c=3*i*i-2*i;if(t.length){a||(a=new Array(t.length));for(var u=t.length-1;u>=0;--u)a[u]=o*t[u]+s*e[u]+l*r[u]+c*n[u];return a}return o*t+s*e+l*r[u]+c*n}},{}],117:[function(t,e,r){"use strict";var n=t("./lib/thunk.js");function i(){this.argTypes=[],this.shimArgs=[],this.arrayArgs=[],this.arrayBlockIndices=[],this.scalarArgs=[],this.offsetArgs=[],this.offsetArgIndex=[],this.indexArgs=[],this.shapeArgs=[],this.funcName="",this.pre=null,this.body=null,this.post=null,this.debug=!1}e.exports=function(t){var e=new i;e.pre=t.pre,e.body=t.body,e.post=t.post;var r=t.args.slice(0);e.argTypes=r;for(var a=0;a0)throw new Error("cwise: pre() block may not reference array args");if(a0)throw new Error("cwise: post() block may not reference array args")}else if("scalar"===o)e.scalarArgs.push(a),e.shimArgs.push("scalar"+a);else if("index"===o){if(e.indexArgs.push(a),a0)throw new Error("cwise: pre() block may not reference array index");if(a0)throw new Error("cwise: post() block may not reference array index")}else if("shape"===o){if(e.shapeArgs.push(a),ar.length)throw new Error("cwise: Too many arguments in pre() block");if(e.body.args.length>r.length)throw new Error("cwise: Too many arguments in body() block");if(e.post.args.length>r.length)throw new Error("cwise: Too many arguments in post() block");return e.debug=!!t.printCode||!!t.debug,e.funcName=t.funcName||"cwise",e.blockSize=t.blockSize||64,n(e)}},{"./lib/thunk.js":119}],118:[function(t,e,r){"use strict";var n=t("uniq");function i(t,e,r){var n,i,a=t.length,o=e.arrayArgs.length,s=e.indexArgs.length>0,l=[],c=[],u=0,f=0;for(n=0;n0&&l.push("var "+c.join(",")),n=a-1;n>=0;--n)u=t[n],l.push(["for(i",n,"=0;i",n,"0&&l.push(["index[",f,"]-=s",f].join("")),l.push(["++index[",u,"]"].join(""))),l.push("}")}return l.join("\n")}function a(t,e,r){for(var n=t.body,i=[],a=[],o=0;o0&&y.push("shape=SS.slice(0)"),t.indexArgs.length>0){var x=new Array(r);for(l=0;l0&&v.push("var "+y.join(",")),l=0;l3&&v.push(a(t.pre,t,s));var k=a(t.body,t,s),M=function(t){for(var e=0,r=t[0].length;e0,c=[],u=0;u0;){"].join("")),c.push(["if(j",u,"<",s,"){"].join("")),c.push(["s",e[u],"=j",u].join("")),c.push(["j",u,"=0"].join("")),c.push(["}else{s",e[u],"=",s].join("")),c.push(["j",u,"-=",s,"}"].join("")),l&&c.push(["index[",e[u],"]=j",u].join(""));for(u=0;u3&&v.push(a(t.post,t,s)),t.debug&&console.log("-----Generated cwise routine for ",e,":\n"+v.join("\n")+"\n----------");var A=[t.funcName||"unnamed","_cwise_loop_",o[0].join("s"),"m",M,function(t){for(var e=new Array(t.length),r=!0,n=0;n0&&(r=r&&e[n]===e[n-1])}return r?e[0]:e.join("")}(s)].join("");return new Function(["function ",A,"(",m.join(","),"){",v.join("\n"),"} return ",A].join(""))()}},{uniq:483}],119:[function(t,e,r){"use strict";var n=t("./compile.js");e.exports=function(t){var e=["'use strict'","var CACHED={}"],r=[],i=t.funcName+"_cwise_thunk";e.push(["return function ",i,"(",t.shimArgs.join(","),"){"].join(""));for(var a=[],o=[],s=[["array",t.arrayArgs[0],".shape.slice(",Math.max(0,t.arrayBlockIndices[0]),t.arrayBlockIndices[0]<0?","+t.arrayBlockIndices[0]+")":")"].join("")],l=[],c=[],u=0;u0&&(l.push("array"+t.arrayArgs[0]+".shape.length===array"+f+".shape.length+"+(Math.abs(t.arrayBlockIndices[0])-Math.abs(t.arrayBlockIndices[u]))),c.push("array"+t.arrayArgs[0]+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[0])+"]===array"+f+".shape[shapeIndex+"+Math.max(0,t.arrayBlockIndices[u])+"]"))}for(t.arrayArgs.length>1&&(e.push("if (!("+l.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same dimensionality!')"),e.push("for(var shapeIndex=array"+t.arrayArgs[0]+".shape.length-"+Math.abs(t.arrayBlockIndices[0])+"; shapeIndex--\x3e0;) {"),e.push("if (!("+c.join(" && ")+")) throw new Error('cwise: Arrays do not all have the same shape!')"),e.push("}")),u=0;ue?1:t>=e?0:NaN},r=function(t){var r;return 1===t.length&&(r=t,t=function(t,n){return e(r(t),n)}),{left:function(e,r,n,i){for(null==n&&(n=0),null==i&&(i=e.length);n>>1;t(e[a],r)<0?n=a+1:i=a}return n},right:function(e,r,n,i){for(null==n&&(n=0),null==i&&(i=e.length);n>>1;t(e[a],r)>0?i=a:n=a+1}return n}}};var n=r(e),i=n.right,a=n.left;function o(t,e){return[t,e]}var s=function(t){return null===t?NaN:+t},l=function(t,e){var r,n,i=t.length,a=0,o=-1,l=0,c=0;if(null==e)for(;++o1)return c/(a-1)},c=function(t,e){var r=l(t,e);return r?Math.sqrt(r):r},u=function(t,e){var r,n,i,a=t.length,o=-1;if(null==e){for(;++o=r)for(n=i=r;++or&&(n=r),i=r)for(n=i=r;++or&&(n=r),i=0?(a>=v?10:a>=y?5:a>=x?2:1)*Math.pow(10,i):-Math.pow(10,-i)/(a>=v?10:a>=y?5:a>=x?2:1)}function _(t,e,r){var n=Math.abs(e-t)/Math.max(0,r),i=Math.pow(10,Math.floor(Math.log(n)/Math.LN10)),a=n/i;return a>=v?i*=10:a>=y?i*=5:a>=x&&(i*=2),e=1)return+r(t[n-1],n-1,t);var n,i=(n-1)*e,a=Math.floor(i),o=+r(t[a],a,t);return o+(+r(t[a+1],a+1,t)-o)*(i-a)}},M=function(t,e){var r,n,i=t.length,a=-1;if(null==e){for(;++a=r)for(n=r;++ar&&(n=r)}else for(;++a=r)for(n=r;++ar&&(n=r);return n},A=function(t){if(!(i=t.length))return[];for(var e=-1,r=M(t,T),n=new Array(r);++et?1:e>=t?0:NaN},t.deviation=c,t.extent=u,t.histogram=function(){var t=g,e=u,r=w;function n(n){var a,o,s=n.length,l=new Array(s);for(a=0;af;)h.pop(),--p;var d,g=new Array(p+1);for(a=0;a<=p;++a)(d=g[a]=[]).x0=a>0?h[a-1]:u,d.x1=a=r)for(n=r;++an&&(n=r)}else for(;++a=r)for(n=r;++an&&(n=r);return n},t.mean=function(t,e){var r,n=t.length,i=n,a=-1,o=0;if(null==e)for(;++a=0;)for(e=(n=t[i]).length;--e>=0;)r[--o]=n[e];return r},t.min=M,t.pairs=function(t,e){null==e&&(e=o);for(var r=0,n=t.length-1,i=t[0],a=new Array(n<0?0:n);r0)return[t];if((n=e0)for(t=Math.ceil(t/o),e=Math.floor(e/o),a=new Array(i=Math.ceil(e-t+1));++s=l.length)return null!=t&&n.sort(t),null!=e?e(n):n;for(var s,c,f,h=-1,p=n.length,d=l[i++],g=r(),m=a();++hl.length)return r;var i,a=c[n-1];return null!=e&&n>=l.length?i=r.entries():(i=[],r.each(function(e,r){i.push({key:r,values:t(e,n)})})),null!=a?i.sort(function(t,e){return a(t.key,e.key)}):i}(u(t,0,a,o),0)},key:function(t){return l.push(t),s},sortKeys:function(t){return c[l.length-1]=t,s},sortValues:function(e){return t=e,s},rollup:function(t){return e=t,s}}},t.set=c,t.map=r,t.keys=function(t){var e=[];for(var r in t)e.push(r);return e},t.values=function(t){var e=[];for(var r in t)e.push(t[r]);return e},t.entries=function(t){var e=[];for(var r in t)e.push({key:r,value:t[r]});return e},Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],125:[function(t,e,r){var n;n=this,function(t){"use strict";var e=function(t,e,r){t.prototype=e.prototype=r,r.constructor=t};function r(t,e){var r=Object.create(t.prototype);for(var n in e)r[n]=e[n];return r}function n(){}var i="\\s*([+-]?\\d+)\\s*",a="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",o="\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",s=/^#([0-9a-f]{3})$/,l=/^#([0-9a-f]{6})$/,c=new RegExp("^rgb\\("+[i,i,i]+"\\)$"),u=new RegExp("^rgb\\("+[o,o,o]+"\\)$"),f=new RegExp("^rgba\\("+[i,i,i,a]+"\\)$"),h=new RegExp("^rgba\\("+[o,o,o,a]+"\\)$"),p=new RegExp("^hsl\\("+[a,o,o]+"\\)$"),d=new RegExp("^hsla\\("+[a,o,o,a]+"\\)$"),g={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function m(t){var e;return t=(t+"").trim().toLowerCase(),(e=s.exec(t))?new _((e=parseInt(e[1],16))>>8&15|e>>4&240,e>>4&15|240&e,(15&e)<<4|15&e,1):(e=l.exec(t))?v(parseInt(e[1],16)):(e=c.exec(t))?new _(e[1],e[2],e[3],1):(e=u.exec(t))?new _(255*e[1]/100,255*e[2]/100,255*e[3]/100,1):(e=f.exec(t))?y(e[1],e[2],e[3],e[4]):(e=h.exec(t))?y(255*e[1]/100,255*e[2]/100,255*e[3]/100,e[4]):(e=p.exec(t))?w(e[1],e[2]/100,e[3]/100,1):(e=d.exec(t))?w(e[1],e[2]/100,e[3]/100,e[4]):g.hasOwnProperty(t)?v(g[t]):"transparent"===t?new _(NaN,NaN,NaN,0):null}function v(t){return new _(t>>16&255,t>>8&255,255&t,1)}function y(t,e,r,n){return n<=0&&(t=e=r=NaN),new _(t,e,r,n)}function x(t){return t instanceof n||(t=m(t)),t?new _((t=t.rgb()).r,t.g,t.b,t.opacity):new _}function b(t,e,r,n){return 1===arguments.length?x(t):new _(t,e,r,null==n?1:n)}function _(t,e,r,n){this.r=+t,this.g=+e,this.b=+r,this.opacity=+n}function w(t,e,r,n){return n<=0?t=e=r=NaN:r<=0||r>=1?t=e=NaN:e<=0&&(t=NaN),new M(t,e,r,n)}function k(t,e,r,i){return 1===arguments.length?function(t){if(t instanceof M)return new M(t.h,t.s,t.l,t.opacity);if(t instanceof n||(t=m(t)),!t)return new M;if(t instanceof M)return t;var e=(t=t.rgb()).r/255,r=t.g/255,i=t.b/255,a=Math.min(e,r,i),o=Math.max(e,r,i),s=NaN,l=o-a,c=(o+a)/2;return l?(s=e===o?(r-i)/l+6*(r0&&c<1?0:s,new M(s,l,c,t.opacity)}(t):new M(t,e,r,null==i?1:i)}function M(t,e,r,n){this.h=+t,this.s=+e,this.l=+r,this.opacity=+n}function A(t,e,r){return 255*(t<60?e+(r-e)*t/60:t<180?r:t<240?e+(r-e)*(240-t)/60:e)}e(n,m,{displayable:function(){return this.rgb().displayable()},toString:function(){return this.rgb()+""}}),e(_,b,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new _(this.r*t,this.g*t,this.b*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new _(this.r*t,this.g*t,this.b*t,this.opacity)},rgb:function(){return this},displayable:function(){return 0<=this.r&&this.r<=255&&0<=this.g&&this.g<=255&&0<=this.b&&this.b<=255&&0<=this.opacity&&this.opacity<=1},toString:function(){var t=this.opacity;return(1===(t=isNaN(t)?1:Math.max(0,Math.min(1,t)))?"rgb(":"rgba(")+Math.max(0,Math.min(255,Math.round(this.r)||0))+", "+Math.max(0,Math.min(255,Math.round(this.g)||0))+", "+Math.max(0,Math.min(255,Math.round(this.b)||0))+(1===t?")":", "+t+")")}})),e(M,k,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new M(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new M(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=this.h%360+360*(this.h<0),e=isNaN(t)||isNaN(this.s)?0:this.s,r=this.l,n=r+(r<.5?r:1-r)*e,i=2*r-n;return new _(A(t>=240?t-240:t+120,i,n),A(t,i,n),A(t<120?t+240:t-120,i,n),this.opacity)},displayable:function(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1}}));var T=Math.PI/180,S=180/Math.PI,C=.95047,E=1,L=1.08883,z=4/29,P=6/29,D=3*P*P,O=P*P*P;function I(t){if(t instanceof B)return new B(t.l,t.a,t.b,t.opacity);if(t instanceof q){var e=t.h*T;return new B(t.l,Math.cos(e)*t.c,Math.sin(e)*t.c,t.opacity)}t instanceof _||(t=x(t));var r=V(t.r),n=V(t.g),i=V(t.b),a=F((.4124564*r+.3575761*n+.1804375*i)/C),o=F((.2126729*r+.7151522*n+.072175*i)/E);return new B(116*o-16,500*(a-o),200*(o-F((.0193339*r+.119192*n+.9503041*i)/L)),t.opacity)}function R(t,e,r,n){return 1===arguments.length?I(t):new B(t,e,r,null==n?1:n)}function B(t,e,r,n){this.l=+t,this.a=+e,this.b=+r,this.opacity=+n}function F(t){return t>O?Math.pow(t,1/3):t/D+z}function N(t){return t>P?t*t*t:D*(t-z)}function j(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function V(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function U(t,e,r,n){return 1===arguments.length?function(t){if(t instanceof q)return new q(t.h,t.c,t.l,t.opacity);t instanceof B||(t=I(t));var e=Math.atan2(t.b,t.a)*S;return new q(e<0?e+360:e,Math.sqrt(t.a*t.a+t.b*t.b),t.l,t.opacity)}(t):new q(t,e,r,null==n?1:n)}function q(t,e,r,n){this.h=+t,this.c=+e,this.l=+r,this.opacity=+n}e(B,R,r(n,{brighter:function(t){return new B(this.l+18*(null==t?1:t),this.a,this.b,this.opacity)},darker:function(t){return new B(this.l-18*(null==t?1:t),this.a,this.b,this.opacity)},rgb:function(){var t=(this.l+16)/116,e=isNaN(this.a)?t:t+this.a/500,r=isNaN(this.b)?t:t-this.b/200;return t=E*N(t),new _(j(3.2404542*(e=C*N(e))-1.5371385*t-.4985314*(r=L*N(r))),j(-.969266*e+1.8760108*t+.041556*r),j(.0556434*e-.2040259*t+1.0572252*r),this.opacity)}})),e(q,U,r(n,{brighter:function(t){return new q(this.h,this.c,this.l+18*(null==t?1:t),this.opacity)},darker:function(t){return new q(this.h,this.c,this.l-18*(null==t?1:t),this.opacity)},rgb:function(){return I(this).rgb()}}));var H=-.14861,G=1.78277,W=-.29227,Y=-.90649,X=1.97294,Z=X*Y,J=X*G,K=G*W-Y*H;function Q(t,e,r,n){return 1===arguments.length?function(t){if(t instanceof $)return new $(t.h,t.s,t.l,t.opacity);t instanceof _||(t=x(t));var e=t.r/255,r=t.g/255,n=t.b/255,i=(K*n+Z*e-J*r)/(K+Z-J),a=n-i,o=(X*(r-i)-W*a)/Y,s=Math.sqrt(o*o+a*a)/(X*i*(1-i)),l=s?Math.atan2(o,a)*S-120:NaN;return new $(l<0?l+360:l,s,i,t.opacity)}(t):new $(t,e,r,null==n?1:n)}function $(t,e,r,n){this.h=+t,this.s=+e,this.l=+r,this.opacity=+n}e($,Q,r(n,{brighter:function(t){return t=null==t?1/.7:Math.pow(1/.7,t),new $(this.h,this.s,this.l*t,this.opacity)},darker:function(t){return t=null==t?.7:Math.pow(.7,t),new $(this.h,this.s,this.l*t,this.opacity)},rgb:function(){var t=isNaN(this.h)?0:(this.h+120)*T,e=+this.l,r=isNaN(this.s)?0:this.s*e*(1-e),n=Math.cos(t),i=Math.sin(t);return new _(255*(e+r*(H*n+G*i)),255*(e+r*(W*n+Y*i)),255*(e+r*(X*n)),this.opacity)}})),t.color=m,t.rgb=b,t.hsl=k,t.lab=R,t.hcl=U,t.cubehelix=Q,Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],126:[function(t,e,r){var n;n=this,function(t){"use strict";var e={value:function(){}};function r(){for(var t,e=0,r=arguments.length,i={};e=0&&(e=t.slice(r+1),t=t.slice(0,r)),t&&!n.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:e}})),l=-1,c=s.length;if(!(arguments.length<2)){if(null!=e&&"function"!=typeof e)throw new Error("invalid callback: "+e);for(;++l0)for(var r,n,i=new Array(r),a=0;ah+c||np+c||au.index){var f=h-s.x-s.vx,m=p-s.y-s.vy,v=f*f+m*m;vt.r&&(t.r=t[e].r)}function h(){if(r){var e,i,a=r.length;for(n=new Array(a),e=0;e=c)){(t.data!==r||t.next)&&(0===f&&(d+=(f=o())*f),0===h&&(d+=(h=o())*h),d1?(null==r?u.remove(t):u.set(t,y(r)),e):u.get(t)},find:function(e,r,n){var i,a,o,s,l,c=0,u=t.length;for(null==n?n=1/0:n*=n,c=0;c1?(h.on(t,r),e):h.on(t)}}},t.forceX=function(t){var e,r,n,i=a(.1);function o(t){for(var i,a=0,o=e.length;a=1?(n=1,e-1):Math.floor(n*e),a=t[i],o=t[i+1],s=i>0?t[i-1]:2*a-o,l=i180||r<-180?r-360*Math.round(r/360):r):a(isNaN(t)?e:t)}function l(t){return 1==(t=+t)?c:function(e,r){return r-e?function(t,e,r){return t=Math.pow(t,r),e=Math.pow(e,r)-t,r=1/r,function(n){return Math.pow(t+n*e,r)}}(e,r,t):a(isNaN(e)?r:e)}}function c(t,e){var r=e-t;return r?o(t,r):a(isNaN(t)?e:t)}var u=function t(r){var n=l(r);function i(t,r){var i=n((t=e.rgb(t)).r,(r=e.rgb(r)).r),a=n(t.g,r.g),o=n(t.b,r.b),s=c(t.opacity,r.opacity);return function(e){return t.r=i(e),t.g=a(e),t.b=o(e),t.opacity=s(e),t+""}}return i.gamma=t,i}(1);function f(t){return function(r){var n,i,a=r.length,o=new Array(a),s=new Array(a),l=new Array(a);for(n=0;na&&(i=e.slice(a,i),s[o]?s[o]+=i:s[++o]=i),(r=r[0])===(n=n[0])?s[o]?s[o]+=n:s[++o]=n:(s[++o]=null,l.push({i:o,x:m(r,n)})),a=x.lastIndex;return a180?e+=360:e-t>180&&(t+=360),a.push({i:r.push(i(r)+"rotate(",null,n)-2,x:m(t,e)})):e&&r.push(i(r)+"rotate("+e+n)}(a.rotate,o.rotate,s,l),function(t,e,r,a){t!==e?a.push({i:r.push(i(r)+"skewX(",null,n)-2,x:m(t,e)}):e&&r.push(i(r)+"skewX("+e+n)}(a.skewX,o.skewX,s,l),function(t,e,r,n,a,o){if(t!==r||e!==n){var s=a.push(i(a)+"scale(",null,",",null,")");o.push({i:s-4,x:m(t,r)},{i:s-2,x:m(e,n)})}else 1===r&&1===n||a.push(i(a)+"scale("+r+","+n+")")}(a.scaleX,a.scaleY,o.scaleX,o.scaleY,s,l),a=o=null,function(t){for(var e,r=-1,n=l.length;++r=(a=(g+v)/2))?g=a:v=a,(u=r>=(o=(m+y)/2))?m=o:y=o,i=p,!(p=p[f=u<<1|c]))return i[f]=d,t;if(s=+t._x.call(null,p.data),l=+t._y.call(null,p.data),e===s&&r===l)return d.next=p,i?i[f]=d:t._root=d,t;do{i=i?i[f]=new Array(4):t._root=new Array(4),(c=e>=(a=(g+v)/2))?g=a:v=a,(u=r>=(o=(m+y)/2))?m=o:y=o}while((f=u<<1|c)==(h=(l>=o)<<1|s>=a));return i[h]=p,i[f]=d,t}var r=function(t,e,r,n,i){this.node=t,this.x0=e,this.y0=r,this.x1=n,this.y1=i};function n(t){return t[0]}function i(t){return t[1]}function a(t,e,r){var a=new o(null==e?n:e,null==r?i:r,NaN,NaN,NaN,NaN);return null==t?a:a.addAll(t)}function o(t,e,r,n,i,a){this._x=t,this._y=e,this._x0=r,this._y0=n,this._x1=i,this._y1=a,this._root=void 0}function s(t){for(var e={data:t.data},r=e;t=t.next;)r=r.next={data:t.data};return e}var l=a.prototype=o.prototype;l.copy=function(){var t,e,r=new o(this._x,this._y,this._x0,this._y0,this._x1,this._y1),n=this._root;if(!n)return r;if(!n.length)return r._root=s(n),r;for(t=[{source:n,target:r._root=new Array(4)}];n=t.pop();)for(var i=0;i<4;++i)(e=n.source[i])&&(e.length?t.push({source:e,target:n.target[i]=new Array(4)}):n.target[i]=s(e));return r},l.add=function(t){var r=+this._x.call(null,t),n=+this._y.call(null,t);return e(this.cover(r,n),r,n,t)},l.addAll=function(t){var r,n,i,a,o=t.length,s=new Array(o),l=new Array(o),c=1/0,u=1/0,f=-1/0,h=-1/0;for(n=0;nf&&(f=i),ah&&(h=a));for(ft||t>i||n>e||e>a))return this;var o,s,l=i-r,c=this._root;switch(s=(e<(n+a)/2)<<1|t<(r+i)/2){case 0:do{(o=new Array(4))[s]=c,c=o}while(a=n+(l*=2),t>(i=r+l)||e>a);break;case 1:do{(o=new Array(4))[s]=c,c=o}while(a=n+(l*=2),(r=i-l)>t||e>a);break;case 2:do{(o=new Array(4))[s]=c,c=o}while(n=a-(l*=2),t>(i=r+l)||n>e);break;case 3:do{(o=new Array(4))[s]=c,c=o}while(n=a-(l*=2),(r=i-l)>t||n>e)}this._root&&this._root.length&&(this._root=c)}return this._x0=r,this._y0=n,this._x1=i,this._y1=a,this},l.data=function(){var t=[];return this.visit(function(e){if(!e.length)do{t.push(e.data)}while(e=e.next)}),t},l.extent=function(t){return arguments.length?this.cover(+t[0][0],+t[0][1]).cover(+t[1][0],+t[1][1]):isNaN(this._x0)?void 0:[[this._x0,this._y0],[this._x1,this._y1]]},l.find=function(t,e,n){var i,a,o,s,l,c,u,f=this._x0,h=this._y0,p=this._x1,d=this._y1,g=[],m=this._root;for(m&&g.push(new r(m,f,h,p,d)),null==n?n=1/0:(f=t-n,h=e-n,p=t+n,d=e+n,n*=n);c=g.pop();)if(!(!(m=c.node)||(a=c.x0)>p||(o=c.y0)>d||(s=c.x1)=y)<<1|t>=v)&&(c=g[g.length-1],g[g.length-1]=g[g.length-1-u],g[g.length-1-u]=c)}else{var x=t-+this._x.call(null,m.data),b=e-+this._y.call(null,m.data),_=x*x+b*b;if(_=(s=(d+m)/2))?d=s:m=s,(u=o>=(l=(g+v)/2))?g=l:v=l,e=p,!(p=p[f=u<<1|c]))return this;if(!p.length)break;(e[f+1&3]||e[f+2&3]||e[f+3&3])&&(r=e,h=f)}for(;p.data!==t;)if(n=p,!(p=p.next))return this;return(i=p.next)&&delete p.next,n?(i?n.next=i:delete n.next,this):e?(i?e[f]=i:delete e[f],(p=e[0]||e[1]||e[2]||e[3])&&p===(e[3]||e[2]||e[1]||e[0])&&!p.length&&(r?r[h]=p:this._root=p),this):(this._root=i,this)},l.removeAll=function(t){for(var e=0,r=t.length;e=0&&r._call.call(null,t),r=r._next;--n}function v(){l=(s=u.now())+c,n=i=0;try{m()}finally{n=0,function(){var t,n,i=e,a=1/0;for(;i;)i._call?(a>i._time&&(a=i._time),t=i,i=i._next):(n=i._next,i._next=null,i=t?t._next=n:e=n);r=t,x(a)}(),l=0}}function y(){var t=u.now(),e=t-s;e>o&&(c-=e,s=t)}function x(t){n||(i&&(i=clearTimeout(i)),t-l>24?(t<1/0&&(i=setTimeout(v,t-u.now()-c)),a&&(a=clearInterval(a))):(a||(s=u.now(),a=setInterval(y,o)),n=1,f(v)))}d.prototype=g.prototype={constructor:d,restart:function(t,n,i){if("function"!=typeof t)throw new TypeError("callback is not a function");i=(null==i?h():+i)+(null==n?0:+n),this._next||r===this||(r?r._next=this:e=this,r=this),this._call=t,this._time=i,x()},stop:function(){this._call&&(this._call=null,this._time=1/0,x())}};t.now=h,t.timer=g,t.timerFlush=m,t.timeout=function(t,e,r){var n=new d;return e=null==e?0:+e,n.restart(function(r){n.stop(),t(r+e)},e,r),n},t.interval=function(t,e,r){var n=new d,i=e;return null==e?(n.restart(t,e,r),n):(e=+e,r=null==r?h():+r,n.restart(function a(o){o+=i,n.restart(a,i+=e,r),t(o)},e,r),n)},Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.d3=n.d3||{})},{}],131:[function(t,e,r){!function(){var t={version:"3.5.17"},r=[].slice,n=function(t){return r.call(t)},i=this.document;function a(t){return t&&(t.ownerDocument||t.document||t).documentElement}function o(t){return t&&(t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView)}if(i)try{n(i.documentElement.childNodes)[0].nodeType}catch(t){n=function(t){for(var e=t.length,r=new Array(e);e--;)r[e]=t[e];return r}}if(Date.now||(Date.now=function(){return+new Date}),i)try{i.createElement("DIV").style.setProperty("opacity",0,"")}catch(t){var s=this.Element.prototype,l=s.setAttribute,c=s.setAttributeNS,u=this.CSSStyleDeclaration.prototype,f=u.setProperty;s.setAttribute=function(t,e){l.call(this,t,e+"")},s.setAttributeNS=function(t,e,r){c.call(this,t,e,r+"")},u.setProperty=function(t,e,r){f.call(this,t,e+"",r)}}function h(t,e){return te?1:t>=e?0:NaN}function p(t){return null===t?NaN:+t}function d(t){return!isNaN(t)}function g(t){return{left:function(e,r,n,i){for(arguments.length<3&&(n=0),arguments.length<4&&(i=e.length);n>>1;t(e[a],r)<0?n=a+1:i=a}return n},right:function(e,r,n,i){for(arguments.length<3&&(n=0),arguments.length<4&&(i=e.length);n>>1;t(e[a],r)>0?i=a:n=a+1}return n}}}t.ascending=h,t.descending=function(t,e){return et?1:e>=t?0:NaN},t.min=function(t,e){var r,n,i=-1,a=t.length;if(1===arguments.length){for(;++i=n){r=n;break}for(;++in&&(r=n)}else{for(;++i=n){r=n;break}for(;++in&&(r=n)}return r},t.max=function(t,e){var r,n,i=-1,a=t.length;if(1===arguments.length){for(;++i=n){r=n;break}for(;++ir&&(r=n)}else{for(;++i=n){r=n;break}for(;++ir&&(r=n)}return r},t.extent=function(t,e){var r,n,i,a=-1,o=t.length;if(1===arguments.length){for(;++a=n){r=i=n;break}for(;++an&&(r=n),i=n){r=i=n;break}for(;++an&&(r=n),i1)return o/(l-1)},t.deviation=function(){var e=t.variance.apply(this,arguments);return e?Math.sqrt(e):e};var m=g(h);function v(t){return t.length}t.bisectLeft=m.left,t.bisect=t.bisectRight=m.right,t.bisector=function(t){return g(1===t.length?function(e,r){return h(t(e),r)}:t)},t.shuffle=function(t,e,r){(a=arguments.length)<3&&(r=t.length,a<2&&(e=0));for(var n,i,a=r-e;a;)i=Math.random()*a--|0,n=t[a+e],t[a+e]=t[i+e],t[i+e]=n;return t},t.permute=function(t,e){for(var r=e.length,n=new Array(r);r--;)n[r]=t[e[r]];return n},t.pairs=function(t){for(var e=0,r=t.length-1,n=t[0],i=new Array(r<0?0:r);e=0;)for(e=(n=t[i]).length;--e>=0;)r[--o]=n[e];return r};var y=Math.abs;function x(t,e){for(var r in e)Object.defineProperty(t.prototype,r,{value:e[r],enumerable:!1})}function b(){this._=Object.create(null)}t.range=function(t,e,r){if(arguments.length<3&&(r=1,arguments.length<2&&(e=t,t=0)),(e-t)/r==1/0)throw new Error("infinite range");var n,i=[],a=function(t){var e=1;for(;t*e%1;)e*=10;return e}(y(r)),o=-1;if(t*=a,e*=a,(r*=a)<0)for(;(n=t+r*++o)>e;)i.push(n/a);else for(;(n=t+r*++o)=i.length)return r?r.call(n,a):e?a.sort(e):a;for(var l,c,u,f,h=-1,p=a.length,d=i[s++],g=new b;++h=i.length)return e;var n=[],o=a[r++];return e.forEach(function(e,i){n.push({key:e,values:t(i,r)})}),o?n.sort(function(t,e){return o(t.key,e.key)}):n}(o(t.map,e,0),0)},n.key=function(t){return i.push(t),n},n.sortKeys=function(t){return a[i.length-1]=t,n},n.sortValues=function(t){return e=t,n},n.rollup=function(t){return r=t,n},n},t.set=function(t){var e=new L;if(t)for(var r=0,n=t.length;r=0&&(n=t.slice(r+1),t=t.slice(0,r)),t)return arguments.length<2?this[t].on(n):this[t].on(n,e);if(2===arguments.length){if(null==e)for(t in this)this.hasOwnProperty(t)&&this[t].on(n,null);return this}},t.event=null,t.requote=function(t){return t.replace(V,"\\$&")};var V=/[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g,U={}.__proto__?function(t,e){t.__proto__=e}:function(t,e){for(var r in e)t[r]=e[r]};function q(t){return U(t,Y),t}var H=function(t,e){return e.querySelector(t)},G=function(t,e){return e.querySelectorAll(t)},W=function(t,e){var r=t.matches||t[D(t,"matchesSelector")];return(W=function(t,e){return r.call(t,e)})(t,e)};"function"==typeof Sizzle&&(H=function(t,e){return Sizzle(t,e)[0]||null},G=Sizzle,W=Sizzle.matchesSelector),t.selection=function(){return t.select(i.documentElement)};var Y=t.selection.prototype=[];function X(t){return"function"==typeof t?t:function(){return H(t,this)}}function Z(t){return"function"==typeof t?t:function(){return G(t,this)}}Y.select=function(t){var e,r,n,i,a=[];t=X(t);for(var o=-1,s=this.length;++o=0&&"xmlns"!==(r=t.slice(0,e))&&(t=t.slice(e+1)),K.hasOwnProperty(r)?{space:K[r],local:t}:t}},Y.attr=function(e,r){if(arguments.length<2){if("string"==typeof e){var n=this.node();return(e=t.ns.qualify(e)).local?n.getAttributeNS(e.space,e.local):n.getAttribute(e)}for(r in e)this.each(Q(r,e[r]));return this}return this.each(Q(e,r))},Y.classed=function(t,e){if(arguments.length<2){if("string"==typeof t){var r=this.node(),n=(t=et(t)).length,i=-1;if(e=r.classList){for(;++i=0;)(r=n[i])&&(a&&a!==r.nextSibling&&a.parentNode.insertBefore(r,a),a=r);return this},Y.sort=function(t){t=function(t){arguments.length||(t=h);return function(e,r){return e&&r?t(e.__data__,r.__data__):!e-!r}}.apply(this,arguments);for(var e=-1,r=this.length;++e0&&(e=e.slice(0,o));var l=dt.get(e);function c(){var t=this[a];t&&(this.removeEventListener(e,t,t.$),delete this[a])}return l&&(e=l,s=mt),o?r?function(){var t=s(r,n(arguments));c.call(this),this.addEventListener(e,this[a]=t,t.$=i),t._=r}:c:r?I:function(){var r,n=new RegExp("^__on([^.]+)"+t.requote(e)+"$");for(var i in this)if(r=i.match(n)){var a=this[i];this.removeEventListener(r[1],a,a.$),delete this[i]}}}t.selection.enter=ft,t.selection.enter.prototype=ht,ht.append=Y.append,ht.empty=Y.empty,ht.node=Y.node,ht.call=Y.call,ht.size=Y.size,ht.select=function(t){for(var e,r,n,i,a,o=[],s=-1,l=this.length;++s=n&&(n=e+1);!(o=s[n])&&++n0?1:t<0?-1:0}function Pt(t,e,r){return(e[0]-t[0])*(r[1]-t[1])-(e[1]-t[1])*(r[0]-t[0])}function Dt(t){return t>1?0:t<-1?At:Math.acos(t)}function Ot(t){return t>1?Ct:t<-1?-Ct:Math.asin(t)}function It(t){return((t=Math.exp(t))+1/t)/2}function Rt(t){return(t=Math.sin(t/2))*t}var Bt=Math.SQRT2;t.interpolateZoom=function(t,e){var r,n,i=t[0],a=t[1],o=t[2],s=e[0],l=e[1],c=e[2],u=s-i,f=l-a,h=u*u+f*f;if(h0&&(e=e.transition().duration(g)),e.call(w.event)}function S(){c&&c.domain(l.range().map(function(t){return(t-h.x)/h.k}).map(l.invert)),f&&f.domain(u.range().map(function(t){return(t-h.y)/h.k}).map(u.invert))}function C(t){m++||t({type:"zoomstart"})}function E(t){S(),t({type:"zoom",scale:h.k,translate:[h.x,h.y]})}function L(t){--m||(t({type:"zoomend"}),r=null)}function z(){var e=this,r=_.of(e,arguments),n=0,i=t.select(o(e)).on(y,function(){n=1,A(t.mouse(e),a),E(r)}).on(x,function(){i.on(y,null).on(x,null),s(n),L(r)}),a=k(t.mouse(e)),s=xt(e);fs.call(e),C(r)}function P(){var e,r=this,n=_.of(r,arguments),i={},a=0,o=".zoom-"+t.event.changedTouches[0].identifier,l="touchmove"+o,c="touchend"+o,u=[],f=t.select(r),p=xt(r);function d(){var n=t.touches(r);return e=h.k,n.forEach(function(t){t.identifier in i&&(i[t.identifier]=k(t))}),n}function g(){var e=t.event.target;t.select(e).on(l,m).on(c,y),u.push(e);for(var n=t.event.changedTouches,o=0,f=n.length;o1){v=p[0];var x=p[1],b=v[0]-x[0],_=v[1]-x[1];a=b*b+_*_}}function m(){var o,l,c,u,f=t.touches(r);fs.call(r);for(var h=0,p=f.length;h360?t-=360:t<0&&(t+=360),t<60?n+(i-n)*t/60:t<180?i:t<240?n+(i-n)*(240-t)/60:n}(t))}return t=isNaN(t)?0:(t%=360)<0?t+360:t,e=isNaN(e)?0:e<0?0:e>1?1:e,n=2*(r=r<0?0:r>1?1:r)-(i=r<=.5?r*(1+e):r+e-r*e),new ae(a(t+120),a(t),a(t-120))}function Gt(e,r,n){return this instanceof Gt?(this.h=+e,this.c=+r,void(this.l=+n)):arguments.length<2?e instanceof Gt?new Gt(e.h,e.c,e.l):ee(e instanceof Xt?e.l:(e=he((e=t.rgb(e)).r,e.g,e.b)).l,e.a,e.b):new Gt(e,r,n)}qt.brighter=function(t){return t=Math.pow(.7,arguments.length?t:1),new Ut(this.h,this.s,this.l/t)},qt.darker=function(t){return t=Math.pow(.7,arguments.length?t:1),new Ut(this.h,this.s,t*this.l)},qt.rgb=function(){return Ht(this.h,this.s,this.l)},t.hcl=Gt;var Wt=Gt.prototype=new Vt;function Yt(t,e,r){return isNaN(t)&&(t=0),isNaN(e)&&(e=0),new Xt(r,Math.cos(t*=Et)*e,Math.sin(t)*e)}function Xt(t,e,r){return this instanceof Xt?(this.l=+t,this.a=+e,void(this.b=+r)):arguments.length<2?t instanceof Xt?new Xt(t.l,t.a,t.b):t instanceof Gt?Yt(t.h,t.c,t.l):he((t=ae(t)).r,t.g,t.b):new Xt(t,e,r)}Wt.brighter=function(t){return new Gt(this.h,this.c,Math.min(100,this.l+Zt*(arguments.length?t:1)))},Wt.darker=function(t){return new Gt(this.h,this.c,Math.max(0,this.l-Zt*(arguments.length?t:1)))},Wt.rgb=function(){return Yt(this.h,this.c,this.l).rgb()},t.lab=Xt;var Zt=18,Jt=.95047,Kt=1,Qt=1.08883,$t=Xt.prototype=new Vt;function te(t,e,r){var n=(t+16)/116,i=n+e/500,a=n-r/200;return new ae(ie(3.2404542*(i=re(i)*Jt)-1.5371385*(n=re(n)*Kt)-.4985314*(a=re(a)*Qt)),ie(-.969266*i+1.8760108*n+.041556*a),ie(.0556434*i-.2040259*n+1.0572252*a))}function ee(t,e,r){return t>0?new Gt(Math.atan2(r,e)*Lt,Math.sqrt(e*e+r*r),t):new Gt(NaN,NaN,t)}function re(t){return t>.206893034?t*t*t:(t-4/29)/7.787037}function ne(t){return t>.008856?Math.pow(t,1/3):7.787037*t+4/29}function ie(t){return Math.round(255*(t<=.00304?12.92*t:1.055*Math.pow(t,1/2.4)-.055))}function ae(t,e,r){return this instanceof ae?(this.r=~~t,this.g=~~e,void(this.b=~~r)):arguments.length<2?t instanceof ae?new ae(t.r,t.g,t.b):ue(""+t,ae,Ht):new ae(t,e,r)}function oe(t){return new ae(t>>16,t>>8&255,255&t)}function se(t){return oe(t)+""}$t.brighter=function(t){return new Xt(Math.min(100,this.l+Zt*(arguments.length?t:1)),this.a,this.b)},$t.darker=function(t){return new Xt(Math.max(0,this.l-Zt*(arguments.length?t:1)),this.a,this.b)},$t.rgb=function(){return te(this.l,this.a,this.b)},t.rgb=ae;var le=ae.prototype=new Vt;function ce(t){return t<16?"0"+Math.max(0,t).toString(16):Math.min(255,t).toString(16)}function ue(t,e,r){var n,i,a,o=0,s=0,l=0;if(n=/([a-z]+)\((.*)\)/.exec(t=t.toLowerCase()))switch(i=n[2].split(","),n[1]){case"hsl":return r(parseFloat(i[0]),parseFloat(i[1])/100,parseFloat(i[2])/100);case"rgb":return e(de(i[0]),de(i[1]),de(i[2]))}return(a=ge.get(t))?e(a.r,a.g,a.b):(null==t||"#"!==t.charAt(0)||isNaN(a=parseInt(t.slice(1),16))||(4===t.length?(o=(3840&a)>>4,o|=o>>4,s=240&a,s|=s>>4,l=15&a,l|=l<<4):7===t.length&&(o=(16711680&a)>>16,s=(65280&a)>>8,l=255&a)),e(o,s,l))}function fe(t,e,r){var n,i,a=Math.min(t/=255,e/=255,r/=255),o=Math.max(t,e,r),s=o-a,l=(o+a)/2;return s?(i=l<.5?s/(o+a):s/(2-o-a),n=t==o?(e-r)/s+(e0&&l<1?0:n),new Ut(n,i,l)}function he(t,e,r){var n=ne((.4124564*(t=pe(t))+.3575761*(e=pe(e))+.1804375*(r=pe(r)))/Jt),i=ne((.2126729*t+.7151522*e+.072175*r)/Kt);return Xt(116*i-16,500*(n-i),200*(i-ne((.0193339*t+.119192*e+.9503041*r)/Qt)))}function pe(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function de(t){var e=parseFloat(t);return"%"===t.charAt(t.length-1)?Math.round(2.55*e):e}le.brighter=function(t){t=Math.pow(.7,arguments.length?t:1);var e=this.r,r=this.g,n=this.b,i=30;return e||r||n?(e&&e=200&&e<300||304===e){try{t=i.call(o,c)}catch(t){return void s.error.call(o,t)}s.load.call(o,t)}else s.error.call(o,c)}return!this.XDomainRequest||"withCredentials"in c||!/^(http(s)?:)?\/\//.test(e)||(c=new XDomainRequest),"onload"in c?c.onload=c.onerror=f:c.onreadystatechange=function(){c.readyState>3&&f()},c.onprogress=function(e){var r=t.event;t.event=e;try{s.progress.call(o,c)}finally{t.event=r}},o.header=function(t,e){return t=(t+"").toLowerCase(),arguments.length<2?l[t]:(null==e?delete l[t]:l[t]=e+"",o)},o.mimeType=function(t){return arguments.length?(r=null==t?null:t+"",o):r},o.responseType=function(t){return arguments.length?(u=t,o):u},o.response=function(t){return i=t,o},["get","post"].forEach(function(t){o[t]=function(){return o.send.apply(o,[t].concat(n(arguments)))}}),o.send=function(t,n,i){if(2===arguments.length&&"function"==typeof n&&(i=n,n=null),c.open(t,e,!0),null==r||"accept"in l||(l.accept=r+",*/*"),c.setRequestHeader)for(var a in l)c.setRequestHeader(a,l[a]);return null!=r&&c.overrideMimeType&&c.overrideMimeType(r),null!=u&&(c.responseType=u),null!=i&&o.on("error",i).on("load",function(t){i(null,t)}),s.beforesend.call(o,c),c.send(null==n?null:n),o},o.abort=function(){return c.abort(),o},t.rebind(o,s,"on"),null==a?o:o.get(function(t){return 1===t.length?function(e,r){t(null==e?r:null)}:t}(a))}ge.forEach(function(t,e){ge.set(t,oe(e))}),t.functor=me,t.xhr=ve(z),t.dsv=function(t,e){var r=new RegExp('["'+t+"\n]"),n=t.charCodeAt(0);function i(t,r,n){arguments.length<3&&(n=r,r=null);var i=ye(t,e,null==r?a:o(r),n);return i.row=function(t){return arguments.length?i.response(null==(r=t)?a:o(t)):r},i}function a(t){return i.parse(t.responseText)}function o(t){return function(e){return i.parse(e.responseText,t)}}function s(e){return e.map(l).join(t)}function l(t){return r.test(t)?'"'+t.replace(/\"/g,'""')+'"':t}return i.parse=function(t,e){var r;return i.parseRows(t,function(t,n){if(r)return r(t,n-1);var i=new Function("d","return {"+t.map(function(t,e){return JSON.stringify(t)+": d["+e+"]"}).join(",")+"}");r=e?function(t,r){return e(i(t),r)}:i})},i.parseRows=function(t,e){var r,i,a={},o={},s=[],l=t.length,c=0,u=0;function f(){if(c>=l)return o;if(i)return i=!1,a;var e=c;if(34===t.charCodeAt(e)){for(var r=e;r++24?(isFinite(e)&&(clearTimeout(we),we=setTimeout(Ae,e)),_e=0):(_e=1,ke(Ae))}function Te(){for(var t=Date.now(),e=xe;e;)t>=e.t&&e.c(t-e.t)&&(e.c=null),e=e.n;return t}function Se(){for(var t,e=xe,r=1/0;e;)e.c?(e.t8?function(t){return t/r}:function(t){return t*r},symbol:t}});t.formatPrefix=function(e,r){var n=0;return(e=+e)&&(e<0&&(e*=-1),r&&(e=t.round(e,Ce(e,r))),n=1+Math.floor(1e-12+Math.log(e)/Math.LN10),n=Math.max(-24,Math.min(24,3*Math.floor((n-1)/3)))),Ee[8+n/3]};var Le=/(?:([^{])?([<>=^]))?([+\- ])?([$#])?(0)?(\d+)?(,)?(\.-?\d+)?([a-z%])?/i,ze=t.map({b:function(t){return t.toString(2)},c:function(t){return String.fromCharCode(t)},o:function(t){return t.toString(8)},x:function(t){return t.toString(16)},X:function(t){return t.toString(16).toUpperCase()},g:function(t,e){return t.toPrecision(e)},e:function(t,e){return t.toExponential(e)},f:function(t,e){return t.toFixed(e)},r:function(e,r){return(e=t.round(e,Ce(e,r))).toFixed(Math.max(0,Math.min(20,Ce(e*(1+1e-15),r))))}});function Pe(t){return t+""}var De=t.time={},Oe=Date;function Ie(){this._=new Date(arguments.length>1?Date.UTC.apply(this,arguments):arguments[0])}Ie.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTime:function(){return this._.getTime()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.valueOf()},setDate:function(){Re.setUTCDate.apply(this._,arguments)},setDay:function(){Re.setUTCDay.apply(this._,arguments)},setFullYear:function(){Re.setUTCFullYear.apply(this._,arguments)},setHours:function(){Re.setUTCHours.apply(this._,arguments)},setMilliseconds:function(){Re.setUTCMilliseconds.apply(this._,arguments)},setMinutes:function(){Re.setUTCMinutes.apply(this._,arguments)},setMonth:function(){Re.setUTCMonth.apply(this._,arguments)},setSeconds:function(){Re.setUTCSeconds.apply(this._,arguments)},setTime:function(){Re.setTime.apply(this._,arguments)}};var Re=Date.prototype;function Be(t,e,r){function n(e){var r=t(e),n=a(r,1);return e-r1)for(;o68?1900:2e3),r+i[0].length):-1}function Je(t,e,r){return/^[+-]\d{4}$/.test(e=e.slice(r,r+5))?(t.Z=-e,r+5):-1}function Ke(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.m=n[0]-1,r+n[0].length):-1}function Qe(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.d=+n[0],r+n[0].length):-1}function $e(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+3));return n?(t.j=+n[0],r+n[0].length):-1}function tr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.H=+n[0],r+n[0].length):-1}function er(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.M=+n[0],r+n[0].length):-1}function rr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+2));return n?(t.S=+n[0],r+n[0].length):-1}function nr(t,e,r){je.lastIndex=0;var n=je.exec(e.slice(r,r+3));return n?(t.L=+n[0],r+n[0].length):-1}function ir(t){var e=t.getTimezoneOffset(),r=e>0?"-":"+",n=y(e)/60|0,i=y(e)%60;return r+Ue(n,"0",2)+Ue(i,"0",2)}function ar(t,e,r){Ve.lastIndex=0;var n=Ve.exec(e.slice(r,r+1));return n?r+n[0].length:-1}function or(t){for(var e=t.length,r=-1;++r0&&s>0&&(l+s+1>e&&(s=Math.max(1,e-l)),a.push(t.substring(r-=s,r+s)),!((l+=s+1)>e));)s=i[o=(o+1)%i.length];return a.reverse().join(n)}:z;return function(e){var n=Le.exec(e),i=n[1]||" ",s=n[2]||">",l=n[3]||"-",c=n[4]||"",u=n[5],f=+n[6],h=n[7],p=n[8],d=n[9],g=1,m="",v="",y=!1,x=!0;switch(p&&(p=+p.substring(1)),(u||"0"===i&&"="===s)&&(u=i="0",s="="),d){case"n":h=!0,d="g";break;case"%":g=100,v="%",d="f";break;case"p":g=100,v="%",d="r";break;case"b":case"o":case"x":case"X":"#"===c&&(m="0"+d.toLowerCase());case"c":x=!1;case"d":y=!0,p=0;break;case"s":g=-1,d="r"}"$"===c&&(m=a[0],v=a[1]),"r"!=d||p||(d="g"),null!=p&&("g"==d?p=Math.max(1,Math.min(21,p)):"e"!=d&&"f"!=d||(p=Math.max(0,Math.min(20,p)))),d=ze.get(d)||Pe;var b=u&&h;return function(e){var n=v;if(y&&e%1)return"";var a=e<0||0===e&&1/e<0?(e=-e,"-"):"-"===l?"":l;if(g<0){var c=t.formatPrefix(e,p);e=c.scale(e),n=c.symbol+v}else e*=g;var _,w,k=(e=d(e,p)).lastIndexOf(".");if(k<0){var M=x?e.lastIndexOf("e"):-1;M<0?(_=e,w=""):(_=e.substring(0,M),w=e.substring(M))}else _=e.substring(0,k),w=r+e.substring(k+1);!u&&h&&(_=o(_,1/0));var A=m.length+_.length+w.length+(b?0:a.length),T=A"===s?T+a+e:"^"===s?T.substring(0,A>>=1)+a+e+T.substring(A):a+(b?e:T+e))+n}}}(e),timeFormat:function(e){var r=e.dateTime,n=e.date,i=e.time,a=e.periods,o=e.days,s=e.shortDays,l=e.months,c=e.shortMonths;function u(t){var e=t.length;function r(r){for(var n,i,a,o=[],s=-1,l=0;++s=c)return-1;if(37===(i=e.charCodeAt(s++))){if(o=e.charAt(s++),!(a=w[o in Ne?e.charAt(s++):o])||(n=a(t,r,n))<0)return-1}else if(i!=r.charCodeAt(n++))return-1}return n}u.utc=function(t){var e=u(t);function r(t){try{var r=new(Oe=Ie);return r._=t,e(r)}finally{Oe=Date}}return r.parse=function(t){try{Oe=Ie;var r=e.parse(t);return r&&r._}finally{Oe=Date}},r.toString=e.toString,r},u.multi=u.utc.multi=or;var h=t.map(),p=qe(o),d=He(o),g=qe(s),m=He(s),v=qe(l),y=He(l),x=qe(c),b=He(c);a.forEach(function(t,e){h.set(t.toLowerCase(),e)});var _={a:function(t){return s[t.getDay()]},A:function(t){return o[t.getDay()]},b:function(t){return c[t.getMonth()]},B:function(t){return l[t.getMonth()]},c:u(r),d:function(t,e){return Ue(t.getDate(),e,2)},e:function(t,e){return Ue(t.getDate(),e,2)},H:function(t,e){return Ue(t.getHours(),e,2)},I:function(t,e){return Ue(t.getHours()%12||12,e,2)},j:function(t,e){return Ue(1+De.dayOfYear(t),e,3)},L:function(t,e){return Ue(t.getMilliseconds(),e,3)},m:function(t,e){return Ue(t.getMonth()+1,e,2)},M:function(t,e){return Ue(t.getMinutes(),e,2)},p:function(t){return a[+(t.getHours()>=12)]},S:function(t,e){return Ue(t.getSeconds(),e,2)},U:function(t,e){return Ue(De.sundayOfYear(t),e,2)},w:function(t){return t.getDay()},W:function(t,e){return Ue(De.mondayOfYear(t),e,2)},x:u(n),X:u(i),y:function(t,e){return Ue(t.getFullYear()%100,e,2)},Y:function(t,e){return Ue(t.getFullYear()%1e4,e,4)},Z:ir,"%":function(){return"%"}},w={a:function(t,e,r){g.lastIndex=0;var n=g.exec(e.slice(r));return n?(t.w=m.get(n[0].toLowerCase()),r+n[0].length):-1},A:function(t,e,r){p.lastIndex=0;var n=p.exec(e.slice(r));return n?(t.w=d.get(n[0].toLowerCase()),r+n[0].length):-1},b:function(t,e,r){x.lastIndex=0;var n=x.exec(e.slice(r));return n?(t.m=b.get(n[0].toLowerCase()),r+n[0].length):-1},B:function(t,e,r){v.lastIndex=0;var n=v.exec(e.slice(r));return n?(t.m=y.get(n[0].toLowerCase()),r+n[0].length):-1},c:function(t,e,r){return f(t,_.c.toString(),e,r)},d:Qe,e:Qe,H:tr,I:tr,j:$e,L:nr,m:Ke,M:er,p:function(t,e,r){var n=h.get(e.slice(r,r+=2).toLowerCase());return null==n?-1:(t.p=n,r)},S:rr,U:We,w:Ge,W:Ye,x:function(t,e,r){return f(t,_.x.toString(),e,r)},X:function(t,e,r){return f(t,_.X.toString(),e,r)},y:Ze,Y:Xe,Z:Je,"%":ar};return u}(e)}};var sr=t.locale({decimal:".",thousands:",",grouping:[3],currency:["$",""],dateTime:"%a %b %e %X %Y",date:"%m/%d/%Y",time:"%H:%M:%S",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});function lr(){}t.format=sr.numberFormat,t.geo={},lr.prototype={s:0,t:0,add:function(t){ur(t,this.t,cr),ur(cr.s,this.s,this),this.s?this.t+=cr.t:this.s=cr.t},reset:function(){this.s=this.t=0},valueOf:function(){return this.s}};var cr=new lr;function ur(t,e,r){var n=r.s=t+e,i=n-t,a=n-i;r.t=t-a+(e-i)}function fr(t,e){t&&pr.hasOwnProperty(t.type)&&pr[t.type](t,e)}t.geo.stream=function(t,e){t&&hr.hasOwnProperty(t.type)?hr[t.type](t,e):fr(t,e)};var hr={Feature:function(t,e){fr(t.geometry,e)},FeatureCollection:function(t,e){for(var r=t.features,n=-1,i=r.length;++n=0?1:-1,s=o*a,l=Math.cos(e),c=Math.sin(e),u=i*c,f=n*l+u*Math.cos(s),h=u*o*Math.sin(s);Cr.add(Math.atan2(h,f)),r=t,n=l,i=c}Er.point=function(o,s){Er.point=a,r=(t=o)*Et,n=Math.cos(s=(e=s)*Et/2+At/4),i=Math.sin(s)},Er.lineEnd=function(){a(t,e)}}function zr(t){var e=t[0],r=t[1],n=Math.cos(r);return[n*Math.cos(e),n*Math.sin(e),Math.sin(r)]}function Pr(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}function Dr(t,e){return[t[1]*e[2]-t[2]*e[1],t[2]*e[0]-t[0]*e[2],t[0]*e[1]-t[1]*e[0]]}function Or(t,e){t[0]+=e[0],t[1]+=e[1],t[2]+=e[2]}function Ir(t,e){return[t[0]*e,t[1]*e,t[2]*e]}function Rr(t){var e=Math.sqrt(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=e,t[1]/=e,t[2]/=e}function Br(t){return[Math.atan2(t[1],t[0]),Ot(t[2])]}function Fr(t,e){return y(t[0]-e[0])kt?i=90:c<-kt&&(r=-90),f[0]=e,f[1]=n}};function p(t,a){u.push(f=[e=t,n=t]),ai&&(i=a)}function d(t,o){var s=zr([t*Et,o*Et]);if(l){var c=Dr(l,s),u=Dr([c[1],-c[0],0],c);Rr(u),u=Br(u);var f=t-a,h=f>0?1:-1,d=u[0]*Lt*h,g=y(f)>180;if(g^(h*ai&&(i=m);else if(g^(h*a<(d=(d+360)%360-180)&&di&&(i=o);g?t_(e,n)&&(n=t):_(t,n)>_(e,n)&&(e=t):n>=e?(tn&&(n=t)):t>a?_(e,t)>_(e,n)&&(n=t):_(t,n)>_(e,n)&&(e=t)}else p(t,o);l=s,a=t}function g(){h.point=d}function m(){f[0]=e,f[1]=n,h.point=p,l=null}function v(t,e){if(l){var r=t-a;c+=y(r)>180?r+(r>0?360:-360):r}else o=t,s=e;Er.point(t,e),d(t,e)}function x(){Er.lineStart()}function b(){v(o,s),Er.lineEnd(),y(c)>kt&&(e=-(n=180)),f[0]=e,f[1]=n,l=null}function _(t,e){return(e-=t)<0?e+360:e}function w(t,e){return t[0]-e[0]}function k(t,e){return e[0]<=e[1]?e[0]<=t&&t<=e[1]:t_(g[0],g[1])&&(g[1]=p[1]),_(p[0],g[1])>_(g[0],g[1])&&(g[0]=p[0])):s.push(g=p);for(var l,c,p,d=-1/0,g=(o=0,s[c=s.length-1]);o<=c;g=p,++o)p=s[o],(l=_(g[1],p[0]))>d&&(d=l,e=p[0],n=g[1])}return u=f=null,e===1/0||r===1/0?[[NaN,NaN],[NaN,NaN]]:[[e,r],[n,i]]}}(),t.geo.centroid=function(e){vr=yr=xr=br=_r=wr=kr=Mr=Ar=Tr=Sr=0,t.geo.stream(e,Nr);var r=Ar,n=Tr,i=Sr,a=r*r+n*n+i*i;return a=0;--s)i.point((f=u[s])[0],f[1]);else n(p.x,p.p.x,-1,i);p=p.p}u=(p=p.o).z,d=!d}while(!p.v);i.lineEnd()}}}function Xr(t){if(e=t.length){for(var e,r,n=0,i=t[0];++n=0?1:-1,k=w*_,M=k>At,A=d*x;if(Cr.add(Math.atan2(A*w*Math.sin(k),g*b+A*Math.cos(k))),a+=M?_+w*Tt:_,M^h>=r^v>=r){var T=Dr(zr(f),zr(t));Rr(T);var S=Dr(i,T);Rr(S);var C=(M^_>=0?-1:1)*Ot(S[2]);(n>C||n===C&&(T[0]||T[1]))&&(o+=M^_>=0?1:-1)}if(!m++)break;h=v,d=x,g=b,f=t}}return(a<-kt||a0){for(x||(o.polygonStart(),x=!0),o.lineStart();++a1&&2&e&&r.push(r.pop().concat(r.shift())),s.push(r.filter(Kr))}return u}}function Kr(t){return t.length>1}function Qr(){var t,e=[];return{lineStart:function(){e.push(t=[])},point:function(e,r){t.push([e,r])},lineEnd:I,buffer:function(){var r=e;return e=[],t=null,r},rejoin:function(){e.length>1&&e.push(e.pop().concat(e.shift()))}}}function $r(t,e){return((t=t.x)[0]<0?t[1]-Ct-kt:Ct-t[1])-((e=e.x)[0]<0?e[1]-Ct-kt:Ct-e[1])}var tn=Jr(Wr,function(t){var e,r=NaN,n=NaN,i=NaN;return{lineStart:function(){t.lineStart(),e=1},point:function(a,o){var s=a>0?At:-At,l=y(a-r);y(l-At)0?Ct:-Ct),t.point(i,n),t.lineEnd(),t.lineStart(),t.point(s,n),t.point(a,n),e=0):i!==s&&l>=At&&(y(r-i)kt?Math.atan((Math.sin(e)*(a=Math.cos(n))*Math.sin(r)-Math.sin(n)*(i=Math.cos(e))*Math.sin(t))/(i*a*o)):(e+n)/2}(r,n,a,o),t.point(i,n),t.lineEnd(),t.lineStart(),t.point(s,n),e=0),t.point(r=a,n=o),i=s},lineEnd:function(){t.lineEnd(),r=n=NaN},clean:function(){return 2-e}}},function(t,e,r,n){var i;if(null==t)i=r*Ct,n.point(-At,i),n.point(0,i),n.point(At,i),n.point(At,0),n.point(At,-i),n.point(0,-i),n.point(-At,-i),n.point(-At,0),n.point(-At,i);else if(y(t[0]-e[0])>kt){var a=t[0]0)){if(a/=h,h<0){if(a0){if(a>f)return;a>u&&(u=a)}if(a=r-l,h||!(a<0)){if(a/=h,h<0){if(a>f)return;a>u&&(u=a)}else if(h>0){if(a0)){if(a/=p,p<0){if(a0){if(a>f)return;a>u&&(u=a)}if(a=n-c,p||!(a<0)){if(a/=p,p<0){if(a>f)return;a>u&&(u=a)}else if(p>0){if(a0&&(i.a={x:l+u*h,y:c+u*p}),f<1&&(i.b={x:l+f*h,y:c+f*p}),i}}}}}}var rn=1e9;function nn(e,r,n,i){return function(l){var c,u,f,h,p,d,g,m,v,y,x,b=l,_=Qr(),w=en(e,r,n,i),k={point:T,lineStart:function(){k.point=S,u&&u.push(f=[]);y=!0,v=!1,g=m=NaN},lineEnd:function(){c&&(S(h,p),d&&v&&_.rejoin(),c.push(_.buffer()));k.point=T,v&&l.lineEnd()},polygonStart:function(){l=_,c=[],u=[],x=!0},polygonEnd:function(){l=b,c=t.merge(c);var r=function(t){for(var e=0,r=u.length,n=t[1],i=0;in&&Pt(c,a,t)>0&&++e:a[1]<=n&&Pt(c,a,t)<0&&--e,c=a;return 0!==e}([e,i]),n=x&&r,a=c.length;(n||a)&&(l.polygonStart(),n&&(l.lineStart(),M(null,null,1,l),l.lineEnd()),a&&Yr(c,o,r,M,l),l.polygonEnd()),c=u=f=null}};function M(t,o,l,c){var u=0,f=0;if(null==t||(u=a(t,l))!==(f=a(o,l))||s(t,o)<0^l>0)do{c.point(0===u||3===u?e:n,u>1?i:r)}while((u=(u+l+4)%4)!==f);else c.point(o[0],o[1])}function A(t,a){return e<=t&&t<=n&&r<=a&&a<=i}function T(t,e){A(t,e)&&l.point(t,e)}function S(t,e){var r=A(t=Math.max(-rn,Math.min(rn,t)),e=Math.max(-rn,Math.min(rn,e)));if(u&&f.push([t,e]),y)h=t,p=e,d=r,y=!1,r&&(l.lineStart(),l.point(t,e));else if(r&&v)l.point(t,e);else{var n={a:{x:g,y:m},b:{x:t,y:e}};w(n)?(v||(l.lineStart(),l.point(n.a.x,n.a.y)),l.point(n.b.x,n.b.y),r||l.lineEnd(),x=!1):r&&(l.lineStart(),l.point(t,e),x=!1)}g=t,m=e,v=r}return k};function a(t,i){return y(t[0]-e)0?0:3:y(t[0]-n)0?2:1:y(t[1]-r)0?1:0:i>0?3:2}function o(t,e){return s(t.x,e.x)}function s(t,e){var r=a(t,1),n=a(e,1);return r!==n?r-n:0===r?e[1]-t[1]:1===r?t[0]-e[0]:2===r?t[1]-e[1]:e[0]-t[0]}}function an(t){var e=0,r=At/3,n=En(t),i=n(e,r);return i.parallels=function(t){return arguments.length?n(e=t[0]*At/180,r=t[1]*At/180):[e/At*180,r/At*180]},i}function on(t,e){var r=Math.sin(t),n=(r+Math.sin(e))/2,i=1+r*(2*n-r),a=Math.sqrt(i)/n;function o(t,e){var r=Math.sqrt(i-2*n*Math.sin(e))/n;return[r*Math.sin(t*=n),a-r*Math.cos(t)]}return o.invert=function(t,e){var r=a-e;return[Math.atan2(t,r)/n,Ot((i-(t*t+r*r)*n*n)/(2*n))]},o}t.geo.clipExtent=function(){var t,e,r,n,i,a,o={stream:function(t){return i&&(i.valid=!1),(i=a(t)).valid=!0,i},extent:function(s){return arguments.length?(a=nn(t=+s[0][0],e=+s[0][1],r=+s[1][0],n=+s[1][1]),i&&(i.valid=!1,i=null),o):[[t,e],[r,n]]}};return o.extent([[0,0],[960,500]])},(t.geo.conicEqualArea=function(){return an(on)}).raw=on,t.geo.albers=function(){return t.geo.conicEqualArea().rotate([96,0]).center([-.6,38.7]).parallels([29.5,45.5]).scale(1070)},t.geo.albersUsa=function(){var e,r,n,i,a=t.geo.albers(),o=t.geo.conicEqualArea().rotate([154,0]).center([-2,58.5]).parallels([55,65]),s=t.geo.conicEqualArea().rotate([157,0]).center([-3,19.9]).parallels([8,18]),l={point:function(t,r){e=[t,r]}};function c(t){var a=t[0],o=t[1];return e=null,r(a,o),e||(n(a,o),e)||i(a,o),e}return c.invert=function(t){var e=a.scale(),r=a.translate(),n=(t[0]-r[0])/e,i=(t[1]-r[1])/e;return(i>=.12&&i<.234&&n>=-.425&&n<-.214?o:i>=.166&&i<.234&&n>=-.214&&n<-.115?s:a).invert(t)},c.stream=function(t){var e=a.stream(t),r=o.stream(t),n=s.stream(t);return{point:function(t,i){e.point(t,i),r.point(t,i),n.point(t,i)},sphere:function(){e.sphere(),r.sphere(),n.sphere()},lineStart:function(){e.lineStart(),r.lineStart(),n.lineStart()},lineEnd:function(){e.lineEnd(),r.lineEnd(),n.lineEnd()},polygonStart:function(){e.polygonStart(),r.polygonStart(),n.polygonStart()},polygonEnd:function(){e.polygonEnd(),r.polygonEnd(),n.polygonEnd()}}},c.precision=function(t){return arguments.length?(a.precision(t),o.precision(t),s.precision(t),c):a.precision()},c.scale=function(t){return arguments.length?(a.scale(t),o.scale(.35*t),s.scale(t),c.translate(a.translate())):a.scale()},c.translate=function(t){if(!arguments.length)return a.translate();var e=a.scale(),u=+t[0],f=+t[1];return r=a.translate(t).clipExtent([[u-.455*e,f-.238*e],[u+.455*e,f+.238*e]]).stream(l).point,n=o.translate([u-.307*e,f+.201*e]).clipExtent([[u-.425*e+kt,f+.12*e+kt],[u-.214*e-kt,f+.234*e-kt]]).stream(l).point,i=s.translate([u-.205*e,f+.212*e]).clipExtent([[u-.214*e+kt,f+.166*e+kt],[u-.115*e-kt,f+.234*e-kt]]).stream(l).point,c},c.scale(1070)};var sn,ln,cn,un,fn,hn,pn={point:I,lineStart:I,lineEnd:I,polygonStart:function(){ln=0,pn.lineStart=dn},polygonEnd:function(){pn.lineStart=pn.lineEnd=pn.point=I,sn+=y(ln/2)}};function dn(){var t,e,r,n;function i(t,e){ln+=n*t-r*e,r=t,n=e}pn.point=function(a,o){pn.point=i,t=r=a,e=n=o},pn.lineEnd=function(){i(t,e)}}var gn={point:function(t,e){tfn&&(fn=t);ehn&&(hn=e)},lineStart:I,lineEnd:I,polygonStart:I,polygonEnd:I};function mn(){var t=vn(4.5),e=[],r={point:n,lineStart:function(){r.point=i},lineEnd:o,polygonStart:function(){r.lineEnd=s},polygonEnd:function(){r.lineEnd=o,r.point=n},pointRadius:function(e){return t=vn(e),r},result:function(){if(e.length){var t=e.join("");return e=[],t}}};function n(r,n){e.push("M",r,",",n,t)}function i(t,n){e.push("M",t,",",n),r.point=a}function a(t,r){e.push("L",t,",",r)}function o(){r.point=n}function s(){e.push("Z")}return r}function vn(t){return"m0,"+t+"a"+t+","+t+" 0 1,1 0,"+-2*t+"a"+t+","+t+" 0 1,1 0,"+2*t+"z"}var yn,xn={point:bn,lineStart:_n,lineEnd:wn,polygonStart:function(){xn.lineStart=kn},polygonEnd:function(){xn.point=bn,xn.lineStart=_n,xn.lineEnd=wn}};function bn(t,e){xr+=t,br+=e,++_r}function _n(){var t,e;function r(r,n){var i=r-t,a=n-e,o=Math.sqrt(i*i+a*a);wr+=o*(t+r)/2,kr+=o*(e+n)/2,Mr+=o,bn(t=r,e=n)}xn.point=function(n,i){xn.point=r,bn(t=n,e=i)}}function wn(){xn.point=bn}function kn(){var t,e,r,n;function i(t,e){var i=t-r,a=e-n,o=Math.sqrt(i*i+a*a);wr+=o*(r+t)/2,kr+=o*(n+e)/2,Mr+=o,Ar+=(o=n*t-r*e)*(r+t),Tr+=o*(n+e),Sr+=3*o,bn(r=t,n=e)}xn.point=function(a,o){xn.point=i,bn(t=r=a,e=n=o)},xn.lineEnd=function(){i(t,e)}}function Mn(t){var e=4.5,r={point:n,lineStart:function(){r.point=i},lineEnd:o,polygonStart:function(){r.lineEnd=s},polygonEnd:function(){r.lineEnd=o,r.point=n},pointRadius:function(t){return e=t,r},result:I};function n(r,n){t.moveTo(r+e,n),t.arc(r,n,e,0,Tt)}function i(e,n){t.moveTo(e,n),r.point=a}function a(e,r){t.lineTo(e,r)}function o(){r.point=n}function s(){t.closePath()}return r}function An(t){var e=.5,r=Math.cos(30*Et),n=16;function i(e){return(n?function(e){var r,i,o,s,l,c,u,f,h,p,d,g,m={point:v,lineStart:y,lineEnd:b,polygonStart:function(){e.polygonStart(),m.lineStart=_},polygonEnd:function(){e.polygonEnd(),m.lineStart=y}};function v(r,n){r=t(r,n),e.point(r[0],r[1])}function y(){f=NaN,m.point=x,e.lineStart()}function x(r,i){var o=zr([r,i]),s=t(r,i);a(f,h,u,p,d,g,f=s[0],h=s[1],u=r,p=o[0],d=o[1],g=o[2],n,e),e.point(f,h)}function b(){m.point=v,e.lineEnd()}function _(){y(),m.point=w,m.lineEnd=k}function w(t,e){x(r=t,e),i=f,o=h,s=p,l=d,c=g,m.point=x}function k(){a(f,h,u,p,d,g,i,o,r,s,l,c,n,e),m.lineEnd=b,b()}return m}:function(e){return Sn(e,function(r,n){r=t(r,n),e.point(r[0],r[1])})})(e)}function a(n,i,o,s,l,c,u,f,h,p,d,g,m,v){var x=u-n,b=f-i,_=x*x+b*b;if(_>4*e&&m--){var w=s+p,k=l+d,M=c+g,A=Math.sqrt(w*w+k*k+M*M),T=Math.asin(M/=A),S=y(y(M)-1)e||y((x*z+b*P)/_-.5)>.3||s*p+l*d+c*g0&&16,i):Math.sqrt(e)},i}function Tn(t){this.stream=t}function Sn(t,e){return{point:e,sphere:function(){t.sphere()},lineStart:function(){t.lineStart()},lineEnd:function(){t.lineEnd()},polygonStart:function(){t.polygonStart()},polygonEnd:function(){t.polygonEnd()}}}function Cn(t){return En(function(){return t})()}function En(e){var r,n,i,a,o,s,l=An(function(t,e){return[(t=r(t,e))[0]*c+a,o-t[1]*c]}),c=150,u=480,f=250,h=0,p=0,d=0,g=0,m=0,v=tn,x=z,b=null,_=null;function w(t){return[(t=i(t[0]*Et,t[1]*Et))[0]*c+a,o-t[1]*c]}function k(t){return(t=i.invert((t[0]-a)/c,(o-t[1])/c))&&[t[0]*Lt,t[1]*Lt]}function M(){i=Gr(n=Dn(d,g,m),r);var t=r(h,p);return a=u-t[0]*c,o=f+t[1]*c,A()}function A(){return s&&(s.valid=!1,s=null),w}return w.stream=function(t){return s&&(s.valid=!1),(s=Ln(v(n,l(x(t))))).valid=!0,s},w.clipAngle=function(t){return arguments.length?(v=null==t?(b=t,tn):function(t){var e=Math.cos(t),r=e>0,n=y(e)>kt;return Jr(i,function(t){var e,s,l,c,u;return{lineStart:function(){c=l=!1,u=1},point:function(f,h){var p,d=[f,h],g=i(f,h),m=r?g?0:o(f,h):g?o(f+(f<0?At:-At),h):0;if(!e&&(c=l=g)&&t.lineStart(),g!==l&&(p=a(e,d),(Fr(e,p)||Fr(d,p))&&(d[0]+=kt,d[1]+=kt,g=i(d[0],d[1]))),g!==l)u=0,g?(t.lineStart(),p=a(d,e),t.point(p[0],p[1])):(p=a(e,d),t.point(p[0],p[1]),t.lineEnd()),e=p;else if(n&&e&&r^g){var v;m&s||!(v=a(d,e,!0))||(u=0,r?(t.lineStart(),t.point(v[0][0],v[0][1]),t.point(v[1][0],v[1][1]),t.lineEnd()):(t.point(v[1][0],v[1][1]),t.lineEnd(),t.lineStart(),t.point(v[0][0],v[0][1])))}!g||e&&Fr(e,d)||t.point(d[0],d[1]),e=d,l=g,s=m},lineEnd:function(){l&&t.lineEnd(),e=null},clean:function(){return u|(c&&l)<<1}}},Bn(t,6*Et),r?[0,-t]:[-At,t-At]);function i(t,r){return Math.cos(t)*Math.cos(r)>e}function a(t,r,n){var i=[1,0,0],a=Dr(zr(t),zr(r)),o=Pr(a,a),s=a[0],l=o-s*s;if(!l)return!n&&t;var c=e*o/l,u=-e*s/l,f=Dr(i,a),h=Ir(i,c);Or(h,Ir(a,u));var p=f,d=Pr(h,p),g=Pr(p,p),m=d*d-g*(Pr(h,h)-1);if(!(m<0)){var v=Math.sqrt(m),x=Ir(p,(-d-v)/g);if(Or(x,h),x=Br(x),!n)return x;var b,_=t[0],w=r[0],k=t[1],M=r[1];w<_&&(b=_,_=w,w=b);var A=w-_,T=y(A-At)0^x[1]<(y(x[0]-_)At^(_<=x[0]&&x[0]<=w)){var S=Ir(p,(-d+v)/g);return Or(S,h),[x,Br(S)]}}}function o(e,n){var i=r?t:At-t,a=0;return e<-i?a|=1:e>i&&(a|=2),n<-i?a|=4:n>i&&(a|=8),a}}((b=+t)*Et),A()):b},w.clipExtent=function(t){return arguments.length?(_=t,x=t?nn(t[0][0],t[0][1],t[1][0],t[1][1]):z,A()):_},w.scale=function(t){return arguments.length?(c=+t,M()):c},w.translate=function(t){return arguments.length?(u=+t[0],f=+t[1],M()):[u,f]},w.center=function(t){return arguments.length?(h=t[0]%360*Et,p=t[1]%360*Et,M()):[h*Lt,p*Lt]},w.rotate=function(t){return arguments.length?(d=t[0]%360*Et,g=t[1]%360*Et,m=t.length>2?t[2]%360*Et:0,M()):[d*Lt,g*Lt,m*Lt]},t.rebind(w,l,"precision"),function(){return r=e.apply(this,arguments),w.invert=r.invert&&k,M()}}function Ln(t){return Sn(t,function(e,r){t.point(e*Et,r*Et)})}function zn(t,e){return[t,e]}function Pn(t,e){return[t>At?t-Tt:t<-At?t+Tt:t,e]}function Dn(t,e,r){return t?e||r?Gr(In(t),Rn(e,r)):In(t):e||r?Rn(e,r):Pn}function On(t){return function(e,r){return[(e+=t)>At?e-Tt:e<-At?e+Tt:e,r]}}function In(t){var e=On(t);return e.invert=On(-t),e}function Rn(t,e){var r=Math.cos(t),n=Math.sin(t),i=Math.cos(e),a=Math.sin(e);function o(t,e){var o=Math.cos(e),s=Math.cos(t)*o,l=Math.sin(t)*o,c=Math.sin(e),u=c*r+s*n;return[Math.atan2(l*i-u*a,s*r-c*n),Ot(u*i+l*a)]}return o.invert=function(t,e){var o=Math.cos(e),s=Math.cos(t)*o,l=Math.sin(t)*o,c=Math.sin(e),u=c*i-l*a;return[Math.atan2(l*i+c*a,s*r+u*n),Ot(u*r-s*n)]},o}function Bn(t,e){var r=Math.cos(t),n=Math.sin(t);return function(i,a,o,s){var l=o*e;null!=i?(i=Fn(r,i),a=Fn(r,a),(o>0?ia)&&(i+=o*Tt)):(i=t+o*Tt,a=t-.5*l);for(var c,u=i;o>0?u>a:u2?t[2]*Et:0),e.invert=function(e){return(e=t.invert(e[0]*Et,e[1]*Et))[0]*=Lt,e[1]*=Lt,e},e},Pn.invert=zn,t.geo.circle=function(){var t,e,r=[0,0],n=6;function i(){var t="function"==typeof r?r.apply(this,arguments):r,n=Dn(-t[0]*Et,-t[1]*Et,0).invert,i=[];return e(null,null,1,{point:function(t,e){i.push(t=n(t,e)),t[0]*=Lt,t[1]*=Lt}}),{type:"Polygon",coordinates:[i]}}return i.origin=function(t){return arguments.length?(r=t,i):r},i.angle=function(r){return arguments.length?(e=Bn((t=+r)*Et,n*Et),i):t},i.precision=function(r){return arguments.length?(e=Bn(t*Et,(n=+r)*Et),i):n},i.angle(90)},t.geo.distance=function(t,e){var r,n=(e[0]-t[0])*Et,i=t[1]*Et,a=e[1]*Et,o=Math.sin(n),s=Math.cos(n),l=Math.sin(i),c=Math.cos(i),u=Math.sin(a),f=Math.cos(a);return Math.atan2(Math.sqrt((r=f*o)*r+(r=c*u-l*f*s)*r),l*u+c*f*s)},t.geo.graticule=function(){var e,r,n,i,a,o,s,l,c,u,f,h,p=10,d=p,g=90,m=360,v=2.5;function x(){return{type:"MultiLineString",coordinates:b()}}function b(){return t.range(Math.ceil(i/g)*g,n,g).map(f).concat(t.range(Math.ceil(l/m)*m,s,m).map(h)).concat(t.range(Math.ceil(r/p)*p,e,p).filter(function(t){return y(t%g)>kt}).map(c)).concat(t.range(Math.ceil(o/d)*d,a,d).filter(function(t){return y(t%m)>kt}).map(u))}return x.lines=function(){return b().map(function(t){return{type:"LineString",coordinates:t}})},x.outline=function(){return{type:"Polygon",coordinates:[f(i).concat(h(s).slice(1),f(n).reverse().slice(1),h(l).reverse().slice(1))]}},x.extent=function(t){return arguments.length?x.majorExtent(t).minorExtent(t):x.minorExtent()},x.majorExtent=function(t){return arguments.length?(i=+t[0][0],n=+t[1][0],l=+t[0][1],s=+t[1][1],i>n&&(t=i,i=n,n=t),l>s&&(t=l,l=s,s=t),x.precision(v)):[[i,l],[n,s]]},x.minorExtent=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],o=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),o>a&&(t=o,o=a,a=t),x.precision(v)):[[r,o],[e,a]]},x.step=function(t){return arguments.length?x.majorStep(t).minorStep(t):x.minorStep()},x.majorStep=function(t){return arguments.length?(g=+t[0],m=+t[1],x):[g,m]},x.minorStep=function(t){return arguments.length?(p=+t[0],d=+t[1],x):[p,d]},x.precision=function(t){return arguments.length?(v=+t,c=Nn(o,a,90),u=jn(r,e,v),f=Nn(l,s,90),h=jn(i,n,v),x):v},x.majorExtent([[-180,-90+kt],[180,90-kt]]).minorExtent([[-180,-80-kt],[180,80+kt]])},t.geo.greatArc=function(){var e,r,n=Vn,i=Un;function a(){return{type:"LineString",coordinates:[e||n.apply(this,arguments),r||i.apply(this,arguments)]}}return a.distance=function(){return t.geo.distance(e||n.apply(this,arguments),r||i.apply(this,arguments))},a.source=function(t){return arguments.length?(n=t,e="function"==typeof t?null:t,a):n},a.target=function(t){return arguments.length?(i=t,r="function"==typeof t?null:t,a):i},a.precision=function(){return arguments.length?a:0},a},t.geo.interpolate=function(t,e){return r=t[0]*Et,n=t[1]*Et,i=e[0]*Et,a=e[1]*Et,o=Math.cos(n),s=Math.sin(n),l=Math.cos(a),c=Math.sin(a),u=o*Math.cos(r),f=o*Math.sin(r),h=l*Math.cos(i),p=l*Math.sin(i),d=2*Math.asin(Math.sqrt(Rt(a-n)+o*l*Rt(i-r))),g=1/Math.sin(d),(m=d?function(t){var e=Math.sin(t*=d)*g,r=Math.sin(d-t)*g,n=r*u+e*h,i=r*f+e*p,a=r*s+e*c;return[Math.atan2(i,n)*Lt,Math.atan2(a,Math.sqrt(n*n+i*i))*Lt]}:function(){return[r*Lt,n*Lt]}).distance=d,m;var r,n,i,a,o,s,l,c,u,f,h,p,d,g,m},t.geo.length=function(e){return yn=0,t.geo.stream(e,qn),yn};var qn={sphere:I,point:I,lineStart:function(){var t,e,r;function n(n,i){var a=Math.sin(i*=Et),o=Math.cos(i),s=y((n*=Et)-t),l=Math.cos(s);yn+=Math.atan2(Math.sqrt((s=o*Math.sin(s))*s+(s=r*a-e*o*l)*s),e*a+r*o*l),t=n,e=a,r=o}qn.point=function(i,a){t=i*Et,e=Math.sin(a*=Et),r=Math.cos(a),qn.point=n},qn.lineEnd=function(){qn.point=qn.lineEnd=I}},lineEnd:I,polygonStart:I,polygonEnd:I};function Hn(t,e){function r(e,r){var n=Math.cos(e),i=Math.cos(r),a=t(n*i);return[a*i*Math.sin(e),a*Math.sin(r)]}return r.invert=function(t,r){var n=Math.sqrt(t*t+r*r),i=e(n),a=Math.sin(i),o=Math.cos(i);return[Math.atan2(t*a,n*o),Math.asin(n&&r*a/n)]},r}var Gn=Hn(function(t){return Math.sqrt(2/(1+t))},function(t){return 2*Math.asin(t/2)});(t.geo.azimuthalEqualArea=function(){return Cn(Gn)}).raw=Gn;var Wn=Hn(function(t){var e=Math.acos(t);return e&&e/Math.sin(e)},z);function Yn(t,e){var r=Math.cos(t),n=function(t){return Math.tan(At/4+t/2)},i=t===e?Math.sin(t):Math.log(r/Math.cos(e))/Math.log(n(e)/n(t)),a=r*Math.pow(n(t),i)/i;if(!i)return Jn;function o(t,e){a>0?e<-Ct+kt&&(e=-Ct+kt):e>Ct-kt&&(e=Ct-kt);var r=a/Math.pow(n(e),i);return[r*Math.sin(i*t),a-r*Math.cos(i*t)]}return o.invert=function(t,e){var r=a-e,n=zt(i)*Math.sqrt(t*t+r*r);return[Math.atan2(t,r)/i,2*Math.atan(Math.pow(a/n,1/i))-Ct]},o}function Xn(t,e){var r=Math.cos(t),n=t===e?Math.sin(t):(r-Math.cos(e))/(e-t),i=r/n+t;if(y(n)1&&Pt(t[r[n-2]],t[r[n-1]],t[i])<=0;)--n;r[n++]=i}return r.slice(0,n)}function ii(t,e){return t[0]-e[0]||t[1]-e[1]}(t.geo.stereographic=function(){return Cn($n)}).raw=$n,ti.invert=function(t,e){return[-e,2*Math.atan(Math.exp(t))-Ct]},(t.geo.transverseMercator=function(){var t=Kn(ti),e=t.center,r=t.rotate;return t.center=function(t){return t?e([-t[1],t[0]]):[(t=e())[1],-t[0]]},t.rotate=function(t){return t?r([t[0],t[1],t.length>2?t[2]+90:90]):[(t=r())[0],t[1],t[2]-90]},r([0,0,90])}).raw=ti,t.geom={},t.geom.hull=function(t){var e=ei,r=ri;if(arguments.length)return n(t);function n(t){if(t.length<3)return[];var n,i=me(e),a=me(r),o=t.length,s=[],l=[];for(n=0;n=0;--n)p.push(t[s[c[n]][2]]);for(n=+f;nkt)s=s.L;else{if(!((i=a-wi(s,o))>kt)){n>-kt?(e=s.P,r=s):i>-kt?(e=s,r=s.N):e=r=s;break}if(!s.R){e=s;break}s=s.R}var l=vi(t);if(fi.insert(e,l),e||r){if(e===r)return Si(e),r=vi(e.site),fi.insert(l,r),l.edge=r.edge=Li(e.site,l.site),Ti(e),void Ti(r);if(r){Si(e),Si(r);var c=e.site,u=c.x,f=c.y,h=t.x-u,p=t.y-f,d=r.site,g=d.x-u,m=d.y-f,v=2*(h*m-p*g),y=h*h+p*p,x=g*g+m*m,b={x:(m*y-p*x)/v+u,y:(h*x-g*y)/v+f};zi(r.edge,c,d,b),l.edge=Li(c,t,null,b),r.edge=Li(t,d,null,b),Ti(e),Ti(r)}else l.edge=Li(e.site,l.site)}}function _i(t,e){var r=t.site,n=r.x,i=r.y,a=i-e;if(!a)return n;var o=t.P;if(!o)return-1/0;var s=(r=o.site).x,l=r.y,c=l-e;if(!c)return s;var u=s-n,f=1/a-1/c,h=u/c;return f?(-h+Math.sqrt(h*h-2*f*(u*u/(-2*c)-l+c/2+i-a/2)))/f+n:(n+s)/2}function wi(t,e){var r=t.N;if(r)return _i(r,e);var n=t.site;return n.y===e?n.x:1/0}function ki(t){this.site=t,this.edges=[]}function Mi(t,e){return e.angle-t.angle}function Ai(){Oi(this),this.x=this.y=this.arc=this.site=this.cy=null}function Ti(t){var e=t.P,r=t.N;if(e&&r){var n=e.site,i=t.site,a=r.site;if(n!==a){var o=i.x,s=i.y,l=n.x-o,c=n.y-s,u=a.x-o,f=2*(l*(m=a.y-s)-c*u);if(!(f>=-Mt)){var h=l*l+c*c,p=u*u+m*m,d=(m*h-c*p)/f,g=(l*p-u*h)/f,m=g+s,v=gi.pop()||new Ai;v.arc=t,v.site=i,v.x=d+o,v.y=m+Math.sqrt(d*d+g*g),v.cy=m,t.circle=v;for(var y=null,x=pi._;x;)if(v.y=s)return;if(h>d){if(a){if(a.y>=c)return}else a={x:m,y:l};r={x:m,y:c}}else{if(a){if(a.y1)if(h>d){if(a){if(a.y>=c)return}else a={x:(l-i)/n,y:l};r={x:(c-i)/n,y:c}}else{if(a){if(a.y=s)return}else a={x:o,y:n*o+i};r={x:s,y:n*s+i}}else{if(a){if(a.xkt||y(i-r)>kt)&&(s.splice(o,0,new Pi((v=a.site,x=u,b=y(n-f)kt?{x:f,y:y(e-f)kt?{x:y(r-d)kt?{x:h,y:y(e-h)kt?{x:y(r-p)=r&&c.x<=i&&c.y>=n&&c.y<=o?[[r,o],[i,o],[i,n],[r,n]]:[]).point=t[s]}),e}function s(t){return t.map(function(t,e){return{x:Math.round(n(t,e)/kt)*kt,y:Math.round(i(t,e)/kt)*kt,i:e}})}return o.links=function(t){return Fi(s(t)).edges.filter(function(t){return t.l&&t.r}).map(function(e){return{source:t[e.l.i],target:t[e.r.i]}})},o.triangles=function(t){var e=[];return Fi(s(t)).cells.forEach(function(r,n){for(var i,a,o,s,l=r.site,c=r.edges.sort(Mi),u=-1,f=c.length,h=c[f-1].edge,p=h.l===l?h.r:h.l;++ua&&(i=e.slice(a,i),s[o]?s[o]+=i:s[++o]=i),(r=r[0])===(n=n[0])?s[o]?s[o]+=n:s[++o]=n:(s[++o]=null,l.push({i:o,x:Gi(r,n)})),a=Xi.lastIndex;return ag&&(g=l.x),l.y>m&&(m=l.y),c.push(l.x),u.push(l.y);else for(f=0;fg&&(g=b),_>m&&(m=_),c.push(b),u.push(_)}var w=g-p,k=m-d;function M(t,e,r,n,i,a,o,s){if(!isNaN(r)&&!isNaN(n))if(t.leaf){var l=t.x,c=t.y;if(null!=l)if(y(l-r)+y(c-n)<.01)A(t,e,r,n,i,a,o,s);else{var u=t.point;t.x=t.y=t.point=null,A(t,u,l,c,i,a,o,s),A(t,e,r,n,i,a,o,s)}else t.x=r,t.y=n,t.point=e}else A(t,e,r,n,i,a,o,s)}function A(t,e,r,n,i,a,o,s){var l=.5*(i+o),c=.5*(a+s),u=r>=l,f=n>=c,h=f<<1|u;t.leaf=!1,u?i=l:o=l,f?a=c:s=c,M(t=t.nodes[h]||(t.nodes[h]={leaf:!0,nodes:[],point:null,x:null,y:null,add:function(t){M(T,t,+v(t,++f),+x(t,f),p,d,g,m)}}),e,r,n,i,a,o,s)}w>k?m=d+w:g=p+k;var T={leaf:!0,nodes:[],point:null,x:null,y:null,add:function(t){M(T,t,+v(t,++f),+x(t,f),p,d,g,m)}};if(T.visit=function(t){!function t(e,r,n,i,a,o){if(!e(r,n,i,a,o)){var s=.5*(n+a),l=.5*(i+o),c=r.nodes;c[0]&&t(e,c[0],n,i,s,l),c[1]&&t(e,c[1],s,i,a,l),c[2]&&t(e,c[2],n,l,s,o),c[3]&&t(e,c[3],s,l,a,o)}}(t,T,p,d,g,m)},T.find=function(t){return function(t,e,r,n,i,a,o){var s,l=1/0;return function t(c,u,f,h,p){if(!(u>a||f>o||h=_)<<1|e>=b,k=w+4;w=0&&!(n=t.interpolators[i](e,r)););return n}function Ji(t,e){var r,n=[],i=[],a=t.length,o=e.length,s=Math.min(t.length,e.length);for(r=0;r=1)return 1;var e=t*t,r=e*t;return 4*(t<.5?r:3*(t-e)+r-.75)}function aa(t){return 1-Math.cos(t*Ct)}function oa(t){return Math.pow(2,10*(t-1))}function sa(t){return 1-Math.sqrt(1-t*t)}function la(t){return t<1/2.75?7.5625*t*t:t<2/2.75?7.5625*(t-=1.5/2.75)*t+.75:t<2.5/2.75?7.5625*(t-=2.25/2.75)*t+.9375:7.5625*(t-=2.625/2.75)*t+.984375}function ca(t,e){return e-=t,function(r){return Math.round(t+e*r)}}function ua(t){var e,r,n,i=[t.a,t.b],a=[t.c,t.d],o=ha(i),s=fa(i,a),l=ha(((e=a)[0]+=(n=-s)*(r=i)[0],e[1]+=n*r[1],e))||0;i[0]*a[1]=0?t.slice(0,n):t,a=n>=0?t.slice(n+1):"in";return i=Qi.get(i)||Ki,a=$i.get(a)||z,e=a(i.apply(null,r.call(arguments,1))),function(t){return t<=0?0:t>=1?1:e(t)}},t.interpolateHcl=function(e,r){e=t.hcl(e),r=t.hcl(r);var n=e.h,i=e.c,a=e.l,o=r.h-n,s=r.c-i,l=r.l-a;isNaN(s)&&(s=0,i=isNaN(i)?r.c:i);isNaN(o)?(o=0,n=isNaN(n)?r.h:n):o>180?o-=360:o<-180&&(o+=360);return function(t){return Yt(n+o*t,i+s*t,a+l*t)+""}},t.interpolateHsl=function(e,r){e=t.hsl(e),r=t.hsl(r);var n=e.h,i=e.s,a=e.l,o=r.h-n,s=r.s-i,l=r.l-a;isNaN(s)&&(s=0,i=isNaN(i)?r.s:i);isNaN(o)?(o=0,n=isNaN(n)?r.h:n):o>180?o-=360:o<-180&&(o+=360);return function(t){return Ht(n+o*t,i+s*t,a+l*t)+""}},t.interpolateLab=function(e,r){e=t.lab(e),r=t.lab(r);var n=e.l,i=e.a,a=e.b,o=r.l-n,s=r.a-i,l=r.b-a;return function(t){return te(n+o*t,i+s*t,a+l*t)+""}},t.interpolateRound=ca,t.transform=function(e){var r=i.createElementNS(t.ns.prefix.svg,"g");return(t.transform=function(t){if(null!=t){r.setAttribute("transform",t);var e=r.transform.baseVal.consolidate()}return new ua(e?e.matrix:pa)})(e)},ua.prototype.toString=function(){return"translate("+this.translate+")rotate("+this.rotate+")skewX("+this.skew+")scale("+this.scale+")"};var pa={a:1,b:0,c:0,d:1,e:0,f:0};function da(t){return t.length?t.pop()+",":""}function ga(e,r){var n=[],i=[];return e=t.transform(e),r=t.transform(r),function(t,e,r,n){if(t[0]!==e[0]||t[1]!==e[1]){var i=r.push("translate(",null,",",null,")");n.push({i:i-4,x:Gi(t[0],e[0])},{i:i-2,x:Gi(t[1],e[1])})}else(e[0]||e[1])&&r.push("translate("+e+")")}(e.translate,r.translate,n,i),function(t,e,r,n){t!==e?(t-e>180?e+=360:e-t>180&&(t+=360),n.push({i:r.push(da(r)+"rotate(",null,")")-2,x:Gi(t,e)})):e&&r.push(da(r)+"rotate("+e+")")}(e.rotate,r.rotate,n,i),function(t,e,r,n){t!==e?n.push({i:r.push(da(r)+"skewX(",null,")")-2,x:Gi(t,e)}):e&&r.push(da(r)+"skewX("+e+")")}(e.skew,r.skew,n,i),function(t,e,r,n){if(t[0]!==e[0]||t[1]!==e[1]){var i=r.push(da(r)+"scale(",null,",",null,")");n.push({i:i-4,x:Gi(t[0],e[0])},{i:i-2,x:Gi(t[1],e[1])})}else 1===e[0]&&1===e[1]||r.push(da(r)+"scale("+e+")")}(e.scale,r.scale,n,i),e=r=null,function(t){for(var e,r=-1,a=i.length;++r0?n=t:(e.c=null,e.t=NaN,e=null,l.end({type:"end",alpha:n=0})):t>0&&(l.start({type:"start",alpha:n=t}),e=Me(s.tick)),s):n},s.start=function(){var t,e,r,n=v.length,l=y.length,u=c[0],d=c[1];for(t=0;t=0;)r.push(i[n])}function Ea(t,e){for(var r=[t],n=[];null!=(t=r.pop());)if(n.push(t),(a=t.children)&&(i=a.length))for(var i,a,o=-1;++o=0;)o.push(u=c[l]),u.parent=a,u.depth=a.depth+1;r&&(a.value=0),a.children=c}else r&&(a.value=+r.call(n,a,a.depth)||0),delete a.children;return Ea(i,function(e){var n,i;t&&(n=e.children)&&n.sort(t),r&&(i=e.parent)&&(i.value+=e.value)}),s}return n.sort=function(e){return arguments.length?(t=e,n):t},n.children=function(t){return arguments.length?(e=t,n):e},n.value=function(t){return arguments.length?(r=t,n):r},n.revalue=function(t){return r&&(Ca(t,function(t){t.children&&(t.value=0)}),Ea(t,function(t){var e;t.children||(t.value=+r.call(n,t,t.depth)||0),(e=t.parent)&&(e.value+=t.value)})),t},n},t.layout.partition=function(){var e=t.layout.hierarchy(),r=[1,1];function n(t,n){var i=e.call(this,t,n);return function t(e,r,n,i){var a=e.children;if(e.x=r,e.y=e.depth*i,e.dx=n,e.dy=i,a&&(o=a.length)){var o,s,l,c=-1;for(n=e.value?n/e.value:0;++cs&&(s=n),o.push(n)}for(r=0;ri&&(n=r,i=e);return n}function qa(t){return t.reduce(Ha,0)}function Ha(t,e){return t+e[1]}function Ga(t,e){return Wa(t,Math.ceil(Math.log(e.length)/Math.LN2+1))}function Wa(t,e){for(var r=-1,n=+t[0],i=(t[1]-n)/e,a=[];++r<=e;)a[r]=i*r+n;return a}function Ya(e){return[t.min(e),t.max(e)]}function Xa(t,e){return t.value-e.value}function Za(t,e){var r=t._pack_next;t._pack_next=e,e._pack_prev=t,e._pack_next=r,r._pack_prev=e}function Ja(t,e){t._pack_next=e,e._pack_prev=t}function Ka(t,e){var r=e.x-t.x,n=e.y-t.y,i=t.r+e.r;return.999*i*i>r*r+n*n}function Qa(t){if((e=t.children)&&(l=e.length)){var e,r,n,i,a,o,s,l,c=1/0,u=-1/0,f=1/0,h=-1/0;if(e.forEach($a),(r=e[0]).x=-r.r,r.y=0,x(r),l>1&&((n=e[1]).x=n.r,n.y=0,x(n),l>2))for(eo(r,n,i=e[2]),x(i),Za(r,i),r._pack_prev=i,Za(i,n),n=r._pack_next,a=3;a0)for(o=-1;++o=f[0]&&l<=f[1]&&((s=c[t.bisect(h,l,1,d)-1]).y+=g,s.push(a[o]));return c}return a.value=function(t){return arguments.length?(r=t,a):r},a.range=function(t){return arguments.length?(n=me(t),a):n},a.bins=function(t){return arguments.length?(i="number"==typeof t?function(e){return Wa(e,t)}:me(t),a):i},a.frequency=function(t){return arguments.length?(e=!!t,a):e},a},t.layout.pack=function(){var e,r=t.layout.hierarchy().sort(Xa),n=0,i=[1,1];function a(t,a){var o=r.call(this,t,a),s=o[0],l=i[0],c=i[1],u=null==e?Math.sqrt:"function"==typeof e?e:function(){return e};if(s.x=s.y=0,Ea(s,function(t){t.r=+u(t.value)}),Ea(s,Qa),n){var f=n*(e?1:Math.max(2*s.r/l,2*s.r/c))/2;Ea(s,function(t){t.r+=f}),Ea(s,Qa),Ea(s,function(t){t.r-=f})}return function t(e,r,n,i){var a=e.children;e.x=r+=i*e.x;e.y=n+=i*e.y;e.r*=i;if(a)for(var o=-1,s=a.length;++op.x&&(p=t),t.depth>d.depth&&(d=t)});var g=r(h,p)/2-h.x,m=n[0]/(p.x+r(p,h)/2+g),v=n[1]/(d.depth||1);Ca(u,function(t){t.x=(t.x+g)*m,t.y=t.depth*v})}return c}function o(t){var e=t.children,n=t.parent.children,i=t.i?n[t.i-1]:null;if(e.length){!function(t){var e,r=0,n=0,i=t.children,a=i.length;for(;--a>=0;)(e=i[a]).z+=r,e.m+=r,r+=e.s+(n+=e.c)}(t);var a=(e[0].z+e[e.length-1].z)/2;i?(t.z=i.z+r(t._,i._),t.m=t.z-a):t.z=a}else i&&(t.z=i.z+r(t._,i._));t.parent.A=function(t,e,n){if(e){for(var i,a=t,o=t,s=e,l=a.parent.children[0],c=a.m,u=o.m,f=s.m,h=l.m;s=io(s),a=no(a),s&&a;)l=no(l),(o=io(o)).a=t,(i=s.z+f-a.z-c+r(s._,a._))>0&&(ao(oo(s,t,n),t,i),c+=i,u+=i),f+=s.m,c+=a.m,h+=l.m,u+=o.m;s&&!io(o)&&(o.t=s,o.m+=f-u),a&&!no(l)&&(l.t=a,l.m+=c-h,n=t)}return n}(t,i,t.parent.A||n[0])}function s(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function l(t){t.x*=n[0],t.y=t.depth*n[1]}return a.separation=function(t){return arguments.length?(r=t,a):r},a.size=function(t){return arguments.length?(i=null==(n=t)?l:null,a):i?null:n},a.nodeSize=function(t){return arguments.length?(i=null==(n=t)?null:l,a):i?n:null},Sa(a,e)},t.layout.cluster=function(){var e=t.layout.hierarchy().sort(null).value(null),r=ro,n=[1,1],i=!1;function a(a,o){var s,l=e.call(this,a,o),c=l[0],u=0;Ea(c,function(e){var n=e.children;n&&n.length?(e.x=function(t){return t.reduce(function(t,e){return t+e.x},0)/t.length}(n),e.y=function(e){return 1+t.max(e,function(t){return t.y})}(n)):(e.x=s?u+=r(e,s):0,e.y=0,s=e)});var f=function t(e){var r=e.children;return r&&r.length?t(r[0]):e}(c),h=function t(e){var r,n=e.children;return n&&(r=n.length)?t(n[r-1]):e}(c),p=f.x-r(f,h)/2,d=h.x+r(h,f)/2;return Ea(c,i?function(t){t.x=(t.x-c.x)*n[0],t.y=(c.y-t.y)*n[1]}:function(t){t.x=(t.x-p)/(d-p)*n[0],t.y=(1-(c.y?t.y/c.y:1))*n[1]}),l}return a.separation=function(t){return arguments.length?(r=t,a):r},a.size=function(t){return arguments.length?(i=null==(n=t),a):i?null:n},a.nodeSize=function(t){return arguments.length?(i=null!=(n=t),a):i?n:null},Sa(a,e)},t.layout.treemap=function(){var e,r=t.layout.hierarchy(),n=Math.round,i=[1,1],a=null,o=so,s=!1,l="squarify",c=.5*(1+Math.sqrt(5));function u(t,e){for(var r,n,i=-1,a=t.length;++i0;)s.push(r=c[i-1]),s.area+=r.area,"squarify"!==l||(n=p(s,g))<=h?(c.pop(),h=n):(s.area-=s.pop().area,d(s,g,a,!1),g=Math.min(a.dx,a.dy),s.length=s.area=0,h=1/0);s.length&&(d(s,g,a,!0),s.length=s.area=0),e.forEach(f)}}function h(t){var e=t.children;if(e&&e.length){var r,n=o(t),i=e.slice(),a=[];for(u(i,n.dx*n.dy/t.value),a.area=0;r=i.pop();)a.push(r),a.area+=r.area,null!=r.z&&(d(a,r.z?n.dx:n.dy,n,!i.length),a.length=a.area=0);e.forEach(h)}}function p(t,e){for(var r,n=t.area,i=0,a=1/0,o=-1,s=t.length;++oi&&(i=r));return e*=e,(n*=n)?Math.max(e*i*c/n,n/(e*a*c)):1/0}function d(t,e,r,i){var a,o=-1,s=t.length,l=r.x,c=r.y,u=e?n(t.area/e):0;if(e==r.dx){for((i||u>r.dy)&&(u=r.dy);++or.dx)&&(u=r.dx);++o1);return t+e*r*Math.sqrt(-2*Math.log(i)/i)}},logNormal:function(){var e=t.random.normal.apply(t,arguments);return function(){return Math.exp(e())}},bates:function(e){var r=t.random.irwinHall(e);return function(){return r()/e}},irwinHall:function(t){return function(){for(var e=0,r=0;r2?mo:fo,s=i?va:ma;return a=t(e,r,s,n),o=t(r,e,s,Zi),l}function l(t){return a(t)}l.invert=function(t){return o(t)};l.domain=function(t){return arguments.length?(e=t.map(Number),s()):e};l.range=function(t){return arguments.length?(r=t,s()):r};l.rangeRound=function(t){return l.range(t).interpolate(ca)};l.clamp=function(t){return arguments.length?(i=t,s()):i};l.interpolate=function(t){return arguments.length?(n=t,s()):n};l.ticks=function(t){return bo(e,t)};l.tickFormat=function(t,r){return _o(e,t,r)};l.nice=function(t){return yo(e,t),s()};l.copy=function(){return t(e,r,n,i)};return s()}([0,1],[0,1],Zi,!1)};var wo={s:1,g:1,p:1,r:1,e:1};function ko(t){return-Math.floor(Math.log(t)/Math.LN10+.01)}t.scale.log=function(){return function e(r,n,i,a){function o(t){return(i?Math.log(t<0?0:t):-Math.log(t>0?0:-t))/Math.log(n)}function s(t){return i?Math.pow(n,t):-Math.pow(n,-t)}function l(t){return r(o(t))}l.invert=function(t){return s(r.invert(t))};l.domain=function(t){return arguments.length?(i=t[0]>=0,r.domain((a=t.map(Number)).map(o)),l):a};l.base=function(t){return arguments.length?(n=+t,r.domain(a.map(o)),l):n};l.nice=function(){var t=ho(a.map(o),i?Math:Ao);return r.domain(t),a=t.map(s),l};l.ticks=function(){var t=co(a),e=[],r=t[0],l=t[1],c=Math.floor(o(r)),u=Math.ceil(o(l)),f=n%1?2:n;if(isFinite(u-c)){if(i){for(;c0;h--)e.push(s(c)*h);for(c=0;e[c]l;u--);e=e.slice(c,u)}return e};l.tickFormat=function(e,r){if(!arguments.length)return Mo;arguments.length<2?r=Mo:"function"!=typeof r&&(r=t.format(r));var i=Math.max(1,n*e/l.ticks().length);return function(t){var e=t/s(Math.round(o(t)));return e*n0?i[t-1]:r[0],tf?0:1;if(c=St)return l(c,p)+(s?l(s,1-p):"")+"Z";var d,g,m,v,y,x,b,_,w,k,M,A,T=0,S=0,C=[];if((v=(+o.apply(this,arguments)||0)/2)&&(m=n===Po?Math.sqrt(s*s+c*c):+n.apply(this,arguments),p||(S*=-1),c&&(S=Ot(m/c*Math.sin(v))),s&&(T=Ot(m/s*Math.sin(v)))),c){y=c*Math.cos(u+S),x=c*Math.sin(u+S),b=c*Math.cos(f-S),_=c*Math.sin(f-S);var E=Math.abs(f-u-2*S)<=At?0:1;if(S&&Fo(y,x,b,_)===p^E){var L=(u+f)/2;y=c*Math.cos(L),x=c*Math.sin(L),b=_=null}}else y=x=0;if(s){w=s*Math.cos(f-T),k=s*Math.sin(f-T),M=s*Math.cos(u+T),A=s*Math.sin(u+T);var z=Math.abs(u-f+2*T)<=At?0:1;if(T&&Fo(w,k,M,A)===1-p^z){var P=(u+f)/2;w=s*Math.cos(P),k=s*Math.sin(P),M=A=null}}else w=k=0;if(h>kt&&(d=Math.min(Math.abs(c-s)/2,+r.apply(this,arguments)))>.001){g=s0?0:1}function No(t,e,r,n,i){var a=t[0]-e[0],o=t[1]-e[1],s=(i?n:-n)/Math.sqrt(a*a+o*o),l=s*o,c=-s*a,u=t[0]+l,f=t[1]+c,h=e[0]+l,p=e[1]+c,d=(u+h)/2,g=(f+p)/2,m=h-u,v=p-f,y=m*m+v*v,x=r-n,b=u*p-h*f,_=(v<0?-1:1)*Math.sqrt(Math.max(0,x*x*y-b*b)),w=(b*v-m*_)/y,k=(-b*m-v*_)/y,M=(b*v+m*_)/y,A=(-b*m+v*_)/y,T=w-d,S=k-g,C=M-d,E=A-g;return T*T+S*S>C*C+E*E&&(w=M,k=A),[[w-l,k-c],[w*r/x,k*r/x]]}function jo(t){var e=ei,r=ri,n=Wr,i=Uo,a=i.key,o=.7;function s(a){var s,l=[],c=[],u=-1,f=a.length,h=me(e),p=me(r);function d(){l.push("M",i(t(c),o))}for(;++u1&&i.push("H",n[0]);return i.join("")},"step-before":Ho,"step-after":Go,basis:Xo,"basis-open":function(t){if(t.length<4)return Uo(t);var e,r=[],n=-1,i=t.length,a=[0],o=[0];for(;++n<3;)e=t[n],a.push(e[0]),o.push(e[1]);r.push(Zo(Qo,a)+","+Zo(Qo,o)),--n;for(;++n9&&(i=3*e/Math.sqrt(i),o[s]=i*r,o[s+1]=i*n));s=-1;for(;++s<=l;)i=(t[Math.min(l,s+1)][0]-t[Math.max(0,s-1)][0])/(6*(1+o[s]*o[s])),a.push([i||0,o[s]*i||0]);return a}(t))}});function Uo(t){return t.length>1?t.join("L"):t+"Z"}function qo(t){return t.join("L")+"Z"}function Ho(t){for(var e=0,r=t.length,n=t[0],i=[n[0],",",n[1]];++e1){s=e[1],a=t[l],l++,n+="C"+(i[0]+o[0])+","+(i[1]+o[1])+","+(a[0]-s[0])+","+(a[1]-s[1])+","+a[0]+","+a[1];for(var c=2;cAt)+",1 "+e}function l(t,e,r,n){return"Q 0,0 "+n}return a.radius=function(t){return arguments.length?(r=me(t),a):r},a.source=function(e){return arguments.length?(t=me(e),a):t},a.target=function(t){return arguments.length?(e=me(t),a):e},a.startAngle=function(t){return arguments.length?(n=me(t),a):n},a.endAngle=function(t){return arguments.length?(i=me(t),a):i},a},t.svg.diagonal=function(){var t=Vn,e=Un,r=is;function n(n,i){var a=t.call(this,n,i),o=e.call(this,n,i),s=(a.y+o.y)/2,l=[a,{x:a.x,y:s},{x:o.x,y:s},o];return"M"+(l=l.map(r))[0]+"C"+l[1]+" "+l[2]+" "+l[3]}return n.source=function(e){return arguments.length?(t=me(e),n):t},n.target=function(t){return arguments.length?(e=me(t),n):e},n.projection=function(t){return arguments.length?(r=t,n):r},n},t.svg.diagonal.radial=function(){var e=t.svg.diagonal(),r=is,n=e.projection;return e.projection=function(t){return arguments.length?n(function(t){return function(){var e=t.apply(this,arguments),r=e[0],n=e[1]-Ct;return[r*Math.cos(n),r*Math.sin(n)]}}(r=t)):r},e},t.svg.symbol=function(){var t=os,e=as;function r(r,n){return(ls.get(t.call(this,r,n))||ss)(e.call(this,r,n))}return r.type=function(e){return arguments.length?(t=me(e),r):t},r.size=function(t){return arguments.length?(e=me(t),r):e},r};var ls=t.map({circle:ss,cross:function(t){var e=Math.sqrt(t/5)/2;return"M"+-3*e+","+-e+"H"+-e+"V"+-3*e+"H"+e+"V"+-e+"H"+3*e+"V"+e+"H"+e+"V"+3*e+"H"+-e+"V"+e+"H"+-3*e+"Z"},diamond:function(t){var e=Math.sqrt(t/(2*us)),r=e*us;return"M0,"+-e+"L"+r+",0 0,"+e+" "+-r+",0Z"},square:function(t){var e=Math.sqrt(t)/2;return"M"+-e+","+-e+"L"+e+","+-e+" "+e+","+e+" "+-e+","+e+"Z"},"triangle-down":function(t){var e=Math.sqrt(t/cs),r=e*cs/2;return"M0,"+r+"L"+e+","+-r+" "+-e+","+-r+"Z"},"triangle-up":function(t){var e=Math.sqrt(t/cs),r=e*cs/2;return"M0,"+-r+"L"+e+","+r+" "+-e+","+r+"Z"}});t.svg.symbolTypes=ls.keys();var cs=Math.sqrt(3),us=Math.tan(30*Et);Y.transition=function(t){for(var e,r,n=ds||++vs,i=bs(t),a=[],o=gs||{time:Date.now(),ease:ia,delay:0,duration:250},s=-1,l=this.length;++s0;)c[--h].call(t,o);if(a>=1)return f.event&&f.event.end.call(t,t.__data__,e),--u.count?delete u[n]:delete t[r],1}f||(a=i.time,o=Me(function(t){var e=f.delay;if(o.t=e+a,e<=t)return h(t-e);o.c=h},0,a),f=u[n]={tween:new b,time:a,timer:o,delay:i.delay,duration:i.duration,ease:i.ease,index:e},i=null,++u.count)}ms.call=Y.call,ms.empty=Y.empty,ms.node=Y.node,ms.size=Y.size,t.transition=function(e,r){return e&&e.transition?ds?e.transition(r):e:t.selection().transition(e)},t.transition.prototype=ms,ms.select=function(t){var e,r,n,i=this.id,a=this.namespace,o=[];t=X(t);for(var s=-1,l=this.length;++srect,.s>rect").attr("width",s[1]-s[0])}function g(t){t.select(".extent").attr("y",l[0]),t.selectAll(".extent,.e>rect,.w>rect").attr("height",l[1]-l[0])}function m(){var f,m,v=this,y=t.select(t.event.target),x=n.of(v,arguments),b=t.select(v),_=y.datum(),w=!/^(n|s)$/.test(_)&&i,k=!/^(e|w)$/.test(_)&&a,M=y.classed("extent"),A=xt(v),T=t.mouse(v),S=t.select(o(v)).on("keydown.brush",function(){32==t.event.keyCode&&(M||(f=null,T[0]-=s[1],T[1]-=l[1],M=2),F())}).on("keyup.brush",function(){32==t.event.keyCode&&2==M&&(T[0]+=s[1],T[1]+=l[1],M=0,F())});if(t.event.changedTouches?S.on("touchmove.brush",L).on("touchend.brush",P):S.on("mousemove.brush",L).on("mouseup.brush",P),b.interrupt().selectAll("*").interrupt(),M)T[0]=s[0]-T[0],T[1]=l[0]-T[1];else if(_){var C=+/w$/.test(_),E=+/^n/.test(_);m=[s[1-C]-T[0],l[1-E]-T[1]],T[0]=s[C],T[1]=l[E]}else t.event.altKey&&(f=T.slice());function L(){var e=t.mouse(v),r=!1;m&&(e[0]+=m[0],e[1]+=m[1]),M||(t.event.altKey?(f||(f=[(s[0]+s[1])/2,(l[0]+l[1])/2]),T[0]=s[+(e[0]1?{floor:function(e){for(;s(e=t.floor(e));)e=Ds(e-1);return e},ceil:function(e){for(;s(e=t.ceil(e));)e=Ds(+e+1);return e}}:t))},i.ticks=function(t,e){var r=co(i.domain()),n=null==t?a(r,10):"number"==typeof t?a(r,t):!t.range&&[{range:t},e];return n&&(t=n[0],e=n[1]),t.range(r[0],Ds(+r[1]+1),e<1?1:e)},i.tickFormat=function(){return n},i.copy=function(){return Ps(e.copy(),r,n)},vo(i,e)}function Ds(t){return new Date(t)}Cs.iso=Date.prototype.toISOString&&+new Date("2000-01-01T00:00:00.000Z")?zs:Ls,zs.parse=function(t){var e=new Date(t);return isNaN(e)?null:e},zs.toString=Ls.toString,De.second=Be(function(t){return new Oe(1e3*Math.floor(t/1e3))},function(t,e){t.setTime(t.getTime()+1e3*Math.floor(e))},function(t){return t.getSeconds()}),De.seconds=De.second.range,De.seconds.utc=De.second.utc.range,De.minute=Be(function(t){return new Oe(6e4*Math.floor(t/6e4))},function(t,e){t.setTime(t.getTime()+6e4*Math.floor(e))},function(t){return t.getMinutes()}),De.minutes=De.minute.range,De.minutes.utc=De.minute.utc.range,De.hour=Be(function(t){var e=t.getTimezoneOffset()/60;return new Oe(36e5*(Math.floor(t/36e5-e)+e))},function(t,e){t.setTime(t.getTime()+36e5*Math.floor(e))},function(t){return t.getHours()}),De.hours=De.hour.range,De.hours.utc=De.hour.utc.range,De.month=Be(function(t){return(t=De.day(t)).setDate(1),t},function(t,e){t.setMonth(t.getMonth()+e)},function(t){return t.getMonth()}),De.months=De.month.range,De.months.utc=De.month.utc.range;var Os=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,2592e6,7776e6,31536e6],Is=[[De.second,1],[De.second,5],[De.second,15],[De.second,30],[De.minute,1],[De.minute,5],[De.minute,15],[De.minute,30],[De.hour,1],[De.hour,3],[De.hour,6],[De.hour,12],[De.day,1],[De.day,2],[De.week,1],[De.month,1],[De.month,3],[De.year,1]],Rs=Cs.multi([[".%L",function(t){return t.getMilliseconds()}],[":%S",function(t){return t.getSeconds()}],["%I:%M",function(t){return t.getMinutes()}],["%I %p",function(t){return t.getHours()}],["%a %d",function(t){return t.getDay()&&1!=t.getDate()}],["%b %d",function(t){return 1!=t.getDate()}],["%B",function(t){return t.getMonth()}],["%Y",Wr]]),Bs={range:function(e,r,n){return t.range(Math.ceil(e/n)*n,+r,n).map(Ds)},floor:z,ceil:z};Is.year=De.year,De.scale=function(){return Ps(t.scale.linear(),Is,Rs)};var Fs=Is.map(function(t){return[t[0].utc,t[1]]}),Ns=Es.multi([[".%L",function(t){return t.getUTCMilliseconds()}],[":%S",function(t){return t.getUTCSeconds()}],["%I:%M",function(t){return t.getUTCMinutes()}],["%I %p",function(t){return t.getUTCHours()}],["%a %d",function(t){return t.getUTCDay()&&1!=t.getUTCDate()}],["%b %d",function(t){return 1!=t.getUTCDate()}],["%B",function(t){return t.getUTCMonth()}],["%Y",Wr]]);function js(t){return JSON.parse(t.responseText)}function Vs(t){var e=i.createRange();return e.selectNode(i.body),e.createContextualFragment(t.responseText)}Fs.year=De.year.utc,De.scale.utc=function(){return Ps(t.scale.linear(),Fs,Ns)},t.text=ve(function(t){return t.responseText}),t.json=function(t,e){return ye(t,"application/json",js,e)},t.html=function(t,e){return ye(t,"text/html",Vs,e)},t.xml=ve(function(t){return t.responseXML}),"object"==typeof e&&e.exports?e.exports=t:this.d3=t}()},{}],132:[function(t,e,r){e.exports=function(){for(var t=0;t=2)return!1;t[r]=n}return!0}):_.filter(function(t){for(var e=0;e<=s;++e){var r=v[t[e]];if(r<0)return!1;t[e]=r}return!0});if(1&s)for(var u=0;u<_.length;++u){var b=_[u],h=b[0];b[0]=b[1],b[1]=h}return _}},{"incremental-convex-hull":357,uniq:483}],134:[function(t,e,r){(function(t){var r=!1;if("undefined"!=typeof Float64Array){var n=new Float64Array(1),i=new Uint32Array(n.buffer);if(n[0]=1,r=!0,1072693248===i[1]){e.exports=function(t){return n[0]=t,[i[0],i[1]]},e.exports.pack=function(t,e){return i[0]=t,i[1]=e,n[0]},e.exports.lo=function(t){return n[0]=t,i[0]},e.exports.hi=function(t){return n[0]=t,i[1]}}else if(1072693248===i[0]){e.exports=function(t){return n[0]=t,[i[1],i[0]]},e.exports.pack=function(t,e){return i[1]=t,i[0]=e,n[0]},e.exports.lo=function(t){return n[0]=t,i[1]},e.exports.hi=function(t){return n[0]=t,i[0]}}else r=!1}if(!r){var a=new t(8);e.exports=function(t){return a.writeDoubleLE(t,0,!0),[a.readUInt32LE(0,!0),a.readUInt32LE(4,!0)]},e.exports.pack=function(t,e){return a.writeUInt32LE(t,0,!0),a.writeUInt32LE(e,4,!0),a.readDoubleLE(0,!0)},e.exports.lo=function(t){return a.writeDoubleLE(t,0,!0),a.readUInt32LE(0,!0)},e.exports.hi=function(t){return a.writeDoubleLE(t,0,!0),a.readUInt32LE(4,!0)}}e.exports.sign=function(t){return e.exports.hi(t)>>>31},e.exports.exponent=function(t){return(e.exports.hi(t)<<1>>>21)-1023},e.exports.fraction=function(t){var r=e.exports.lo(t),n=e.exports.hi(t),i=1048575&n;return 2146435072&n&&(i+=1<<20),[r,i]},e.exports.denormalized=function(t){return!(2146435072&e.exports.hi(t))}}).call(this,t("buffer").Buffer)},{buffer:86}],135:[function(t,e,r){var n=t("abs-svg-path"),i=t("normalize-svg-path"),a={M:"moveTo",C:"bezierCurveTo"};e.exports=function(t,e){t.beginPath(),i(n(e)).forEach(function(e){var r=e[0],n=e.slice(1);t[a[r]].apply(t,n)}),t.closePath()}},{"abs-svg-path":45,"normalize-svg-path":395}],136:[function(t,e,r){e.exports=function(t){switch(t){case"int8":return Int8Array;case"int16":return Int16Array;case"int32":return Int32Array;case"uint8":return Uint8Array;case"uint16":return Uint16Array;case"uint32":return Uint32Array;case"float32":return Float32Array;case"float64":return Float64Array;case"array":return Array;case"uint8_clamped":return Uint8ClampedArray}}},{}],137:[function(t,e,r){"use strict";e.exports=function(t,e){switch(void 0===e&&(e=0),typeof t){case"number":if(t>0)return function(t,e){var r,n;for(r=new Array(t),n=0;n80*r){n=l=t[0],s=c=t[1];for(var b=r;bl&&(l=u),p>c&&(c=p);g=0!==(g=Math.max(l-n,c-s))?1/g:0}return o(y,x,r,n,s,g),x}function i(t,e,r,n,i){var a,o;if(i===A(t,e,r,n)>0)for(a=e;a=e;a-=n)o=w(a,t[a],t[a+1],o);return o&&y(o,o.next)&&(k(o),o=o.next),o}function a(t,e){if(!t)return t;e||(e=t);var r,n=t;do{if(r=!1,n.steiner||!y(n,n.next)&&0!==v(n.prev,n,n.next))n=n.next;else{if(k(n),(n=e=n.prev)===n.next)break;r=!0}}while(r||n!==e);return e}function o(t,e,r,n,i,f,h){if(t){!h&&f&&function(t,e,r,n){var i=t;do{null===i.z&&(i.z=p(i.x,i.y,e,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next}while(i!==t);i.prevZ.nextZ=null,i.prevZ=null,function(t){var e,r,n,i,a,o,s,l,c=1;do{for(r=t,t=null,a=null,o=0;r;){for(o++,n=r,s=0,e=0;e0||l>0&&n;)0!==s&&(0===l||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),a?a.nextZ=i:t=i,i.prevZ=a,a=i;r=n}a.nextZ=null,c*=2}while(o>1)}(i)}(t,n,i,f);for(var d,g,m=t;t.prev!==t.next;)if(d=t.prev,g=t.next,f?l(t,n,i,f):s(t))e.push(d.i/r),e.push(t.i/r),e.push(g.i/r),k(t),t=g.next,m=g.next;else if((t=g)===m){h?1===h?o(t=c(t,e,r),e,r,n,i,f,2):2===h&&u(t,e,r,n,i,f):o(a(t),e,r,n,i,f,1);break}}}function s(t){var e=t.prev,r=t,n=t.next;if(v(e,r,n)>=0)return!1;for(var i=t.next.next;i!==t.prev;){if(g(e.x,e.y,r.x,r.y,n.x,n.y,i.x,i.y)&&v(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function l(t,e,r,n){var i=t.prev,a=t,o=t.next;if(v(i,a,o)>=0)return!1;for(var s=i.xa.x?i.x>o.x?i.x:o.x:a.x>o.x?a.x:o.x,u=i.y>a.y?i.y>o.y?i.y:o.y:a.y>o.y?a.y:o.y,f=p(s,l,e,r,n),h=p(c,u,e,r,n),d=t.prevZ,m=t.nextZ;d&&d.z>=f&&m&&m.z<=h;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;if(d=d.prevZ,m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}for(;d&&d.z>=f;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;m&&m.z<=h;){if(m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function c(t,e,r){var n=t;do{var i=n.prev,a=n.next.next;!y(i,a)&&x(i,n,n.next,a)&&b(i,a)&&b(a,i)&&(e.push(i.i/r),e.push(n.i/r),e.push(a.i/r),k(n),k(n.next),n=t=a),n=n.next}while(n!==t);return n}function u(t,e,r,n,i,s){var l=t;do{for(var c=l.next.next;c!==l.prev;){if(l.i!==c.i&&m(l,c)){var u=_(l,c);return l=a(l,l.next),u=a(u,u.next),o(l,e,r,n,i,s),void o(u,e,r,n,i,s)}c=c.next}l=l.next}while(l!==t)}function f(t,e){return t.x-e.x}function h(t,e){if(e=function(t,e){var r,n=e,i=t.x,a=t.y,o=-1/0;do{if(a<=n.y&&a>=n.next.y&&n.next.y!==n.y){var s=n.x+(a-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(s<=i&&s>o){if(o=s,s===i){if(a===n.y)return n;if(a===n.next.y)return n.next}r=n.x=n.x&&n.x>=u&&i!==n.x&&g(ar.x)&&b(n,t)&&(r=n,h=l),n=n.next;return r}(t,e)){var r=_(e,t);a(r,r.next)}}function p(t,e,r,n,i){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-r)*i)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-n)*i)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function d(t){var e=t,r=t;do{e.x=0&&(t-o)*(n-s)-(r-o)*(e-s)>=0&&(r-o)*(a-s)-(i-o)*(n-s)>=0}function m(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){var r=t;do{if(r.i!==t.i&&r.next.i!==t.i&&r.i!==e.i&&r.next.i!==e.i&&x(r,r.next,t,e))return!0;r=r.next}while(r!==t);return!1}(t,e)&&b(t,e)&&b(e,t)&&function(t,e){var r=t,n=!1,i=(t.x+e.x)/2,a=(t.y+e.y)/2;do{r.y>a!=r.next.y>a&&r.next.y!==r.y&&i<(r.next.x-r.x)*(a-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next}while(r!==t);return n}(t,e)}function v(t,e,r){return(e.y-t.y)*(r.x-e.x)-(e.x-t.x)*(r.y-e.y)}function y(t,e){return t.x===e.x&&t.y===e.y}function x(t,e,r,n){return!!(y(t,e)&&y(r,n)||y(t,n)&&y(r,e))||v(t,e,r)>0!=v(t,e,n)>0&&v(r,n,t)>0!=v(r,n,e)>0}function b(t,e){return v(t.prev,t,t.next)<0?v(t,e,t.next)>=0&&v(t,t.prev,e)>=0:v(t,e,t.prev)<0||v(t,t.next,e)<0}function _(t,e){var r=new M(t.i,t.x,t.y),n=new M(e.i,e.x,e.y),i=t.next,a=e.prev;return t.next=e,e.prev=t,r.next=i,i.prev=r,n.next=r,r.prev=n,a.next=n,n.prev=a,n}function w(t,e,r,n){var i=new M(t,e,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function k(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function M(t,e,r){this.i=t,this.x=e,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function A(t,e,r,n){for(var i=0,a=e,o=r-n;a0&&(n+=t[i-1].length,r.holes.push(n))}return r}},{}],139:[function(t,e,r){"use strict";e.exports=function(t,e){var r=t.length;if("number"!=typeof e){e=0;for(var i=0;i=55296&&y<=56319&&(w+=t[++r]),w=k?h.call(k,M,w,g):w,e?(p.value=w,d(m,g,p)):m[g]=w,++g;v=g}if(void 0===v)for(v=o(t.length),e&&(m=new e(v)),r=0;r0?1:-1}},{}],150:[function(t,e,r){"use strict";var n=t("../math/sign"),i=Math.abs,a=Math.floor;e.exports=function(t){return isNaN(t)?0:0!==(t=Number(t))&&isFinite(t)?n(t)*a(i(t)):t}},{"../math/sign":147}],151:[function(t,e,r){"use strict";var n=t("./to-integer"),i=Math.max;e.exports=function(t){return i(0,n(t))}},{"./to-integer":150}],152:[function(t,e,r){"use strict";var n=t("./valid-callable"),i=t("./valid-value"),a=Function.prototype.bind,o=Function.prototype.call,s=Object.keys,l=Object.prototype.propertyIsEnumerable;e.exports=function(t,e){return function(r,c){var u,f=arguments[2],h=arguments[3];return r=Object(i(r)),n(c),u=s(r),h&&u.sort("function"==typeof h?a.call(h,r):void 0),"function"!=typeof t&&(t=u[t]),o.call(t,u,function(t,n){return l.call(r,t)?o.call(c,f,r[t],t,r,n):e})}}},{"./valid-callable":170,"./valid-value":172}],153:[function(t,e,r){"use strict";e.exports=t("./is-implemented")()?Object.assign:t("./shim")},{"./is-implemented":154,"./shim":155}],154:[function(t,e,r){"use strict";e.exports=function(){var t,e=Object.assign;return"function"==typeof e&&(e(t={foo:"raz"},{bar:"dwa"},{trzy:"trzy"}),t.foo+t.bar+t.trzy==="razdwatrzy")}},{}],155:[function(t,e,r){"use strict";var n=t("../keys"),i=t("../valid-value"),a=Math.max;e.exports=function(t,e){var r,o,s,l=a(arguments.length,2);for(t=Object(i(t)),s=function(n){try{t[n]=e[n]}catch(t){r||(r=t)}},o=1;o-1}},{}],176:[function(t,e,r){"use strict";var n=Object.prototype.toString,i=n.call("");e.exports=function(t){return"string"==typeof t||t&&"object"==typeof t&&(t instanceof String||n.call(t)===i)||!1}},{}],177:[function(t,e,r){"use strict";var n=Object.create(null),i=Math.random;e.exports=function(){var t;do{t=i().toString(36).slice(2)}while(n[t]);return t}},{}],178:[function(t,e,r){"use strict";var n,i=t("es5-ext/object/set-prototype-of"),a=t("es5-ext/string/#/contains"),o=t("d"),s=t("es6-symbol"),l=t("./"),c=Object.defineProperty;n=e.exports=function(t,e){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");l.call(this,t),e=e?a.call(e,"key+value")?"key+value":a.call(e,"key")?"key":"value":"value",c(this,"__kind__",o("",e))},i&&i(n,l),delete n.prototype.constructor,n.prototype=Object.create(l.prototype,{_resolve:o(function(t){return"value"===this.__kind__?this.__list__[t]:"key+value"===this.__kind__?[t,this.__list__[t]]:t})}),c(n.prototype,s.toStringTag,o("c","Array Iterator"))},{"./":181,d:122,"es5-ext/object/set-prototype-of":167,"es5-ext/string/#/contains":173,"es6-symbol":186}],179:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/object/valid-callable"),a=t("es5-ext/string/is-string"),o=t("./get"),s=Array.isArray,l=Function.prototype.call,c=Array.prototype.some;e.exports=function(t,e){var r,u,f,h,p,d,g,m,v=arguments[2];if(s(t)||n(t)?r="array":a(t)?r="string":t=o(t),i(e),f=function(){h=!0},"array"!==r)if("string"!==r)for(u=t.next();!u.done;){if(l.call(e,v,u.value,f),h)return;u=t.next()}else for(d=t.length,p=0;p=55296&&m<=56319&&(g+=t[++p]),l.call(e,v,g,f),!h);++p);else c.call(t,function(t){return l.call(e,v,t,f),h})}},{"./get":180,"es5-ext/function/is-arguments":144,"es5-ext/object/valid-callable":170,"es5-ext/string/is-string":176}],180:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/string/is-string"),a=t("./array"),o=t("./string"),s=t("./valid-iterable"),l=t("es6-symbol").iterator;e.exports=function(t){return"function"==typeof s(t)[l]?t[l]():n(t)?new a(t):i(t)?new o(t):new a(t)}},{"./array":178,"./string":183,"./valid-iterable":184,"es5-ext/function/is-arguments":144,"es5-ext/string/is-string":176,"es6-symbol":186}],181:[function(t,e,r){"use strict";var n,i=t("es5-ext/array/#/clear"),a=t("es5-ext/object/assign"),o=t("es5-ext/object/valid-callable"),s=t("es5-ext/object/valid-value"),l=t("d"),c=t("d/auto-bind"),u=t("es6-symbol"),f=Object.defineProperty,h=Object.defineProperties;e.exports=n=function(t,e){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");h(this,{__list__:l("w",s(t)),__context__:l("w",e),__nextIndex__:l("w",0)}),e&&(o(e.on),e.on("_add",this._onAdd),e.on("_delete",this._onDelete),e.on("_clear",this._onClear))},delete n.prototype.constructor,h(n.prototype,a({_next:l(function(){var t;if(this.__list__)return this.__redo__&&void 0!==(t=this.__redo__.shift())?t:this.__nextIndex__=this.__nextIndex__||(++this.__nextIndex__,this.__redo__?(this.__redo__.forEach(function(e,r){e>=t&&(this.__redo__[r]=++e)},this),this.__redo__.push(t)):f(this,"__redo__",l("c",[t])))}),_onDelete:l(function(t){var e;t>=this.__nextIndex__||(--this.__nextIndex__,this.__redo__&&(-1!==(e=this.__redo__.indexOf(t))&&this.__redo__.splice(e,1),this.__redo__.forEach(function(e,r){e>t&&(this.__redo__[r]=--e)},this)))}),_onClear:l(function(){this.__redo__&&i.call(this.__redo__),this.__nextIndex__=0})}))),f(n.prototype,u.iterator,l(function(){return this}))},{d:122,"d/auto-bind":121,"es5-ext/array/#/clear":140,"es5-ext/object/assign":153,"es5-ext/object/valid-callable":170,"es5-ext/object/valid-value":172,"es6-symbol":186}],182:[function(t,e,r){"use strict";var n=t("es5-ext/function/is-arguments"),i=t("es5-ext/object/is-value"),a=t("es5-ext/string/is-string"),o=t("es6-symbol").iterator,s=Array.isArray;e.exports=function(t){return!!i(t)&&(!!s(t)||(!!a(t)||(!!n(t)||"function"==typeof t[o])))}},{"es5-ext/function/is-arguments":144,"es5-ext/object/is-value":161,"es5-ext/string/is-string":176,"es6-symbol":186}],183:[function(t,e,r){"use strict";var n,i=t("es5-ext/object/set-prototype-of"),a=t("d"),o=t("es6-symbol"),s=t("./"),l=Object.defineProperty;n=e.exports=function(t){if(!(this instanceof n))throw new TypeError("Constructor requires 'new'");t=String(t),s.call(this,t),l(this,"__length__",a("",t.length))},i&&i(n,s),delete n.prototype.constructor,n.prototype=Object.create(s.prototype,{_next:a(function(){if(this.__list__)return this.__nextIndex__=55296&&e<=56319?r+this.__list__[this.__nextIndex__++]:r})}),l(n.prototype,o.toStringTag,a("c","String Iterator"))},{"./":181,d:122,"es5-ext/object/set-prototype-of":167,"es6-symbol":186}],184:[function(t,e,r){"use strict";var n=t("./is-iterable");e.exports=function(t){if(!n(t))throw new TypeError(t+" is not iterable");return t}},{"./is-iterable":182}],185:[function(t,e,r){(function(n,i){!function(t,n){"object"==typeof r&&void 0!==e?e.exports=n():t.ES6Promise=n()}(this,function(){"use strict";function e(t){return"function"==typeof t}var r=Array.isArray?Array.isArray:function(t){return"[object Array]"===Object.prototype.toString.call(t)},a=0,o=void 0,s=void 0,l=function(t,e){g[a]=t,g[a+1]=e,2===(a+=2)&&(s?s(m):_())};var c="undefined"!=typeof window?window:void 0,u=c||{},f=u.MutationObserver||u.WebKitMutationObserver,h="undefined"==typeof self&&void 0!==n&&"[object process]"==={}.toString.call(n),p="undefined"!=typeof Uint8ClampedArray&&"undefined"!=typeof importScripts&&"undefined"!=typeof MessageChannel;function d(){var t=setTimeout;return function(){return t(m,1)}}var g=new Array(1e3);function m(){for(var t=0;t0&&this._events[t].length>r&&(this._events[t].warned=!0,console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.",this._events[t].length),"function"==typeof console.trace&&console.trace()),this},n.prototype.on=n.prototype.addListener,n.prototype.once=function(t,e){if(!i(e))throw TypeError("listener must be a function");var r=!1;function n(){this.removeListener(t,n),r||(r=!0,e.apply(this,arguments))}return n.listener=e,this.on(t,n),this},n.prototype.removeListener=function(t,e){var r,n,o,s;if(!i(e))throw TypeError("listener must be a function");if(!this._events||!this._events[t])return this;if(o=(r=this._events[t]).length,n=-1,r===e||i(r.listener)&&r.listener===e)delete this._events[t],this._events.removeListener&&this.emit("removeListener",t,e);else if(a(r)){for(s=o;s-- >0;)if(r[s]===e||r[s].listener&&r[s].listener===e){n=s;break}if(n<0)return this;1===r.length?(r.length=0,delete this._events[t]):r.splice(n,1),this._events.removeListener&&this.emit("removeListener",t,e)}return this},n.prototype.removeAllListeners=function(t){var e,r;if(!this._events)return this;if(!this._events.removeListener)return 0===arguments.length?this._events={}:this._events[t]&&delete this._events[t],this;if(0===arguments.length){for(e in this._events)"removeListener"!==e&&this.removeAllListeners(e);return this.removeAllListeners("removeListener"),this._events={},this}if(i(r=this._events[t]))this.removeListener(t,r);else if(r)for(;r.length;)this.removeListener(t,r[r.length-1]);return delete this._events[t],this},n.prototype.listeners=function(t){return this._events&&this._events[t]?i(this._events[t])?[this._events[t]]:this._events[t].slice():[]},n.prototype.listenerCount=function(t){if(this._events){var e=this._events[t];if(i(e))return 1;if(e)return e.length}return 0},n.listenerCount=function(t,e){return t.listenerCount(e)}},{}],196:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n=e||0,i=r||1;return[[t[12]+t[0],t[13]+t[1],t[14]+t[2],t[15]+t[3]],[t[12]-t[0],t[13]-t[1],t[14]-t[2],t[15]-t[3]],[t[12]+t[4],t[13]+t[5],t[14]+t[6],t[15]+t[7]],[t[12]-t[4],t[13]-t[5],t[14]-t[6],t[15]-t[7]],[n*t[12]+t[8],n*t[13]+t[9],n*t[14]+t[10],n*t[15]+t[11]],[i*t[12]-t[8],i*t[13]-t[9],i*t[14]-t[10],i*t[15]-t[11]]]}},{}],197:[function(t,e,r){"use strict";e.exports=function(t){var e=typeof t;if("string"===e){var r=t;if(0===(t=+t)&&function(t){for(var e,r=t.length,n=0;n13)&&32!==e&&133!==e&&160!==e&&5760!==e&&6158!==e&&(e<8192||e>8205)&&8232!==e&&8233!==e&&8239!==e&&8287!==e&&8288!==e&&12288!==e&&65279!==e)return!1;return!0}(r))return!1}else if("number"!==e)return!1;return t-t<1}},{}],198:[function(t,e,r){"use strict";e.exports=function(t,e,r){switch(arguments.length){case 0:return new o([0],[0],0);case 1:if("number"==typeof t){var n=l(t);return new o(n,n,0)}return new o(t,l(t.length),0);case 2:if("number"==typeof e){var n=l(t.length);return new o(t,n,+e)}r=0;case 3:if(t.length!==e.length)throw new Error("state and velocity lengths must match");return new o(t,e,r)}};var n=t("cubic-hermite"),i=t("binary-search-bounds");function a(t,e,r){return Math.min(e,Math.max(t,r))}function o(t,e,r){this.dimension=t.length,this.bounds=[new Array(this.dimension),new Array(this.dimension)];for(var n=0;n=r-1){h=l.length-1;var d=t-e[r-1];for(p=0;p=r-1)for(var u=s.length-1,f=(e[r-1],0);f=0;--r)if(t[--e])return!1;return!0},s.jump=function(t){var e=this.lastT(),r=this.dimension;if(!(t0;--f)n.push(a(l[f-1],c[f-1],arguments[f])),i.push(0)}},s.push=function(t){var e=this.lastT(),r=this.dimension;if(!(t1e-6?1/s:0;this._time.push(t);for(var h=r;h>0;--h){var p=a(c[h-1],u[h-1],arguments[h]);n.push(p),i.push((p-n[o++])*f)}}},s.set=function(t){var e=this.dimension;if(!(t0;--l)r.push(a(o[l-1],s[l-1],arguments[l])),n.push(0)}},s.move=function(t){var e=this.lastT(),r=this.dimension;if(!(t<=e||arguments.length!==r+1)){var n=this._state,i=this._velocity,o=n.length-this.dimension,s=this.bounds,l=s[0],c=s[1],u=t-e,f=u>1e-6?1/u:0;this._time.push(t);for(var h=r;h>0;--h){var p=arguments[h];n.push(a(l[h-1],c[h-1],n[o++]+p)),i.push(p*f)}}},s.idle=function(t){var e=this.lastT();if(!(t=0;--f)n.push(a(l[f],c[f],n[o]+u*i[o])),i.push(0),o+=1}}},{"binary-search-bounds":73,"cubic-hermite":116}],199:[function(t,e,r){var n=t("dtype");e.exports=function(t,e,r){if(!t)throw new TypeError("must specify data as first parameter");if(r=0|+(r||0),Array.isArray(t)&&Array.isArray(t[0])){var i=t[0].length,a=t.length*i;e&&"string"!=typeof e||(e=new(n(e||"float32"))(a+r));var o=e.length-r;if(a!==o)throw new Error("source length "+a+" ("+i+"x"+t.length+") does not match destination length "+o);for(var s=0,l=r;s=0;--p){o=u[p];f[p]<=0?u[p]=new a(o._color,o.key,o.value,u[p+1],o.right,o._count+1):u[p]=new a(o._color,o.key,o.value,o.left,u[p+1],o._count+1)}for(p=u.length-1;p>1;--p){var d=u[p-1];o=u[p];if(d._color===i||o._color===i)break;var g=u[p-2];if(g.left===d)if(d.left===o){if(!(m=g.right)||m._color!==n){if(g._color=n,g.left=d.right,d._color=i,d.right=g,u[p-2]=d,u[p-1]=o,l(g),l(d),p>=3)(v=u[p-3]).left===g?v.left=d:v.right=d;break}d._color=i,g.right=s(i,m),g._color=n,p-=1}else{if(!(m=g.right)||m._color!==n){if(d.right=o.left,g._color=n,g.left=o.right,o._color=i,o.left=d,o.right=g,u[p-2]=o,u[p-1]=d,l(g),l(d),l(o),p>=3)(v=u[p-3]).left===g?v.left=o:v.right=o;break}d._color=i,g.right=s(i,m),g._color=n,p-=1}else if(d.right===o){if(!(m=g.left)||m._color!==n){if(g._color=n,g.right=d.left,d._color=i,d.left=g,u[p-2]=d,u[p-1]=o,l(g),l(d),p>=3)(v=u[p-3]).right===g?v.right=d:v.left=d;break}d._color=i,g.left=s(i,m),g._color=n,p-=1}else{var m;if(!(m=g.left)||m._color!==n){var v;if(d.left=o.right,g._color=n,g.right=o.left,o._color=i,o.right=d,o.left=g,u[p-2]=o,u[p-1]=d,l(g),l(d),l(o),p>=3)(v=u[p-3]).right===g?v.right=o:v.left=o;break}d._color=i,g.left=s(i,m),g._color=n,p-=1}}return u[0]._color=i,new c(r,u[0])},u.forEach=function(t,e,r){if(this.root)switch(arguments.length){case 1:return function t(e,r){var n;if(r.left&&(n=t(e,r.left)))return n;return(n=e(r.key,r.value))||(r.right?t(e,r.right):void 0)}(t,this.root);case 2:return function t(e,r,n,i){if(r(e,i.key)<=0){var a;if(i.left&&(a=t(e,r,n,i.left)))return a;if(a=n(i.key,i.value))return a}if(i.right)return t(e,r,n,i.right)}(e,this._compare,t,this.root);case 3:if(this._compare(e,r)>=0)return;return function t(e,r,n,i,a){var o,s=n(e,a.key),l=n(r,a.key);if(s<=0){if(a.left&&(o=t(e,r,n,i,a.left)))return o;if(l>0&&(o=i(a.key,a.value)))return o}if(l>0&&a.right)return t(e,r,n,i,a.right)}(e,r,this._compare,t,this.root)}},Object.defineProperty(u,"begin",{get:function(){for(var t=[],e=this.root;e;)t.push(e),e=e.left;return new f(this,t)}}),Object.defineProperty(u,"end",{get:function(){for(var t=[],e=this.root;e;)t.push(e),e=e.right;return new f(this,t)}}),u.at=function(t){if(t<0)return new f(this,[]);for(var e=this.root,r=[];;){if(r.push(e),e.left){if(t=e.right._count)break;e=e.right}return new f(this,[])},u.ge=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a<=0&&(i=n.length),r=a<=0?r.left:r.right}return n.length=i,new f(this,n)},u.gt=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a<0&&(i=n.length),r=a<0?r.left:r.right}return n.length=i,new f(this,n)},u.lt=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a>0&&(i=n.length),r=a<=0?r.left:r.right}return n.length=i,new f(this,n)},u.le=function(t){for(var e=this._compare,r=this.root,n=[],i=0;r;){var a=e(t,r.key);n.push(r),a>=0&&(i=n.length),r=a<0?r.left:r.right}return n.length=i,new f(this,n)},u.find=function(t){for(var e=this._compare,r=this.root,n=[];r;){var i=e(t,r.key);if(n.push(r),0===i)return new f(this,n);r=i<=0?r.left:r.right}return new f(this,[])},u.remove=function(t){var e=this.find(t);return e?e.remove():this},u.get=function(t){for(var e=this._compare,r=this.root;r;){var n=e(t,r.key);if(0===n)return r.value;r=n<=0?r.left:r.right}};var h=f.prototype;function p(t,e){t.key=e.key,t.value=e.value,t.left=e.left,t.right=e.right,t._color=e._color,t._count=e._count}function d(t,e){return te?1:0}Object.defineProperty(h,"valid",{get:function(){return this._stack.length>0}}),Object.defineProperty(h,"node",{get:function(){return this._stack.length>0?this._stack[this._stack.length-1]:null},enumerable:!0}),h.clone=function(){return new f(this.tree,this._stack.slice())},h.remove=function(){var t=this._stack;if(0===t.length)return this.tree;var e=new Array(t.length),r=t[t.length-1];e[e.length-1]=new a(r._color,r.key,r.value,r.left,r.right,r._count);for(var u=t.length-2;u>=0;--u){(r=t[u]).left===t[u+1]?e[u]=new a(r._color,r.key,r.value,e[u+1],r.right,r._count):e[u]=new a(r._color,r.key,r.value,r.left,e[u+1],r._count)}if((r=e[e.length-1]).left&&r.right){var f=e.length;for(r=r.left;r.right;)e.push(r),r=r.right;var h=e[f-1];e.push(new a(r._color,h.key,h.value,r.left,r.right,r._count)),e[f-1].key=r.key,e[f-1].value=r.value;for(u=e.length-2;u>=f;--u)r=e[u],e[u]=new a(r._color,r.key,r.value,r.left,e[u+1],r._count);e[f-1].left=e[f]}if((r=e[e.length-1])._color===n){var d=e[e.length-2];d.left===r?d.left=null:d.right===r&&(d.right=null),e.pop();for(u=0;u=0;--u){if(e=t[u],0===u)return void(e._color=i);if((r=t[u-1]).left===e){if((a=r.right).right&&a.right._color===n)return c=(a=r.right=o(a)).right=o(a.right),r.right=a.left,a.left=r,a.right=c,a._color=r._color,e._color=i,r._color=i,c._color=i,l(r),l(a),u>1&&((f=t[u-2]).left===r?f.left=a:f.right=a),void(t[u-1]=a);if(a.left&&a.left._color===n)return c=(a=r.right=o(a)).left=o(a.left),r.right=c.left,a.left=c.right,c.left=r,c.right=a,c._color=r._color,r._color=i,a._color=i,e._color=i,l(r),l(a),l(c),u>1&&((f=t[u-2]).left===r?f.left=c:f.right=c),void(t[u-1]=c);if(a._color===i){if(r._color===n)return r._color=i,void(r.right=s(n,a));r.right=s(n,a);continue}a=o(a),r.right=a.left,a.left=r,a._color=r._color,r._color=n,l(r),l(a),u>1&&((f=t[u-2]).left===r?f.left=a:f.right=a),t[u-1]=a,t[u]=r,u+11&&((f=t[u-2]).right===r?f.right=a:f.left=a),void(t[u-1]=a);if(a.right&&a.right._color===n)return c=(a=r.left=o(a)).right=o(a.right),r.left=c.right,a.right=c.left,c.right=r,c.left=a,c._color=r._color,r._color=i,a._color=i,e._color=i,l(r),l(a),l(c),u>1&&((f=t[u-2]).right===r?f.right=c:f.left=c),void(t[u-1]=c);if(a._color===i){if(r._color===n)return r._color=i,void(r.left=s(n,a));r.left=s(n,a);continue}var f;a=o(a),r.left=a.right,a.right=r,a._color=r._color,r._color=n,l(r),l(a),u>1&&((f=t[u-2]).right===r?f.right=a:f.left=a),t[u-1]=a,t[u]=r,u+10)return this._stack[this._stack.length-1].key},enumerable:!0}),Object.defineProperty(h,"value",{get:function(){if(this._stack.length>0)return this._stack[this._stack.length-1].value},enumerable:!0}),Object.defineProperty(h,"index",{get:function(){var t=0,e=this._stack;if(0===e.length){var r=this.tree.root;return r?r._count:0}e[e.length-1].left&&(t=e[e.length-1].left._count);for(var n=e.length-2;n>=0;--n)e[n+1]===e[n].right&&(++t,e[n].left&&(t+=e[n].left._count));return t},enumerable:!0}),h.next=function(){var t=this._stack;if(0!==t.length){var e=t[t.length-1];if(e.right)for(e=e.right;e;)t.push(e),e=e.left;else for(t.pop();t.length>0&&t[t.length-1].right===e;)e=t[t.length-1],t.pop()}},Object.defineProperty(h,"hasNext",{get:function(){var t=this._stack;if(0===t.length)return!1;if(t[t.length-1].right)return!0;for(var e=t.length-1;e>0;--e)if(t[e-1].left===t[e])return!0;return!1}}),h.update=function(t){var e=this._stack;if(0===e.length)throw new Error("Can't update empty node!");var r=new Array(e.length),n=e[e.length-1];r[r.length-1]=new a(n._color,n.key,t,n.left,n.right,n._count);for(var i=e.length-2;i>=0;--i)(n=e[i]).left===e[i+1]?r[i]=new a(n._color,n.key,n.value,r[i+1],n.right,n._count):r[i]=new a(n._color,n.key,n.value,n.left,r[i+1],n._count);return new c(this.tree._compare,r[0])},h.prev=function(){var t=this._stack;if(0!==t.length){var e=t[t.length-1];if(e.left)for(e=e.left;e;)t.push(e),e=e.right;else for(t.pop();t.length>0&&t[t.length-1].left===e;)e=t[t.length-1],t.pop()}},Object.defineProperty(h,"hasPrev",{get:function(){var t=this._stack;if(0===t.length)return!1;if(t[t.length-1].left)return!0;for(var e=t.length-1;e>0;--e)if(t[e-1].right===t[e])return!0;return!1}})},{}],201:[function(t,e,r){var n=[.9999999999998099,676.5203681218851,-1259.1392167224028,771.3234287776531,-176.6150291621406,12.507343278686905,-.13857109526572012,9984369578019572e-21,1.5056327351493116e-7],i=607/128,a=[.9999999999999971,57.15623566586292,-59.59796035547549,14.136097974741746,-.4919138160976202,3399464998481189e-20,4652362892704858e-20,-9837447530487956e-20,.0001580887032249125,-.00021026444172410488,.00021743961811521265,-.0001643181065367639,8441822398385275e-20,-26190838401581408e-21,36899182659531625e-22];function o(t){if(t<0)return Number("0/0");for(var e=a[0],r=a.length-1;r>0;--r)e+=a[r]/(t+r);var n=t+i+.5;return.5*Math.log(2*Math.PI)+(t+.5)*Math.log(n)-n+Math.log(e)-Math.log(t)}e.exports=function t(e){if(e<.5)return Math.PI/(Math.sin(Math.PI*e)*t(1-e));if(e>100)return Math.exp(o(e));e-=1;for(var r=n[0],i=1;i<9;i++)r+=n[i]/(e+i);var a=e+7+.5;return Math.sqrt(2*Math.PI)*Math.pow(a,e+.5)*Math.exp(-a)*r},e.exports.log=o},{}],202:[function(t,e,r){e.exports=function(t,e){if("string"!=typeof t)throw new TypeError("must specify type string");if(e=e||{},"undefined"==typeof document&&!e.canvas)return null;var r=e.canvas||document.createElement("canvas");"number"==typeof e.width&&(r.width=e.width);"number"==typeof e.height&&(r.height=e.height);var n,i=e;try{var a=[t];0===t.indexOf("webgl")&&a.push("experimental-"+t);for(var o=0;o0?(p[u]=-1,d[u]=0):(p[u]=0,d[u]=1)}}var g=[0,0,0],m={model:l,view:l,projection:l};f.isOpaque=function(){return!0},f.isTransparent=function(){return!1},f.drawTransparent=function(t){};var v=[0,0,0],y=[0,0,0],x=[0,0,0];f.draw=function(t){t=t||m;for(var e=this.gl,r=t.model||l,n=t.view||l,i=t.projection||l,a=this.bounds,s=o(r,n,i,a),u=s.cubeEdges,f=s.axis,h=n[12],b=n[13],_=n[14],w=n[15],k=this.pixelRatio*(i[3]*h+i[7]*b+i[11]*_+i[15]*w)/e.drawingBufferHeight,M=0;M<3;++M)this.lastCubeProps.cubeEdges[M]=u[M],this.lastCubeProps.axis[M]=f[M];var A=p;for(M=0;M<3;++M)d(p[M],M,this.bounds,u,f);e=this.gl;var T=g;for(M=0;M<3;++M)this.backgroundEnable[M]?T[M]=f[M]:T[M]=0;this._background.draw(r,n,i,a,T,this.backgroundColor),this._lines.bind(r,n,i,this);for(M=0;M<3;++M){var S=[0,0,0];f[M]>0?S[M]=a[1][M]:S[M]=a[0][M];for(var C=0;C<2;++C){var E=(M+1+C)%3,L=(M+1+(1^C))%3;this.gridEnable[E]&&this._lines.drawGrid(E,L,this.bounds,S,this.gridColor[E],this.gridWidth[E]*this.pixelRatio)}for(C=0;C<2;++C){E=(M+1+C)%3,L=(M+1+(1^C))%3;this.zeroEnable[L]&&a[0][L]<=0&&a[1][L]>=0&&this._lines.drawZero(E,L,this.bounds,S,this.zeroLineColor[L],this.zeroLineWidth[L]*this.pixelRatio)}}for(M=0;M<3;++M){this.lineEnable[M]&&this._lines.drawAxisLine(M,this.bounds,A[M].primalOffset,this.lineColor[M],this.lineWidth[M]*this.pixelRatio),this.lineMirror[M]&&this._lines.drawAxisLine(M,this.bounds,A[M].mirrorOffset,this.lineColor[M],this.lineWidth[M]*this.pixelRatio);var z=c(v,A[M].primalMinor),P=c(y,A[M].mirrorMinor),D=this.lineTickLength;for(C=0;C<3;++C){var O=k/r[5*C];z[C]*=D[C]*O,P[C]*=D[C]*O}this.lineTickEnable[M]&&this._lines.drawAxisTicks(M,A[M].primalOffset,z,this.lineTickColor[M],this.lineTickWidth[M]*this.pixelRatio),this.lineTickMirror[M]&&this._lines.drawAxisTicks(M,A[M].mirrorOffset,P,this.lineTickColor[M],this.lineTickWidth[M]*this.pixelRatio)}this._lines.unbind(),this._text.bind(r,n,i,this.pixelRatio);for(M=0;M<3;++M){var I=A[M].primalMinor,R=c(x,A[M].primalOffset);for(C=0;C<3;++C)this.lineTickEnable[M]&&(R[C]+=k*I[C]*Math.max(this.lineTickLength[C],0)/r[5*C]);if(this.tickEnable[M]){for(C=0;C<3;++C)R[C]+=k*I[C]*this.tickPad[C]/r[5*C];this._text.drawTicks(M,this.tickSize[M],this.tickAngle[M],R,this.tickColor[M])}if(this.labelEnable[M]){for(C=0;C<3;++C)R[C]+=k*I[C]*this.labelPad[C]/r[5*C];R[M]+=.5*(a[0][M]+a[1][M]),this._text.drawLabel(M,this.labelSize[M],this.labelAngle[M],R,this.labelColor[M])}}this._text.unbind()},f.dispose=function(){this._text.dispose(),this._lines.dispose(),this._background.dispose(),this._lines=null,this._text=null,this._background=null,this.gl=null}},{"./lib/background.js":204,"./lib/cube.js":205,"./lib/lines.js":206,"./lib/text.js":208,"./lib/ticks.js":209}],204:[function(t,e,r){"use strict";e.exports=function(t){for(var e=[],r=[],s=0,l=0;l<3;++l)for(var c=(l+1)%3,u=(l+2)%3,f=[0,0,0],h=[0,0,0],p=-1;p<=1;p+=2){r.push(s,s+2,s+1,s+1,s+2,s+3),f[l]=p,h[l]=p;for(var d=-1;d<=1;d+=2){f[c]=d;for(var g=-1;g<=1;g+=2)f[u]=g,e.push(f[0],f[1],f[2],h[0],h[1],h[2]),s+=1}var m=c;c=u,u=m}var v=n(t,new Float32Array(e)),y=n(t,new Uint16Array(r),t.ELEMENT_ARRAY_BUFFER),x=i(t,[{buffer:v,type:t.FLOAT,size:3,offset:0,stride:24},{buffer:v,type:t.FLOAT,size:3,offset:12,stride:24}],y),b=a(t);return b.attributes.position.location=0,b.attributes.normal.location=1,new o(t,v,x,b)};var n=t("gl-buffer"),i=t("gl-vao"),a=t("./shaders").bg;function o(t,e,r,n){this.gl=t,this.buffer=e,this.vao=r,this.shader=n}var s=o.prototype;s.draw=function(t,e,r,n,i,a){for(var o=!1,s=0;s<3;++s)o=o||i[s];if(o){var l=this.gl;l.enable(l.POLYGON_OFFSET_FILL),l.polygonOffset(1,2),this.shader.bind(),this.shader.uniforms={model:t,view:e,projection:r,bounds:n,enable:i,colors:a},this.vao.bind(),this.vao.draw(this.gl.TRIANGLES,36),this.vao.unbind(),l.disable(l.POLYGON_OFFSET_FILL)}},s.dispose=function(){this.vao.dispose(),this.buffer.dispose(),this.shader.dispose()}},{"./shaders":207,"gl-buffer":211,"gl-vao":284}],205:[function(t,e,r){"use strict";e.exports=function(t,e,r,a){i(s,e,t),i(s,r,s);for(var p=0,y=0;y<2;++y){u[2]=a[y][2];for(var x=0;x<2;++x){u[1]=a[x][1];for(var b=0;b<2;++b)u[0]=a[b][0],h(l[p],u,s),p+=1}}for(var _=-1,y=0;y<8;++y){for(var w=l[y][3],k=0;k<3;++k)c[y][k]=l[y][k]/w;w<0&&(_<0?_=y:c[y][2]S&&(_|=1<S&&(_|=1<c[y][1]&&(I=y));for(var R=-1,y=0;y<3;++y){var B=I^1<c[F][0]&&(F=B)}}var N=g;N[0]=N[1]=N[2]=0,N[n.log2(R^I)]=I&R,N[n.log2(I^F)]=I&F;var j=7^F;j===_||j===O?(j=7^R,N[n.log2(F^j)]=j&F):N[n.log2(R^j)]=j&R;for(var V=m,U=_,M=0;M<3;++M)V[M]=U&1< 0.0) {\n vec3 nPosition = mix(bounds[0], bounds[1], 0.5 * (position + 1.0));\n gl_Position = projection * view * model * vec4(nPosition, 1.0);\n } else {\n gl_Position = vec4(0,0,0,0);\n }\n colorChannel = abs(normal);\n}"]),u=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec4 colors[3];\n\nvarying vec3 colorChannel;\n\nvoid main() {\n gl_FragColor = colorChannel.x * colors[0] + \n colorChannel.y * colors[1] +\n colorChannel.z * colors[2];\n}"]);r.bg=function(t){return i(t,c,u,null,[{name:"position",type:"vec3"},{name:"normal",type:"vec3"}])}},{"gl-shader":268,glslify:353}],208:[function(t,e,r){(function(r){"use strict";e.exports=function(t,e,r,a,s,l){var u=n(t),f=i(t,[{buffer:u,size:3}]),h=o(t);h.attributes.position.location=0;var p=new c(t,h,u,f);return p.update(e,r,a,s,l),p};var n=t("gl-buffer"),i=t("gl-vao"),a=t("vectorize-text"),o=t("./shaders").text,s=window||r.global||{},l=s.__TEXT_CACHE||{};s.__TEXT_CACHE={};function c(t,e,r,n){this.gl=t,this.shader=e,this.buffer=r,this.vao=n,this.tickOffset=this.tickCount=this.labelOffset=this.labelCount=null}var u=c.prototype,f=[0,0];u.bind=function(t,e,r,n){this.vao.bind(),this.shader.bind();var i=this.shader.uniforms;i.model=t,i.view=e,i.projection=r,i.pixelScale=n,f[0]=this.gl.drawingBufferWidth,f[1]=this.gl.drawingBufferHeight,this.shader.uniforms.resolution=f},u.unbind=function(){this.vao.unbind()},u.update=function(t,e,r,n,i){this.gl;var o=[];function s(t,e,r,n){var i=l[r];i||(i=l[r]={});var s=i[e];s||(s=i[e]=function(t,e){try{return a(t,e)}catch(t){return console.warn("error vectorizing text:",t),{cells:[],positions:[]}}}(e,{triangles:!0,font:r,textAlign:"center",textBaseline:"middle"}));for(var c=(n||12)/12,u=s.positions,f=s.cells,h=0,p=f.length;h=0;--g){var m=u[d[g]];o.push(c*m[0],-c*m[1],t)}}for(var c=[0,0,0],u=[0,0,0],f=[0,0,0],h=[0,0,0],p=0;p<3;++p){f[p]=o.length/3|0,s(.5*(t[0][p]+t[1][p]),e[p],r),h[p]=(o.length/3|0)-f[p],c[p]=o.length/3|0;for(var d=0;d=0&&(i=r.length-n-1);var a=Math.pow(10,i),o=Math.round(t*e*a),s=o+"";if(s.indexOf("e")>=0)return s;var l=o/a,c=o%a;o<0?(l=0|-Math.ceil(l),c=0|-c):(l=0|Math.floor(l),c|=0);var u=""+l;if(o<0&&(u="-"+u),i){for(var f=""+c;f.length=t[0][i];--o)a.push({x:o*e[i],text:n(e[i],o)});r.push(a)}return r},r.equal=function(t,e){for(var r=0;r<3;++r){if(t[r].length!==e[r].length)return!1;for(var n=0;nr)throw new Error("gl-buffer: If resizing buffer, must not specify offset");return t.bufferSubData(e,a,i),r}function u(t,e){for(var r=n.malloc(t.length,e),i=t.length,a=0;a=0;--n){if(e[n]!==r)return!1;r*=t[n]}return!0}(t.shape,t.stride))0===t.offset&&t.data.length===t.shape[0]?this.length=c(this.gl,this.type,this.length,this.usage,t.data,e):this.length=c(this.gl,this.type,this.length,this.usage,t.data.subarray(t.offset,t.shape[0]),e);else{var s=n.malloc(t.size,r),l=a(s,t.shape);i.assign(l,t),this.length=c(this.gl,this.type,this.length,this.usage,e<0?s:s.subarray(0,t.size),e),n.free(s)}}else if(Array.isArray(t)){var f;f=this.type===this.gl.ELEMENT_ARRAY_BUFFER?u(t,"uint16"):u(t,"float32"),this.length=c(this.gl,this.type,this.length,this.usage,e<0?f:f.subarray(0,t.length),e),n.free(f)}else if("object"==typeof t&&"number"==typeof t.length)this.length=c(this.gl,this.type,this.length,this.usage,t,e);else{if("number"!=typeof t&&void 0!==t)throw new Error("gl-buffer: Invalid data type");if(e>=0)throw new Error("gl-buffer: Cannot specify offset when resizing buffer");(t|=0)<=0&&(t=1),this.gl.bufferData(this.type,0|t,this.usage),this.length=t}},e.exports=function(t,e,r,n){if(r=r||t.ARRAY_BUFFER,n=n||t.DYNAMIC_DRAW,r!==t.ARRAY_BUFFER&&r!==t.ELEMENT_ARRAY_BUFFER)throw new Error("gl-buffer: Invalid type for webgl buffer, must be either gl.ARRAY_BUFFER or gl.ELEMENT_ARRAY_BUFFER");if(n!==t.DYNAMIC_DRAW&&n!==t.STATIC_DRAW&&n!==t.STREAM_DRAW)throw new Error("gl-buffer: Invalid usage for buffer, must be either gl.DYNAMIC_DRAW, gl.STATIC_DRAW or gl.STREAM_DRAW");var i=t.createBuffer(),a=new s(t,r,i,0,n);return a.update(e),a}},{ndarray:393,"ndarray-ops":387,"typedarray-pool":481}],212:[function(t,e,r){"use strict";var n=t("gl-vec3"),i=(t("gl-vec4"),function(t,e){for(var r=0;r=e)return r-1;return r}),a=n.create(),o=n.create(),s=function(t,e,r){return tr?r:t},l=function(t,e,r,l){var c=t[0],u=t[1],f=t[2],h=r[0].length,p=r[1].length,d=r[2].length,g=i(r[0],c),m=i(r[1],u),v=i(r[2],f),y=g+1,x=m+1,b=v+1;if(l&&(g=s(g,0,h-1),y=s(y,0,h-1),m=s(m,0,p-1),x=s(x,0,p-1),v=s(v,0,d-1),b=s(b,0,d-1)),g<0||m<0||v<0||y>=h||x>=p||b>=d)return n.create();var _=(c-r[0][g])/(r[0][y]-r[0][g]),w=(u-r[1][m])/(r[1][x]-r[1][m]),k=(f-r[2][v])/(r[2][b]-r[2][v]);(_<0||_>1||isNaN(_))&&(_=0),(w<0||w>1||isNaN(w))&&(w=0),(k<0||k>1||isNaN(k))&&(k=0);var M=v*h*p,A=b*h*p,T=m*h,S=x*h,C=g,E=y,L=e[T+M+C],z=e[T+M+E],P=e[S+M+C],D=e[S+M+E],O=e[T+A+C],I=e[T+A+E],R=e[S+A+C],B=e[S+A+E],F=n.create();return n.lerp(F,L,z,_),n.lerp(a,P,D,_),n.lerp(F,F,a,w),n.lerp(a,O,I,_),n.lerp(o,R,B,_),n.lerp(a,a,o,w),n.lerp(F,F,a,k),F};e.exports=function(t,e){var r;r=t.positions?t.positions:function(t){for(var e=t[0],r=t[1],n=t[2],i=[],a=0;as&&(s=n.length(b)),x&&(y=Math.min(y,2*n.distance(g,_)/(n.length(m)+n.length(b)))),g=_,m=b,v.push(b)}var w=[c,f,p],k=[u,h,d];e&&(e[0]=w,e[1]=k),0===s&&(s=1);var M=1/s;isFinite(y)&&!isNaN(y)||(y=1),o.vectorScale=y;var A=function(t,e,r){var i=n.create();return void 0!==t&&n.set(i,t,e,r),i}(0,1,0),T=t.coneSize||.5;t.absoluteConeSize&&(T=t.absoluteConeSize*M),o.coneScale=T;x=0;for(var S=0;x1.0001)return null;m+=g[u]}if(Math.abs(m-1)>.001)return null;return[f,function(t,e){for(var r=[0,0,0],n=0;n=1},x.isTransparent=function(){return this.opacity<1},x.pickSlots=1,x.setPickBase=function(t){this.pickId=t},x.highlight=function(t){if(t&&this.contourEnable){for(var e=h(this.cells,this.intensity,t.intensity),r=e.cells,n=e.vertexIds,i=e.vertexWeights,a=r.length,o=p.mallocFloat32(6*a),s=0,l=0;l0&&((f=this.triShader).bind(),f.uniforms=s,this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind());this.edgeCount>0&&this.lineWidth>0&&((f=this.lineShader).bind(),f.uniforms=s,this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind());this.pointCount>0&&((f=this.pointShader).bind(),f.uniforms=s,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind());this.contourEnable&&this.contourCount>0&&this.contourLineWidth>0&&((f=this.contourShader).bind(),f.uniforms=s,this.contourVAO.bind(),e.drawArrays(e.LINES,0,this.contourCount),this.contourVAO.unbind())},x.drawPick=function(t){t=t||{};for(var e=this.gl,r=t.model||v,n=t.view||v,i=t.projection||v,a=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],o=0;o<3;++o)a[0][o]=Math.max(a[0][o],this.clipBounds[0][o]),a[1][o]=Math.min(a[1][o],this.clipBounds[1][o]);this._model=[].slice.call(r),this._view=[].slice.call(n),this._projection=[].slice.call(i),this._resolution=[e.drawingBufferWidth,e.drawingBufferHeight];var s,l={model:r,view:n,projection:i,clipBounds:a,vectorScale:this.vectorScale,coneScale:this.coneScale,coneOffset:this.coneOffset,pickId:this.pickId/255};((s=this.pickShader).bind(),s.uniforms=l,this.triangleCount>0&&(this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind()),this.edgeCount>0&&(this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind()),this.pointCount>0)&&((s=this.pointPickShader).bind(),s.uniforms=l,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind())},x.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;var e=t.value[0]+256*t.value[1]+65536*t.value[2],r=this.cells[e],n=this.positions[r[1]].slice(0,3);return{index:Math.floor(r[1]/48),position:n,dataCoordinate:n}},x.dispose=function(){this.texture.dispose(),this.triShader.dispose(),this.pickShader.dispose(),this.triangleVAO.dispose(),this.trianglePositions.dispose(),this.triangleVectors.dispose(),this.triangleColors.dispose(),this.triangleUVs.dispose(),this.triangleNormals.dispose(),this.triangleIds.dispose(),this.edgeVAO.dispose(),this.edgePositions.dispose(),this.edgeColors.dispose(),this.edgeUVs.dispose(),this.edgeIds.dispose(),this.pointVAO.dispose(),this.pointPositions.dispose(),this.pointColors.dispose(),this.pointUVs.dispose(),this.pointSizes.dispose(),this.pointIds.dispose(),this.contourVAO.dispose(),this.contourPositions.dispose()},e.exports=function(t,e){1===arguments.length&&(t=(e=t).gl);var r=e.triShader||function(t){var e=n(t,g.vertex,g.fragment,null,g.attributes);return e.attributes.position.location=0,e.attributes.color.location=2,e.attributes.uv.location=3,e.attributes.vector.location=5,e}(t),s=b(t),l=o(t,u(new Uint8Array([255,255,255,255]),[1,1,4]));l.generateMipmap(),l.minFilter=t.LINEAR_MIPMAP_LINEAR,l.magFilter=t.LINEAR;var c=i(t),f=i(t),h=i(t),p=i(t),d=i(t),m=i(t),v=a(t,[{buffer:c,type:t.FLOAT,size:4},{buffer:m,type:t.UNSIGNED_BYTE,size:4,normalized:!0},{buffer:h,type:t.FLOAT,size:4},{buffer:p,type:t.FLOAT,size:2},{buffer:d,type:t.FLOAT,size:3},{buffer:f,type:t.FLOAT,size:3}]),x=i(t),_=i(t),w=i(t),k=i(t),M=a(t,[{buffer:x,type:t.FLOAT,size:3},{buffer:k,type:t.UNSIGNED_BYTE,size:4,normalized:!0},{buffer:_,type:t.FLOAT,size:4},{buffer:w,type:t.FLOAT,size:2}]),A=i(t),T=i(t),S=i(t),C=i(t),E=i(t),L=a(t,[{buffer:A,type:t.FLOAT,size:3},{buffer:E,type:t.UNSIGNED_BYTE,size:4,normalized:!0},{buffer:T,type:t.FLOAT,size:4},{buffer:S,type:t.FLOAT,size:2},{buffer:C,type:t.FLOAT,size:1}]),z=i(t),P=new y(t,l,r,null,null,s,null,null,c,f,m,h,p,d,v,x,k,_,w,M,A,E,T,S,C,L,z,a(t,[{buffer:z,type:t.FLOAT,size:3}]));return P.update(e),P}},{"./closest-point":213,"./shaders":215,colormap:107,"gl-buffer":211,"gl-mat4/invert":235,"gl-mat4/multiply":237,"gl-shader":268,"gl-texture2d":280,"gl-vao":284,ndarray:393,normals:396,"simplicial-complex-contour":454,"typedarray-pool":481}],215:[function(t,e,r){var n=t("glslify"),i=n(["precision mediump float;\n#define GLSLIFY 1\n\nfloat inverse(float m) {\n return 1.0 / m;\n}\n\nmat2 inverse(mat2 m) {\n return mat2(m[1][1],-m[0][1],\n -m[1][0], m[0][0]) / (m[0][0]*m[1][1] - m[0][1]*m[1][0]);\n}\n\nmat3 inverse(mat3 m) {\n float a00 = m[0][0], a01 = m[0][1], a02 = m[0][2];\n float a10 = m[1][0], a11 = m[1][1], a12 = m[1][2];\n float a20 = m[2][0], a21 = m[2][1], a22 = m[2][2];\n\n float b01 = a22 * a11 - a12 * a21;\n float b11 = -a22 * a10 + a12 * a20;\n float b21 = a21 * a10 - a11 * a20;\n\n float det = a00 * b01 + a01 * b11 + a02 * b21;\n\n return mat3(b01, (-a22 * a01 + a02 * a21), (a12 * a01 - a02 * a11),\n b11, (a22 * a00 - a02 * a20), (-a12 * a00 + a02 * a10),\n b21, (-a21 * a00 + a01 * a20), (a11 * a00 - a01 * a10)) / det;\n}\n\nmat4 inverse(mat4 m) {\n float\n a00 = m[0][0], a01 = m[0][1], a02 = m[0][2], a03 = m[0][3],\n a10 = m[1][0], a11 = m[1][1], a12 = m[1][2], a13 = m[1][3],\n a20 = m[2][0], a21 = m[2][1], a22 = m[2][2], a23 = m[2][3],\n a30 = m[3][0], a31 = m[3][1], a32 = m[3][2], a33 = m[3][3],\n\n b00 = a00 * a11 - a01 * a10,\n b01 = a00 * a12 - a02 * a10,\n b02 = a00 * a13 - a03 * a10,\n b03 = a01 * a12 - a02 * a11,\n b04 = a01 * a13 - a03 * a11,\n b05 = a02 * a13 - a03 * a12,\n b06 = a20 * a31 - a21 * a30,\n b07 = a20 * a32 - a22 * a30,\n b08 = a20 * a33 - a23 * a30,\n b09 = a21 * a32 - a22 * a31,\n b10 = a21 * a33 - a23 * a31,\n b11 = a22 * a33 - a23 * a32,\n\n det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n return mat4(\n a11 * b11 - a12 * b10 + a13 * b09,\n a02 * b10 - a01 * b11 - a03 * b09,\n a31 * b05 - a32 * b04 + a33 * b03,\n a22 * b04 - a21 * b05 - a23 * b03,\n a12 * b08 - a10 * b11 - a13 * b07,\n a00 * b11 - a02 * b08 + a03 * b07,\n a32 * b02 - a30 * b05 - a33 * b01,\n a20 * b05 - a22 * b02 + a23 * b01,\n a10 * b10 - a11 * b08 + a13 * b06,\n a01 * b08 - a00 * b10 - a03 * b06,\n a30 * b04 - a31 * b02 + a33 * b00,\n a21 * b02 - a20 * b04 - a23 * b00,\n a11 * b07 - a10 * b09 - a12 * b06,\n a00 * b09 - a01 * b07 + a02 * b06,\n a31 * b01 - a30 * b03 - a32 * b00,\n a20 * b03 - a21 * b01 + a22 * b00) / det;\n}\n\nvec3 getOrthogonalVector(vec3 v) {\n // Return up-vector for only-z vector.\n // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n // From the above if-statement we have ||a|| > 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n// segment + 0 top vertex\n// segment + 1 perimeter vertex a+1\n// segment + 2 perimeter vertex a\n// segment + 3 center base vertex\n// segment + 4 perimeter vertex a\n// segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float index, float coneOffset, out vec3 normal) {\n\n const float segmentCount = 8.0;\n\n index = mod(index, segmentCount * 6.0);\n\n float segment = floor(index/6.0);\n float segmentIndex = index - (segment*6.0);\n\n normal = -normalize(d);\n\n if (segmentIndex == 3.0) {\n return mix(vec3(0.0), -d, coneOffset);\n }\n\n // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)\n float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);\n float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n vec3 v1 = mix(d, vec3(0.0), coneOffset);\n vec3 v2 = v1 - d;\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d)*0.25;\n vec3 y = v * sin(angle) * length(d)*0.25;\n vec3 v3 = v2 + x + y;\n if (segmentIndex <= 2.0) {\n vec3 tx = u * sin(angle);\n vec3 ty = v * -cos(angle);\n vec3 tangent = tx + ty;\n normal = normalize(cross(v3 - v1, tangent));\n }\n\n if (segmentIndex == 0.0) {\n return mix(d, vec3(0.0), coneOffset);\n }\n return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 color, position;\nattribute vec2 uv;\nuniform float vectorScale;\nuniform float coneScale;\n\nuniform float coneOffset;\n\nuniform mat4 model\n , view\n , projection;\nuniform vec3 eyePosition\n , lightPosition;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n // Scale the vector magnitude to stay constant with\n // model & view changes.\n vec3 normal;\n vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal), 0.0);\n normal = normalize(normal * inverse(mat3(model)));\n\n // vec4 m_position = model * vec4(conePosition, 1.0);\n vec4 t_position = view * conePosition;\n gl_Position = projection * t_position;\n f_color = color; //vec4(position.w, color.r, 0, 0);\n f_normal = normal;\n f_data = conePosition.xyz;\n f_eyeDirection = eyePosition - conePosition.xyz;\n f_lightDirection = lightPosition - conePosition.xyz;\n f_uv = uv;\n}\n"]),a=n(["precision mediump float;\n#define GLSLIFY 1\n\nfloat beckmannDistribution(float x, float roughness) {\n float NdotH = max(x, 0.0001);\n float cos2Alpha = NdotH * NdotH;\n float tan2Alpha = (cos2Alpha - 1.0) / cos2Alpha;\n float roughness2 = roughness * roughness;\n float denom = 3.141592653589793 * roughness2 * cos2Alpha * cos2Alpha;\n return exp(tan2Alpha / roughness2) / denom;\n}\n\nfloat cookTorranceSpecular(\n vec3 lightDirection,\n vec3 viewDirection,\n vec3 surfaceNormal,\n float roughness,\n float fresnel) {\n\n float VdotN = max(dot(viewDirection, surfaceNormal), 0.0);\n float LdotN = max(dot(lightDirection, surfaceNormal), 0.0);\n\n //Half angle vector\n vec3 H = normalize(lightDirection + viewDirection);\n\n //Geometric term\n float NdotH = max(dot(surfaceNormal, H), 0.0);\n float VdotH = max(dot(viewDirection, H), 0.000001);\n float LdotH = max(dot(lightDirection, H), 0.000001);\n float G1 = (2.0 * NdotH * VdotN) / VdotH;\n float G2 = (2.0 * NdotH * LdotN) / LdotH;\n float G = min(1.0, min(G1, G2));\n \n //Distribution term\n float D = beckmannDistribution(NdotH, roughness);\n\n //Fresnel term\n float F = pow(1.0 - VdotN, fresnel);\n\n //Multiply terms and done\n return G * F * D / max(3.14159265 * VdotN, 0.000001);\n}\n\nuniform vec3 clipBounds[2];\nuniform float roughness\n , fresnel\n , kambient\n , kdiffuse\n , kspecular\n , opacity;\nuniform sampler2D texture;\n\nvarying vec3 f_normal\n , f_lightDirection\n , f_eyeDirection\n , f_data;\nvarying vec4 f_color;\nvarying vec2 f_uv;\n\nvoid main() {\n //if(any(lessThan(f_data, clipBounds[0])) || \n // any(greaterThan(f_data, clipBounds[1]))) {\n // discard;\n //}\n\n vec3 N = normalize(f_normal);\n vec3 L = normalize(f_lightDirection);\n vec3 V = normalize(f_eyeDirection);\n \n if(!gl_FrontFacing) {\n N = -N;\n }\n\n float specular = cookTorranceSpecular(L, V, N, roughness, fresnel);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n vec4 surfaceColor = texture2D(texture, f_uv);\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = litColor * opacity;\n}"]),o=n(["precision mediump float;\n#define GLSLIFY 1\n\nvec3 getOrthogonalVector(vec3 v) {\n // Return up-vector for only-z vector.\n // Return ax + by + cz = 0, a point that lies on the plane that has v as a normal and that isn't (0,0,0).\n // From the above if-statement we have ||a|| > 0 U ||b|| > 0.\n // Assign z = 0, x = -b, y = a:\n // a*-b + b*a + c*0 = -ba + ba + 0 = 0\n if (v.x*v.x > v.z*v.z || v.y*v.y > v.z*v.z) {\n return normalize(vec3(-v.y, v.x, 0.0));\n } else {\n return normalize(vec3(0.0, v.z, -v.y));\n }\n}\n\n// Calculate the cone vertex and normal at the given index.\n//\n// The returned vertex is for a cone with its top at origin and height of 1.0,\n// pointing in the direction of the vector attribute.\n//\n// Each cone is made up of a top vertex, a center base vertex and base perimeter vertices.\n// These vertices are used to make up the triangles of the cone by the following:\n// segment + 0 top vertex\n// segment + 1 perimeter vertex a+1\n// segment + 2 perimeter vertex a\n// segment + 3 center base vertex\n// segment + 4 perimeter vertex a\n// segment + 5 perimeter vertex a+1\n// Where segment is the number of the radial segment * 6 and a is the angle at that radial segment.\n// To go from index to segment, floor(index / 6)\n// To go from segment to angle, 2*pi * (segment/segmentCount)\n// To go from index to segment index, index - (segment*6)\n//\nvec3 getConePosition(vec3 d, float index, float coneOffset, out vec3 normal) {\n\n const float segmentCount = 8.0;\n\n index = mod(index, segmentCount * 6.0);\n\n float segment = floor(index/6.0);\n float segmentIndex = index - (segment*6.0);\n\n normal = -normalize(d);\n\n if (segmentIndex == 3.0) {\n return mix(vec3(0.0), -d, coneOffset);\n }\n\n // angle = 2pi * ((segment + ((segmentIndex == 1.0 || segmentIndex == 5.0) ? 1.0 : 0.0)) / segmentCount)\n float nextAngle = float(segmentIndex == 1.0 || segmentIndex == 5.0);\n float angle = 2.0 * 3.14159 * ((segment + nextAngle) / segmentCount);\n\n vec3 v1 = mix(d, vec3(0.0), coneOffset);\n vec3 v2 = v1 - d;\n\n vec3 u = getOrthogonalVector(d);\n vec3 v = normalize(cross(u, d));\n\n vec3 x = u * cos(angle) * length(d)*0.25;\n vec3 y = v * sin(angle) * length(d)*0.25;\n vec3 v3 = v2 + x + y;\n if (segmentIndex <= 2.0) {\n vec3 tx = u * sin(angle);\n vec3 ty = v * -cos(angle);\n vec3 tangent = tx + ty;\n normal = normalize(cross(v3 - v1, tangent));\n }\n\n if (segmentIndex == 0.0) {\n return mix(d, vec3(0.0), coneOffset);\n }\n return v3;\n}\n\nattribute vec3 vector;\nattribute vec4 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nuniform float vectorScale;\nuniform float coneScale;\nuniform float coneOffset;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n vec3 normal;\n vec4 conePosition = model * vec4(position.xyz, 1.0) + vec4(getConePosition(mat3(model) * ((vectorScale * coneScale) * vector), position.w, coneOffset, normal), 0.0);\n gl_Position = projection * view * conePosition;\n f_id = id;\n f_position = position.xyz;\n}\n"]),s=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(f_position, clipBounds[0])) || \n any(greaterThan(f_position, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"]);r.meshShader={vertex:i,fragment:a,attributes:[{name:"position",type:"vec4"},{name:"normal",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"},{name:"vector",type:"vec3"}]},r.pickShader={vertex:o,fragment:s,attributes:[{name:"position",type:"vec4"},{name:"id",type:"vec4"},{name:"vector",type:"vec3"}]}},{glslify:353}],216:[function(t,e,r){e.exports={0:"NONE",1:"ONE",2:"LINE_LOOP",3:"LINE_STRIP",4:"TRIANGLES",5:"TRIANGLE_STRIP",6:"TRIANGLE_FAN",256:"DEPTH_BUFFER_BIT",512:"NEVER",513:"LESS",514:"EQUAL",515:"LEQUAL",516:"GREATER",517:"NOTEQUAL",518:"GEQUAL",519:"ALWAYS",768:"SRC_COLOR",769:"ONE_MINUS_SRC_COLOR",770:"SRC_ALPHA",771:"ONE_MINUS_SRC_ALPHA",772:"DST_ALPHA",773:"ONE_MINUS_DST_ALPHA",774:"DST_COLOR",775:"ONE_MINUS_DST_COLOR",776:"SRC_ALPHA_SATURATE",1024:"STENCIL_BUFFER_BIT",1028:"FRONT",1029:"BACK",1032:"FRONT_AND_BACK",1280:"INVALID_ENUM",1281:"INVALID_VALUE",1282:"INVALID_OPERATION",1285:"OUT_OF_MEMORY",1286:"INVALID_FRAMEBUFFER_OPERATION",2304:"CW",2305:"CCW",2849:"LINE_WIDTH",2884:"CULL_FACE",2885:"CULL_FACE_MODE",2886:"FRONT_FACE",2928:"DEPTH_RANGE",2929:"DEPTH_TEST",2930:"DEPTH_WRITEMASK",2931:"DEPTH_CLEAR_VALUE",2932:"DEPTH_FUNC",2960:"STENCIL_TEST",2961:"STENCIL_CLEAR_VALUE",2962:"STENCIL_FUNC",2963:"STENCIL_VALUE_MASK",2964:"STENCIL_FAIL",2965:"STENCIL_PASS_DEPTH_FAIL",2966:"STENCIL_PASS_DEPTH_PASS",2967:"STENCIL_REF",2968:"STENCIL_WRITEMASK",2978:"VIEWPORT",3024:"DITHER",3042:"BLEND",3088:"SCISSOR_BOX",3089:"SCISSOR_TEST",3106:"COLOR_CLEAR_VALUE",3107:"COLOR_WRITEMASK",3317:"UNPACK_ALIGNMENT",3333:"PACK_ALIGNMENT",3379:"MAX_TEXTURE_SIZE",3386:"MAX_VIEWPORT_DIMS",3408:"SUBPIXEL_BITS",3410:"RED_BITS",3411:"GREEN_BITS",3412:"BLUE_BITS",3413:"ALPHA_BITS",3414:"DEPTH_BITS",3415:"STENCIL_BITS",3553:"TEXTURE_2D",4352:"DONT_CARE",4353:"FASTEST",4354:"NICEST",5120:"BYTE",5121:"UNSIGNED_BYTE",5122:"SHORT",5123:"UNSIGNED_SHORT",5124:"INT",5125:"UNSIGNED_INT",5126:"FLOAT",5386:"INVERT",5890:"TEXTURE",6401:"STENCIL_INDEX",6402:"DEPTH_COMPONENT",6406:"ALPHA",6407:"RGB",6408:"RGBA",6409:"LUMINANCE",6410:"LUMINANCE_ALPHA",7680:"KEEP",7681:"REPLACE",7682:"INCR",7683:"DECR",7936:"VENDOR",7937:"RENDERER",7938:"VERSION",9728:"NEAREST",9729:"LINEAR",9984:"NEAREST_MIPMAP_NEAREST",9985:"LINEAR_MIPMAP_NEAREST",9986:"NEAREST_MIPMAP_LINEAR",9987:"LINEAR_MIPMAP_LINEAR",10240:"TEXTURE_MAG_FILTER",10241:"TEXTURE_MIN_FILTER",10242:"TEXTURE_WRAP_S",10243:"TEXTURE_WRAP_T",10497:"REPEAT",10752:"POLYGON_OFFSET_UNITS",16384:"COLOR_BUFFER_BIT",32769:"CONSTANT_COLOR",32770:"ONE_MINUS_CONSTANT_COLOR",32771:"CONSTANT_ALPHA",32772:"ONE_MINUS_CONSTANT_ALPHA",32773:"BLEND_COLOR",32774:"FUNC_ADD",32777:"BLEND_EQUATION_RGB",32778:"FUNC_SUBTRACT",32779:"FUNC_REVERSE_SUBTRACT",32819:"UNSIGNED_SHORT_4_4_4_4",32820:"UNSIGNED_SHORT_5_5_5_1",32823:"POLYGON_OFFSET_FILL",32824:"POLYGON_OFFSET_FACTOR",32854:"RGBA4",32855:"RGB5_A1",32873:"TEXTURE_BINDING_2D",32926:"SAMPLE_ALPHA_TO_COVERAGE",32928:"SAMPLE_COVERAGE",32936:"SAMPLE_BUFFERS",32937:"SAMPLES",32938:"SAMPLE_COVERAGE_VALUE",32939:"SAMPLE_COVERAGE_INVERT",32968:"BLEND_DST_RGB",32969:"BLEND_SRC_RGB",32970:"BLEND_DST_ALPHA",32971:"BLEND_SRC_ALPHA",33071:"CLAMP_TO_EDGE",33170:"GENERATE_MIPMAP_HINT",33189:"DEPTH_COMPONENT16",33306:"DEPTH_STENCIL_ATTACHMENT",33635:"UNSIGNED_SHORT_5_6_5",33648:"MIRRORED_REPEAT",33901:"ALIASED_POINT_SIZE_RANGE",33902:"ALIASED_LINE_WIDTH_RANGE",33984:"TEXTURE0",33985:"TEXTURE1",33986:"TEXTURE2",33987:"TEXTURE3",33988:"TEXTURE4",33989:"TEXTURE5",33990:"TEXTURE6",33991:"TEXTURE7",33992:"TEXTURE8",33993:"TEXTURE9",33994:"TEXTURE10",33995:"TEXTURE11",33996:"TEXTURE12",33997:"TEXTURE13",33998:"TEXTURE14",33999:"TEXTURE15",34000:"TEXTURE16",34001:"TEXTURE17",34002:"TEXTURE18",34003:"TEXTURE19",34004:"TEXTURE20",34005:"TEXTURE21",34006:"TEXTURE22",34007:"TEXTURE23",34008:"TEXTURE24",34009:"TEXTURE25",34010:"TEXTURE26",34011:"TEXTURE27",34012:"TEXTURE28",34013:"TEXTURE29",34014:"TEXTURE30",34015:"TEXTURE31",34016:"ACTIVE_TEXTURE",34024:"MAX_RENDERBUFFER_SIZE",34041:"DEPTH_STENCIL",34055:"INCR_WRAP",34056:"DECR_WRAP",34067:"TEXTURE_CUBE_MAP",34068:"TEXTURE_BINDING_CUBE_MAP",34069:"TEXTURE_CUBE_MAP_POSITIVE_X",34070:"TEXTURE_CUBE_MAP_NEGATIVE_X",34071:"TEXTURE_CUBE_MAP_POSITIVE_Y",34072:"TEXTURE_CUBE_MAP_NEGATIVE_Y",34073:"TEXTURE_CUBE_MAP_POSITIVE_Z",34074:"TEXTURE_CUBE_MAP_NEGATIVE_Z",34076:"MAX_CUBE_MAP_TEXTURE_SIZE",34338:"VERTEX_ATTRIB_ARRAY_ENABLED",34339:"VERTEX_ATTRIB_ARRAY_SIZE",34340:"VERTEX_ATTRIB_ARRAY_STRIDE",34341:"VERTEX_ATTRIB_ARRAY_TYPE",34342:"CURRENT_VERTEX_ATTRIB",34373:"VERTEX_ATTRIB_ARRAY_POINTER",34466:"NUM_COMPRESSED_TEXTURE_FORMATS",34467:"COMPRESSED_TEXTURE_FORMATS",34660:"BUFFER_SIZE",34661:"BUFFER_USAGE",34816:"STENCIL_BACK_FUNC",34817:"STENCIL_BACK_FAIL",34818:"STENCIL_BACK_PASS_DEPTH_FAIL",34819:"STENCIL_BACK_PASS_DEPTH_PASS",34877:"BLEND_EQUATION_ALPHA",34921:"MAX_VERTEX_ATTRIBS",34922:"VERTEX_ATTRIB_ARRAY_NORMALIZED",34930:"MAX_TEXTURE_IMAGE_UNITS",34962:"ARRAY_BUFFER",34963:"ELEMENT_ARRAY_BUFFER",34964:"ARRAY_BUFFER_BINDING",34965:"ELEMENT_ARRAY_BUFFER_BINDING",34975:"VERTEX_ATTRIB_ARRAY_BUFFER_BINDING",35040:"STREAM_DRAW",35044:"STATIC_DRAW",35048:"DYNAMIC_DRAW",35632:"FRAGMENT_SHADER",35633:"VERTEX_SHADER",35660:"MAX_VERTEX_TEXTURE_IMAGE_UNITS",35661:"MAX_COMBINED_TEXTURE_IMAGE_UNITS",35663:"SHADER_TYPE",35664:"FLOAT_VEC2",35665:"FLOAT_VEC3",35666:"FLOAT_VEC4",35667:"INT_VEC2",35668:"INT_VEC3",35669:"INT_VEC4",35670:"BOOL",35671:"BOOL_VEC2",35672:"BOOL_VEC3",35673:"BOOL_VEC4",35674:"FLOAT_MAT2",35675:"FLOAT_MAT3",35676:"FLOAT_MAT4",35678:"SAMPLER_2D",35680:"SAMPLER_CUBE",35712:"DELETE_STATUS",35713:"COMPILE_STATUS",35714:"LINK_STATUS",35715:"VALIDATE_STATUS",35716:"INFO_LOG_LENGTH",35717:"ATTACHED_SHADERS",35718:"ACTIVE_UNIFORMS",35719:"ACTIVE_UNIFORM_MAX_LENGTH",35720:"SHADER_SOURCE_LENGTH",35721:"ACTIVE_ATTRIBUTES",35722:"ACTIVE_ATTRIBUTE_MAX_LENGTH",35724:"SHADING_LANGUAGE_VERSION",35725:"CURRENT_PROGRAM",36003:"STENCIL_BACK_REF",36004:"STENCIL_BACK_VALUE_MASK",36005:"STENCIL_BACK_WRITEMASK",36006:"FRAMEBUFFER_BINDING",36007:"RENDERBUFFER_BINDING",36048:"FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE",36049:"FRAMEBUFFER_ATTACHMENT_OBJECT_NAME",36050:"FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL",36051:"FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE",36053:"FRAMEBUFFER_COMPLETE",36054:"FRAMEBUFFER_INCOMPLETE_ATTACHMENT",36055:"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT",36057:"FRAMEBUFFER_INCOMPLETE_DIMENSIONS",36061:"FRAMEBUFFER_UNSUPPORTED",36064:"COLOR_ATTACHMENT0",36096:"DEPTH_ATTACHMENT",36128:"STENCIL_ATTACHMENT",36160:"FRAMEBUFFER",36161:"RENDERBUFFER",36162:"RENDERBUFFER_WIDTH",36163:"RENDERBUFFER_HEIGHT",36164:"RENDERBUFFER_INTERNAL_FORMAT",36168:"STENCIL_INDEX8",36176:"RENDERBUFFER_RED_SIZE",36177:"RENDERBUFFER_GREEN_SIZE",36178:"RENDERBUFFER_BLUE_SIZE",36179:"RENDERBUFFER_ALPHA_SIZE",36180:"RENDERBUFFER_DEPTH_SIZE",36181:"RENDERBUFFER_STENCIL_SIZE",36194:"RGB565",36336:"LOW_FLOAT",36337:"MEDIUM_FLOAT",36338:"HIGH_FLOAT",36339:"LOW_INT",36340:"MEDIUM_INT",36341:"HIGH_INT",36346:"SHADER_COMPILER",36347:"MAX_VERTEX_UNIFORM_VECTORS",36348:"MAX_VARYING_VECTORS",36349:"MAX_FRAGMENT_UNIFORM_VECTORS",37440:"UNPACK_FLIP_Y_WEBGL",37441:"UNPACK_PREMULTIPLY_ALPHA_WEBGL",37442:"CONTEXT_LOST_WEBGL",37443:"UNPACK_COLORSPACE_CONVERSION_WEBGL",37444:"BROWSER_DEFAULT_WEBGL"}},{}],217:[function(t,e,r){var n=t("./1.0/numbers");e.exports=function(t){return n[t]}},{"./1.0/numbers":216}],218:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl,r=n(e),o=i(e,[{buffer:r,type:e.FLOAT,size:3,offset:0,stride:40},{buffer:r,type:e.FLOAT,size:4,offset:12,stride:40},{buffer:r,type:e.FLOAT,size:3,offset:28,stride:40}]),l=a(e);l.attributes.position.location=0,l.attributes.color.location=1,l.attributes.offset.location=2;var c=new s(e,r,o,l);return c.update(t),c};var n=t("gl-buffer"),i=t("gl-vao"),a=t("./shaders/index"),o=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function s(t,e,r,n){this.gl=t,this.shader=n,this.buffer=e,this.vao=r,this.pixelRatio=1,this.bounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.lineWidth=[1,1,1],this.capSize=[10,10,10],this.lineCount=[0,0,0],this.lineOffset=[0,0,0],this.opacity=1}var l=s.prototype;function c(t,e){for(var r=0;r<3;++r)t[0][r]=Math.min(t[0][r],e[r]),t[1][r]=Math.max(t[1][r],e[r])}l.isOpaque=function(){return this.opacity>=1},l.isTransparent=function(){return this.opacity<1},l.drawTransparent=l.draw=function(t){var e=this.gl,r=this.shader.uniforms;this.shader.bind();var n=r.view=t.view||o,i=r.projection=t.projection||o;r.model=t.model||o,r.clipBounds=this.clipBounds,r.opacity=this.opacity;var a=n[12],s=n[13],l=n[14],c=n[15],u=this.pixelRatio*(i[3]*a+i[7]*s+i[11]*l+i[15]*c)/e.drawingBufferHeight;this.vao.bind();for(var f=0;f<3;++f)e.lineWidth(this.lineWidth[f]),r.capSize=this.capSize[f]*u,this.lineCount[f]&&e.drawArrays(e.LINES,this.lineOffset[f],this.lineCount[f]);this.vao.unbind()};var u=function(){for(var t=new Array(3),e=0;e<3;++e){for(var r=[],n=1;n<=2;++n)for(var i=-1;i<=1;i+=2){var a=[0,0,0];a[(n+e)%3]=i,r.push(a)}t[e]=r}return t}();function f(t,e,r,n){for(var i=u[n],a=0;a0)(g=u.slice())[s]+=p[1][s],i.push(u[0],u[1],u[2],d[0],d[1],d[2],d[3],0,0,0,g[0],g[1],g[2],d[0],d[1],d[2],d[3],0,0,0),c(this.bounds,g),o+=2+f(i,g,d,s)}}this.lineCount[s]=o-this.lineOffset[s]}this.buffer.update(i)}},l.dispose=function(){this.shader.dispose(),this.buffer.dispose(),this.vao.dispose()}},{"./shaders/index":219,"gl-buffer":211,"gl-vao":284}],219:[function(t,e,r){"use strict";var n=t("glslify"),i=t("gl-shader"),a=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position, offset;\nattribute vec4 color;\nuniform mat4 model, view, projection;\nuniform float capSize;\nvarying vec4 fragColor;\nvarying vec3 fragPosition;\n\nvoid main() {\n vec4 worldPosition = model * vec4(position, 1.0);\n worldPosition = (worldPosition / worldPosition.w) + vec4(capSize * offset, 0.0);\n gl_Position = projection * view * worldPosition;\n fragColor = color;\n fragPosition = position;\n}"]),o=n(["precision mediump float;\n#define GLSLIFY 1\nuniform vec3 clipBounds[2];\nuniform float opacity;\nvarying vec3 fragPosition;\nvarying vec4 fragColor;\n\nvoid main() {\n if(any(lessThan(fragPosition, clipBounds[0])) || any(greaterThan(fragPosition, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = opacity * fragColor;\n}"]);e.exports=function(t){return i(t,a,o,null,[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"offset",type:"vec3"}])}},{"gl-shader":268,glslify:353}],220:[function(t,e,r){"use strict";var n=t("gl-texture2d");e.exports=function(t,e,r,n){i||(i=t.FRAMEBUFFER_UNSUPPORTED,a=t.FRAMEBUFFER_INCOMPLETE_ATTACHMENT,o=t.FRAMEBUFFER_INCOMPLETE_DIMENSIONS,s=t.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT);var c=t.getExtension("WEBGL_draw_buffers");!l&&c&&function(t,e){var r=t.getParameter(e.MAX_COLOR_ATTACHMENTS_WEBGL);l=new Array(r+1);for(var n=0;n<=r;++n){for(var i=new Array(r),a=0;au||r<0||r>u)throw new Error("gl-fbo: Parameters are too large for FBO");var f=1;if("color"in(n=n||{})){if((f=Math.max(0|n.color,0))<0)throw new Error("gl-fbo: Must specify a nonnegative number of colors");if(f>1){if(!c)throw new Error("gl-fbo: Multiple draw buffer extension not supported");if(f>t.getParameter(c.MAX_COLOR_ATTACHMENTS_WEBGL))throw new Error("gl-fbo: Context does not support "+f+" draw buffers")}}var h=t.UNSIGNED_BYTE,p=t.getExtension("OES_texture_float");if(n.float&&f>0){if(!p)throw new Error("gl-fbo: Context does not support floating point textures");h=t.FLOAT}else n.preferFloat&&f>0&&p&&(h=t.FLOAT);var g=!0;"depth"in n&&(g=!!n.depth);var m=!1;"stencil"in n&&(m=!!n.stencil);return new d(t,e,r,h,f,g,m,c)};var i,a,o,s,l=null;function c(t){return[t.getParameter(t.FRAMEBUFFER_BINDING),t.getParameter(t.RENDERBUFFER_BINDING),t.getParameter(t.TEXTURE_BINDING_2D)]}function u(t,e){t.bindFramebuffer(t.FRAMEBUFFER,e[0]),t.bindRenderbuffer(t.RENDERBUFFER,e[1]),t.bindTexture(t.TEXTURE_2D,e[2])}function f(t){switch(t){case i:throw new Error("gl-fbo: Framebuffer unsupported");case a:throw new Error("gl-fbo: Framebuffer incomplete attachment");case o:throw new Error("gl-fbo: Framebuffer incomplete dimensions");case s:throw new Error("gl-fbo: Framebuffer incomplete missing attachment");default:throw new Error("gl-fbo: Framebuffer failed for unspecified reason")}}function h(t,e,r,i,a,o){if(!i)return null;var s=n(t,e,r,a,i);return s.magFilter=t.NEAREST,s.minFilter=t.NEAREST,s.mipSamples=1,s.bind(),t.framebufferTexture2D(t.FRAMEBUFFER,o,t.TEXTURE_2D,s.handle,0),s}function p(t,e,r,n,i){var a=t.createRenderbuffer();return t.bindRenderbuffer(t.RENDERBUFFER,a),t.renderbufferStorage(t.RENDERBUFFER,n,e,r),t.framebufferRenderbuffer(t.FRAMEBUFFER,i,t.RENDERBUFFER,a),a}function d(t,e,r,n,i,a,o,s){this.gl=t,this._shape=[0|e,0|r],this._destroyed=!1,this._ext=s,this.color=new Array(i);for(var d=0;d1&&s.drawBuffersWEBGL(l[o]);var y=r.getExtension("WEBGL_depth_texture");y?d?t.depth=h(r,i,a,y.UNSIGNED_INT_24_8_WEBGL,r.DEPTH_STENCIL,r.DEPTH_STENCIL_ATTACHMENT):g&&(t.depth=h(r,i,a,r.UNSIGNED_SHORT,r.DEPTH_COMPONENT,r.DEPTH_ATTACHMENT)):g&&d?t._depth_rb=p(r,i,a,r.DEPTH_STENCIL,r.DEPTH_STENCIL_ATTACHMENT):g?t._depth_rb=p(r,i,a,r.DEPTH_COMPONENT16,r.DEPTH_ATTACHMENT):d&&(t._depth_rb=p(r,i,a,r.STENCIL_INDEX,r.STENCIL_ATTACHMENT));var x=r.checkFramebufferStatus(r.FRAMEBUFFER);if(x!==r.FRAMEBUFFER_COMPLETE){for(t._destroyed=!0,r.bindFramebuffer(r.FRAMEBUFFER,null),r.deleteFramebuffer(t.handle),t.handle=null,t.depth&&(t.depth.dispose(),t.depth=null),t._depth_rb&&(r.deleteRenderbuffer(t._depth_rb),t._depth_rb=null),v=0;vi||r<0||r>i)throw new Error("gl-fbo: Can't resize FBO, invalid dimensions");t._shape[0]=e,t._shape[1]=r;for(var a=c(n),o=0;o>8*p&255;this.pickOffset=r,i.bind();var d=i.uniforms;d.viewTransform=t,d.pickOffset=e,d.shape=this.shape;var g=i.attributes;return this.positionBuffer.bind(),g.position.pointer(),this.weightBuffer.bind(),g.weight.pointer(s.UNSIGNED_BYTE,!1),this.idBuffer.bind(),g.pickId.pointer(s.UNSIGNED_BYTE,!1),s.drawArrays(s.TRIANGLES,0,o),r+this.shape[0]*this.shape[1]}}}(),f.pick=function(t,e,r){var n=this.pickOffset,i=this.shape[0]*this.shape[1];if(r=n+i)return null;var a=r-n,o=this.xData,s=this.yData;return{object:this,pointId:a,dataCoord:[o[a%this.shape[0]],s[a/this.shape[0]|0]]}},f.update=function(t){var e=(t=t||{}).shape||[0,0],r=t.x||i(e[0]),o=t.y||i(e[1]),s=t.z||new Float32Array(e[0]*e[1]);this.xData=r,this.yData=o;var l=t.colorLevels||[0],c=t.colorValues||[0,0,0,1],u=l.length,f=this.bounds,p=f[0]=r[0],d=f[1]=o[0],g=1/((f[2]=r[r.length-1])-p),m=1/((f[3]=o[o.length-1])-d),v=e[0],y=e[1];this.shape=[v,y];var x=(v-1)*(y-1)*(h.length>>>1);this.numVertices=x;for(var b=a.mallocUint8(4*x),_=a.mallocFloat32(2*x),w=a.mallocUint8(2*x),k=a.mallocUint32(x),M=0,A=0;A FLOAT_MAX) {\n return vec4(127.0, 128.0, 0.0, 0.0) / 255.0;\n } else if(v < -FLOAT_MAX) {\n return vec4(255.0, 128.0, 0.0, 0.0) / 255.0;\n }\n\n highp vec4 c = vec4(0,0,0,0);\n\n //Compute exponent and mantissa\n highp float e = floor(log2(av));\n highp float m = av * pow(2.0, -e) - 1.0;\n \n //Unpack mantissa\n c[1] = floor(128.0 * m);\n m -= c[1] / 128.0;\n c[2] = floor(32768.0 * m);\n m -= c[2] / 32768.0;\n c[3] = floor(8388608.0 * m);\n \n //Unpack exponent\n highp float ebias = e + 127.0;\n c[0] = floor(ebias / 2.0);\n ebias -= c[0] * 2.0;\n c[1] += floor(ebias) * 128.0; \n\n //Unpack sign bit\n c[0] += 128.0 * step(0.0, -v);\n\n //Scale back to range\n return c / 255.0;\n}\n\nuniform float pickId;\nuniform vec3 clipBounds[2];\n\nvarying vec3 worldPosition;\nvarying float pixelArcLength;\nvarying vec4 fragColor;\n\nvoid main() {\n if(any(lessThan(worldPosition, clipBounds[0])) || any(greaterThan(worldPosition, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId/255.0, encode_float_1540259130(pixelArcLength).xyz);\n}"]),l=[{name:"position",type:"vec3"},{name:"nextPosition",type:"vec3"},{name:"arcLength",type:"float"},{name:"lineWidth",type:"float"},{name:"color",type:"vec4"}];r.createShader=function(t){return i(t,a,o,null,l)},r.createPickShader=function(t){return i(t,a,s,null,l)}},{"gl-shader":268,glslify:353}],226:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl||t.scene&&t.scene.gl,r=u(e);r.attributes.position.location=0,r.attributes.nextPosition.location=1,r.attributes.arcLength.location=2,r.attributes.lineWidth.location=3,r.attributes.color.location=4;var o=f(e);o.attributes.position.location=0,o.attributes.nextPosition.location=1,o.attributes.arcLength.location=2,o.attributes.lineWidth.location=3,o.attributes.color.location=4;for(var s=n(e),c=i(e,[{buffer:s,size:3,offset:0,stride:48},{buffer:s,size:3,offset:12,stride:48},{buffer:s,size:1,offset:24,stride:48},{buffer:s,size:1,offset:28,stride:48},{buffer:s,size:4,offset:32,stride:48}]),h=l(new Array(1024),[256,1,4]),p=0;p<1024;++p)h.data[p]=255;var d=a(e,h);d.wrap=e.REPEAT;var g=new m(e,r,o,s,c,d);return g.update(t),g};var n=t("gl-buffer"),i=t("gl-vao"),a=t("gl-texture2d"),o=t("glsl-read-float"),s=t("binary-search-bounds"),l=t("ndarray"),c=t("./lib/shaders"),u=c.createShader,f=c.createPickShader,h=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function p(t,e){for(var r=0,n=0;n<3;++n){var i=t[n]-e[n];r+=i*i}return Math.sqrt(r)}function d(t){for(var e=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],r=0;r<3;++r)e[0][r]=Math.max(t[0][r],e[0][r]),e[1][r]=Math.min(t[1][r],e[1][r]);return e}function g(t,e,r,n){this.arcLength=t,this.position=e,this.index=r,this.dataCoordinate=n}function m(t,e,r,n,i,a){this.gl=t,this.shader=e,this.pickShader=r,this.buffer=n,this.vao=i,this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.points=[],this.arcLength=[],this.vertexCount=0,this.bounds=[[0,0,0],[0,0,0]],this.pickId=0,this.lineWidth=1,this.texture=a,this.dashScale=1,this.opacity=1,this.dirty=!0,this.pixelRatio=1}var v=m.prototype;v.isTransparent=function(){return this.opacity<1},v.isOpaque=function(){return this.opacity>=1},v.pickSlots=1,v.setPickBase=function(t){this.pickId=t},v.drawTransparent=v.draw=function(t){var e=this.gl,r=this.shader,n=this.vao;r.bind(),r.uniforms={model:t.model||h,view:t.view||h,projection:t.projection||h,clipBounds:d(this.clipBounds),dashTexture:this.texture.bind(),dashScale:this.dashScale/this.arcLength[this.arcLength.length-1],opacity:this.opacity,screenShape:[e.drawingBufferWidth,e.drawingBufferHeight],pixelRatio:this.pixelRatio},n.bind(),n.draw(e.TRIANGLE_STRIP,this.vertexCount),n.unbind()},v.drawPick=function(t){var e=this.gl,r=this.pickShader,n=this.vao;r.bind(),r.uniforms={model:t.model||h,view:t.view||h,projection:t.projection||h,pickId:this.pickId,clipBounds:d(this.clipBounds),screenShape:[e.drawingBufferWidth,e.drawingBufferHeight],pixelRatio:this.pixelRatio},n.bind(),n.draw(e.TRIANGLE_STRIP,this.vertexCount),n.unbind()},v.update=function(t){var e,r;this.dirty=!0;var n=!!t.connectGaps;"dashScale"in t&&(this.dashScale=t.dashScale),"opacity"in t&&(this.opacity=+t.opacity);var i=t.position||t.positions;if(i){var a=t.color||t.colors||[0,0,0,1],o=t.lineWidth||1,c=[],u=[],f=[],h=0,d=0,g=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],m=!1;t:for(e=1;e0){for(var w=0;w<24;++w)c.push(c[c.length-12]);d+=2,m=!0}continue t}g[0][r]=Math.min(g[0][r],b[r],_[r]),g[1][r]=Math.max(g[1][r],b[r],_[r])}Array.isArray(a[0])?(v=a[e-1],y=a[e]):v=y=a,3===v.length&&(v=[v[0],v[1],v[2],1]),3===y.length&&(y=[y[0],y[1],y[2],1]),x=Array.isArray(o)?o[e-1]:o;var k=h;if(h+=p(b,_),m){for(r=0;r<2;++r)c.push(b[0],b[1],b[2],_[0],_[1],_[2],k,x,v[0],v[1],v[2],v[3]);d+=2,m=!1}c.push(b[0],b[1],b[2],_[0],_[1],_[2],k,x,v[0],v[1],v[2],v[3],b[0],b[1],b[2],_[0],_[1],_[2],k,-x,v[0],v[1],v[2],v[3],_[0],_[1],_[2],b[0],b[1],b[2],h,-x,y[0],y[1],y[2],y[3],_[0],_[1],_[2],b[0],b[1],b[2],h,x,y[0],y[1],y[2],y[3]),d+=4}if(this.buffer.update(c),u.push(h),f.push(i[i.length-1].slice()),this.bounds=g,this.vertexCount=d,this.points=f,this.arcLength=u,"dashes"in t){var M=t.dashes.slice();for(M.unshift(0),e=1;e1.0001)return null;m+=g[u]}if(Math.abs(m-1)>.001)return null;return[f,function(t,e){for(var r=[0,0,0],n=0;n 0.25) {\n discard;\n }\n gl_FragColor = f_color * texture2D(texture, f_uv) * opacity;\n}"]),u=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n f_id = id;\n f_position = position;\n}"]),f=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(f_position, clipBounds[0])) || \n any(greaterThan(f_position, clipBounds[1]))) {\n discard;\n }\n gl_FragColor = vec4(pickId, f_id.xyz);\n}"]),h=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\nattribute float pointSize;\nattribute vec4 id;\n\nuniform mat4 model, view, projection;\nuniform vec3 clipBounds[2];\n\nvarying vec3 f_position;\nvarying vec4 f_id;\n\nvoid main() {\n if(any(lessThan(position, clipBounds[0])) || \n any(greaterThan(position, clipBounds[1]))) {\n gl_Position = vec4(0,0,0,0);\n } else {\n gl_Position = projection * view * model * vec4(position, 1.0);\n gl_PointSize = pointSize;\n }\n f_id = id;\n f_position = position;\n}"]),p=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec3 position;\n\nuniform mat4 model, view, projection;\n\nvoid main() {\n gl_Position = projection * view * model * vec4(position, 1.0);\n}"]),d=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec3 contourColor;\n\nvoid main() {\n gl_FragColor = vec4(contourColor,1);\n}\n"]);r.meshShader={vertex:i,fragment:a,attributes:[{name:"position",type:"vec3"},{name:"normal",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"}]},r.wireShader={vertex:o,fragment:s,attributes:[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"}]},r.pointShader={vertex:l,fragment:c,attributes:[{name:"position",type:"vec3"},{name:"color",type:"vec4"},{name:"uv",type:"vec2"},{name:"pointSize",type:"float"}]},r.pickShader={vertex:u,fragment:f,attributes:[{name:"position",type:"vec3"},{name:"id",type:"vec4"}]},r.pointPickShader={vertex:h,fragment:f,attributes:[{name:"position",type:"vec3"},{name:"pointSize",type:"float"},{name:"id",type:"vec4"}]},r.contourShader={vertex:p,fragment:d,attributes:[{name:"position",type:"vec3"}]}},{glslify:353}],249:[function(t,e,r){"use strict";var n=t("gl-shader"),i=t("gl-buffer"),a=t("gl-vao"),o=t("gl-texture2d"),s=t("normals"),l=t("gl-mat4/multiply"),c=t("gl-mat4/invert"),u=t("ndarray"),f=t("colormap"),h=t("simplicial-complex-contour"),p=t("typedarray-pool"),d=t("./lib/shaders"),g=t("./lib/closest-point"),m=d.meshShader,v=d.wireShader,y=d.pointShader,x=d.pickShader,b=d.pointPickShader,_=d.contourShader,w=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1];function k(t,e,r,n,i,a,o,s,l,c,u,f,h,p,d,g,m,v,y,x,b,_,k,M,A,T,S){this.gl=t,this.cells=[],this.positions=[],this.intensity=[],this.texture=e,this.dirty=!0,this.triShader=r,this.lineShader=n,this.pointShader=i,this.pickShader=a,this.pointPickShader=o,this.contourShader=s,this.trianglePositions=l,this.triangleColors=u,this.triangleNormals=h,this.triangleUVs=f,this.triangleIds=c,this.triangleVAO=p,this.triangleCount=0,this.lineWidth=1,this.edgePositions=d,this.edgeColors=m,this.edgeUVs=v,this.edgeIds=g,this.edgeVAO=y,this.edgeCount=0,this.pointPositions=x,this.pointColors=_,this.pointUVs=k,this.pointSizes=M,this.pointIds=b,this.pointVAO=A,this.pointCount=0,this.contourLineWidth=1,this.contourPositions=T,this.contourVAO=S,this.contourCount=0,this.contourColor=[0,0,0],this.contourEnable=!0,this.pickId=1,this.bounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.lightPosition=[1e5,1e5,0],this.ambientLight=.8,this.diffuseLight=.8,this.specularLight=2,this.roughness=.5,this.fresnel=1.5,this.opacity=1,this._model=w,this._view=w,this._projection=w,this._resolution=[1,1]}var M=k.prototype;function A(t){var e=n(t,y.vertex,y.fragment);return e.attributes.position.location=0,e.attributes.color.location=2,e.attributes.uv.location=3,e.attributes.pointSize.location=4,e}function T(t){var e=n(t,x.vertex,x.fragment);return e.attributes.position.location=0,e.attributes.id.location=1,e}function S(t){var e=n(t,b.vertex,b.fragment);return e.attributes.position.location=0,e.attributes.id.location=1,e.attributes.pointSize.location=4,e}function C(t){var e=n(t,_.vertex,_.fragment);return e.attributes.position.location=0,e}M.isOpaque=function(){return this.opacity>=1},M.isTransparent=function(){return this.opacity<1},M.pickSlots=1,M.setPickBase=function(t){this.pickId=t},M.highlight=function(t){if(t&&this.contourEnable){for(var e=h(this.cells,this.intensity,t.intensity),r=e.cells,n=e.vertexIds,i=e.vertexWeights,a=r.length,o=p.mallocFloat32(6*a),s=0,l=0;l0&&((f=this.triShader).bind(),f.uniforms=s,this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind());this.edgeCount>0&&this.lineWidth>0&&((f=this.lineShader).bind(),f.uniforms=s,this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind());this.pointCount>0&&((f=this.pointShader).bind(),f.uniforms=s,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind());this.contourEnable&&this.contourCount>0&&this.contourLineWidth>0&&((f=this.contourShader).bind(),f.uniforms=s,this.contourVAO.bind(),e.drawArrays(e.LINES,0,this.contourCount),this.contourVAO.unbind())},M.drawPick=function(t){t=t||{};for(var e=this.gl,r=t.model||w,n=t.view||w,i=t.projection||w,a=[[-1e6,-1e6,-1e6],[1e6,1e6,1e6]],o=0;o<3;++o)a[0][o]=Math.max(a[0][o],this.clipBounds[0][o]),a[1][o]=Math.min(a[1][o],this.clipBounds[1][o]);this._model=[].slice.call(r),this._view=[].slice.call(n),this._projection=[].slice.call(i),this._resolution=[e.drawingBufferWidth,e.drawingBufferHeight];var s,l={model:r,view:n,projection:i,clipBounds:a,pickId:this.pickId/255};((s=this.pickShader).bind(),s.uniforms=l,this.triangleCount>0&&(this.triangleVAO.bind(),e.drawArrays(e.TRIANGLES,0,3*this.triangleCount),this.triangleVAO.unbind()),this.edgeCount>0&&(this.edgeVAO.bind(),e.lineWidth(this.lineWidth),e.drawArrays(e.LINES,0,2*this.edgeCount),this.edgeVAO.unbind()),this.pointCount>0)&&((s=this.pointPickShader).bind(),s.uniforms=l,this.pointVAO.bind(),e.drawArrays(e.POINTS,0,this.pointCount),this.pointVAO.unbind())},M.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;for(var e=t.value[0]+256*t.value[1]+65536*t.value[2],r=this.cells[e],n=this.positions,i=new Array(r.length),a=0;ai[M]&&(r.uniforms.dataAxis=c,r.uniforms.screenOffset=u,r.uniforms.color=m[t],r.uniforms.angle=v[t],a.drawArrays(a.TRIANGLES,i[M],i[A]-i[M]))),y[t]&&k&&(u[1^t]-=T*p*x[t],r.uniforms.dataAxis=f,r.uniforms.screenOffset=u,r.uniforms.color=b[t],r.uniforms.angle=_[t],a.drawArrays(a.TRIANGLES,w,k)),u[1^t]=T*s[2+(1^t)]-1,d[t+2]&&(u[1^t]+=T*p*g[t+2],Mi[M]&&(r.uniforms.dataAxis=c,r.uniforms.screenOffset=u,r.uniforms.color=m[t+2],r.uniforms.angle=v[t+2],a.drawArrays(a.TRIANGLES,i[M],i[A]-i[M]))),y[t+2]&&k&&(u[1^t]+=T*p*x[t+2],r.uniforms.dataAxis=f,r.uniforms.screenOffset=u,r.uniforms.color=b[t+2],r.uniforms.angle=_[t+2],a.drawArrays(a.TRIANGLES,w,k))}),g.drawTitle=function(){var t=[0,0],e=[0,0];return function(){var r=this.plot,n=this.shader,i=r.gl,a=r.screenBox,o=r.titleCenter,s=r.titleAngle,l=r.titleColor,c=r.pixelRatio;if(this.titleCount){for(var u=0;u<2;++u)e[u]=2*(o[u]*c-a[u])/(a[2+u]-a[u])-1;n.bind(),n.uniforms.dataAxis=t,n.uniforms.screenOffset=e,n.uniforms.angle=s,n.uniforms.color=l,i.drawArrays(i.TRIANGLES,this.titleOffset,this.titleCount)}}}(),g.bind=(h=[0,0],p=[0,0],d=[0,0],function(){var t=this.plot,e=this.shader,r=t._tickBounds,n=t.dataBox,i=t.screenBox,a=t.viewBox;e.bind();for(var o=0;o<2;++o){var s=r[o],l=r[o+2]-s,c=.5*(n[o+2]+n[o]),u=n[o+2]-n[o],f=a[o],g=a[o+2]-f,m=i[o],v=i[o+2]-m;p[o]=2*l/u*g/v,h[o]=2*(s-c)/u*g/v}d[1]=2*t.pixelRatio/(i[3]-i[1]),d[0]=d[1]*(i[3]-i[1])/(i[2]-i[0]),e.uniforms.dataScale=p,e.uniforms.dataShift=h,e.uniforms.textScale=d,this.vbo.bind(),e.attributes.textCoordinate.pointer()}),g.update=function(t){var e,r,n,i,o,s=[],l=t.ticks,c=t.bounds;for(o=0;o<2;++o){var u=[Math.floor(s.length/3)],f=[-1/0],h=l[o];for(e=0;e=0){var g=e[d]-n[d]*(e[d+2]-e[d])/(n[d+2]-n[d]);0===d?o.drawLine(g,e[1],g,e[3],p[d],h[d]):o.drawLine(e[0],g,e[2],g,p[d],h[d])}}for(d=0;d=0;--t)this.objects[t].dispose();this.objects.length=0;for(t=this.overlays.length-1;t>=0;--t)this.overlays[t].dispose();this.overlays.length=0,this.gl=null},c.addObject=function(t){this.objects.indexOf(t)<0&&(this.objects.push(t),this.setDirty())},c.removeObject=function(t){for(var e=this.objects,r=0;r0&&0===L[e-1];)L.pop(),z.pop().dispose()}window.addEventListener("resize",j),F.update=function(t){e||(t=t||{},P=!0,D=!0)},F.add=function(t){e||(t.axes=A,C.push(t),E.push(-1),P=!0,D=!0,V())},F.remove=function(t){if(!e){var r=C.indexOf(t);r<0||(C.splice(r,1),E.pop(),P=!0,D=!0,V())}},F.dispose=function(){if(!e&&(e=!0,window.removeEventListener("resize",j),r.removeEventListener("webglcontextlost",H),F.mouseListener.enabled=!1,!F.contextLost)){A.dispose(),S.dispose();for(var t=0;tb.distance)continue;for(var u=0;u0){r=Math.round(Math.pow(10,e));return Math.ceil(t/r)*r}return Math.ceil(t)}function m(t){return"boolean"!=typeof t||t}},{"./lib/shader":257,"3d-view-controls":41,"a-big-triangle":44,"gl-axes3d":203,"gl-axes3d/properties":210,"gl-fbo":220,"gl-mat4/perspective":238,"gl-select-static":267,"gl-spikes3d":277,"is-mobile":364,"mouse-change":378}],259:[function(t,e,r){var n=t("glslify");r.pointVertex=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\n\nuniform mat3 matrix;\nuniform float pointSize;\nuniform float pointCloud;\n\nhighp float rand(vec2 co) {\n highp float a = 12.9898;\n highp float b = 78.233;\n highp float c = 43758.5453;\n highp float d = dot(co.xy, vec2(a, b));\n highp float e = mod(d, 3.14);\n return fract(sin(e) * c);\n}\n\nvoid main() {\n vec3 hgPosition = matrix * vec3(position, 1);\n gl_Position = vec4(hgPosition.xy, 0, hgPosition.z);\n // if we don't jitter the point size a bit, overall point cloud\n // saturation 'jumps' on zooming, which is disturbing and confusing\n gl_PointSize = pointSize * ((19.5 + rand(position)) / 20.0);\n if(pointCloud != 0.0) { // pointCloud is truthy\n // get the same square surface as circle would be\n gl_PointSize *= 0.886;\n }\n}"]),r.pointFragment=n(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec4 color, borderColor;\nuniform float centerFraction;\nuniform float pointCloud;\n\nvoid main() {\n float radius;\n vec4 baseColor;\n if(pointCloud != 0.0) { // pointCloud is truthy\n if(centerFraction == 1.0) {\n gl_FragColor = color;\n } else {\n gl_FragColor = mix(borderColor, color, centerFraction);\n }\n } else {\n radius = length(2.0 * gl_PointCoord.xy - 1.0);\n if(radius > 1.0) {\n discard;\n }\n baseColor = mix(borderColor, color, step(radius, centerFraction));\n gl_FragColor = vec4(baseColor.rgb * baseColor.a, baseColor.a);\n }\n}\n"]),r.pickVertex=n(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec2 position;\nattribute vec4 pickId;\n\nuniform mat3 matrix;\nuniform float pointSize;\nuniform vec4 pickOffset;\n\nvarying vec4 fragId;\n\nvoid main() {\n vec3 hgPosition = matrix * vec3(position, 1);\n gl_Position = vec4(hgPosition.xy, 0, hgPosition.z);\n gl_PointSize = pointSize;\n\n vec4 id = pickId + pickOffset;\n id.y += floor(id.x / 256.0);\n id.x -= floor(id.x / 256.0) * 256.0;\n\n id.z += floor(id.y / 256.0);\n id.y -= floor(id.y / 256.0) * 256.0;\n\n id.w += floor(id.z / 256.0);\n id.z -= floor(id.z / 256.0) * 256.0;\n\n fragId = id;\n}\n"]),r.pickFragment=n(["precision mediump float;\n#define GLSLIFY 1\n\nvarying vec4 fragId;\n\nvoid main() {\n float radius = length(2.0 * gl_PointCoord.xy - 1.0);\n if(radius > 1.0) {\n discard;\n }\n gl_FragColor = fragId / 255.0;\n}\n"])},{glslify:353}],260:[function(t,e,r){"use strict";var n=t("gl-shader"),i=t("gl-buffer"),a=t("typedarray-pool"),o=t("./lib/shader");function s(t,e,r,n,i){this.plot=t,this.offsetBuffer=e,this.pickBuffer=r,this.shader=n,this.pickShader=i,this.sizeMin=.5,this.sizeMinCap=2,this.sizeMax=20,this.areaRatio=1,this.pointCount=0,this.color=[1,0,0,1],this.borderColor=[0,0,0,1],this.blend=!1,this.pickOffset=0,this.points=null}e.exports=function(t,e){var r=t.gl,a=i(r),l=i(r),c=n(r,o.pointVertex,o.pointFragment),u=n(r,o.pickVertex,o.pickFragment),f=new s(t,a,l,c,u);return f.update(e),t.addObject(f),f};var l,c,u=s.prototype;u.dispose=function(){this.shader.dispose(),this.pickShader.dispose(),this.offsetBuffer.dispose(),this.pickBuffer.dispose(),this.plot.removeObject(this)},u.update=function(t){var e;function r(e,r){return e in t?t[e]:r}t=t||{},this.sizeMin=r("sizeMin",.5),this.sizeMax=r("sizeMax",20),this.color=r("color",[1,0,0,1]).slice(),this.areaRatio=r("areaRatio",1),this.borderColor=r("borderColor",[0,0,0,1]).slice(),this.blend=r("blend",!1);var n=t.positions.length>>>1,i=t.positions instanceof Float32Array,o=t.idToIndex instanceof Int32Array&&t.idToIndex.length>=n,s=t.positions,l=i?s:a.mallocFloat32(s.length),c=o?t.idToIndex:a.mallocInt32(n);if(i||l.set(s),!o)for(l.set(s),e=0;e>>1;for(r=0;r=e[0]&&a<=e[2]&&o>=e[1]&&o<=e[3]&&n++}return n}(this.points,i),u=this.plot.pickPixelRatio*Math.max(Math.min(this.sizeMinCap,this.sizeMin),Math.min(this.sizeMax,this.sizeMax/Math.pow(s,.33333)));l[0]=2/a,l[4]=2/o,l[6]=-2*i[0]/a-1,l[7]=-2*i[1]/o-1,this.offsetBuffer.bind(),r.bind(),r.attributes.position.pointer(),r.uniforms.matrix=l,r.uniforms.color=this.color,r.uniforms.borderColor=this.borderColor,r.uniforms.pointCloud=u<5,r.uniforms.pointSize=u,r.uniforms.centerFraction=Math.min(1,Math.max(0,Math.sqrt(1-this.areaRatio))),e&&(c[0]=255&t,c[1]=t>>8&255,c[2]=t>>16&255,c[3]=t>>24&255,this.pickBuffer.bind(),r.attributes.pickId.pointer(n.UNSIGNED_BYTE),r.uniforms.pickOffset=c,this.pickOffset=t);var f=n.getParameter(n.BLEND),h=n.getParameter(n.DITHER);return f&&!this.blend&&n.disable(n.BLEND),h&&n.disable(n.DITHER),n.drawArrays(n.POINTS,0,this.pointCount),f&&!this.blend&&n.enable(n.BLEND),h&&n.enable(n.DITHER),t+this.pointCount}),u.draw=u.unifiedDraw,u.drawPick=u.unifiedDraw,u.pick=function(t,e,r){var n=this.pickOffset,i=this.pointCount;if(r=n+i)return null;var a=r-n,o=this.points;return{object:this,pointId:a,dataCoord:[o[2*a],o[2*a+1]]}}},{"./lib/shader":259,"gl-buffer":211,"gl-shader":268,"typedarray-pool":481}],261:[function(t,e,r){e.exports=function(t,e,r,n){var i,a,o,s,l,c=e[0],u=e[1],f=e[2],h=e[3],p=r[0],d=r[1],g=r[2],m=r[3];(a=c*p+u*d+f*g+h*m)<0&&(a=-a,p=-p,d=-d,g=-g,m=-m);1-a>1e-6?(i=Math.acos(a),o=Math.sin(i),s=Math.sin((1-n)*i)/o,l=Math.sin(n*i)/o):(s=1-n,l=n);return t[0]=s*c+l*p,t[1]=s*u+l*d,t[2]=s*f+l*g,t[3]=s*h+l*m,t}},{}],262:[function(t,e,r){"use strict";var n=t("vectorize-text");e.exports=function(t,e){var r=i[e];r||(r=i[e]={});if(t in r)return r[t];for(var a=n(t,{textAlign:"center",textBaseline:"middle",lineHeight:1,font:e}),o=n(t,{triangles:!0,textAlign:"center",textBaseline:"middle",lineHeight:1,font:e}),s=[[1/0,1/0],[-1/0,-1/0]],l=0;l=1)return!0;for(var t=0;t<3;++t)if(this.axesProject[t]&&this.projectOpacity[t]>=1)return!0;return!1};var g=[0,0],m=[0,0,0],v=[0,0,0],y=[0,0,0,1],x=[0,0,0,1],b=c.slice(),_=[0,0,0],w=[[0,0,0],[0,0,0]];function k(t){return t[0]=t[1]=t[2]=0,t}function M(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=1,t}function A(t,e,r,n){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[r]=n,t}function T(t,e,r,n,i){var a,s=e.axesProject,l=e.gl,u=t.uniforms,h=r.model||c,p=r.view||c,d=r.projection||c,T=e.axesBounds,S=function(t){for(var e=w,r=0;r<2;++r)for(var n=0;n<3;++n)e[r][n]=Math.max(Math.min(t[r][n],1e8),-1e8);return e}(e.clipBounds);a=e.axes&&e.axes.lastCubeProps?e.axes.lastCubeProps.axis:[1,1,1],g[0]=2/l.drawingBufferWidth,g[1]=2/l.drawingBufferHeight,t.bind(),u.view=p,u.projection=d,u.screenSize=g,u.highlightId=e.highlightId,u.highlightScale=e.highlightScale,u.clipBounds=S,u.pickGroup=e.pickId/255,u.pixelRatio=e.pixelRatio;for(var C=0;C<3;++C)if(s[C]&&e.projectOpacity[C]<1===n){u.scale=e.projectScale[C],u.opacity=e.projectOpacity[C];for(var E=b,L=0;L<16;++L)E[L]=0;for(L=0;L<4;++L)E[5*L]=1;E[5*C]=0,a[C]<0?E[12+C]=T[0][C]:E[12+C]=T[1][C],o(E,h,E),u.model=E;var z=(C+1)%3,P=(C+2)%3,D=k(m),O=k(v);D[z]=1,O[P]=1;var I=f(0,0,0,M(y,D)),R=f(0,0,0,M(x,O));if(Math.abs(I[1])>Math.abs(R[1])){var B=I;I=R,R=B,B=D,D=O,O=B;var F=z;z=P,P=F}I[0]<0&&(D[z]=-1),R[1]>0&&(O[P]=-1);var N=0,j=0;for(L=0;L<4;++L)N+=Math.pow(h[4*z+L],2),j+=Math.pow(h[4*P+L],2);D[z]/=Math.sqrt(N),O[P]/=Math.sqrt(j),u.axes[0]=D,u.axes[1]=O,u.fragClipBounds[0]=A(_,S[0],C,-1e8),u.fragClipBounds[1]=A(_,S[1],C,1e8),e.vao.draw(l.TRIANGLES,e.vertexCount),e.lineWidth>0&&(l.lineWidth(e.lineWidth),e.vao.draw(l.LINES,e.lineVertexCount,e.vertexCount))}}var S=[[-1e8,-1e8,-1e8],[1e8,1e8,1e8]];function C(t,e,r,n,i,a){var o=r.gl;if(r.vao.bind(),i===r.opacity<1||a){t.bind();var s=t.uniforms;s.model=n.model||c,s.view=n.view||c,s.projection=n.projection||c,g[0]=2/o.drawingBufferWidth,g[1]=2/o.drawingBufferHeight,s.screenSize=g,s.highlightId=r.highlightId,s.highlightScale=r.highlightScale,s.fragClipBounds=S,s.clipBounds=r.axes.bounds,s.opacity=r.opacity,s.pickGroup=r.pickId/255,s.pixelRatio=r.pixelRatio,r.vao.draw(o.TRIANGLES,r.vertexCount),r.lineWidth>0&&(o.lineWidth(r.lineWidth),r.vao.draw(o.LINES,r.lineVertexCount,r.vertexCount))}T(e,r,n,i),r.vao.unbind()}d.draw=function(t){C(this.useOrtho?this.orthoShader:this.shader,this.projectShader,this,t,!1,!1)},d.drawTransparent=function(t){C(this.useOrtho?this.orthoShader:this.shader,this.projectShader,this,t,!0,!1)},d.drawPick=function(t){C(this.useOrtho?this.pickOrthoShader:this.pickPerspectiveShader,this.pickProjectShader,this,t,!1,!0)},d.pick=function(t){if(!t)return null;if(t.id!==this.pickId)return null;var e=t.value[2]+(t.value[1]<<8)+(t.value[0]<<16);if(e>=this.pointCount||e<0)return null;var r=this.points[e],n=this._selectResult;n.index=e;for(var i=0;i<3;++i)n.position[i]=n.dataCoordinate[i]=r[i];return n},d.highlight=function(t){if(t){var e=t.index,r=255&e,n=e>>8&255,i=e>>16&255;this.highlightId=[r/255,n/255,i/255,0]}else this.highlightId=[1,1,1,1]},d.update=function(t){if("perspective"in(t=t||{})&&(this.useOrtho=!t.perspective),"orthographic"in t&&(this.useOrtho=!!t.orthographic),"lineWidth"in t&&(this.lineWidth=t.lineWidth),"project"in t)if(Array.isArray(t.project))this.axesProject=t.project;else{var e=!!t.project;this.axesProject=[e,e,e]}if("projectScale"in t)if(Array.isArray(t.projectScale))this.projectScale=t.projectScale.slice();else{var r=+t.projectScale;this.projectScale=[r,r,r]}if("projectOpacity"in t)if(Array.isArray(t.projectOpacity))this.projectOpacity=t.projectOpacity.slice();else{r=+t.projectOpacity;this.projectOpacity=[r,r,r]}"opacity"in t&&(this.opacity=t.opacity),this.dirty=!0;var n=t.position;if(n){var i=t.font||"normal",o=t.alignment||[0,0],s=[1/0,1/0,1/0],c=[-1/0,-1/0,-1/0],u=t.glyph,f=t.color,h=t.size,p=t.angle,d=t.lineColor,g=0,m=0,v=0,y=n.length;t:for(var x=0;x0&&(L[0]=-o[0]*(1+M[0][0]));var q=w.cells,H=w.positions;for(_=0;_0){var v=r*u;o.drawBox(f-v,h-v,p+v,h+v,a),o.drawBox(f-v,d-v,p+v,d+v,a),o.drawBox(f-v,h-v,f+v,d+v,a),o.drawBox(p-v,h-v,p+v,d+v,a)}}}},s.update=function(t){t=t||{},this.innerFill=!!t.innerFill,this.outerFill=!!t.outerFill,this.innerColor=(t.innerColor||[0,0,0,.5]).slice(),this.outerColor=(t.outerColor||[0,0,0,.5]).slice(),this.borderColor=(t.borderColor||[0,0,0,1]).slice(),this.borderWidth=t.borderWidth||0,this.selectBox=(t.selectBox||this.selectBox).slice()},s.dispose=function(){this.boxBuffer.dispose(),this.boxShader.dispose(),this.plot.removeOverlay(this)}},{"./lib/shaders":265,"gl-buffer":211,"gl-shader":268}],267:[function(t,e,r){"use strict";e.exports=function(t,e){var r=n(t,e),a=i.mallocUint8(e[0]*e[1]*4);return new c(t,r,a)};var n=t("gl-fbo"),i=t("typedarray-pool"),a=t("ndarray"),o=t("bit-twiddle").nextPow2,s=t("cwise/lib/wrapper")({args:["array",{offset:[0,0,1],array:0},{offset:[0,0,2],array:0},{offset:[0,0,3],array:0},"scalar","scalar","index"],pre:{body:"{this_closestD2=1e8,this_closestX=-1,this_closestY=-1}",args:[],thisVars:["this_closestD2","this_closestX","this_closestY"],localVars:[]},body:{body:"{if(_inline_16_arg0_<255||_inline_16_arg1_<255||_inline_16_arg2_<255||_inline_16_arg3_<255){var _inline_16_l=_inline_16_arg4_-_inline_16_arg6_[0],_inline_16_a=_inline_16_arg5_-_inline_16_arg6_[1],_inline_16_f=_inline_16_l*_inline_16_l+_inline_16_a*_inline_16_a;_inline_16_fthis.buffer.length){i.free(this.buffer);for(var n=this.buffer=i.mallocUint8(o(r*e*4)),a=0;ar)for(t=r;te)for(t=e;t=0){for(var k=0|w.type.charAt(w.type.length-1),M=new Array(k),A=0;A=0;)T+=1;_[y]=T}var S=new Array(r.length);function C(){h.program=o.program(p,h._vref,h._fref,b,_);for(var t=0;t=0){var d=h.charCodeAt(h.length-1)-48;if(d<2||d>4)throw new n("","Invalid data type for attribute "+f+": "+h);o(t,e,p[0],i,d,a,f)}else{if(!(h.indexOf("mat")>=0))throw new n("","Unknown data type for attribute "+f+": "+h);var d=h.charCodeAt(h.length-1)-48;if(d<2||d>4)throw new n("","Invalid data type for attribute "+f+": "+h);s(t,e,p,i,d,a,f)}}}return a};var n=t("./GLError");function i(t,e,r,n,i,a){this._gl=t,this._wrapper=e,this._index=r,this._locations=n,this._dimension=i,this._constFunc=a}var a=i.prototype;function o(t,e,r,n,a,o,s){for(var l=["gl","v"],c=[],u=0;u4)throw new i("","Invalid uniform dimension type for matrix "+name+": "+r);return"gl.uniformMatrix"+a+"fv(locations["+e+"],false,obj"+t+")"}throw new i("","Unknown uniform data type for "+name+": "+r)}var a=r.charCodeAt(r.length-1)-48;if(a<2||a>4)throw new i("","Invalid data type");switch(r.charAt(0)){case"b":case"i":return"gl.uniform"+a+"iv(locations["+e+"],obj"+t+")";case"v":return"gl.uniform"+a+"fv(locations["+e+"],obj"+t+")";default:throw new i("","Unrecognized data type for vector "+name+": "+r)}}}function c(e){for(var n=["return function updateProperty(obj){"],i=function t(e,r){if("object"!=typeof r)return[[e,r]];var n=[];for(var i in r){var a=r[i],o=e;parseInt(i)+""===i?o+="["+i+"]":o+="."+i,"object"==typeof a?n.push.apply(n,t(o,a)):n.push([o,a])}return n}("",e),a=0;a4)throw new i("","Invalid data type");return"b"===t.charAt(0)?o(r,!1):o(r,0)}if(0===t.indexOf("mat")&&4===t.length){var r=t.charCodeAt(t.length-1)-48;if(r<2||r>4)throw new i("","Invalid uniform dimension type for matrix "+name+": "+t);return o(r*r,0)}throw new i("","Unknown uniform data type for "+name+": "+t)}}(r[u].type);var p}function f(t){var e;if(Array.isArray(t)){e=new Array(t.length);for(var r=0;r1){l[0]in o||(o[l[0]]=[]),o=o[l[0]];for(var c=1;c1)for(var l=0;l 0.0 ||\n any(lessThan(worldCoordinate, clipBounds[0])) || any(greaterThan(worldCoordinate, clipBounds[1]))) {\n discard;\n }\n\n vec3 N = normalize(surfaceNormal);\n vec3 V = normalize(eyeDirection);\n vec3 L = normalize(lightDirection);\n\n if(gl_FrontFacing) {\n N = -N;\n }\n\n float specular = max(beckmannSpecular(L, V, N, roughness), 0.);\n float diffuse = min(kambient + kdiffuse * max(dot(N, L), 0.0), 1.0);\n\n //decide how to interpolate color \u2014 in vertex or in fragment\n vec4 surfaceColor = step(vertexColor, .5) * texture2D(colormap, vec2(value, value)) + step(.5, vertexColor) * vColor;\n\n vec4 litColor = surfaceColor.a * vec4(diffuse * surfaceColor.rgb + kspecular * vec3(1,1,1) * specular, 1.0);\n\n gl_FragColor = mix(litColor, contourColor, contourTint) * opacity;\n}\n"]),s=i(["precision mediump float;\n#define GLSLIFY 1\n\nattribute vec4 uv;\nattribute float f;\n\nuniform mat3 permutation;\nuniform mat4 model, view, projection;\nuniform float height, zOffset;\nuniform sampler2D colormap;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 lightDirection, eyeDirection, surfaceNormal;\nvarying vec4 vColor;\n\nvoid main() {\n vec3 dataCoordinate = permutation * vec3(uv.xy, height);\n vec4 worldPosition = model * vec4(dataCoordinate, 1.0);\n\n vec4 clipPosition = projection * view * worldPosition;\n clipPosition.z = clipPosition.z + zOffset;\n\n gl_Position = clipPosition;\n value = f;\n kill = -1.0;\n worldCoordinate = dataCoordinate;\n planeCoordinate = uv.zw;\n\n vColor = texture2D(colormap, vec2(value, value));\n\n //Don't do lighting for contours\n surfaceNormal = vec3(1,0,0);\n eyeDirection = vec3(0,1,0);\n lightDirection = vec3(0,0,1);\n}\n"]),l=i(["precision mediump float;\n#define GLSLIFY 1\n\nuniform vec2 shape;\nuniform vec3 clipBounds[2];\nuniform float pickId;\n\nvarying float value, kill;\nvarying vec3 worldCoordinate;\nvarying vec2 planeCoordinate;\nvarying vec3 surfaceNormal;\n\nvec2 splitFloat(float v) {\n float vh = 255.0 * v;\n float upper = floor(vh);\n float lower = fract(vh);\n return vec2(upper / 255.0, floor(lower * 16.0) / 16.0);\n}\n\nvoid main() {\n if(kill > 0.0 ||\n any(lessThan(worldCoordinate, clipBounds[0])) || any(greaterThan(worldCoordinate, clipBounds[1]))) {\n discard;\n }\n vec2 ux = splitFloat(planeCoordinate.x / shape.x);\n vec2 uy = splitFloat(planeCoordinate.y / shape.y);\n gl_FragColor = vec4(pickId, ux.x, uy.x, ux.y + (uy.y/16.0));\n}\n"]);r.createShader=function(t){var e=n(t,a,o,null,[{name:"uv",type:"vec4"},{name:"f",type:"vec3"},{name:"normal",type:"vec3"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e.attributes.normal.location=2,e},r.createPickShader=function(t){var e=n(t,a,l,null,[{name:"uv",type:"vec4"},{name:"f",type:"vec3"},{name:"normal",type:"vec3"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e.attributes.normal.location=2,e},r.createContourShader=function(t){var e=n(t,s,o,null,[{name:"uv",type:"vec4"},{name:"f",type:"float"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e},r.createPickContourShader=function(t){var e=n(t,s,l,null,[{name:"uv",type:"vec4"},{name:"f",type:"float"}]);return e.attributes.uv.location=0,e.attributes.f.location=1,e}},{"gl-shader":268,glslify:353}],279:[function(t,e,r){"use strict";e.exports=function(t){var e=t.gl,r=y(e),n=b(e),s=x(e),l=_(e),c=i(e),u=a(e,[{buffer:c,size:4,stride:w,offset:0},{buffer:c,size:3,stride:w,offset:16},{buffer:c,size:3,stride:w,offset:28}]),f=i(e),h=a(e,[{buffer:f,size:4,stride:20,offset:0},{buffer:f,size:1,stride:20,offset:16}]),p=i(e),d=a(e,[{buffer:p,size:2,type:e.FLOAT}]),g=o(e,1,S,e.RGBA,e.UNSIGNED_BYTE);g.minFilter=e.LINEAR,g.magFilter=e.LINEAR;var m=new C(e,[0,0],[[0,0,0],[0,0,0]],r,n,c,u,g,s,l,f,h,p,d),v={levels:[[],[],[]]};for(var k in t)v[k]=t[k];return v.colormap=v.colormap||"jet",m.update(v),m};var n=t("bit-twiddle"),i=t("gl-buffer"),a=t("gl-vao"),o=t("gl-texture2d"),s=t("typedarray-pool"),l=t("colormap"),c=t("ndarray-ops"),u=t("ndarray-pack"),f=t("ndarray"),h=t("surface-nets"),p=t("gl-mat4/multiply"),d=t("gl-mat4/invert"),g=t("binary-search-bounds"),m=t("ndarray-gradient"),v=t("./lib/shaders"),y=v.createShader,x=v.createContourShader,b=v.createPickShader,_=v.createPickContourShader,w=40,k=[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1],M=[[0,0],[0,1],[1,0],[1,1],[1,0],[0,1]],A=[[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0]];function T(t,e,r,n,i){this.position=t,this.index=e,this.uv=r,this.level=n,this.dataCoordinate=i}!function(){for(var t=0;t<3;++t){var e=A[t],r=(t+2)%3;e[(t+1)%3+0]=1,e[r+3]=1,e[t+6]=1}}();var S=256;function C(t,e,r,n,i,a,o,l,c,u,h,p,d,g){this.gl=t,this.shape=e,this.bounds=r,this.intensityBounds=[],this._shader=n,this._pickShader=i,this._coordinateBuffer=a,this._vao=o,this._colorMap=l,this._contourShader=c,this._contourPickShader=u,this._contourBuffer=h,this._contourVAO=p,this._contourOffsets=[[],[],[]],this._contourCounts=[[],[],[]],this._vertexCount=0,this._pickResult=new T([0,0,0],[0,0],[0,0],[0,0,0],[0,0,0]),this._dynamicBuffer=d,this._dynamicVAO=g,this._dynamicOffsets=[0,0,0],this._dynamicCounts=[0,0,0],this.contourWidth=[1,1,1],this.contourLevels=[[1],[1],[1]],this.contourTint=[0,0,0],this.contourColor=[[.5,.5,.5,1],[.5,.5,.5,1],[.5,.5,.5,1]],this.showContour=!0,this.showSurface=!0,this.enableHighlight=[!0,!0,!0],this.highlightColor=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.highlightTint=[1,1,1],this.highlightLevel=[-1,-1,-1],this.enableDynamic=[!0,!0,!0],this.dynamicLevel=[NaN,NaN,NaN],this.dynamicColor=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.dynamicTint=[1,1,1],this.dynamicWidth=[1,1,1],this.axesBounds=[[1/0,1/0,1/0],[-1/0,-1/0,-1/0]],this.surfaceProject=[!1,!1,!1],this.contourProject=[[!1,!1,!1],[!1,!1,!1],[!1,!1,!1]],this.colorBounds=[!1,!1],this._field=[f(s.mallocFloat(1024),[0,0]),f(s.mallocFloat(1024),[0,0]),f(s.mallocFloat(1024),[0,0])],this.pickId=1,this.clipBounds=[[-1/0,-1/0,-1/0],[1/0,1/0,1/0]],this.snapToData=!1,this.opacity=1,this.lightPosition=[10,1e4,0],this.ambientLight=.8,this.diffuseLight=.8,this.specularLight=2,this.roughness=.5,this.fresnel=1.5,this.vertexColor=0,this.dirty=!0}var E=C.prototype;E.isTransparent=function(){return this.opacity<1},E.isOpaque=function(){if(this.opacity>=1)return!0;for(var t=0;t<3;++t)if(this._contourCounts[t].length>0||this._dynamicCounts[t]>0)return!0;return!1},E.pickSlots=1,E.setPickBase=function(t){this.pickId=t};var L=[0,0,0],z={showSurface:!1,showContour:!1,projections:[k.slice(),k.slice(),k.slice()],clipBounds:[[[0,0,0],[0,0,0]],[[0,0,0],[0,0,0]],[[0,0,0],[0,0,0]]]};function P(t,e){var r,n,i,a=e.axes&&e.axes.lastCubeProps.axis||L,o=e.showSurface,s=e.showContour;for(r=0;r<3;++r)for(o=o||e.surfaceProject[r],n=0;n<3;++n)s=s||e.contourProject[r][n];for(r=0;r<3;++r){var l=z.projections[r];for(n=0;n<16;++n)l[n]=0;for(n=0;n<4;++n)l[5*n]=1;l[5*r]=0,l[12+r]=e.axesBounds[+(a[r]>0)][r],p(l,t.model,l);var c=z.clipBounds[r];for(i=0;i<2;++i)for(n=0;n<3;++n)c[i][n]=t.clipBounds[i][n];c[0][r]=-1e8,c[1][r]=1e8}return z.showSurface=o,z.showContour=s,z}var D={model:k,view:k,projection:k,inverseModel:k.slice(),lowerBound:[0,0,0],upperBound:[0,0,0],colorMap:0,clipBounds:[[0,0,0],[0,0,0]],height:0,contourTint:0,contourColor:[0,0,0,1],permutation:[1,0,0,0,1,0,0,0,1],zOffset:-1e-4,kambient:1,kdiffuse:1,kspecular:1,lightPosition:[1e3,1e3,1e3],eyePosition:[0,0,0],roughness:1,fresnel:1,opacity:1,vertexColor:0},O=k.slice(),I=[1,0,0,0,1,0,0,0,1];function R(t,e){t=t||{};var r=this.gl;r.disable(r.CULL_FACE),this._colorMap.bind(0);var n=D;n.model=t.model||k,n.view=t.view||k,n.projection=t.projection||k,n.lowerBound=[this.bounds[0][0],this.bounds[0][1],this.colorBounds[0]||this.bounds[0][2]],n.upperBound=[this.bounds[1][0],this.bounds[1][1],this.colorBounds[1]||this.bounds[1][2]],n.contourColor=this.contourColor[0],n.inverseModel=d(n.inverseModel,n.model);for(var i=0;i<2;++i)for(var a=n.clipBounds[i],o=0;o<3;++o)a[o]=Math.min(Math.max(this.clipBounds[i][o],-1e8),1e8);n.kambient=this.ambientLight,n.kdiffuse=this.diffuseLight,n.kspecular=this.specularLight,n.roughness=this.roughness,n.fresnel=this.fresnel,n.opacity=this.opacity,n.height=0,n.permutation=I,n.vertexColor=this.vertexColor;var s=O;for(p(s,n.view,n.model),p(s,n.projection,s),d(s,s),i=0;i<3;++i)n.eyePosition[i]=s[12+i]/s[15];var l=s[15];for(i=0;i<3;++i)l+=this.lightPosition[i]*s[4*i+3];for(i=0;i<3;++i){var c=s[12+i];for(o=0;o<3;++o)c+=s[4*o+i]*this.lightPosition[o];n.lightPosition[i]=c/l}var u=P(n,this);if(u.showSurface&&e===this.opacity<1){for(this._shader.bind(),this._shader.uniforms=n,this._vao.bind(),this.showSurface&&this._vertexCount&&this._vao.draw(r.TRIANGLES,this._vertexCount),i=0;i<3;++i)this.surfaceProject[i]&&this.vertexCount&&(this._shader.uniforms.model=u.projections[i],this._shader.uniforms.clipBounds=u.clipBounds[i],this._vao.draw(r.TRIANGLES,this._vertexCount));this._vao.unbind()}if(u.showContour&&!e){var f=this._contourShader;n.kambient=1,n.kdiffuse=0,n.kspecular=0,n.opacity=1,f.bind(),f.uniforms=n;var h=this._contourVAO;for(h.bind(),i=0;i<3;++i)for(f.uniforms.permutation=A[i],r.lineWidth(this.contourWidth[i]),o=0;o>4)/16)/255,i=Math.floor(n),a=n-i,o=e[1]*(t.value[1]+(15&t.value[2])/16)/255,s=Math.floor(o),l=o-s;i+=1,s+=1;var c=r.position;c[0]=c[1]=c[2]=0;for(var u=0;u<2;++u)for(var f=u?a:1-a,h=0;h<2;++h)for(var p=i+u,d=s+h,m=f*(h?l:1-l),v=0;v<3;++v)c[v]+=this._field[v].get(p,d)*m;for(var y=this._pickResult.level,x=0;x<3;++x)if(y[x]=g.le(this.contourLevels[x],c[x]),y[x]<0)this.contourLevels[x].length>0&&(y[x]=0);else if(y[x]Math.abs(_-c[x])&&(y[x]+=1)}for(r.index[0]=a<.5?i:i+1,r.index[1]=l<.5?s:s+1,r.uv[0]=n/e[0],r.uv[1]=o/e[1],v=0;v<3;++v)r.dataCoordinate[v]=this._field[v].get(r.index[0],r.index[1]);return r},E.update=function(t){t=t||{},this.dirty=!0,"contourWidth"in t&&(this.contourWidth=N(t.contourWidth,Number)),"showContour"in t&&(this.showContour=N(t.showContour,Boolean)),"showSurface"in t&&(this.showSurface=!!t.showSurface),"contourTint"in t&&(this.contourTint=N(t.contourTint,Boolean)),"contourColor"in t&&(this.contourColor=V(t.contourColor)),"contourProject"in t&&(this.contourProject=N(t.contourProject,function(t){return N(t,Boolean)})),"surfaceProject"in t&&(this.surfaceProject=t.surfaceProject),"dynamicColor"in t&&(this.dynamicColor=V(t.dynamicColor)),"dynamicTint"in t&&(this.dynamicTint=N(t.dynamicTint,Number)),"dynamicWidth"in t&&(this.dynamicWidth=N(t.dynamicWidth,Number)),"opacity"in t&&(this.opacity=t.opacity),"colorBounds"in t&&(this.colorBounds=t.colorBounds),"vertexColor"in t&&(this.vertexColor=t.vertexColor?1:0);var e=t.field||t.coords&&t.coords[2]||null,r=!1;if(e||(e=this._field[2].shape[0]||this._field[2].shape[2]?this._field[2].lo(1,1).hi(this._field[2].shape[0]-2,this._field[2].shape[1]-2):this._field[2].hi(0,0)),"field"in t||"coords"in t){var i=(e.shape[0]+2)*(e.shape[1]+2);i>this._field[2].data.length&&(s.freeFloat(this._field[2].data),this._field[2].data=s.mallocFloat(n.nextPow2(i))),this._field[2]=f(this._field[2].data,[e.shape[0]+2,e.shape[1]+2]),F(this._field[2],e),this.shape=e.shape.slice();for(var a=this.shape,o=0;o<2;++o)this._field[2].size>this._field[o].data.length&&(s.freeFloat(this._field[o].data),this._field[o].data=s.mallocFloat(this._field[2].size)),this._field[o]=f(this._field[o].data,[a[0]+2,a[1]+2]);if(t.coords){var p=t.coords;if(!Array.isArray(p)||3!==p.length)throw new Error("gl-surface: invalid coordinates for x/y");for(o=0;o<2;++o){var d=p[o];for(b=0;b<2;++b)if(d.shape[b]!==a[b])throw new Error("gl-surface: coords have incorrect shape");F(this._field[o],d)}}else if(t.ticks){var g=t.ticks;if(!Array.isArray(g)||2!==g.length)throw new Error("gl-surface: invalid ticks");for(o=0;o<2;++o){var v=g[o];if((Array.isArray(v)||v.length)&&(v=f(v)),v.shape[0]!==a[o])throw new Error("gl-surface: invalid tick length");var y=f(v.data,a);y.stride[o]=v.stride[0],y.stride[1^o]=0,F(this._field[o],y)}}else{for(o=0;o<2;++o){var x=[0,0];x[o]=1,this._field[o]=f(this._field[o].data,[a[0]+2,a[1]+2],x,0)}this._field[0].set(0,0,0);for(var b=0;b0){for(var kt=0;kt<5;++kt)nt.pop();W-=1}continue t}nt.push(st[0],st[1],ut[0],ut[1],st[2]),W+=1}}ot.push(W)}this._contourOffsets[it]=at,this._contourCounts[it]=ot}var Mt=s.mallocFloat(nt.length);for(o=0;os||o[1]<0||o[1]>s)throw new Error("gl-texture2d: Invalid texture size");var l=d(o,e.stride.slice()),c=0;"float32"===r?c=t.FLOAT:"float64"===r?(c=t.FLOAT,l=!1,r="float32"):"uint8"===r?c=t.UNSIGNED_BYTE:(c=t.UNSIGNED_BYTE,l=!1,r="uint8");var f,p,m=0;if(2===o.length)m=t.LUMINANCE,o=[o[0],o[1],1],e=n(e.data,o,[e.stride[0],e.stride[1],1],e.offset);else{if(3!==o.length)throw new Error("gl-texture2d: Invalid shape for texture");if(1===o[2])m=t.ALPHA;else if(2===o[2])m=t.LUMINANCE_ALPHA;else if(3===o[2])m=t.RGB;else{if(4!==o[2])throw new Error("gl-texture2d: Invalid shape for pixel coords");m=t.RGBA}}c!==t.FLOAT||t.getExtension("OES_texture_float")||(c=t.UNSIGNED_BYTE,l=!1);var v=e.size;if(l)f=0===e.offset&&e.data.length===v?e.data:e.data.subarray(e.offset,e.offset+v);else{var y=[o[2],o[2]*o[0],1];p=a.malloc(v,r);var x=n(p,o,y,0);"float32"!==r&&"float64"!==r||c!==t.UNSIGNED_BYTE?i.assign(x,e):u(x,e),f=p.subarray(0,v)}var b=g(t);t.texImage2D(t.TEXTURE_2D,0,m,o[0],o[1],0,m,c,f),l||a.free(p);return new h(t,b,o[0],o[1],m,c)}(t,e)}throw new Error("gl-texture2d: Invalid arguments for texture2d constructor")};var o=null,s=null,l=null;function c(t){return"undefined"!=typeof HTMLCanvasElement&&t instanceof HTMLCanvasElement||"undefined"!=typeof HTMLImageElement&&t instanceof HTMLImageElement||"undefined"!=typeof HTMLVideoElement&&t instanceof HTMLVideoElement||"undefined"!=typeof ImageData&&t instanceof ImageData}var u=function(t,e){i.muls(t,e,255)};function f(t,e,r){var n=t.gl,i=n.getParameter(n.MAX_TEXTURE_SIZE);if(e<0||e>i||r<0||r>i)throw new Error("gl-texture2d: Invalid texture size");return t._shape=[e,r],t.bind(),n.texImage2D(n.TEXTURE_2D,0,t.format,e,r,0,t.format,t.type,null),t._mipLevels=[0],t}function h(t,e,r,n,i,a){this.gl=t,this.handle=e,this.format=i,this.type=a,this._shape=[r,n],this._mipLevels=[0],this._magFilter=t.NEAREST,this._minFilter=t.NEAREST,this._wrapS=t.CLAMP_TO_EDGE,this._wrapT=t.CLAMP_TO_EDGE,this._anisoSamples=1;var o=this,s=[this._wrapS,this._wrapT];Object.defineProperties(s,[{get:function(){return o._wrapS},set:function(t){return o.wrapS=t}},{get:function(){return o._wrapT},set:function(t){return o.wrapT=t}}]),this._wrapVector=s;var l=[this._shape[0],this._shape[1]];Object.defineProperties(l,[{get:function(){return o._shape[0]},set:function(t){return o.width=t}},{get:function(){return o._shape[1]},set:function(t){return o.height=t}}]),this._shapeVector=l}var p=h.prototype;function d(t,e){return 3===t.length?1===e[2]&&e[1]===t[0]*t[2]&&e[0]===t[2]:1===e[0]&&e[1]===t[0]}function g(t){var e=t.createTexture();return t.bindTexture(t.TEXTURE_2D,e),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MIN_FILTER,t.NEAREST),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_MAG_FILTER,t.NEAREST),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_S,t.CLAMP_TO_EDGE),t.texParameteri(t.TEXTURE_2D,t.TEXTURE_WRAP_T,t.CLAMP_TO_EDGE),e}function m(t,e,r,n,i){var a=t.getParameter(t.MAX_TEXTURE_SIZE);if(e<0||e>a||r<0||r>a)throw new Error("gl-texture2d: Invalid texture shape");if(i===t.FLOAT&&!t.getExtension("OES_texture_float"))throw new Error("gl-texture2d: Floating point textures not supported on this platform");var o=g(t);return t.texImage2D(t.TEXTURE_2D,0,n,e,r,0,n,i,null),new h(t,o,e,r,n,i)}Object.defineProperties(p,{minFilter:{get:function(){return this._minFilter},set:function(t){this.bind();var e=this.gl;if(this.type===e.FLOAT&&o.indexOf(t)>=0&&(e.getExtension("OES_texture_float_linear")||(t=e.NEAREST)),s.indexOf(t)<0)throw new Error("gl-texture2d: Unknown filter mode "+t);return e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MIN_FILTER,t),this._minFilter=t}},magFilter:{get:function(){return this._magFilter},set:function(t){this.bind();var e=this.gl;if(this.type===e.FLOAT&&o.indexOf(t)>=0&&(e.getExtension("OES_texture_float_linear")||(t=e.NEAREST)),s.indexOf(t)<0)throw new Error("gl-texture2d: Unknown filter mode "+t);return e.texParameteri(e.TEXTURE_2D,e.TEXTURE_MAG_FILTER,t),this._magFilter=t}},mipSamples:{get:function(){return this._anisoSamples},set:function(t){var e=this._anisoSamples;if(this._anisoSamples=0|Math.max(t,1),e!==this._anisoSamples){var r=this.gl.getExtension("EXT_texture_filter_anisotropic");r&&this.gl.texParameterf(this.gl.TEXTURE_2D,r.TEXTURE_MAX_ANISOTROPY_EXT,this._anisoSamples)}return this._anisoSamples}},wrapS:{get:function(){return this._wrapS},set:function(t){if(this.bind(),l.indexOf(t)<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);return this.gl.texParameteri(this.gl.TEXTURE_2D,this.gl.TEXTURE_WRAP_S,t),this._wrapS=t}},wrapT:{get:function(){return this._wrapT},set:function(t){if(this.bind(),l.indexOf(t)<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);return this.gl.texParameteri(this.gl.TEXTURE_2D,this.gl.TEXTURE_WRAP_T,t),this._wrapT=t}},wrap:{get:function(){return this._wrapVector},set:function(t){if(Array.isArray(t)||(t=[t,t]),2!==t.length)throw new Error("gl-texture2d: Must specify wrap mode for rows and columns");for(var e=0;e<2;++e)if(l.indexOf(t[e])<0)throw new Error("gl-texture2d: Unknown wrap mode "+t);this._wrapS=t[0],this._wrapT=t[1];var r=this.gl;return this.bind(),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_S,this._wrapS),r.texParameteri(r.TEXTURE_2D,r.TEXTURE_WRAP_T,this._wrapT),t}},shape:{get:function(){return this._shapeVector},set:function(t){if(Array.isArray(t)){if(2!==t.length)throw new Error("gl-texture2d: Invalid texture shape")}else t=[0|t,0|t];return f(this,0|t[0],0|t[1]),[0|t[0],0|t[1]]}},width:{get:function(){return this._shape[0]},set:function(t){return f(this,t|=0,this._shape[1]),t}},height:{get:function(){return this._shape[1]},set:function(t){return t|=0,f(this,this._shape[0],t),t}}}),p.bind=function(t){var e=this.gl;return void 0!==t&&e.activeTexture(e.TEXTURE0+(0|t)),e.bindTexture(e.TEXTURE_2D,this.handle),void 0!==t?0|t:e.getParameter(e.ACTIVE_TEXTURE)-e.TEXTURE0},p.dispose=function(){this.gl.deleteTexture(this.handle)},p.generateMipmap=function(){this.bind(),this.gl.generateMipmap(this.gl.TEXTURE_2D);for(var t=Math.min(this._shape[0],this._shape[1]),e=0;t>0;++e,t>>>=1)this._mipLevels.indexOf(e)<0&&this._mipLevels.push(e)},p.setPixels=function(t,e,r,o){var s=this.gl;this.bind(),Array.isArray(e)?(o=r,r=0|e[1],e=0|e[0]):(e=e||0,r=r||0),o=o||0;var l=c(t)?t:t.raw;if(l){this._mipLevels.indexOf(o)<0?(s.texImage2D(s.TEXTURE_2D,0,this.format,this.format,this.type,l),this._mipLevels.push(o)):s.texSubImage2D(s.TEXTURE_2D,o,e,r,this.format,this.type,l)}else{if(!(t.shape&&t.stride&&t.data))throw new Error("gl-texture2d: Unsupported data type");if(t.shape.length<2||e+t.shape[1]>this._shape[1]>>>o||r+t.shape[0]>this._shape[0]>>>o||e<0||r<0)throw new Error("gl-texture2d: Texture dimensions are out of bounds");!function(t,e,r,o,s,l,c,f){var h=f.dtype,p=f.shape.slice();if(p.length<2||p.length>3)throw new Error("gl-texture2d: Invalid ndarray, must be 2d or 3d");var g=0,m=0,v=d(p,f.stride.slice());"float32"===h?g=t.FLOAT:"float64"===h?(g=t.FLOAT,v=!1,h="float32"):"uint8"===h?g=t.UNSIGNED_BYTE:(g=t.UNSIGNED_BYTE,v=!1,h="uint8");if(2===p.length)m=t.LUMINANCE,p=[p[0],p[1],1],f=n(f.data,p,[f.stride[0],f.stride[1],1],f.offset);else{if(3!==p.length)throw new Error("gl-texture2d: Invalid shape for texture");if(1===p[2])m=t.ALPHA;else if(2===p[2])m=t.LUMINANCE_ALPHA;else if(3===p[2])m=t.RGB;else{if(4!==p[2])throw new Error("gl-texture2d: Invalid shape for pixel coords");m=t.RGBA}p[2]}m!==t.LUMINANCE&&m!==t.ALPHA||s!==t.LUMINANCE&&s!==t.ALPHA||(m=s);if(m!==s)throw new Error("gl-texture2d: Incompatible texture format for setPixels");var y=f.size,x=c.indexOf(o)<0;x&&c.push(o);if(g===l&&v)0===f.offset&&f.data.length===y?x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,f.data):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,f.data):x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,f.data.subarray(f.offset,f.offset+y)):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,f.data.subarray(f.offset,f.offset+y));else{var b;b=l===t.FLOAT?a.mallocFloat32(y):a.mallocUint8(y);var _=n(b,p,[p[2],p[2]*p[0],1]);g===t.FLOAT&&l===t.UNSIGNED_BYTE?u(_,f):i.assign(_,f),x?t.texImage2D(t.TEXTURE_2D,o,s,p[0],p[1],0,s,l,b.subarray(0,y)):t.texSubImage2D(t.TEXTURE_2D,o,e,r,p[0],p[1],s,l,b.subarray(0,y)),l===t.FLOAT?a.freeFloat32(b):a.freeUint8(b)}}(s,e,r,o,this.format,this.type,this._mipLevels,t)}}},{ndarray:393,"ndarray-ops":387,"typedarray-pool":481}],281:[function(t,e,r){"use strict";e.exports=function(t,e,r){e?e.bind():t.bindBuffer(t.ELEMENT_ARRAY_BUFFER,null);var n=0|t.getParameter(t.MAX_VERTEX_ATTRIBS);if(r){if(r.length>n)throw new Error("gl-vao: Too many vertex attributes");for(var i=0;i1?0:Math.acos(s)};var n=t("./fromValues"),i=t("./normalize"),a=t("./dot")},{"./dot":293,"./fromValues":295,"./normalize":304}],287:[function(t,e,r){e.exports=function(t){var e=new Float32Array(3);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e}},{}],288:[function(t,e,r){e.exports=function(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t}},{}],289:[function(t,e,r){e.exports=function(){var t=new Float32Array(3);return t[0]=0,t[1]=0,t[2]=0,t}},{}],290:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2];return t[0]=i*l-a*s,t[1]=a*o-n*l,t[2]=n*s-i*o,t}},{}],291:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2];return Math.sqrt(r*r+n*n+i*i)}},{}],292:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]/r[0],t[1]=e[1]/r[1],t[2]=e[2]/r[2],t}},{}],293:[function(t,e,r){e.exports=function(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]}},{}],294:[function(t,e,r){e.exports=function(t,e,r,i,a,o){var s,l;e||(e=3);r||(r=0);l=i?Math.min(i*e+r,t.length):t.length;for(s=r;s0&&(a=1/Math.sqrt(a),t[0]=e[0]*a,t[1]=e[1]*a,t[2]=e[2]*a);return t}},{}],305:[function(t,e,r){e.exports=function(t,e){e=e||1;var r=2*Math.random()*Math.PI,n=2*Math.random()-1,i=Math.sqrt(1-n*n)*e;return t[0]=Math.cos(r)*i,t[1]=Math.sin(r)*i,t[2]=n*e,t}},{}],306:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[0],a[1]=i[1]*Math.cos(n)-i[2]*Math.sin(n),a[2]=i[1]*Math.sin(n)+i[2]*Math.cos(n),t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],307:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[2]*Math.sin(n)+i[0]*Math.cos(n),a[1]=i[1],a[2]=i[2]*Math.cos(n)-i[0]*Math.sin(n),t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],308:[function(t,e,r){e.exports=function(t,e,r,n){var i=[],a=[];return i[0]=e[0]-r[0],i[1]=e[1]-r[1],i[2]=e[2]-r[2],a[0]=i[0]*Math.cos(n)-i[1]*Math.sin(n),a[1]=i[0]*Math.sin(n)+i[1]*Math.cos(n),a[2]=i[2],t[0]=a[0]+r[0],t[1]=a[1]+r[1],t[2]=a[2]+r[2],t}},{}],309:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t}},{}],310:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e[0]+r[0]*n,t[1]=e[1]+r[1]*n,t[2]=e[2]+r[2]*n,t}},{}],311:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e,t[1]=r,t[2]=n,t}},{}],312:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2];return r*r+n*n+i*i}},{}],313:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2];return e*e+r*r+n*n}},{}],314:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t}},{}],315:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2];return t[0]=n*r[0]+i*r[3]+a*r[6],t[1]=n*r[1]+i*r[4]+a*r[7],t[2]=n*r[2]+i*r[5]+a*r[8],t}},{}],316:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[3]*n+r[7]*i+r[11]*a+r[15];return o=o||1,t[0]=(r[0]*n+r[4]*i+r[8]*a+r[12])/o,t[1]=(r[1]*n+r[5]*i+r[9]*a+r[13])/o,t[2]=(r[2]*n+r[6]*i+r[10]*a+r[14])/o,t}},{}],317:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2],c=r[3],u=c*n+s*a-l*i,f=c*i+l*n-o*a,h=c*a+o*i-s*n,p=-o*n-s*i-l*a;return t[0]=u*c+p*-o+f*-l-h*-s,t[1]=f*c+p*-s+h*-o-u*-l,t[2]=h*c+p*-l+u*-s-f*-o,t}},{}],318:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]+r[0],t[1]=e[1]+r[1],t[2]=e[2]+r[2],t[3]=e[3]+r[3],t}},{}],319:[function(t,e,r){e.exports=function(t){var e=new Float32Array(4);return e[0]=t[0],e[1]=t[1],e[2]=t[2],e[3]=t[3],e}},{}],320:[function(t,e,r){e.exports=function(t,e){return t[0]=e[0],t[1]=e[1],t[2]=e[2],t[3]=e[3],t}},{}],321:[function(t,e,r){e.exports=function(){var t=new Float32Array(4);return t[0]=0,t[1]=0,t[2]=0,t[3]=0,t}},{}],322:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return Math.sqrt(r*r+n*n+i*i+a*a)}},{}],323:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]/r[0],t[1]=e[1]/r[1],t[2]=e[2]/r[2],t[3]=e[3]/r[3],t}},{}],324:[function(t,e,r){e.exports=function(t,e){return t[0]*e[0]+t[1]*e[1]+t[2]*e[2]+t[3]*e[3]}},{}],325:[function(t,e,r){e.exports=function(t,e,r,n){var i=new Float32Array(4);return i[0]=t,i[1]=e,i[2]=r,i[3]=n,i}},{}],326:[function(t,e,r){e.exports={create:t("./create"),clone:t("./clone"),fromValues:t("./fromValues"),copy:t("./copy"),set:t("./set"),add:t("./add"),subtract:t("./subtract"),multiply:t("./multiply"),divide:t("./divide"),min:t("./min"),max:t("./max"),scale:t("./scale"),scaleAndAdd:t("./scaleAndAdd"),distance:t("./distance"),squaredDistance:t("./squaredDistance"),length:t("./length"),squaredLength:t("./squaredLength"),negate:t("./negate"),inverse:t("./inverse"),normalize:t("./normalize"),dot:t("./dot"),lerp:t("./lerp"),random:t("./random"),transformMat4:t("./transformMat4"),transformQuat:t("./transformQuat")}},{"./add":318,"./clone":319,"./copy":320,"./create":321,"./distance":322,"./divide":323,"./dot":324,"./fromValues":325,"./inverse":327,"./length":328,"./lerp":329,"./max":330,"./min":331,"./multiply":332,"./negate":333,"./normalize":334,"./random":335,"./scale":336,"./scaleAndAdd":337,"./set":338,"./squaredDistance":339,"./squaredLength":340,"./subtract":341,"./transformMat4":342,"./transformQuat":343}],327:[function(t,e,r){e.exports=function(t,e){return t[0]=1/e[0],t[1]=1/e[1],t[2]=1/e[2],t[3]=1/e[3],t}},{}],328:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2],i=t[3];return Math.sqrt(e*e+r*r+n*n+i*i)}},{}],329:[function(t,e,r){e.exports=function(t,e,r,n){var i=e[0],a=e[1],o=e[2],s=e[3];return t[0]=i+n*(r[0]-i),t[1]=a+n*(r[1]-a),t[2]=o+n*(r[2]-o),t[3]=s+n*(r[3]-s),t}},{}],330:[function(t,e,r){e.exports=function(t,e,r){return t[0]=Math.max(e[0],r[0]),t[1]=Math.max(e[1],r[1]),t[2]=Math.max(e[2],r[2]),t[3]=Math.max(e[3],r[3]),t}},{}],331:[function(t,e,r){e.exports=function(t,e,r){return t[0]=Math.min(e[0],r[0]),t[1]=Math.min(e[1],r[1]),t[2]=Math.min(e[2],r[2]),t[3]=Math.min(e[3],r[3]),t}},{}],332:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r[0],t[1]=e[1]*r[1],t[2]=e[2]*r[2],t[3]=e[3]*r[3],t}},{}],333:[function(t,e,r){e.exports=function(t,e){return t[0]=-e[0],t[1]=-e[1],t[2]=-e[2],t[3]=-e[3],t}},{}],334:[function(t,e,r){e.exports=function(t,e){var r=e[0],n=e[1],i=e[2],a=e[3],o=r*r+n*n+i*i+a*a;o>0&&(o=1/Math.sqrt(o),t[0]=r*o,t[1]=n*o,t[2]=i*o,t[3]=a*o);return t}},{}],335:[function(t,e,r){var n=t("./normalize"),i=t("./scale");e.exports=function(t,e){return e=e||1,t[0]=Math.random(),t[1]=Math.random(),t[2]=Math.random(),t[3]=Math.random(),n(t,t),i(t,t,e),t}},{"./normalize":334,"./scale":336}],336:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]*r,t[1]=e[1]*r,t[2]=e[2]*r,t[3]=e[3]*r,t}},{}],337:[function(t,e,r){e.exports=function(t,e,r,n){return t[0]=e[0]+r[0]*n,t[1]=e[1]+r[1]*n,t[2]=e[2]+r[2]*n,t[3]=e[3]+r[3]*n,t}},{}],338:[function(t,e,r){e.exports=function(t,e,r,n,i){return t[0]=e,t[1]=r,t[2]=n,t[3]=i,t}},{}],339:[function(t,e,r){e.exports=function(t,e){var r=e[0]-t[0],n=e[1]-t[1],i=e[2]-t[2],a=e[3]-t[3];return r*r+n*n+i*i+a*a}},{}],340:[function(t,e,r){e.exports=function(t){var e=t[0],r=t[1],n=t[2],i=t[3];return e*e+r*r+n*n+i*i}},{}],341:[function(t,e,r){e.exports=function(t,e,r){return t[0]=e[0]-r[0],t[1]=e[1]-r[1],t[2]=e[2]-r[2],t[3]=e[3]-r[3],t}},{}],342:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=e[3];return t[0]=r[0]*n+r[4]*i+r[8]*a+r[12]*o,t[1]=r[1]*n+r[5]*i+r[9]*a+r[13]*o,t[2]=r[2]*n+r[6]*i+r[10]*a+r[14]*o,t[3]=r[3]*n+r[7]*i+r[11]*a+r[15]*o,t}},{}],343:[function(t,e,r){e.exports=function(t,e,r){var n=e[0],i=e[1],a=e[2],o=r[0],s=r[1],l=r[2],c=r[3],u=c*n+s*a-l*i,f=c*i+l*n-o*a,h=c*a+o*i-s*n,p=-o*n-s*i-l*a;return t[0]=u*c+p*-o+f*-l-h*-s,t[1]=f*c+p*-s+h*-o-u*-l,t[2]=h*c+p*-l+u*-s-f*-o,t[3]=e[3],t}},{}],344:[function(t,e,r){e.exports=function(t,e,r,a){return n[0]=a,n[1]=r,n[2]=e,n[3]=t,i[0]};var n=new Uint8Array(4),i=new Float32Array(n.buffer)},{}],345:[function(t,e,r){var n=t("glsl-tokenizer"),i=t("atob-lite");e.exports=function(t){for(var e=Array.isArray(t)?t:n(t),r=0;r0)continue;r=t.slice(0,1).join("")}return B(r),z+=r.length,(S=S.slice(r.length)).length}}function H(){return/[^a-fA-F0-9]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function G(){return"."===e?(S.push(e),T=g,r=e,M+1):/[eE]/.test(e)?(S.push(e),T=g,r=e,M+1):"x"===e&&1===S.length&&"0"===S[0]?(T=_,S.push(e),r=e,M+1):/[^\d]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function W(){return"f"===e&&(S.push(e),r=e,M+=1),/[eE]/.test(e)?(S.push(e),r=e,M+1):"-"===e&&/[eE]/.test(r)?(S.push(e),r=e,M+1):/[^\d]/.test(e)?(B(S.join("")),T=l,M):(S.push(e),r=e,M+1)}function Y(){if(/[^\d\w_]/.test(e)){var t=S.join("");return T=R.indexOf(t)>-1?y:I.indexOf(t)>-1?v:m,B(S.join("")),T=l,M}return S.push(e),r=e,M+1}};var n=t("./lib/literals"),i=t("./lib/operators"),a=t("./lib/builtins"),o=t("./lib/literals-300es"),s=t("./lib/builtins-300es"),l=999,c=9999,u=0,f=1,h=2,p=3,d=4,g=5,m=6,v=7,y=8,x=9,b=10,_=11,w=["block-comment","line-comment","preprocessor","operator","integer","float","ident","builtin","keyword","whitespace","eof","integer"]},{"./lib/builtins":348,"./lib/builtins-300es":347,"./lib/literals":350,"./lib/literals-300es":349,"./lib/operators":351}],347:[function(t,e,r){var n=t("./builtins");n=n.slice().filter(function(t){return!/^(gl\_|texture)/.test(t)}),e.exports=n.concat(["gl_VertexID","gl_InstanceID","gl_Position","gl_PointSize","gl_FragCoord","gl_FrontFacing","gl_FragDepth","gl_PointCoord","gl_MaxVertexAttribs","gl_MaxVertexUniformVectors","gl_MaxVertexOutputVectors","gl_MaxFragmentInputVectors","gl_MaxVertexTextureImageUnits","gl_MaxCombinedTextureImageUnits","gl_MaxTextureImageUnits","gl_MaxFragmentUniformVectors","gl_MaxDrawBuffers","gl_MinProgramTexelOffset","gl_MaxProgramTexelOffset","gl_DepthRangeParameters","gl_DepthRange","trunc","round","roundEven","isnan","isinf","floatBitsToInt","floatBitsToUint","intBitsToFloat","uintBitsToFloat","packSnorm2x16","unpackSnorm2x16","packUnorm2x16","unpackUnorm2x16","packHalf2x16","unpackHalf2x16","outerProduct","transpose","determinant","inverse","texture","textureSize","textureProj","textureLod","textureOffset","texelFetch","texelFetchOffset","textureProjOffset","textureLodOffset","textureProjLod","textureProjLodOffset","textureGrad","textureGradOffset","textureProjGrad","textureProjGradOffset"])},{"./builtins":348}],348:[function(t,e,r){e.exports=["abs","acos","all","any","asin","atan","ceil","clamp","cos","cross","dFdx","dFdy","degrees","distance","dot","equal","exp","exp2","faceforward","floor","fract","gl_BackColor","gl_BackLightModelProduct","gl_BackLightProduct","gl_BackMaterial","gl_BackSecondaryColor","gl_ClipPlane","gl_ClipVertex","gl_Color","gl_DepthRange","gl_DepthRangeParameters","gl_EyePlaneQ","gl_EyePlaneR","gl_EyePlaneS","gl_EyePlaneT","gl_Fog","gl_FogCoord","gl_FogFragCoord","gl_FogParameters","gl_FragColor","gl_FragCoord","gl_FragData","gl_FragDepth","gl_FragDepthEXT","gl_FrontColor","gl_FrontFacing","gl_FrontLightModelProduct","gl_FrontLightProduct","gl_FrontMaterial","gl_FrontSecondaryColor","gl_LightModel","gl_LightModelParameters","gl_LightModelProducts","gl_LightProducts","gl_LightSource","gl_LightSourceParameters","gl_MaterialParameters","gl_MaxClipPlanes","gl_MaxCombinedTextureImageUnits","gl_MaxDrawBuffers","gl_MaxFragmentUniformComponents","gl_MaxLights","gl_MaxTextureCoords","gl_MaxTextureImageUnits","gl_MaxTextureUnits","gl_MaxVaryingFloats","gl_MaxVertexAttribs","gl_MaxVertexTextureImageUnits","gl_MaxVertexUniformComponents","gl_ModelViewMatrix","gl_ModelViewMatrixInverse","gl_ModelViewMatrixInverseTranspose","gl_ModelViewMatrixTranspose","gl_ModelViewProjectionMatrix","gl_ModelViewProjectionMatrixInverse","gl_ModelViewProjectionMatrixInverseTranspose","gl_ModelViewProjectionMatrixTranspose","gl_MultiTexCoord0","gl_MultiTexCoord1","gl_MultiTexCoord2","gl_MultiTexCoord3","gl_MultiTexCoord4","gl_MultiTexCoord5","gl_MultiTexCoord6","gl_MultiTexCoord7","gl_Normal","gl_NormalMatrix","gl_NormalScale","gl_ObjectPlaneQ","gl_ObjectPlaneR","gl_ObjectPlaneS","gl_ObjectPlaneT","gl_Point","gl_PointCoord","gl_PointParameters","gl_PointSize","gl_Position","gl_ProjectionMatrix","gl_ProjectionMatrixInverse","gl_ProjectionMatrixInverseTranspose","gl_ProjectionMatrixTranspose","gl_SecondaryColor","gl_TexCoord","gl_TextureEnvColor","gl_TextureMatrix","gl_TextureMatrixInverse","gl_TextureMatrixInverseTranspose","gl_TextureMatrixTranspose","gl_Vertex","greaterThan","greaterThanEqual","inversesqrt","length","lessThan","lessThanEqual","log","log2","matrixCompMult","max","min","mix","mod","normalize","not","notEqual","pow","radians","reflect","refract","sign","sin","smoothstep","sqrt","step","tan","texture2D","texture2DLod","texture2DProj","texture2DProjLod","textureCube","textureCubeLod","texture2DLodEXT","texture2DProjLodEXT","textureCubeLodEXT","texture2DGradEXT","texture2DProjGradEXT","textureCubeGradEXT"]},{}],349:[function(t,e,r){var n=t("./literals");e.exports=n.slice().concat(["layout","centroid","smooth","case","mat2x2","mat2x3","mat2x4","mat3x2","mat3x3","mat3x4","mat4x2","mat4x3","mat4x4","uint","uvec2","uvec3","uvec4","samplerCubeShadow","sampler2DArray","sampler2DArrayShadow","isampler2D","isampler3D","isamplerCube","isampler2DArray","usampler2D","usampler3D","usamplerCube","usampler2DArray","coherent","restrict","readonly","writeonly","resource","atomic_uint","noperspective","patch","sample","subroutine","common","partition","active","filter","image1D","image2D","image3D","imageCube","iimage1D","iimage2D","iimage3D","iimageCube","uimage1D","uimage2D","uimage3D","uimageCube","image1DArray","image2DArray","iimage1DArray","iimage2DArray","uimage1DArray","uimage2DArray","image1DShadow","image2DShadow","image1DArrayShadow","image2DArrayShadow","imageBuffer","iimageBuffer","uimageBuffer","sampler1DArray","sampler1DArrayShadow","isampler1D","isampler1DArray","usampler1D","usampler1DArray","isampler2DRect","usampler2DRect","samplerBuffer","isamplerBuffer","usamplerBuffer","sampler2DMS","isampler2DMS","usampler2DMS","sampler2DMSArray","isampler2DMSArray","usampler2DMSArray"])},{"./literals":350}],350:[function(t,e,r){e.exports=["precision","highp","mediump","lowp","attribute","const","uniform","varying","break","continue","do","for","while","if","else","in","out","inout","float","int","void","bool","true","false","discard","return","mat2","mat3","mat4","vec2","vec3","vec4","ivec2","ivec3","ivec4","bvec2","bvec3","bvec4","sampler1D","sampler2D","sampler3D","samplerCube","sampler1DShadow","sampler2DShadow","struct","asm","class","union","enum","typedef","template","this","packed","goto","switch","default","inline","noinline","volatile","public","static","extern","external","interface","long","short","double","half","fixed","unsigned","input","output","hvec2","hvec3","hvec4","dvec2","dvec3","dvec4","fvec2","fvec3","fvec4","sampler2DRect","sampler3DRect","sampler2DRectShadow","sizeof","cast","namespace","using"]},{}],351:[function(t,e,r){e.exports=["<<=",">>=","++","--","<<",">>","<=",">=","==","!=","&&","||","+=","-=","*=","/=","%=","&=","^^","^=","|=","(",")","[","]",".","!","~","*","/","%","+","-","<",">","&","^","|","?",":","=",",",";","{","}"]},{}],352:[function(t,e,r){var n=t("./index");e.exports=function(t,e){var r=n(e),i=[];return i=(i=i.concat(r(t))).concat(r(null))}},{"./index":346}],353:[function(t,e,r){e.exports=function(t){"string"==typeof t&&(t=[t]);for(var e=[].slice.call(arguments,1),r=[],n=0;n>1,u=-7,f=r?i-1:0,h=r?-1:1,p=t[e+f];for(f+=h,a=p&(1<<-u)-1,p>>=-u,u+=s;u>0;a=256*a+t[e+f],f+=h,u-=8);for(o=a&(1<<-u)-1,a>>=-u,u+=n;u>0;o=256*o+t[e+f],f+=h,u-=8);if(0===a)a=1-c;else{if(a===l)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,n),a-=c}return(p?-1:1)*o*Math.pow(2,a-n)},r.write=function(t,e,r,n,i,a){var o,s,l,c=8*a-i-1,u=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:a-1,d=n?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,o=u):(o=Math.floor(Math.log(e)/Math.LN2),e*(l=Math.pow(2,-o))<1&&(o--,l*=2),(e+=o+f>=1?h/l:h*Math.pow(2,1-f))*l>=2&&(o++,l/=2),o+f>=u?(s=0,o=u):o+f>=1?(s=(e*l-1)*Math.pow(2,i),o+=f):(s=e*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;t[r+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;t[r+p]=255&o,p+=d,o/=256,c-=8);t[r+p-d]|=128*g}},{}],357:[function(t,e,r){"use strict";e.exports=function(t,e){var r=t.length;if(0===r)throw new Error("Must have at least d+1 points");var i=t[0].length;if(r<=i)throw new Error("Must input at least d+1 points");var o=t.slice(0,i+1),s=n.apply(void 0,o);if(0===s)throw new Error("Input not in general position");for(var l=new Array(i+1),u=0;u<=i;++u)l[u]=u;s<0&&(l[0]=1,l[1]=0);for(var f=new a(l,new Array(i+1),!1),h=f.adjacent,p=new Array(i+2),u=0;u<=i;++u){for(var d=l.slice(),g=0;g<=i;++g)g===u&&(d[g]=-1);var m=d[0];d[0]=d[1],d[1]=m;var v=new a(d,new Array(i+1),!0);h[u]=v,p[u]=v}p[i+1]=f;for(var u=0;u<=i;++u)for(var d=h[u].vertices,y=h[u].adjacent,g=0;g<=i;++g){var x=d[g];if(x<0)y[g]=f;else for(var b=0;b<=i;++b)h[b].vertices.indexOf(x)<0&&(y[g]=h[b])}for(var _=new c(i,o,p),w=!!e,u=i+1;u0&&e.push(","),e.push("tuple[",r,"]");e.push(")}return orient");var i=new Function("test",e.join("")),a=n[t+1];return a||(a=n),i(a)}(t)),this.orient=a}var u=c.prototype;u.handleBoundaryDegeneracy=function(t,e){var r=this.dimension,n=this.vertices.length-1,i=this.tuple,a=this.vertices,o=[t];for(t.lastVisited=-n;o.length>0;){(t=o.pop()).vertices;for(var s=t.adjacent,l=0;l<=r;++l){var c=s[l];if(c.boundary&&!(c.lastVisited<=-n)){for(var u=c.vertices,f=0;f<=r;++f){var h=u[f];i[f]=h<0?e:a[h]}var p=this.orient();if(p>0)return c;c.lastVisited=-n,0===p&&o.push(c)}}}return null},u.walk=function(t,e){var r=this.vertices.length-1,n=this.dimension,i=this.vertices,a=this.tuple,o=e?this.interior.length*Math.random()|0:this.interior.length-1,s=this.interior[o];t:for(;!s.boundary;){for(var l=s.vertices,c=s.adjacent,u=0;u<=n;++u)a[u]=i[l[u]];s.lastVisited=r;for(u=0;u<=n;++u){var f=c[u];if(!(f.lastVisited>=r)){var h=a[u];a[u]=t;var p=this.orient();if(a[u]=h,p<0){s=f;continue t}f.boundary?f.lastVisited=-r:f.lastVisited=r}}return}return s},u.addPeaks=function(t,e){var r=this.vertices.length-1,n=this.dimension,i=this.vertices,l=this.tuple,c=this.interior,u=this.simplices,f=[e];e.lastVisited=r,e.vertices[e.vertices.indexOf(-1)]=r,e.boundary=!1,c.push(e);for(var h=[];f.length>0;){var p=(e=f.pop()).vertices,d=e.adjacent,g=p.indexOf(r);if(!(g<0))for(var m=0;m<=n;++m)if(m!==g){var v=d[m];if(v.boundary&&!(v.lastVisited>=r)){var y=v.vertices;if(v.lastVisited!==-r){for(var x=0,b=0;b<=n;++b)y[b]<0?(x=b,l[b]=t):l[b]=i[y[b]];if(this.orient()>0){y[x]=r,v.boundary=!1,c.push(v),f.push(v),v.lastVisited=r;continue}v.lastVisited=-r}var _=v.adjacent,w=p.slice(),k=d.slice(),M=new a(w,k,!0);u.push(M);var A=_.indexOf(e);if(!(A<0)){_[A]=M,k[g]=v,w[m]=-1,k[m]=e,d[m]=M,M.flip();for(b=0;b<=n;++b){var T=w[b];if(!(T<0||T===r)){for(var S=new Array(n-1),C=0,E=0;E<=n;++E){var L=w[E];L<0||E===b||(S[C++]=L)}h.push(new o(S,M,b))}}}}}}h.sort(s);for(m=0;m+1=0?o[l++]=s[u]:c=1&u;if(c===(1&t)){var f=o[0];o[0]=o[1],o[1]=f}e.push(o)}}return e}},{"robust-orientation":446,"simplicial-complex":456}],358:[function(t,e,r){"use strict";var n=t("binary-search-bounds"),i=0,a=1;function o(t,e,r,n,i){this.mid=t,this.left=e,this.right=r,this.leftPoints=n,this.rightPoints=i,this.count=(e?e.count:0)+(r?r.count:0)+n.length}e.exports=function(t){if(!t||0===t.length)return new x(null);return new x(y(t))};var s=o.prototype;function l(t,e){t.mid=e.mid,t.left=e.left,t.right=e.right,t.leftPoints=e.leftPoints,t.rightPoints=e.rightPoints,t.count=e.count}function c(t,e){var r=y(e);t.mid=r.mid,t.left=r.left,t.right=r.right,t.leftPoints=r.leftPoints,t.rightPoints=r.rightPoints,t.count=r.count}function u(t,e){var r=t.intervals([]);r.push(e),c(t,r)}function f(t,e){var r=t.intervals([]),n=r.indexOf(e);return n<0?i:(r.splice(n,1),c(t,r),a)}function h(t,e,r){for(var n=0;n=0&&t[n][1]>=e;--n){var i=r(t[n]);if(i)return i}}function d(t,e){for(var r=0;r>1],i=[],a=[],s=[];for(r=0;r3*(e+1)?u(this,t):this.left.insert(t):this.left=y([t]);else if(t[0]>this.mid)this.right?4*(this.right.count+1)>3*(e+1)?u(this,t):this.right.insert(t):this.right=y([t]);else{var r=n.ge(this.leftPoints,t,m),i=n.ge(this.rightPoints,t,v);this.leftPoints.splice(r,0,t),this.rightPoints.splice(i,0,t)}},s.remove=function(t){var e=this.count-this.leftPoints;if(t[1]3*(e-1)?f(this,t):2===(c=this.left.remove(t))?(this.left=null,this.count-=1,a):(c===a&&(this.count-=1),c):i;if(t[0]>this.mid)return this.right?4*(this.left?this.left.count:0)>3*(e-1)?f(this,t):2===(c=this.right.remove(t))?(this.right=null,this.count-=1,a):(c===a&&(this.count-=1),c):i;if(1===this.count)return this.leftPoints[0]===t?2:i;if(1===this.leftPoints.length&&this.leftPoints[0]===t){if(this.left&&this.right){for(var r=this,o=this.left;o.right;)r=o,o=o.right;if(r===this)o.right=this.right;else{var s=this.left,c=this.right;r.count-=o.count,r.right=o.left,o.left=s,o.right=c}l(this,o),this.count=(this.left?this.left.count:0)+(this.right?this.right.count:0)+this.leftPoints.length}else this.left?l(this,this.left):l(this,this.right);return a}for(s=n.ge(this.leftPoints,t,m);sthis.mid){var r;if(this.right)if(r=this.right.queryPoint(t,e))return r;return p(this.rightPoints,t,e)}return d(this.leftPoints,e)},s.queryInterval=function(t,e,r){var n;if(tthis.mid&&this.right&&(n=this.right.queryInterval(t,e,r)))return n;return ethis.mid?p(this.rightPoints,t,r):d(this.leftPoints,r)};var b=x.prototype;b.insert=function(t){this.root?this.root.insert(t):this.root=new o(t[0],null,null,[t],[t])},b.remove=function(t){if(this.root){var e=this.root.remove(t);return 2===e&&(this.root=null),e!==i}return!1},b.queryPoint=function(t,e){if(this.root)return this.root.queryPoint(t,e)},b.queryInterval=function(t,e,r){if(t<=e&&this.root)return this.root.queryInterval(t,e,r)},Object.defineProperty(b,"count",{get:function(){return this.root?this.root.count:0}}),Object.defineProperty(b,"intervals",{get:function(){return this.root?this.root.intervals([]):[]}})},{"binary-search-bounds":73}],359:[function(t,e,r){"use strict";e.exports=function(t,e){e=e||new Array(t.length);for(var r=0;r4))}},{}],368:[function(t,e,r){e.exports=function(t,e,r){return t*(1-r)+e*r}},{}],369:[function(t,e,r){(function(n){"use strict";!function(t){"object"==typeof r&&void 0!==e?e.exports=t():("undefined"!=typeof window?window:void 0!==n?n:"undefined"!=typeof self?self:this).mapboxgl=t()}(function(){return function e(r,n,i){function a(s,l){if(!n[s]){if(!r[s]){var c="function"==typeof t&&t;if(!l&&c)return c(s,!0);if(o)return o(s,!0);var u=new Error("Cannot find module '"+s+"'");throw u.code="MODULE_NOT_FOUND",u}var f=n[s]={exports:{}};r[s][0].call(f.exports,function(t){var e=r[s][1][t];return a(e||t)},f,f.exports,e,r,n,i)}return n[s].exports}for(var o="function"==typeof t&&t,s=0;s0){e+=Math.abs(i(t[0]));for(var r=1;r2){for(l=0;li.maxh||t>i.maxw||r<=i.maxh&&t<=i.maxw&&(o=i.maxw*i.maxh-t*r)a.free)){if(r===a.h)return this.allocShelf(s,t,r,n);r>a.h||ru)&&(f=2*Math.max(t,u)),(ll)&&(c=2*Math.max(r,l)),this.resize(f,c),this.packOne(t,r,n)):null},t.prototype.allocFreebin=function(t,e,r,n){var i=this.freebins.splice(t,1)[0];return i.id=n,i.w=e,i.h=r,i.refcount=0,this.bins[n]=i,this.ref(i),i},t.prototype.allocShelf=function(t,e,r,n){var i=this.shelves[t].alloc(e,r,n);return this.bins[n]=i,this.ref(i),i},t.prototype.shrink=function(){if(this.shelves.length>0){for(var t=0,e=0,r=0;rthis.free||e>this.h)return null;var i=this.x;return this.x+=t,this.free-=t,new r(n,i,this.y,t,e,t,this.h)},e.prototype.resize=function(t){return this.free+=t-this.w,this.w=t,!0},t},"object"==typeof r&&void 0!==e?e.exports=i():n.ShelfPack=i()},{}],6:[function(t,e,r){function n(t,e,r,n,i,a){this.fontSize=t||24,this.buffer=void 0===e?3:e,this.cutoff=n||.25,this.fontFamily=i||"sans-serif",this.fontWeight=a||"normal",this.radius=r||8;var o=this.size=this.fontSize+2*this.buffer;this.canvas=document.createElement("canvas"),this.canvas.width=this.canvas.height=o,this.ctx=this.canvas.getContext("2d"),this.ctx.font=this.fontWeight+" "+this.fontSize+"px "+this.fontFamily,this.ctx.textBaseline="middle",this.ctx.fillStyle="black",this.gridOuter=new Float64Array(o*o),this.gridInner=new Float64Array(o*o),this.f=new Float64Array(o),this.d=new Float64Array(o),this.z=new Float64Array(o+1),this.v=new Int16Array(o),this.middle=Math.round(o/2*(navigator.userAgent.indexOf("Gecko/")>=0?1.2:1))}function i(t,e,r,n,i,o,s){for(var l=0;l(n=1))return n;for(;ra?r=i:n=i,i=.5*(n-r)+r}return i},n.prototype.solve=function(t,e){return this.sampleCurveY(this.solveCurveX(t,e))}},{}],8:[function(t,e,r){e.exports.VectorTile=t("./lib/vectortile.js"),e.exports.VectorTileFeature=t("./lib/vectortilefeature.js"),e.exports.VectorTileLayer=t("./lib/vectortilelayer.js")},{"./lib/vectortile.js":9,"./lib/vectortilefeature.js":10,"./lib/vectortilelayer.js":11}],9:[function(t,e,r){function n(t,e,r){if(3===t){var n=new i(r,r.readVarint()+r.pos);n.length&&(e[n.name]=n)}}var i=t("./vectortilelayer");e.exports=function(t,e){this.layers=t.readFields(n,{},e)}},{"./vectortilelayer":11}],10:[function(t,e,r){function n(t,e,r,n,a){this.properties={},this.extent=r,this.type=0,this._pbf=t,this._geometry=-1,this._keys=n,this._values=a,t.readFields(i,this,e)}function i(t,e,r){1==t?e.id=r.readVarint():2==t?function(t,e){for(var r=t.readVarint()+t.pos;t.pos>3}if(i--,1===n||2===n)a+=t.readSVarint(),s+=t.readSVarint(),1===n&&(e&&l.push(e),e=[]),e.push(new o(a,s));else{if(7!==n)throw new Error("unknown command "+n);e&&e.push(e[0].clone())}}return e&&l.push(e),l},n.prototype.bbox=function(){var t=this._pbf;t.pos=this._geometry;for(var e=t.readVarint()+t.pos,r=1,n=0,i=0,a=0,o=1/0,s=-1/0,l=1/0,c=-1/0;t.pos>3}if(n--,1===r||2===r)(i+=t.readSVarint())s&&(s=i),(a+=t.readSVarint())c&&(c=a);else if(7!==r)throw new Error("unknown command "+r)}return[o,l,s,c]},n.prototype.toGeoJSON=function(t,e,r){function i(t){for(var e=0;e>3;e=1===n?t.readString():2===n?t.readFloat():3===n?t.readDouble():4===n?t.readVarint64():5===n?t.readVarint():6===n?t.readSVarint():7===n?t.readBoolean():null}return e}(r))}var a=t("./vectortilefeature.js");e.exports=n,n.prototype.feature=function(t){if(t<0||t>=this._features.length)throw new Error("feature index out of bounds");this._pbf.pos=this._features[t];var e=this._pbf.readVarint()+this._pbf.pos;return new a(this._pbf,e,this.extent,this._keys,this._values)}},{"./vectortilefeature.js":10}],12:[function(t,e,r){var n;n=this,function(t){function e(t,e,n){var i=r(256*t,256*(e=Math.pow(2,n)-e-1),n),a=r(256*(t+1),256*(e+1),n);return i[0]+","+i[1]+","+a[0]+","+a[1]}function r(t,e,r){var n=2*Math.PI*6378137/256/Math.pow(2,r);return[t*n-2*Math.PI*6378137/2,e*n-2*Math.PI*6378137/2]}t.getURL=function(t,r,n,i,a,o){return o=o||{},t+"?"+["bbox="+e(n,i,a),"format="+(o.format||"image/png"),"service="+(o.service||"WMS"),"version="+(o.version||"1.1.1"),"request="+(o.request||"GetMap"),"srs="+(o.srs||"EPSG:3857"),"width="+(o.width||256),"height="+(o.height||256),"layers="+r].join("&")},t.getTileBBox=e,t.getMercCoords=r,Object.defineProperty(t,"__esModule",{value:!0})}("object"==typeof r&&void 0!==e?r:n.WhooTS=n.WhooTS||{})},{}],13:[function(t,e,r){function n(t){return(t=Math.round(t))<0?0:t>255?255:t}function i(t){return n("%"===t[t.length-1]?parseFloat(t)/100*255:parseInt(t))}function a(t){return function(t){return t<0?0:t>1?1:t}("%"===t[t.length-1]?parseFloat(t)/100:parseFloat(t))}function o(t,e,r){return r<0?r+=1:r>1&&(r-=1),6*r<1?t+(e-t)*r*6:2*r<1?e:3*r<2?t+(e-t)*(2/3-r)*6:t}var s={transparent:[0,0,0,0],aliceblue:[240,248,255,1],antiquewhite:[250,235,215,1],aqua:[0,255,255,1],aquamarine:[127,255,212,1],azure:[240,255,255,1],beige:[245,245,220,1],bisque:[255,228,196,1],black:[0,0,0,1],blanchedalmond:[255,235,205,1],blue:[0,0,255,1],blueviolet:[138,43,226,1],brown:[165,42,42,1],burlywood:[222,184,135,1],cadetblue:[95,158,160,1],chartreuse:[127,255,0,1],chocolate:[210,105,30,1],coral:[255,127,80,1],cornflowerblue:[100,149,237,1],cornsilk:[255,248,220,1],crimson:[220,20,60,1],cyan:[0,255,255,1],darkblue:[0,0,139,1],darkcyan:[0,139,139,1],darkgoldenrod:[184,134,11,1],darkgray:[169,169,169,1],darkgreen:[0,100,0,1],darkgrey:[169,169,169,1],darkkhaki:[189,183,107,1],darkmagenta:[139,0,139,1],darkolivegreen:[85,107,47,1],darkorange:[255,140,0,1],darkorchid:[153,50,204,1],darkred:[139,0,0,1],darksalmon:[233,150,122,1],darkseagreen:[143,188,143,1],darkslateblue:[72,61,139,1],darkslategray:[47,79,79,1],darkslategrey:[47,79,79,1],darkturquoise:[0,206,209,1],darkviolet:[148,0,211,1],deeppink:[255,20,147,1],deepskyblue:[0,191,255,1],dimgray:[105,105,105,1],dimgrey:[105,105,105,1],dodgerblue:[30,144,255,1],firebrick:[178,34,34,1],floralwhite:[255,250,240,1],forestgreen:[34,139,34,1],fuchsia:[255,0,255,1],gainsboro:[220,220,220,1],ghostwhite:[248,248,255,1],gold:[255,215,0,1],goldenrod:[218,165,32,1],gray:[128,128,128,1],green:[0,128,0,1],greenyellow:[173,255,47,1],grey:[128,128,128,1],honeydew:[240,255,240,1],hotpink:[255,105,180,1],indianred:[205,92,92,1],indigo:[75,0,130,1],ivory:[255,255,240,1],khaki:[240,230,140,1],lavender:[230,230,250,1],lavenderblush:[255,240,245,1],lawngreen:[124,252,0,1],lemonchiffon:[255,250,205,1],lightblue:[173,216,230,1],lightcoral:[240,128,128,1],lightcyan:[224,255,255,1],lightgoldenrodyellow:[250,250,210,1],lightgray:[211,211,211,1],lightgreen:[144,238,144,1],lightgrey:[211,211,211,1],lightpink:[255,182,193,1],lightsalmon:[255,160,122,1],lightseagreen:[32,178,170,1],lightskyblue:[135,206,250,1],lightslategray:[119,136,153,1],lightslategrey:[119,136,153,1],lightsteelblue:[176,196,222,1],lightyellow:[255,255,224,1],lime:[0,255,0,1],limegreen:[50,205,50,1],linen:[250,240,230,1],magenta:[255,0,255,1],maroon:[128,0,0,1],mediumaquamarine:[102,205,170,1],mediumblue:[0,0,205,1],mediumorchid:[186,85,211,1],mediumpurple:[147,112,219,1],mediumseagreen:[60,179,113,1],mediumslateblue:[123,104,238,1],mediumspringgreen:[0,250,154,1],mediumturquoise:[72,209,204,1],mediumvioletred:[199,21,133,1],midnightblue:[25,25,112,1],mintcream:[245,255,250,1],mistyrose:[255,228,225,1],moccasin:[255,228,181,1],navajowhite:[255,222,173,1],navy:[0,0,128,1],oldlace:[253,245,230,1],olive:[128,128,0,1],olivedrab:[107,142,35,1],orange:[255,165,0,1],orangered:[255,69,0,1],orchid:[218,112,214,1],palegoldenrod:[238,232,170,1],palegreen:[152,251,152,1],paleturquoise:[175,238,238,1],palevioletred:[219,112,147,1],papayawhip:[255,239,213,1],peachpuff:[255,218,185,1],peru:[205,133,63,1],pink:[255,192,203,1],plum:[221,160,221,1],powderblue:[176,224,230,1],purple:[128,0,128,1],rebeccapurple:[102,51,153,1],red:[255,0,0,1],rosybrown:[188,143,143,1],royalblue:[65,105,225,1],saddlebrown:[139,69,19,1],salmon:[250,128,114,1],sandybrown:[244,164,96,1],seagreen:[46,139,87,1],seashell:[255,245,238,1],sienna:[160,82,45,1],silver:[192,192,192,1],skyblue:[135,206,235,1],slateblue:[106,90,205,1],slategray:[112,128,144,1],slategrey:[112,128,144,1],snow:[255,250,250,1],springgreen:[0,255,127,1],steelblue:[70,130,180,1],tan:[210,180,140,1],teal:[0,128,128,1],thistle:[216,191,216,1],tomato:[255,99,71,1],turquoise:[64,224,208,1],violet:[238,130,238,1],wheat:[245,222,179,1],white:[255,255,255,1],whitesmoke:[245,245,245,1],yellow:[255,255,0,1],yellowgreen:[154,205,50,1]};try{r.parseCSSColor=function(t){var e,r=t.replace(/ /g,"").toLowerCase();if(r in s)return s[r].slice();if("#"===r[0])return 4===r.length?(e=parseInt(r.substr(1),16))>=0&&e<=4095?[(3840&e)>>4|(3840&e)>>8,240&e|(240&e)>>4,15&e|(15&e)<<4,1]:null:7===r.length&&(e=parseInt(r.substr(1),16))>=0&&e<=16777215?[(16711680&e)>>16,(65280&e)>>8,255&e,1]:null;var l=r.indexOf("("),c=r.indexOf(")");if(-1!==l&&c+1===r.length){var u=r.substr(0,l),f=r.substr(l+1,c-(l+1)).split(","),h=1;switch(u){case"rgba":if(4!==f.length)return null;h=a(f.pop());case"rgb":return 3!==f.length?null:[i(f[0]),i(f[1]),i(f[2]),h];case"hsla":if(4!==f.length)return null;h=a(f.pop());case"hsl":if(3!==f.length)return null;var p=(parseFloat(f[0])%360+360)%360/360,d=a(f[1]),g=a(f[2]),m=g<=.5?g*(d+1):g+d-g*d,v=2*g-m;return[n(255*o(v,m,p+1/3)),n(255*o(v,m,p)),n(255*o(v,m,p-1/3)),h];default:return null}}return null}}catch(t){}},{}],14:[function(t,e,r){function n(t,e,r){r=r||2;var n,s,l,c,u,p,g,m=e&&e.length,v=m?e[0]*r:t.length,y=i(t,0,v,r,!0),x=[];if(!y)return x;if(m&&(y=function(t,e,r,n){var o,s,l,c,u,p=[];for(o=0,s=e.length;o80*r){n=l=t[0],s=c=t[1];for(var b=r;bl&&(l=u),p>c&&(c=p);g=0!==(g=Math.max(l-n,c-s))?1/g:0}return o(y,x,r,n,s,g),x}function i(t,e,r,n,i){var a,o;if(i===A(t,e,r,n)>0)for(a=e;a=e;a-=n)o=w(a,t[a],t[a+1],o);return o&&y(o,o.next)&&(k(o),o=o.next),o}function a(t,e){if(!t)return t;e||(e=t);var r,n=t;do{if(r=!1,n.steiner||!y(n,n.next)&&0!==v(n.prev,n,n.next))n=n.next;else{if(k(n),(n=e=n.prev)===n.next)break;r=!0}}while(r||n!==e);return e}function o(t,e,r,n,i,f,h){if(t){!h&&f&&function(t,e,r,n){var i=t;do{null===i.z&&(i.z=p(i.x,i.y,e,r,n)),i.prevZ=i.prev,i.nextZ=i.next,i=i.next}while(i!==t);i.prevZ.nextZ=null,i.prevZ=null,function(t){var e,r,n,i,a,o,s,l,c=1;do{for(r=t,t=null,a=null,o=0;r;){for(o++,n=r,s=0,e=0;e0||l>0&&n;)0!==s&&(0===l||!n||r.z<=n.z)?(i=r,r=r.nextZ,s--):(i=n,n=n.nextZ,l--),a?a.nextZ=i:t=i,i.prevZ=a,a=i;r=n}a.nextZ=null,c*=2}while(o>1)}(i)}(t,n,i,f);for(var d,g,m=t;t.prev!==t.next;)if(d=t.prev,g=t.next,f?l(t,n,i,f):s(t))e.push(d.i/r),e.push(t.i/r),e.push(g.i/r),k(t),t=g.next,m=g.next;else if((t=g)===m){h?1===h?o(t=c(t,e,r),e,r,n,i,f,2):2===h&&u(t,e,r,n,i,f):o(a(t),e,r,n,i,f,1);break}}}function s(t){var e=t.prev,r=t,n=t.next;if(v(e,r,n)>=0)return!1;for(var i=t.next.next;i!==t.prev;){if(g(e.x,e.y,r.x,r.y,n.x,n.y,i.x,i.y)&&v(i.prev,i,i.next)>=0)return!1;i=i.next}return!0}function l(t,e,r,n){var i=t.prev,a=t,o=t.next;if(v(i,a,o)>=0)return!1;for(var s=i.xa.x?i.x>o.x?i.x:o.x:a.x>o.x?a.x:o.x,u=i.y>a.y?i.y>o.y?i.y:o.y:a.y>o.y?a.y:o.y,f=p(s,l,e,r,n),h=p(c,u,e,r,n),d=t.prevZ,m=t.nextZ;d&&d.z>=f&&m&&m.z<=h;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;if(d=d.prevZ,m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}for(;d&&d.z>=f;){if(d!==t.prev&&d!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,d.x,d.y)&&v(d.prev,d,d.next)>=0)return!1;d=d.prevZ}for(;m&&m.z<=h;){if(m!==t.prev&&m!==t.next&&g(i.x,i.y,a.x,a.y,o.x,o.y,m.x,m.y)&&v(m.prev,m,m.next)>=0)return!1;m=m.nextZ}return!0}function c(t,e,r){var n=t;do{var i=n.prev,a=n.next.next;!y(i,a)&&x(i,n,n.next,a)&&b(i,a)&&b(a,i)&&(e.push(i.i/r),e.push(n.i/r),e.push(a.i/r),k(n),k(n.next),n=t=a),n=n.next}while(n!==t);return n}function u(t,e,r,n,i,s){var l=t;do{for(var c=l.next.next;c!==l.prev;){if(l.i!==c.i&&m(l,c)){var u=_(l,c);return l=a(l,l.next),u=a(u,u.next),o(l,e,r,n,i,s),void o(u,e,r,n,i,s)}c=c.next}l=l.next}while(l!==t)}function f(t,e){return t.x-e.x}function h(t,e){if(e=function(t,e){var r,n=e,i=t.x,a=t.y,o=-1/0;do{if(a<=n.y&&a>=n.next.y&&n.next.y!==n.y){var s=n.x+(a-n.y)*(n.next.x-n.x)/(n.next.y-n.y);if(s<=i&&s>o){if(o=s,s===i){if(a===n.y)return n;if(a===n.next.y)return n.next}r=n.x=n.x&&n.x>=u&&i!==n.x&&g(ar.x)&&b(n,t)&&(r=n,h=l),n=n.next;return r}(t,e)){var r=_(e,t);a(r,r.next)}}function p(t,e,r,n,i){return(t=1431655765&((t=858993459&((t=252645135&((t=16711935&((t=32767*(t-r)*i)|t<<8))|t<<4))|t<<2))|t<<1))|(e=1431655765&((e=858993459&((e=252645135&((e=16711935&((e=32767*(e-n)*i)|e<<8))|e<<4))|e<<2))|e<<1))<<1}function d(t){var e=t,r=t;do{e.x=0&&(t-o)*(n-s)-(r-o)*(e-s)>=0&&(r-o)*(a-s)-(i-o)*(n-s)>=0}function m(t,e){return t.next.i!==e.i&&t.prev.i!==e.i&&!function(t,e){var r=t;do{if(r.i!==t.i&&r.next.i!==t.i&&r.i!==e.i&&r.next.i!==e.i&&x(r,r.next,t,e))return!0;r=r.next}while(r!==t);return!1}(t,e)&&b(t,e)&&b(e,t)&&function(t,e){var r=t,n=!1,i=(t.x+e.x)/2,a=(t.y+e.y)/2;do{r.y>a!=r.next.y>a&&r.next.y!==r.y&&i<(r.next.x-r.x)*(a-r.y)/(r.next.y-r.y)+r.x&&(n=!n),r=r.next}while(r!==t);return n}(t,e)}function v(t,e,r){return(e.y-t.y)*(r.x-e.x)-(e.x-t.x)*(r.y-e.y)}function y(t,e){return t.x===e.x&&t.y===e.y}function x(t,e,r,n){return!!(y(t,e)&&y(r,n)||y(t,n)&&y(r,e))||v(t,e,r)>0!=v(t,e,n)>0&&v(r,n,t)>0!=v(r,n,e)>0}function b(t,e){return v(t.prev,t,t.next)<0?v(t,e,t.next)>=0&&v(t,t.prev,e)>=0:v(t,e,t.prev)<0||v(t,t.next,e)<0}function _(t,e){var r=new M(t.i,t.x,t.y),n=new M(e.i,e.x,e.y),i=t.next,a=e.prev;return t.next=e,e.prev=t,r.next=i,i.prev=r,n.next=r,r.prev=n,a.next=n,n.prev=a,n}function w(t,e,r,n){var i=new M(t,e,r);return n?(i.next=n.next,i.prev=n,n.next.prev=i,n.next=i):(i.prev=i,i.next=i),i}function k(t){t.next.prev=t.prev,t.prev.next=t.next,t.prevZ&&(t.prevZ.nextZ=t.nextZ),t.nextZ&&(t.nextZ.prevZ=t.prevZ)}function M(t,e,r){this.i=t,this.x=e,this.y=r,this.prev=null,this.next=null,this.z=null,this.prevZ=null,this.nextZ=null,this.steiner=!1}function A(t,e,r,n){for(var i=0,a=e,o=r-n;a0&&(n+=t[i-1].length,r.holes.push(n))}return r}},{}],15:[function(t,e,r){function n(t,e){return function(r){return t(r,e)}}function i(t,e){e=!!e,t[0]=a(t[0],e);for(var r=1;r=0}(t)===e?t:t.reverse()}var o=t("@mapbox/geojson-area");e.exports=function t(e,r){switch(e&&e.type||null){case"FeatureCollection":return e.features=e.features.map(n(t,r)),e;case"Feature":return e.geometry=t(e.geometry,r),e;case"Polygon":case"MultiPolygon":return function(t,e){return"Polygon"===t.type?t.coordinates=i(t.coordinates,e):"MultiPolygon"===t.type&&(t.coordinates=t.coordinates.map(n(i,e))),t}(e,r);default:return e}}},{"@mapbox/geojson-area":1}],16:[function(t,e,r){function n(t,e,r,n,i){for(var a=0;a=r&&o<=n&&(e.push(t[a]),e.push(t[a+1]),e.push(t[a+2]))}}function i(t,e,r,n,i,a){for(var c=[],u=0===i?s:l,f=0;f=r&&u(c,h,p,g,m,r):v>n?y<=n&&u(c,h,p,g,m,n):o(c,h,p,d),y=r&&(u(c,h,p,g,m,r),x=!0),y>n&&v<=n&&(u(c,h,p,g,m,n),x=!0),!a&&x&&(c.size=t.size,e.push(c),c=[])}var b=t.length-3;h=t[b],p=t[b+1],d=t[b+2],(v=0===i?h:p)>=r&&v<=n&&o(c,h,p,d),b=c.length-3,a&&b>=3&&(c[b]!==c[0]||c[b+1]!==c[1])&&o(c,c[0],c[1],c[2]),c.length&&(c.size=t.size,e.push(c))}function a(t,e,r,n,a,o){for(var s=0;s=(r/=e)&&u<=o)return t;if(l>o||u=r&&v<=o)f.push(p);else if(!(m>o||v0&&(o+=n?(i*h-f*a)/2:Math.sqrt(Math.pow(f-i,2)+Math.pow(h-a,2))),i=f,a=h}var p=e.length-3;e[2]=1,c(e,0,p,r),e[p+2]=1,e.size=Math.abs(o)}function o(t,e,r,n){for(var i=0;i1?1:r}e.exports=function(t,e){var r=[];if("FeatureCollection"===t.type)for(var i=0;i24)throw new Error("maxZoom should be in the 0-24 range");var n=1<1&&console.time("creation"),g=this.tiles[d]=c(t,p,r,n,m,e===f.maxZoom),this.tileCoords.push({z:e,x:r,y:n}),h)){h>1&&(console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",e,r,n,g.numFeatures,g.numPoints,g.numSimplified),console.timeEnd("creation"));var v="z"+e;this.stats[v]=(this.stats[v]||0)+1,this.total++}if(g.source=t,a){if(e===f.maxZoom||e===a)continue;var y=1<1&&console.time("clipping");var x,b,_,w,k,M,A=.5*f.buffer/f.extent,T=.5-A,S=.5+A,C=1+A;x=b=_=w=null,k=s(t,p,r-A,r+S,0,g.minX,g.maxX),M=s(t,p,r+T,r+C,0,g.minX,g.maxX),t=null,k&&(x=s(k,p,n-A,n+S,1,g.minY,g.maxY),b=s(k,p,n+T,n+C,1,g.minY,g.maxY),k=null),M&&(_=s(M,p,n-A,n+S,1,g.minY,g.maxY),w=s(M,p,n+T,n+C,1,g.minY,g.maxY),M=null),h>1&&console.timeEnd("clipping"),u.push(x||[],e+1,2*r,2*n),u.push(b||[],e+1,2*r,2*n+1),u.push(_||[],e+1,2*r+1,2*n),u.push(w||[],e+1,2*r+1,2*n+1)}}},n.prototype.getTile=function(t,e,r){var n=this.options,a=n.extent,s=n.debug;if(t<0||t>24)return null;var l=1<1&&console.log("drilling down to z%d-%d-%d",t,e,r);for(var u,f=t,h=e,p=r;!u&&f>0;)f--,h=Math.floor(h/2),p=Math.floor(p/2),u=this.tiles[i(f,h,p)];return u&&u.source?(s>1&&console.log("found parent tile z%d-%d-%d",f,h,p),s>1&&console.time("drilling down"),this.splitTile(u.source,f,h,p,t,e,r),s>1&&console.timeEnd("drilling down"),this.tiles[c]?o.tile(this.tiles[c],a):null):null}},{"./clip":16,"./convert":17,"./tile":21,"./transform":22,"./wrap":23}],20:[function(t,e,r){function n(t,e,r,n,i,a){var o=i-r,s=a-n;if(0!==o||0!==s){var l=((t-r)*o+(e-n)*s)/(o*o+s*s);l>1?(r=i,n=a):l>0&&(r+=o*l,n+=s*l)}return(o=t-r)*o+(s=e-n)*s}e.exports=function t(e,r,i,a){for(var o,s=a,l=e[r],c=e[r+1],u=e[i],f=e[i+1],h=r+3;hs&&(o=h,s=p)}s>a&&(o-r>3&&t(e,r,o,a),e[o+2]=s,i-o>3&&t(e,o,i,a))}},{}],21:[function(t,e,r){function n(t,e,r,n){var a=e.geometry,o=e.type,s=[];if("Point"===o||"MultiPoint"===o)for(var l=0;ls)&&(r.numSimplified++,l.push(e[c]),l.push(e[c+1])),r.numPoints++;a&&function(t,e){for(var r=0,n=0,i=t.length,a=i-2;n0===e)for(n=0,i=t.length;ns.maxX&&(s.maxX=f),h>s.maxY&&(s.maxY=h)}return s}},{}],22:[function(t,e,r){function n(t,e,r,n,i,a){return[Math.round(r*(t*n-i)),Math.round(r*(e*n-a))]}r.tile=function(t,e){if(t.transformed)return t;var r,i,a,o=t.z2,s=t.x,l=t.y;for(r=0;r=c[h+0]&&n>=c[h+1]?(o[f]=!0,a.push(l[f])):o[f]=!1}}},n.prototype._forEachCell=function(t,e,r,n,i,a,o){for(var s=this._convertToCellCoord(t),l=this._convertToCellCoord(e),c=this._convertToCellCoord(r),u=this._convertToCellCoord(n),f=s;f<=c;f++)for(var h=l;h<=u;h++){var p=this.d*h+f;if(i.call(this,t,e,r,n,p,a,o))return}},n.prototype._convertToCellCoord=function(t){return Math.max(0,Math.min(this.d-1,Math.floor(t*this.scale)+this.padding))},n.prototype.toArrayBuffer=function(){if(this.arrayBuffer)return this.arrayBuffer;for(var t=this.cells,e=i+this.cells.length+1+1,r=0,n=0;n>1,u=-7,f=r?i-1:0,h=r?-1:1,p=t[e+f];for(f+=h,a=p&(1<<-u)-1,p>>=-u,u+=s;u>0;a=256*a+t[e+f],f+=h,u-=8);for(o=a&(1<<-u)-1,a>>=-u,u+=n;u>0;o=256*o+t[e+f],f+=h,u-=8);if(0===a)a=1-c;else{if(a===l)return o?NaN:1/0*(p?-1:1);o+=Math.pow(2,n),a-=c}return(p?-1:1)*o*Math.pow(2,a-n)},r.write=function(t,e,r,n,i,a){var o,s,l,c=8*a-i-1,u=(1<>1,h=23===i?Math.pow(2,-24)-Math.pow(2,-77):0,p=n?0:a-1,d=n?1:-1,g=e<0||0===e&&1/e<0?1:0;for(e=Math.abs(e),isNaN(e)||e===1/0?(s=isNaN(e)?1:0,o=u):(o=Math.floor(Math.log(e)/Math.LN2),e*(l=Math.pow(2,-o))<1&&(o--,l*=2),(e+=o+f>=1?h/l:h*Math.pow(2,1-f))*l>=2&&(o++,l/=2),o+f>=u?(s=0,o=u):o+f>=1?(s=(e*l-1)*Math.pow(2,i),o+=f):(s=e*Math.pow(2,f-1)*Math.pow(2,i),o=0));i>=8;t[r+p]=255&s,p+=d,s/=256,i-=8);for(o=o<0;t[r+p]=255&o,p+=d,o/=256,c-=8);t[r+p-d]|=128*g}},{}],26:[function(t,e,r){function n(t,e,r,n,s){e=e||i,r=r||a,s=s||Array,this.nodeSize=n||64,this.points=t,this.ids=new s(t.length),this.coords=new s(2*t.length);for(var l=0;l=r&&s<=i&&l>=n&&l<=a&&u.push(t[d]);else{var g=Math.floor((p+h)/2);s=e[2*g],l=e[2*g+1],s>=r&&s<=i&&l>=n&&l<=a&&u.push(t[g]);var m=(f+1)%2;(0===f?r<=s:n<=l)&&(c.push(p),c.push(g-1),c.push(m)),(0===f?i>=s:a>=l)&&(c.push(g+1),c.push(h),c.push(m))}}return u}},{}],28:[function(t,e,r){function n(t,e,r,n){i(t,r,n),i(e,2*r,2*n),i(e,2*r+1,2*n+1)}function i(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}e.exports=function t(e,r,i,a,o,s){if(!(o-a<=i)){var l=Math.floor((a+o)/2);(function t(e,r,i,a,o,s){for(;o>a;){if(o-a>600){var l=o-a+1,c=i-a+1,u=Math.log(l),f=.5*Math.exp(2*u/3),h=.5*Math.sqrt(u*f*(l-f)/l)*(c-l/2<0?-1:1);t(e,r,i,Math.max(a,Math.floor(i-c*f/l+h)),Math.min(o,Math.floor(i+(l-c)*f/l+h)),s)}var p=r[2*i+s],d=a,g=o;for(n(e,r,a,i),r[2*o+s]>p&&n(e,r,a,o);dp;)g--}r[2*a+s]===p?n(e,r,a,g):n(e,r,++g,o),g<=i&&(a=g+1),i<=g&&(o=g-1)}})(e,r,l,a,o,s%2),t(e,r,i,a,l-1,s+1),t(e,r,i,l+1,o,s+1)}}},{}],29:[function(t,e,r){function n(t,e,r,n){var i=t-r,a=e-n;return i*i+a*a}e.exports=function(t,e,r,i,a,o){for(var s=[0,t.length-1,0],l=[],c=a*a;s.length;){var u=s.pop(),f=s.pop(),h=s.pop();if(f-h<=o)for(var p=h;p<=f;p++)n(e[2*p],e[2*p+1],r,i)<=c&&l.push(t[p]);else{var d=Math.floor((h+f)/2),g=e[2*d],m=e[2*d+1];n(g,m,r,i)<=c&&l.push(t[d]);var v=(u+1)%2;(0===u?r-a<=g:i-a<=m)&&(s.push(h),s.push(d-1),s.push(v)),(0===u?r+a>=g:i+a>=m)&&(s.push(d+1),s.push(f),s.push(v))}}return l}},{}],30:[function(t,e,r){function n(t){this.buf=ArrayBuffer.isView&&ArrayBuffer.isView(t)?t:new Uint8Array(t||0),this.pos=0,this.type=0,this.length=this.buf.length}function i(t){return t.type===n.Bytes?t.readVarint()+t.pos:t.pos+1}function a(t,e,r){return r?4294967296*e+(t>>>0):4294967296*(e>>>0)+(t>>>0)}function o(t,e,r){var n=e<=16383?1:e<=2097151?2:e<=268435455?3:Math.ceil(Math.log(e)/(7*Math.LN2));r.realloc(n);for(var i=r.pos-1;i>=t;i--)r.buf[i+n]=r.buf[i]}function s(t,e){for(var r=0;r>>8,t[r+2]=e>>>16,t[r+3]=e>>>24}function y(t,e){return(t[e]|t[e+1]<<8|t[e+2]<<16)+(t[e+3]<<24)}e.exports=n;var x=t("ieee754");n.Varint=0,n.Fixed64=1,n.Bytes=2,n.Fixed32=5;n.prototype={destroy:function(){this.buf=null},readFields:function(t,e,r){for(r=r||this.length;this.pos>3,a=this.pos;this.type=7&n,t(i,e,this),this.pos===a&&this.skip(n)}return e},readMessage:function(t,e){return this.readFields(t,e,this.readVarint()+this.pos)},readFixed32:function(){var t=m(this.buf,this.pos);return this.pos+=4,t},readSFixed32:function(){var t=y(this.buf,this.pos);return this.pos+=4,t},readFixed64:function(){var t=m(this.buf,this.pos)+4294967296*m(this.buf,this.pos+4);return this.pos+=8,t},readSFixed64:function(){var t=m(this.buf,this.pos)+4294967296*y(this.buf,this.pos+4);return this.pos+=8,t},readFloat:function(){var t=x.read(this.buf,this.pos,!0,23,4);return this.pos+=4,t},readDouble:function(){var t=x.read(this.buf,this.pos,!0,52,8);return this.pos+=8,t},readVarint:function(t){var e,r,n=this.buf;return e=127&(r=n[this.pos++]),r<128?e:(e|=(127&(r=n[this.pos++]))<<7,r<128?e:(e|=(127&(r=n[this.pos++]))<<14,r<128?e:(e|=(127&(r=n[this.pos++]))<<21,r<128?e:function(t,e,r){var n,i,o=r.buf;if(n=(112&(i=o[r.pos++]))>>4,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<3,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<10,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<17,i<128)return a(t,n,e);if(n|=(127&(i=o[r.pos++]))<<24,i<128)return a(t,n,e);if(n|=(1&(i=o[r.pos++]))<<31,i<128)return a(t,n,e);throw new Error("Expected varint not more than 10 bytes")}(e|=(15&(r=n[this.pos]))<<28,t,this))))},readVarint64:function(){return this.readVarint(!0)},readSVarint:function(){var t=this.readVarint();return t%2==1?(t+1)/-2:t/2},readBoolean:function(){return Boolean(this.readVarint())},readString:function(){var t=this.readVarint()+this.pos,e=function(t,e,r){for(var n="",i=e;i239?4:l>223?3:l>191?2:1;if(i+u>r)break;1===u?l<128&&(c=l):2===u?128==(192&(a=t[i+1]))&&(c=(31&l)<<6|63&a)<=127&&(c=null):3===u?(a=t[i+1],o=t[i+2],128==(192&a)&&128==(192&o)&&((c=(15&l)<<12|(63&a)<<6|63&o)<=2047||c>=55296&&c<=57343)&&(c=null)):4===u&&(a=t[i+1],o=t[i+2],s=t[i+3],128==(192&a)&&128==(192&o)&&128==(192&s)&&((c=(15&l)<<18|(63&a)<<12|(63&o)<<6|63&s)<=65535||c>=1114112)&&(c=null)),null===c?(c=65533,u=1):c>65535&&(c-=65536,n+=String.fromCharCode(c>>>10&1023|55296),c=56320|1023&c),n+=String.fromCharCode(c),i+=u}return n}(this.buf,this.pos,t);return this.pos=t,e},readBytes:function(){var t=this.readVarint()+this.pos,e=this.buf.subarray(this.pos,t);return this.pos=t,e},readPackedVarint:function(t,e){var r=i(this);for(t=t||[];this.pos127;);else if(e===n.Bytes)this.pos=this.readVarint()+this.pos;else if(e===n.Fixed32)this.pos+=4;else{if(e!==n.Fixed64)throw new Error("Unimplemented type: "+e);this.pos+=8}},writeTag:function(t,e){this.writeVarint(t<<3|e)},realloc:function(t){for(var e=this.length||16;e268435455||t<0?function(t,e){var r,n;if(t>=0?(r=t%4294967296|0,n=t/4294967296|0):(n=~(-t/4294967296),4294967295^(r=~(-t%4294967296))?r=r+1|0:(r=0,n=n+1|0)),t>=0x10000000000000000||t<-0x10000000000000000)throw new Error("Given varint doesn't fit into 10 bytes");e.realloc(10),function(t,e,r){r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos++]=127&t|128,t>>>=7,r.buf[r.pos]=127&t}(r,0,e),function(t,e){var r=(7&t)<<4;e.buf[e.pos++]|=r|((t>>>=3)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t|((t>>>=7)?128:0),t&&(e.buf[e.pos++]=127&t)))))}(n,e)}(t,this):(this.realloc(4),this.buf[this.pos++]=127&t|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=127&(t>>>=7)|(t>127?128:0),t<=127||(this.buf[this.pos++]=t>>>7&127))))},writeSVarint:function(t){this.writeVarint(t<0?2*-t-1:2*t)},writeBoolean:function(t){this.writeVarint(Boolean(t))},writeString:function(t){t=String(t),this.realloc(4*t.length),this.pos++;var e=this.pos;this.pos=function(t,e,r){for(var n,i,a=0;a55295&&n<57344){if(!i){n>56319||a+1===e.length?(t[r++]=239,t[r++]=191,t[r++]=189):i=n;continue}if(n<56320){t[r++]=239,t[r++]=191,t[r++]=189,i=n;continue}n=i-55296<<10|n-56320|65536,i=null}else i&&(t[r++]=239,t[r++]=191,t[r++]=189,i=null);n<128?t[r++]=n:(n<2048?t[r++]=n>>6|192:(n<65536?t[r++]=n>>12|224:(t[r++]=n>>18|240,t[r++]=n>>12&63|128),t[r++]=n>>6&63|128),t[r++]=63&n|128)}return r}(this.buf,t,this.pos);var r=this.pos-e;r>=128&&o(e,r,this),this.pos=e-1,this.writeVarint(r),this.pos+=r},writeFloat:function(t){this.realloc(4),x.write(this.buf,t,this.pos,!0,23,4),this.pos+=4},writeDouble:function(t){this.realloc(8),x.write(this.buf,t,this.pos,!0,52,8),this.pos+=8},writeBytes:function(t){var e=t.length;this.writeVarint(e),this.realloc(e);for(var r=0;r=128&&o(r,n,this),this.pos=r-1,this.writeVarint(n),this.pos+=n},writeMessage:function(t,e,r){this.writeTag(t,n.Bytes),this.writeRawMessage(e,r)},writePackedVarint:function(t,e){this.writeMessage(t,s,e)},writePackedSVarint:function(t,e){this.writeMessage(t,l,e)},writePackedBoolean:function(t,e){this.writeMessage(t,f,e)},writePackedFloat:function(t,e){this.writeMessage(t,c,e)},writePackedDouble:function(t,e){this.writeMessage(t,u,e)},writePackedFixed32:function(t,e){this.writeMessage(t,h,e)},writePackedSFixed32:function(t,e){this.writeMessage(t,p,e)},writePackedFixed64:function(t,e){this.writeMessage(t,d,e)},writePackedSFixed64:function(t,e){this.writeMessage(t,g,e)},writeBytesField:function(t,e){this.writeTag(t,n.Bytes),this.writeBytes(e)},writeFixed32Field:function(t,e){this.writeTag(t,n.Fixed32),this.writeFixed32(e)},writeSFixed32Field:function(t,e){this.writeTag(t,n.Fixed32),this.writeSFixed32(e)},writeFixed64Field:function(t,e){this.writeTag(t,n.Fixed64),this.writeFixed64(e)},writeSFixed64Field:function(t,e){this.writeTag(t,n.Fixed64),this.writeSFixed64(e)},writeVarintField:function(t,e){this.writeTag(t,n.Varint),this.writeVarint(e)},writeSVarintField:function(t,e){this.writeTag(t,n.Varint),this.writeSVarint(e)},writeStringField:function(t,e){this.writeTag(t,n.Bytes),this.writeString(e)},writeFloatField:function(t,e){this.writeTag(t,n.Fixed32),this.writeFloat(e)},writeDoubleField:function(t,e){this.writeTag(t,n.Fixed64),this.writeDouble(e)},writeBooleanField:function(t,e){this.writeVarintField(t,Boolean(e))}}},{ieee754:25}],31:[function(t,e,r){function n(t,e,r){var n=t[e];t[e]=t[r],t[r]=n}function i(t,e){return te?1:0}e.exports=function t(e,r,a,o,s){for(a=a||0,o=o||e.length-1,s=s||i;o>a;){if(o-a>600){var l=o-a+1,c=r-a+1,u=Math.log(l),f=.5*Math.exp(2*u/3),h=.5*Math.sqrt(u*f*(l-f)/l)*(c-l/2<0?-1:1);t(e,r,Math.max(a,Math.floor(r-c*f/l+h)),Math.min(o,Math.floor(r+(l-c)*f/l+h)),s)}var p=e[r],d=a,g=o;for(n(e,a,r),s(e[o],p)>0&&n(e,a,o);d0;)g--}0===s(e[a],p)?n(e,a,g):n(e,++g,o),g<=r&&(a=g+1),r<=g&&(o=g-1)}}},{}],32:[function(t,e,r){function n(t){this.options=u(Object.create(this.options),t),this.trees=new Array(this.options.maxZoom+1)}function i(t,e,r,n,i){return{x:t,y:e,zoom:1/0,id:n,properties:i,parentId:-1,numPoints:r}}function a(t,e){var r=t.geometry.coordinates;return{x:l(r[0]),y:c(r[1]),zoom:1/0,id:e,parentId:-1}}function o(t){return{type:"Feature",properties:s(t),geometry:{type:"Point",coordinates:[function(t){return 360*(t-.5)}(t.x),function(t){var e=(180-360*t)*Math.PI/180;return 360*Math.atan(Math.exp(e))/Math.PI-90}(t.y)]}}}function s(t){var e=t.numPoints,r=e>=1e4?Math.round(e/1e3)+"k":e>=1e3?Math.round(e/100)/10+"k":e;return u(u({},t.properties),{cluster:!0,cluster_id:t.id,point_count:e,point_count_abbreviated:r})}function l(t){return t/360+.5}function c(t){var e=Math.sin(t*Math.PI/180),r=.5-.25*Math.log((1+e)/(1-e))/Math.PI;return r<0?0:r>1?1:r}function u(t,e){for(var r in e)t[r]=e[r];return t}function f(t){return t.x}function h(t){return t.y}var p=t("kdbush");e.exports=function(t){return new n(t)},n.prototype={options:{minZoom:0,maxZoom:16,radius:40,extent:512,nodeSize:64,log:!1,reduce:null,initial:function(){return{}},map:function(t){return t}},load:function(t){var e=this.options.log;e&&console.time("total time");var r="prepare "+t.length+" points";e&&console.time(r),this.points=t;var n=t.map(a);e&&console.timeEnd(r);for(var i=this.options.maxZoom;i>=this.options.minZoom;i--){var o=+Date.now();this.trees[i+1]=p(n,f,h,this.options.nodeSize,Float32Array),n=this._cluster(n,i),e&&console.log("z%d: %d clusters in %dms",i,n.length,+Date.now()-o)}return this.trees[this.options.minZoom]=p(n,f,h,this.options.nodeSize,Float32Array),e&&console.timeEnd("total time"),this},getClusters:function(t,e){for(var r=this.trees[this._limitZoom(e)],n=r.range(l(t[0]),c(t[3]),l(t[2]),c(t[1])),i=[],a=0;a0)for(var r=this.length>>1;r>=0;r--)this._down(r)}function i(t,e){return te?1:0}e.exports=n,n.prototype={push:function(t){this.data.push(t),this.length++,this._up(this.length-1)},pop:function(){if(0!==this.length){var t=this.data[0];return this.length--,this.length>0&&(this.data[0]=this.data[this.length],this._down(0)),this.data.pop(),t}},peek:function(){return this.data[0]},_up:function(t){for(var e=this.data,r=this.compare,n=e[t];t>0;){var i=t-1>>1,a=e[i];if(r(n,a)>=0)break;e[t]=a,t=i}e[t]=n},_down:function(t){for(var e=this.data,r=this.compare,n=this.length,i=n>>1,a=e[t];t=0)break;e[t]=l,t=o}e[t]=a}}},{}],34:[function(t,e,r){function n(t){var e=new f;return function(t,e){for(var r in t.layers)e.writeMessage(3,i,t.layers[r])}(t,e),e.finish()}function i(t,e){e.writeVarintField(15,t.version||1),e.writeStringField(1,t.name||""),e.writeVarintField(5,t.extent||4096);var r,n={keys:[],values:[],keycache:{},valuecache:{}};for(r=0;r>31}function c(t,e){for(var r=t.loadGeometry(),n=t.type,i=0,a=0,o=r.length,c=0;c=u||f<0||f>=u)){var h=r.segments.prepareSegment(4,r.layoutVertexArray,r.indexArray),p=h.vertexLength;n(r.layoutVertexArray,c,f,-1,-1),n(r.layoutVertexArray,c,f,1,-1),n(r.layoutVertexArray,c,f,1,1),n(r.layoutVertexArray,c,f,-1,1),r.indexArray.emplaceBack(p,p+1,p+2),r.indexArray.emplaceBack(p,p+3,p+2),h.vertexLength+=4,h.primitiveLength+=2}}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,t)},f("CircleBucket",h,{omit:["layers"]}),e.exports=h},{"../../util/web_worker_transfer":278,"../array_types":39,"../extent":53,"../index_array_type":55,"../load_geometry":56,"../program_configuration":58,"../segment":60,"./circle_attributes":41}],43:[function(t,e,r){arguments[4][41][0].apply(r,arguments)},{"../../util/struct_array":271,dup:41}],44:[function(t,e,r){var n=t("../array_types").FillLayoutArray,i=t("./fill_attributes").members,a=t("../segment").SegmentVector,o=t("../program_configuration").ProgramConfigurationSet,s=t("../index_array_type"),l=s.LineIndexArray,c=s.TriangleIndexArray,u=t("../load_geometry"),f=t("earcut"),h=t("../../util/classify_rings"),p=t("../../util/web_worker_transfer").register,d=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new n,this.indexArray=new c,this.indexArray2=new l,this.programConfigurations=new o(i,t.layers,t.zoom),this.segments=new a,this.segments2=new a};d.prototype.populate=function(t,e){for(var r=this,n=0,i=t;nd)||t.y===e.y&&(t.y<0||t.y>d)}function a(t){return t.every(function(t){return t.x<0})||t.every(function(t){return t.x>d})||t.every(function(t){return t.y<0})||t.every(function(t){return t.y>d})}var o=t("../array_types").FillExtrusionLayoutArray,s=t("./fill_extrusion_attributes").members,l=t("../segment"),c=l.SegmentVector,u=l.MAX_VERTEX_ARRAY_LENGTH,f=t("../program_configuration").ProgramConfigurationSet,h=t("../index_array_type").TriangleIndexArray,p=t("../load_geometry"),d=t("../extent"),g=t("earcut"),m=t("../../util/classify_rings"),v=t("../../util/web_worker_transfer").register,y=Math.pow(2,13),x=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new o,this.indexArray=new h,this.programConfigurations=new f(s,t.layers,t.zoom),this.segments=new c};x.prototype.populate=function(t,e){for(var r=this,n=0,i=t;n=1){var w=y[b-1];if(!i(_,w)){p.vertexLength+4>u&&(p=r.segments.prepareSegment(4,r.layoutVertexArray,r.indexArray));var k=_.sub(w)._perp()._unit(),M=w.dist(_);x+M>32768&&(x=0),n(r.layoutVertexArray,_.x,_.y,k.x,k.y,0,0,x),n(r.layoutVertexArray,_.x,_.y,k.x,k.y,0,1,x),x+=M,n(r.layoutVertexArray,w.x,w.y,k.x,k.y,0,0,x),n(r.layoutVertexArray,w.x,w.y,k.x,k.y,0,1,x);var A=p.vertexLength;r.indexArray.emplaceBack(A,A+1,A+2),r.indexArray.emplaceBack(A+1,A+2,A+3),p.vertexLength+=4,p.primitiveLength+=2}}}}p.vertexLength+c>u&&(p=r.segments.prepareSegment(c,r.layoutVertexArray,r.indexArray));for(var T=[],S=[],C=p.vertexLength,E=0,L=l;E>6)}var i=t("../array_types").LineLayoutArray,a=t("./line_attributes").members,o=t("../segment").SegmentVector,s=t("../program_configuration").ProgramConfigurationSet,l=t("../index_array_type").TriangleIndexArray,c=t("../load_geometry"),u=t("../extent"),f=t("@mapbox/vector-tile").VectorTileFeature.types,h=t("../../util/web_worker_transfer").register,p=63,d=Math.cos(Math.PI/180*37.5),g=.5,m=Math.pow(2,14)/g,v=function(t){this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.layoutVertexArray=new i,this.indexArray=new l,this.programConfigurations=new s(a,t.layers,t.zoom),this.segments=new o};v.prototype.populate=function(t,e){for(var r=this,n=0,i=t;n=2&&t[l-1].equals(t[l-2]);)l--;for(var c=0;cc){var z=m.dist(w);if(z>2*h){var P=m.sub(m.sub(w)._mult(h/z)._round());o.distance+=P.dist(w),o.addCurrentVertex(P,o.distance,M.mult(1),0,0,!1,g),w=P}}var D=w&&k,O=D?r:k?x:b;if(D&&"round"===O&&(Ei&&(O="bevel"),"bevel"===O&&(E>2&&(O="flipbevel"),E100)S=A.clone().mult(-1);else{var I=M.x*A.y-M.y*A.x>0?-1:1,R=E*M.add(A).mag()/M.sub(A).mag();S._perp()._mult(R*I)}o.addCurrentVertex(m,o.distance,S,0,0,!1,g),o.addCurrentVertex(m,o.distance,S.mult(-1),0,0,!1,g)}else if("bevel"===O||"fakeround"===O){var B=M.x*A.y-M.y*A.x>0,F=-Math.sqrt(E*E-1);if(B?(y=0,v=F):(v=0,y=F),_||o.addCurrentVertex(m,o.distance,M,v,y,!1,g),"fakeround"===O){for(var N=Math.floor(8*(.5-(C-.5))),j=void 0,V=0;V=0;U--)j=M.mult((U+1)/(N+1))._add(A)._unit(),o.addPieSliceVertex(m,o.distance,j,B,g)}k&&o.addCurrentVertex(m,o.distance,A,-v,-y,!1,g)}else"butt"===O?(_||o.addCurrentVertex(m,o.distance,M,0,0,!1,g),k&&o.addCurrentVertex(m,o.distance,A,0,0,!1,g)):"square"===O?(_||(o.addCurrentVertex(m,o.distance,M,1,1,!1,g),o.e1=o.e2=-1),k&&o.addCurrentVertex(m,o.distance,A,-1,-1,!1,g)):"round"===O&&(_||(o.addCurrentVertex(m,o.distance,M,0,0,!1,g),o.addCurrentVertex(m,o.distance,M,1,1,!0,g),o.e1=o.e2=-1),k&&(o.addCurrentVertex(m,o.distance,A,-1,-1,!0,g),o.addCurrentVertex(m,o.distance,A,0,0,!1,g)));if(L&&T2*h){var H=m.add(k.sub(m)._mult(h/q)._round());o.distance+=H.dist(m),o.addCurrentVertex(H,o.distance,A.mult(1),0,0,!1,g),m=H}}_=!1}this.programConfigurations.populatePaintArrays(this.layoutVertexArray.length,e)}},v.prototype.addCurrentVertex=function(t,e,r,i,a,o,s){var l,c=this.layoutVertexArray,u=this.indexArray;l=r.clone(),i&&l._sub(r.perp()._mult(i)),n(c,t,l,o,!1,i,e),this.e3=s.vertexLength++,this.e1>=0&&this.e2>=0&&(u.emplaceBack(this.e1,this.e2,this.e3),s.primitiveLength++),this.e1=this.e2,this.e2=this.e3,l=r.mult(-1),a&&l._sub(r.perp()._mult(a)),n(c,t,l,o,!0,-a,e),this.e3=s.vertexLength++,this.e1>=0&&this.e2>=0&&(u.emplaceBack(this.e1,this.e2,this.e3),s.primitiveLength++),this.e1=this.e2,this.e2=this.e3,e>m/2&&(this.distance=0,this.addCurrentVertex(t,this.distance,r,i,a,o,s))},v.prototype.addPieSliceVertex=function(t,e,r,i,a){r=r.mult(i?-1:1);var o=this.layoutVertexArray,s=this.indexArray;n(o,t,r,!1,i,0,e),this.e3=a.vertexLength++,this.e1>=0&&this.e2>=0&&(s.emplaceBack(this.e1,this.e2,this.e3),a.primitiveLength++),i?this.e2=this.e3:this.e1=this.e3},h("LineBucket",v,{omit:["layers"]}),e.exports=v},{"../../util/web_worker_transfer":278,"../array_types":39,"../extent":53,"../index_array_type":55,"../load_geometry":56,"../program_configuration":58,"../segment":60,"./line_attributes":48,"@mapbox/vector-tile":8}],50:[function(t,e,r){var n=t("../../util/struct_array").createLayout,i={symbolLayoutAttributes:n([{name:"a_pos_offset",components:4,type:"Int16"},{name:"a_data",components:4,type:"Uint16"}]),dynamicLayoutAttributes:n([{name:"a_projected_pos",components:3,type:"Float32"}],4),placementOpacityAttributes:n([{name:"a_fade_opacity",components:1,type:"Uint32"}],4),collisionVertexAttributes:n([{name:"a_placed",components:2,type:"Uint8"}],4),collisionBox:n([{type:"Int16",name:"anchorPointX"},{type:"Int16",name:"anchorPointY"},{type:"Int16",name:"x1"},{type:"Int16",name:"y1"},{type:"Int16",name:"x2"},{type:"Int16",name:"y2"},{type:"Uint32",name:"featureIndex"},{type:"Uint16",name:"sourceLayerIndex"},{type:"Uint16",name:"bucketIndex"},{type:"Int16",name:"radius"},{type:"Int16",name:"signedDistanceFromAnchor"}]),collisionBoxLayout:n([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4),collisionCircleLayout:n([{name:"a_pos",components:2,type:"Int16"},{name:"a_anchor_pos",components:2,type:"Int16"},{name:"a_extrude",components:2,type:"Int16"}],4),placement:n([{type:"Int16",name:"anchorX"},{type:"Int16",name:"anchorY"},{type:"Uint16",name:"glyphStartIndex"},{type:"Uint16",name:"numGlyphs"},{type:"Uint32",name:"vertexStartIndex"},{type:"Uint32",name:"lineStartIndex"},{type:"Uint32",name:"lineLength"},{type:"Uint16",name:"segment"},{type:"Uint16",name:"lowerSize"},{type:"Uint16",name:"upperSize"},{type:"Float32",name:"lineOffsetX"},{type:"Float32",name:"lineOffsetY"},{type:"Uint8",name:"writingMode"},{type:"Uint8",name:"hidden"}]),glyphOffset:n([{type:"Float32",name:"offsetX"}]),lineVertex:n([{type:"Int16",name:"x"},{type:"Int16",name:"y"},{type:"Int16",name:"tileUnitDistanceFromAnchor"}])};e.exports=i},{"../../util/struct_array":271}],51:[function(t,e,r){function n(t,e,r,n,i,a,o,s){t.emplaceBack(e,r,Math.round(64*n),Math.round(64*i),a,o,s?s[0]:0,s?s[1]:0)}function i(t,e,r){t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r),t.emplaceBack(e.x,e.y,r)}var a=t("./symbol_attributes"),o=a.symbolLayoutAttributes,s=a.collisionVertexAttributes,l=a.collisionBoxLayout,c=a.collisionCircleLayout,u=a.dynamicLayoutAttributes,f=t("../array_types"),h=f.SymbolLayoutArray,p=f.SymbolDynamicLayoutArray,d=f.SymbolOpacityArray,g=f.CollisionBoxLayoutArray,m=f.CollisionCircleLayoutArray,v=f.CollisionVertexArray,y=f.PlacedSymbolArray,x=f.GlyphOffsetArray,b=f.SymbolLineVertexArray,_=t("@mapbox/point-geometry"),w=t("../segment").SegmentVector,k=t("../program_configuration").ProgramConfigurationSet,M=t("../index_array_type"),A=M.TriangleIndexArray,T=M.LineIndexArray,S=t("../../symbol/transform_text"),C=t("../../symbol/mergelines"),E=t("../../util/script_detection"),L=t("../load_geometry"),z=t("@mapbox/vector-tile").VectorTileFeature.types,P=t("../../util/verticalize_punctuation"),D=(t("../../symbol/anchor"),t("../../symbol/symbol_size").getSizeData),O=t("../../util/web_worker_transfer").register,I=[{name:"a_fade_opacity",components:1,type:"Uint8",offset:0}],R=function(t){this.layoutVertexArray=new h,this.indexArray=new A,this.programConfigurations=t,this.segments=new w,this.dynamicLayoutVertexArray=new p,this.opacityVertexArray=new d,this.placedSymbolArray=new y};R.prototype.upload=function(t,e){this.layoutVertexBuffer=t.createVertexBuffer(this.layoutVertexArray,o.members),this.indexBuffer=t.createIndexBuffer(this.indexArray,e),this.programConfigurations.upload(t),this.dynamicLayoutVertexBuffer=t.createVertexBuffer(this.dynamicLayoutVertexArray,u.members,!0),this.opacityVertexBuffer=t.createVertexBuffer(this.opacityVertexArray,I,!0),this.opacityVertexBuffer.itemSize=1},R.prototype.destroy=function(){this.layoutVertexBuffer&&(this.layoutVertexBuffer.destroy(),this.indexBuffer.destroy(),this.programConfigurations.destroy(),this.segments.destroy(),this.dynamicLayoutVertexBuffer.destroy(),this.opacityVertexBuffer.destroy())},O("SymbolBuffers",R);var B=function(t,e,r){this.layoutVertexArray=new t,this.layoutAttributes=e,this.indexArray=new r,this.segments=new w,this.collisionVertexArray=new v};B.prototype.upload=function(t){this.layoutVertexBuffer=t.createVertexBuffer(this.layoutVertexArray,this.layoutAttributes),this.indexBuffer=t.createIndexBuffer(this.indexArray),this.collisionVertexBuffer=t.createVertexBuffer(this.collisionVertexArray,s.members,!0)},B.prototype.destroy=function(){this.layoutVertexBuffer&&(this.layoutVertexBuffer.destroy(),this.indexBuffer.destroy(),this.segments.destroy(),this.collisionVertexBuffer.destroy())},O("CollisionBuffers",B);var F=function(t){this.collisionBoxArray=t.collisionBoxArray,this.zoom=t.zoom,this.overscaling=t.overscaling,this.layers=t.layers,this.layerIds=this.layers.map(function(t){return t.id}),this.index=t.index,this.pixelRatio=t.pixelRatio;var e=this.layers[0]._unevaluatedLayout._values;this.textSizeData=D(this.zoom,e["text-size"]),this.iconSizeData=D(this.zoom,e["icon-size"]);var r=this.layers[0].layout;this.sortFeaturesByY=r.get("text-allow-overlap")||r.get("icon-allow-overlap")||r.get("text-ignore-placement")||r.get("icon-ignore-placement")};F.prototype.createArrays=function(){this.text=new R(new k(o.members,this.layers,this.zoom,function(t){return/^text/.test(t)})),this.icon=new R(new k(o.members,this.layers,this.zoom,function(t){return/^icon/.test(t)})),this.collisionBox=new B(g,l.members,T),this.collisionCircle=new B(m,c.members,A),this.glyphOffsetArray=new x,this.lineVertexArray=new b},F.prototype.populate=function(t,e){var r=this.layers[0],n=r.layout,i=n.get("text-font"),a=n.get("text-field"),o=n.get("icon-image"),s=("constant"!==a.value.kind||a.value.value.length>0)&&("constant"!==i.value.kind||i.value.value.length>0),l="constant"!==o.value.kind||o.value.value&&o.value.value.length>0;if(this.features=[],s||l){for(var c=e.iconDependencies,u=e.glyphDependencies,f={zoom:this.zoom},h=0,p=t;h=0;s--)a[s]={x:e[s].x,y:e[s].y,tileUnitDistanceFromAnchor:i},s>0&&(i+=e[s-1].dist(e[s]));for(var l=0;l0;t.addCollisionDebugVertices(l,c,u,f,h?t.collisionCircle:t.collisionBox,s.anchorPoint,n,h)}}}},F.prototype.deserializeCollisionBoxes=function(t,e,r,n,i){for(var a={},o=e;o0},F.prototype.hasIconData=function(){return this.icon.segments.get().length>0},F.prototype.hasCollisionBoxData=function(){return this.collisionBox.segments.get().length>0},F.prototype.hasCollisionCircleData=function(){return this.collisionCircle.segments.get().length>0},F.prototype.sortFeatures=function(t){var e=this;if(this.sortFeaturesByY&&this.sortedAngle!==t&&(this.sortedAngle=t,!(this.text.segments.get().length>1||this.icon.segments.get().length>1))){for(var r=[],n=0;n=this.dim+this.border||e<-this.border||e>=this.dim+this.border)throw new RangeError("out of range source coordinates for DEM data");return(e+this.border)*this.stride+(t+this.border)},a("Level",o);var s=function(t,e,r){this.uid=t,this.scale=e||1,this.level=r||new o(256,512),this.loaded=!!r};s.prototype.loadFromImage=function(t){if(t.height!==t.width)throw new RangeError("DEM tiles must be square");for(var e=this.level=new o(t.width,t.width/2),r=t.data,n=0;no.max||c.yo.max)&&i.warnOnce("Geometry exceeds allowed extent, reduce your vector tile buffer size")}return r}},{"../util/util":275,"./extent":53}],57:[function(t,e,r){var n=t("../util/struct_array").createLayout;e.exports=n([{name:"a_pos",type:"Int16",components:2}])},{"../util/struct_array":271}],58:[function(t,e,r){function n(t){return[a(255*t.r,255*t.g),a(255*t.b,255*t.a)]}function i(t,e){return{"text-opacity":"opacity","icon-opacity":"opacity","text-color":"fill_color","icon-color":"fill_color","text-halo-color":"halo_color","icon-halo-color":"halo_color","text-halo-blur":"halo_blur","icon-halo-blur":"halo_blur","text-halo-width":"halo_width","icon-halo-width":"halo_width","line-gap-width":"gapwidth"}[t]||t.replace(e+"-","").replace(/-/g,"_")}var a=t("../shaders/encode_attribute").packUint8ToFloat,o=(t("../style-spec/util/color"),t("../util/web_worker_transfer").register),s=t("../style/properties").PossiblyEvaluatedPropertyValue,l=t("./array_types"),c=l.StructArrayLayout1f4,u=l.StructArrayLayout2f8,f=l.StructArrayLayout4f16,h=function(t,e,r){this.value=t,this.name=e,this.type=r,this.statistics={max:-1/0}};h.prototype.defines=function(){return["#define HAS_UNIFORM_u_"+this.name]},h.prototype.populatePaintArray=function(){},h.prototype.upload=function(){},h.prototype.destroy=function(){},h.prototype.setUniforms=function(t,e,r,n){var i=n.constantOr(this.value),a=t.gl;"color"===this.type?a.uniform4f(e.uniforms["u_"+this.name],i.r,i.g,i.b,i.a):a.uniform1f(e.uniforms["u_"+this.name],i)};var p=function(t,e,r){this.expression=t,this.name=e,this.type=r,this.statistics={max:-1/0};var n="color"===r?u:c;this.paintVertexAttributes=[{name:"a_"+e,type:"Float32",components:"color"===r?2:1,offset:0}],this.paintVertexArray=new n};p.prototype.defines=function(){return[]},p.prototype.populatePaintArray=function(t,e){var r=this.paintVertexArray,i=r.length;r.reserve(t);var a=this.expression.evaluate({zoom:0},e);if("color"===this.type)for(var o=n(a),s=i;sa&&n("Max vertices per segment is "+a+": bucket requested "+t),(!o||o.vertexLength+t>e.exports.MAX_VERTEX_ARRAY_LENGTH)&&(o={vertexOffset:r.length,primitiveOffset:i.length,vertexLength:0,primitiveLength:0},this.segments.push(o)),o},o.prototype.get=function(){return this.segments},o.prototype.destroy=function(){for(var t=0,e=this.segments;t90||this.lat<-90)throw new Error("Invalid LngLat latitude value: must be between -90 and 90")};i.prototype.wrap=function(){return new i(n(this.lng,-180,180),this.lat)},i.prototype.toArray=function(){return[this.lng,this.lat]},i.prototype.toString=function(){return"LngLat("+this.lng+", "+this.lat+")"},i.prototype.toBounds=function(e){var r=360*e/40075017,n=r/Math.cos(Math.PI/180*this.lat);return new(t("./lng_lat_bounds"))(new i(this.lng-n,this.lat-r),new i(this.lng+n,this.lat+r))},i.convert=function(t){if(t instanceof i)return t;if(Array.isArray(t)&&(2===t.length||3===t.length))return new i(Number(t[0]),Number(t[1]));if(!Array.isArray(t)&&"object"==typeof t&&null!==t)return new i(Number(t.lng),Number(t.lat));throw new Error("`LngLatLike` argument must be specified as a LngLat instance, an object {lng: , lat: }, or an array of [, ]")},e.exports=i},{"../util/util":275,"./lng_lat_bounds":63}],63:[function(t,e,r){var n=t("./lng_lat"),i=function(t,e){t&&(e?this.setSouthWest(t).setNorthEast(e):4===t.length?this.setSouthWest([t[0],t[1]]).setNorthEast([t[2],t[3]]):this.setSouthWest(t[0]).setNorthEast(t[1]))};i.prototype.setNorthEast=function(t){return this._ne=t instanceof n?new n(t.lng,t.lat):n.convert(t),this},i.prototype.setSouthWest=function(t){return this._sw=t instanceof n?new n(t.lng,t.lat):n.convert(t),this},i.prototype.extend=function(t){var e,r,a=this._sw,o=this._ne;if(t instanceof n)e=t,r=t;else{if(!(t instanceof i))return Array.isArray(t)?t.every(Array.isArray)?this.extend(i.convert(t)):this.extend(n.convert(t)):this;if(e=t._sw,r=t._ne,!e||!r)return this}return a||o?(a.lng=Math.min(e.lng,a.lng),a.lat=Math.min(e.lat,a.lat),o.lng=Math.max(r.lng,o.lng),o.lat=Math.max(r.lat,o.lat)):(this._sw=new n(e.lng,e.lat),this._ne=new n(r.lng,r.lat)),this},i.prototype.getCenter=function(){return new n((this._sw.lng+this._ne.lng)/2,(this._sw.lat+this._ne.lat)/2)},i.prototype.getSouthWest=function(){return this._sw},i.prototype.getNorthEast=function(){return this._ne},i.prototype.getNorthWest=function(){return new n(this.getWest(),this.getNorth())},i.prototype.getSouthEast=function(){return new n(this.getEast(),this.getSouth())},i.prototype.getWest=function(){return this._sw.lng},i.prototype.getSouth=function(){return this._sw.lat},i.prototype.getEast=function(){return this._ne.lng},i.prototype.getNorth=function(){return this._ne.lat},i.prototype.toArray=function(){return[this._sw.toArray(),this._ne.toArray()]},i.prototype.toString=function(){return"LngLatBounds("+this._sw.toString()+", "+this._ne.toString()+")"},i.prototype.isEmpty=function(){return!(this._sw&&this._ne)},i.convert=function(t){return!t||t instanceof i?t:new i(t)},e.exports=i},{"./lng_lat":62}],64:[function(t,e,r){var n=t("./lng_lat"),i=t("@mapbox/point-geometry"),a=t("./coordinate"),o=t("../util/util"),s=t("../style-spec/util/interpolate").number,l=t("../util/tile_cover"),c=t("../source/tile_id"),u=(c.CanonicalTileID,c.UnwrappedTileID),f=t("../data/extent"),h=t("@mapbox/gl-matrix"),p=h.vec4,d=h.mat4,g=h.mat2,m=function(t,e,r){this.tileSize=512,this._renderWorldCopies=void 0===r||r,this._minZoom=t||0,this._maxZoom=e||22,this.latRange=[-85.05113,85.05113],this.width=0,this.height=0,this._center=new n(0,0),this.zoom=0,this.angle=0,this._fov=.6435011087932844,this._pitch=0,this._unmodified=!0,this._posMatrixCache={},this._alignedPosMatrixCache={}},v={minZoom:{},maxZoom:{},renderWorldCopies:{},worldSize:{},centerPoint:{},size:{},bearing:{},pitch:{},fov:{},zoom:{},center:{},unmodified:{},x:{},y:{},point:{}};m.prototype.clone=function(){var t=new m(this._minZoom,this._maxZoom,this._renderWorldCopies);return t.tileSize=this.tileSize,t.latRange=this.latRange,t.width=this.width,t.height=this.height,t._center=this._center,t.zoom=this.zoom,t.angle=this.angle,t._fov=this._fov,t._pitch=this._pitch,t._unmodified=this._unmodified,t._calcMatrices(),t},v.minZoom.get=function(){return this._minZoom},v.minZoom.set=function(t){this._minZoom!==t&&(this._minZoom=t,this.zoom=Math.max(this.zoom,t))},v.maxZoom.get=function(){return this._maxZoom},v.maxZoom.set=function(t){this._maxZoom!==t&&(this._maxZoom=t,this.zoom=Math.min(this.zoom,t))},v.renderWorldCopies.get=function(){return this._renderWorldCopies},v.worldSize.get=function(){return this.tileSize*this.scale},v.centerPoint.get=function(){return this.size._div(2)},v.size.get=function(){return new i(this.width,this.height)},v.bearing.get=function(){return-this.angle/Math.PI*180},v.bearing.set=function(t){var e=-o.wrap(t,-180,180)*Math.PI/180;this.angle!==e&&(this._unmodified=!1,this.angle=e,this._calcMatrices(),this.rotationMatrix=g.create(),g.rotate(this.rotationMatrix,this.rotationMatrix,this.angle))},v.pitch.get=function(){return this._pitch/Math.PI*180},v.pitch.set=function(t){var e=o.clamp(t,0,60)/180*Math.PI;this._pitch!==e&&(this._unmodified=!1,this._pitch=e,this._calcMatrices())},v.fov.get=function(){return this._fov/Math.PI*180},v.fov.set=function(t){t=Math.max(.01,Math.min(60,t)),this._fov!==t&&(this._unmodified=!1,this._fov=t/180*Math.PI,this._calcMatrices())},v.zoom.get=function(){return this._zoom},v.zoom.set=function(t){var e=Math.min(Math.max(t,this.minZoom),this.maxZoom);this._zoom!==e&&(this._unmodified=!1,this._zoom=e,this.scale=this.zoomScale(e),this.tileZoom=Math.floor(e),this.zoomFraction=e-this.tileZoom,this._constrain(),this._calcMatrices())},v.center.get=function(){return this._center},v.center.set=function(t){t.lat===this._center.lat&&t.lng===this._center.lng||(this._unmodified=!1,this._center=t,this._constrain(),this._calcMatrices())},m.prototype.coveringZoomLevel=function(t){return(t.roundZoom?Math.round:Math.floor)(this.zoom+this.scaleZoom(this.tileSize/t.tileSize))},m.prototype.getVisibleUnwrappedCoordinates=function(t){var e=this.pointCoordinate(new i(0,0),0),r=this.pointCoordinate(new i(this.width,0),0),n=Math.floor(e.column),a=Math.floor(r.column),o=[new u(0,t)];if(this._renderWorldCopies)for(var s=n;s<=a;s++)0!==s&&o.push(new u(s,t));return o},m.prototype.coveringTiles=function(t){var e=this.coveringZoomLevel(t),r=e;if(void 0!==t.minzoom&&et.maxzoom&&(e=t.maxzoom);var n=this.pointCoordinate(this.centerPoint,e),a=new i(n.column-.5,n.row-.5),o=[this.pointCoordinate(new i(0,0),e),this.pointCoordinate(new i(this.width,0),e),this.pointCoordinate(new i(this.width,this.height),e),this.pointCoordinate(new i(0,this.height),e)];return l(e,o,t.reparseOverscaled?r:e,this._renderWorldCopies).sort(function(t,e){return a.dist(t.canonical)-a.dist(e.canonical)})},m.prototype.resize=function(t,e){this.width=t,this.height=e,this.pixelsToGLUnits=[2/t,-2/e],this._constrain(),this._calcMatrices()},v.unmodified.get=function(){return this._unmodified},m.prototype.zoomScale=function(t){return Math.pow(2,t)},m.prototype.scaleZoom=function(t){return Math.log(t)/Math.LN2},m.prototype.project=function(t){return new i(this.lngX(t.lng),this.latY(t.lat))},m.prototype.unproject=function(t){return new n(this.xLng(t.x),this.yLat(t.y))},v.x.get=function(){return this.lngX(this.center.lng)},v.y.get=function(){return this.latY(this.center.lat)},v.point.get=function(){return new i(this.x,this.y)},m.prototype.lngX=function(t){return(180+t)*this.worldSize/360},m.prototype.latY=function(t){return(180-180/Math.PI*Math.log(Math.tan(Math.PI/4+t*Math.PI/360)))*this.worldSize/360},m.prototype.xLng=function(t){return 360*t/this.worldSize-180},m.prototype.yLat=function(t){var e=180-360*t/this.worldSize;return 360/Math.PI*Math.atan(Math.exp(e*Math.PI/180))-90},m.prototype.setLocationAtPoint=function(t,e){var r=this.pointCoordinate(e)._sub(this.pointCoordinate(this.centerPoint));this.center=this.coordinateLocation(this.locationCoordinate(t)._sub(r)),this._renderWorldCopies&&(this.center=this.center.wrap())},m.prototype.locationPoint=function(t){return this.coordinatePoint(this.locationCoordinate(t))},m.prototype.pointLocation=function(t){return this.coordinateLocation(this.pointCoordinate(t))},m.prototype.locationCoordinate=function(t){return new a(this.lngX(t.lng)/this.tileSize,this.latY(t.lat)/this.tileSize,this.zoom).zoomTo(this.tileZoom)},m.prototype.coordinateLocation=function(t){var e=t.zoomTo(this.zoom);return new n(this.xLng(e.column*this.tileSize),this.yLat(e.row*this.tileSize))},m.prototype.pointCoordinate=function(t,e){void 0===e&&(e=this.tileZoom);var r=[t.x,t.y,0,1],n=[t.x,t.y,1,1];p.transformMat4(r,r,this.pixelMatrixInverse),p.transformMat4(n,n,this.pixelMatrixInverse);var i=r[3],o=n[3],l=r[1]/i,c=n[1]/o,u=r[2]/i,f=n[2]/o,h=u===f?0:(0-u)/(f-u);return new a(s(r[0]/i,n[0]/o,h)/this.tileSize,s(l,c,h)/this.tileSize,this.zoom)._zoomTo(e)},m.prototype.coordinatePoint=function(t){var e=t.zoomTo(this.zoom),r=[e.column*this.tileSize,e.row*this.tileSize,0,1];return p.transformMat4(r,r,this.pixelMatrix),new i(r[0]/r[3],r[1]/r[3])},m.prototype.calculatePosMatrix=function(t,e){void 0===e&&(e=!1);var r=t.key,n=e?this._alignedPosMatrixCache:this._posMatrixCache;if(n[r])return n[r];var i=t.canonical,a=this.worldSize/this.zoomScale(i.z),o=i.x+Math.pow(2,i.z)*t.wrap,s=d.identity(new Float64Array(16));return d.translate(s,s,[o*a,i.y*a,0]),d.scale(s,s,[a/f,a/f,1]),d.multiply(s,e?this.alignedProjMatrix:this.projMatrix,s),n[r]=new Float32Array(s),n[r]},m.prototype._constrain=function(){if(this.center&&this.width&&this.height&&!this._constraining){this._constraining=!0;var t,e,r,n,a=-90,o=90,s=-180,l=180,c=this.size,u=this._unmodified;if(this.latRange){var f=this.latRange;a=this.latY(f[1]),t=(o=this.latY(f[0]))-ao&&(n=o-g)}if(this.lngRange){var m=this.x,v=c.x/2;m-vl&&(r=l-v)}void 0===r&&void 0===n||(this.center=this.unproject(new i(void 0!==r?r:this.x,void 0!==n?n:this.y))),this._unmodified=u,this._constraining=!1}},m.prototype._calcMatrices=function(){if(this.height){this.cameraToCenterDistance=.5/Math.tan(this._fov/2)*this.height;var t=this._fov/2,e=Math.PI/2+this._pitch,r=Math.sin(t)*this.cameraToCenterDistance/Math.sin(Math.PI-e-t),n=this.x,i=this.y,a=1.01*(Math.cos(Math.PI/2-this._pitch)*r+this.cameraToCenterDistance),o=new Float64Array(16);d.perspective(o,this._fov,this.width/this.height,1,a),d.scale(o,o,[1,-1,1]),d.translate(o,o,[0,0,-this.cameraToCenterDistance]),d.rotateX(o,o,this._pitch),d.rotateZ(o,o,this.angle),d.translate(o,o,[-n,-i,0]);var s=this.worldSize/(2*Math.PI*6378137*Math.abs(Math.cos(this.center.lat*(Math.PI/180))));d.scale(o,o,[1,1,s,1]),this.projMatrix=o;var l=this.width%2/2,c=this.height%2/2,u=Math.cos(this.angle),f=Math.sin(this.angle),h=n-Math.round(n)+u*l+f*c,p=i-Math.round(i)+u*c+f*l,g=new Float64Array(o);if(d.translate(g,g,[h>.5?h-1:h,p>.5?p-1:p,0]),this.alignedProjMatrix=g,o=d.create(),d.scale(o,o,[this.width/2,-this.height/2,1]),d.translate(o,o,[1,-1,0]),this.pixelMatrix=d.multiply(new Float64Array(16),o,this.projMatrix),!(o=d.invert(new Float64Array(16),this.pixelMatrix)))throw new Error("failed to invert matrix");this.pixelMatrixInverse=o,this._posMatrixCache={},this._alignedPosMatrixCache={}}},Object.defineProperties(m.prototype,v),e.exports=m},{"../data/extent":53,"../source/tile_id":114,"../style-spec/util/interpolate":158,"../util/tile_cover":273,"../util/util":275,"./coordinate":61,"./lng_lat":62,"@mapbox/gl-matrix":2,"@mapbox/point-geometry":4}],65:[function(t,e,r){var n=t("../style-spec/util/color"),i=function(t,e,r){this.blendFunction=t,this.blendColor=e,this.mask=r};i.disabled=new i(i.Replace=[1,0],n.transparent,[!1,!1,!1,!1]),i.unblended=new i(i.Replace,n.transparent,[!0,!0,!0,!0]),i.alphaBlended=new i([1,771],n.transparent,[!0,!0,!0,!0]),e.exports=i},{"../style-spec/util/color":153}],66:[function(t,e,r){var n=t("./index_buffer"),i=t("./vertex_buffer"),a=t("./framebuffer"),o=(t("./depth_mode"),t("./stencil_mode"),t("./color_mode")),s=t("../util/util"),l=t("./value"),c=l.ClearColor,u=l.ClearDepth,f=l.ClearStencil,h=l.ColorMask,p=l.DepthMask,d=l.StencilMask,g=l.StencilFunc,m=l.StencilOp,v=l.StencilTest,y=l.DepthRange,x=l.DepthTest,b=l.DepthFunc,_=l.Blend,w=l.BlendFunc,k=l.BlendColor,M=l.Program,A=l.LineWidth,T=l.ActiveTextureUnit,S=l.Viewport,C=l.BindFramebuffer,E=l.BindRenderbuffer,L=l.BindTexture,z=l.BindVertexBuffer,P=l.BindElementBuffer,D=l.BindVertexArrayOES,O=l.PixelStoreUnpack,I=l.PixelStoreUnpackPremultiplyAlpha,R=function(t){this.gl=t,this.extVertexArrayObject=this.gl.getExtension("OES_vertex_array_object"),this.lineWidthRange=t.getParameter(t.ALIASED_LINE_WIDTH_RANGE),this.clearColor=new c(this),this.clearDepth=new u(this),this.clearStencil=new f(this),this.colorMask=new h(this),this.depthMask=new p(this),this.stencilMask=new d(this),this.stencilFunc=new g(this),this.stencilOp=new m(this),this.stencilTest=new v(this),this.depthRange=new y(this),this.depthTest=new x(this),this.depthFunc=new b(this),this.blend=new _(this),this.blendFunc=new w(this),this.blendColor=new k(this),this.program=new M(this),this.lineWidth=new A(this),this.activeTexture=new T(this),this.viewport=new S(this),this.bindFramebuffer=new C(this),this.bindRenderbuffer=new E(this),this.bindTexture=new L(this),this.bindVertexBuffer=new z(this),this.bindElementBuffer=new P(this),this.bindVertexArrayOES=this.extVertexArrayObject&&new D(this),this.pixelStoreUnpack=new O(this),this.pixelStoreUnpackPremultiplyAlpha=new I(this),this.extTextureFilterAnisotropic=t.getExtension("EXT_texture_filter_anisotropic")||t.getExtension("MOZ_EXT_texture_filter_anisotropic")||t.getExtension("WEBKIT_EXT_texture_filter_anisotropic"),this.extTextureFilterAnisotropic&&(this.extTextureFilterAnisotropicMax=t.getParameter(this.extTextureFilterAnisotropic.MAX_TEXTURE_MAX_ANISOTROPY_EXT)),this.extTextureHalfFloat=t.getExtension("OES_texture_half_float"),this.extTextureHalfFloat&&t.getExtension("OES_texture_half_float_linear")};R.prototype.createIndexBuffer=function(t,e){return new n(this,t,e)},R.prototype.createVertexBuffer=function(t,e,r){return new i(this,t,e,r)},R.prototype.createRenderbuffer=function(t,e,r){var n=this.gl,i=n.createRenderbuffer();return this.bindRenderbuffer.set(i),n.renderbufferStorage(n.RENDERBUFFER,t,e,r),this.bindRenderbuffer.set(null),i},R.prototype.createFramebuffer=function(t,e){return new a(this,t,e)},R.prototype.clear=function(t){var e=t.color,r=t.depth,n=this.gl,i=0;e&&(i|=n.COLOR_BUFFER_BIT,this.clearColor.set(e),this.colorMask.set([!0,!0,!0,!0])),void 0!==r&&(i|=n.DEPTH_BUFFER_BIT,this.clearDepth.set(r),this.depthMask.set(!0)),n.clear(i)},R.prototype.setDepthMode=function(t){t.func!==this.gl.ALWAYS||t.mask?(this.depthTest.set(!0),this.depthFunc.set(t.func),this.depthMask.set(t.mask),this.depthRange.set(t.range)):this.depthTest.set(!1)},R.prototype.setStencilMode=function(t){t.func!==this.gl.ALWAYS||t.mask?(this.stencilTest.set(!0),this.stencilMask.set(t.mask),this.stencilOp.set([t.fail,t.depthFail,t.pass]),this.stencilFunc.set({func:t.test.func,ref:t.ref,mask:t.test.mask})):this.stencilTest.set(!1)},R.prototype.setColorMode=function(t){s.deepEqual(t.blendFunction,o.Replace)?this.blend.set(!1):(this.blend.set(!0),this.blendFunc.set(t.blendFunction),this.blendColor.set(t.blendColor)),this.colorMask.set(t.mask)},e.exports=R},{"../util/util":275,"./color_mode":65,"./depth_mode":67,"./framebuffer":68,"./index_buffer":69,"./stencil_mode":70,"./value":71,"./vertex_buffer":72}],67:[function(t,e,r){var n=function(t,e,r){this.func=t,this.mask=e,this.range=r};n.ReadOnly=!1,n.ReadWrite=!0,n.disabled=new n(519,n.ReadOnly,[0,1]),e.exports=n},{}],68:[function(t,e,r){var n=t("./value"),i=n.ColorAttachment,a=n.DepthAttachment,o=function(t,e,r){this.context=t,this.width=e,this.height=r;var n=t.gl,o=this.framebuffer=n.createFramebuffer();this.colorAttachment=new i(t,o),this.depthAttachment=new a(t,o)};o.prototype.destroy=function(){var t=this.context.gl,e=this.colorAttachment.get();e&&t.deleteTexture(e);var r=this.depthAttachment.get();r&&t.deleteRenderbuffer(r),t.deleteFramebuffer(this.framebuffer)},e.exports=o},{"./value":71}],69:[function(t,e,r){var n=function(t,e,r){this.context=t;var n=t.gl;this.buffer=n.createBuffer(),this.dynamicDraw=Boolean(r),this.unbindVAO(),t.bindElementBuffer.set(this.buffer),n.bufferData(n.ELEMENT_ARRAY_BUFFER,e.arrayBuffer,this.dynamicDraw?n.DYNAMIC_DRAW:n.STATIC_DRAW),this.dynamicDraw||delete e.arrayBuffer};n.prototype.unbindVAO=function(){this.context.extVertexArrayObject&&this.context.bindVertexArrayOES.set(null)},n.prototype.bind=function(){this.context.bindElementBuffer.set(this.buffer)},n.prototype.updateData=function(t){var e=this.context.gl;this.unbindVAO(),this.bind(),e.bufferSubData(e.ELEMENT_ARRAY_BUFFER,0,t.arrayBuffer)},n.prototype.destroy=function(){var t=this.context.gl;this.buffer&&(t.deleteBuffer(this.buffer),delete this.buffer)},e.exports=n},{}],70:[function(t,e,r){var n=function(t,e,r,n,i,a){this.test=t,this.ref=e,this.mask=r,this.fail=n,this.depthFail=i,this.pass=a};n.disabled=new n({func:519,mask:0},0,0,7680,7680,7680),e.exports=n},{}],71:[function(t,e,r){var n=t("../style-spec/util/color"),i=t("../util/util"),a=function(t){this.context=t,this.current=n.transparent};a.prototype.get=function(){return this.current},a.prototype.set=function(t){var e=this.current;t.r===e.r&&t.g===e.g&&t.b===e.b&&t.a===e.a||(this.context.gl.clearColor(t.r,t.g,t.b,t.a),this.current=t)};var o=function(t){this.context=t,this.current=1};o.prototype.get=function(){return this.current},o.prototype.set=function(t){this.current!==t&&(this.context.gl.clearDepth(t),this.current=t)};var s=function(t){this.context=t,this.current=0};s.prototype.get=function(){return this.current},s.prototype.set=function(t){this.current!==t&&(this.context.gl.clearStencil(t),this.current=t)};var l=function(t){this.context=t,this.current=[!0,!0,!0,!0]};l.prototype.get=function(){return this.current},l.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]||(this.context.gl.colorMask(t[0],t[1],t[2],t[3]),this.current=t)};var c=function(t){this.context=t,this.current=!0};c.prototype.get=function(){return this.current},c.prototype.set=function(t){this.current!==t&&(this.context.gl.depthMask(t),this.current=t)};var u=function(t){this.context=t,this.current=255};u.prototype.get=function(){return this.current},u.prototype.set=function(t){this.current!==t&&(this.context.gl.stencilMask(t),this.current=t)};var f=function(t){this.context=t,this.current={func:t.gl.ALWAYS,ref:0,mask:255}};f.prototype.get=function(){return this.current},f.prototype.set=function(t){var e=this.current;t.func===e.func&&t.ref===e.ref&&t.mask===e.mask||(this.context.gl.stencilFunc(t.func,t.ref,t.mask),this.current=t)};var h=function(t){this.context=t;var e=this.context.gl;this.current=[e.KEEP,e.KEEP,e.KEEP]};h.prototype.get=function(){return this.current},h.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]||(this.context.gl.stencilOp(t[0],t[1],t[2]),this.current=t)};var p=function(t){this.context=t,this.current=!1};p.prototype.get=function(){return this.current},p.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.STENCIL_TEST):e.disable(e.STENCIL_TEST),this.current=t}};var d=function(t){this.context=t,this.current=[0,1]};d.prototype.get=function(){return this.current},d.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]||(this.context.gl.depthRange(t[0],t[1]),this.current=t)};var g=function(t){this.context=t,this.current=!1};g.prototype.get=function(){return this.current},g.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.DEPTH_TEST):e.disable(e.DEPTH_TEST),this.current=t}};var m=function(t){this.context=t,this.current=t.gl.LESS};m.prototype.get=function(){return this.current},m.prototype.set=function(t){this.current!==t&&(this.context.gl.depthFunc(t),this.current=t)};var v=function(t){this.context=t,this.current=!1};v.prototype.get=function(){return this.current},v.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;t?e.enable(e.BLEND):e.disable(e.BLEND),this.current=t}};var y=function(t){this.context=t;var e=this.context.gl;this.current=[e.ONE,e.ZERO]};y.prototype.get=function(){return this.current},y.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]||(this.context.gl.blendFunc(t[0],t[1]),this.current=t)};var x=function(t){this.context=t,this.current=n.transparent};x.prototype.get=function(){return this.current},x.prototype.set=function(t){var e=this.current;t.r===e.r&&t.g===e.g&&t.b===e.b&&t.a===e.a||(this.context.gl.blendColor(t.r,t.g,t.b,t.a),this.current=t)};var b=function(t){this.context=t,this.current=null};b.prototype.get=function(){return this.current},b.prototype.set=function(t){this.current!==t&&(this.context.gl.useProgram(t),this.current=t)};var _=function(t){this.context=t,this.current=1};_.prototype.get=function(){return this.current},_.prototype.set=function(t){var e=this.context.lineWidthRange,r=i.clamp(t,e[0],e[1]);this.current!==r&&(this.context.gl.lineWidth(r),this.current=t)};var w=function(t){this.context=t,this.current=t.gl.TEXTURE0};w.prototype.get=function(){return this.current},w.prototype.set=function(t){this.current!==t&&(this.context.gl.activeTexture(t),this.current=t)};var k=function(t){this.context=t;var e=this.context.gl;this.current=[0,0,e.drawingBufferWidth,e.drawingBufferHeight]};k.prototype.get=function(){return this.current},k.prototype.set=function(t){var e=this.current;t[0]===e[0]&&t[1]===e[1]&&t[2]===e[2]&&t[3]===e[3]||(this.context.gl.viewport(t[0],t[1],t[2],t[3]),this.current=t)};var M=function(t){this.context=t,this.current=null};M.prototype.get=function(){return this.current},M.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindFramebuffer(e.FRAMEBUFFER,t),this.current=t}};var A=function(t){this.context=t,this.current=null};A.prototype.get=function(){return this.current},A.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindRenderbuffer(e.RENDERBUFFER,t),this.current=t}};var T=function(t){this.context=t,this.current=null};T.prototype.get=function(){return this.current},T.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindTexture(e.TEXTURE_2D,t),this.current=t}};var S=function(t){this.context=t,this.current=null};S.prototype.get=function(){return this.current},S.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.bindBuffer(e.ARRAY_BUFFER,t),this.current=t}};var C=function(t){this.context=t,this.current=null};C.prototype.get=function(){return this.current},C.prototype.set=function(t){var e=this.context.gl;e.bindBuffer(e.ELEMENT_ARRAY_BUFFER,t),this.current=t};var E=function(t){this.context=t,this.current=null};E.prototype.get=function(){return this.current},E.prototype.set=function(t){this.current!==t&&this.context.extVertexArrayObject&&(this.context.extVertexArrayObject.bindVertexArrayOES(t),this.current=t)};var L=function(t){this.context=t,this.current=4};L.prototype.get=function(){return this.current},L.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.pixelStorei(e.UNPACK_ALIGNMENT,t),this.current=t}};var z=function(t){this.context=t,this.current=!1};z.prototype.get=function(){return this.current},z.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL,t),this.current=t}};var P=function(t,e){this.context=t,this.current=null,this.parent=e};P.prototype.get=function(){return this.current};var D=function(t){function e(e,r){t.call(this,e,r),this.dirty=!1}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.set=function(t){if(this.dirty||this.current!==t){var e=this.context.gl;this.context.bindFramebuffer.set(this.parent),e.framebufferTexture2D(e.FRAMEBUFFER,e.COLOR_ATTACHMENT0,e.TEXTURE_2D,t,0),this.current=t,this.dirty=!1}},e.prototype.setDirty=function(){this.dirty=!0},e}(P),O=function(t){function e(){t.apply(this,arguments)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.set=function(t){if(this.current!==t){var e=this.context.gl;this.context.bindFramebuffer.set(this.parent),e.framebufferRenderbuffer(e.FRAMEBUFFER,e.DEPTH_ATTACHMENT,e.RENDERBUFFER,t),this.current=t}},e}(P);e.exports={ClearColor:a,ClearDepth:o,ClearStencil:s,ColorMask:l,DepthMask:c,StencilMask:u,StencilFunc:f,StencilOp:h,StencilTest:p,DepthRange:d,DepthTest:g,DepthFunc:m,Blend:v,BlendFunc:y,BlendColor:x,Program:b,LineWidth:_,ActiveTextureUnit:w,Viewport:k,BindFramebuffer:M,BindRenderbuffer:A,BindTexture:T,BindVertexBuffer:S,BindElementBuffer:C,BindVertexArrayOES:E,PixelStoreUnpack:L,PixelStoreUnpackPremultiplyAlpha:z,ColorAttachment:D,DepthAttachment:O}},{"../style-spec/util/color":153,"../util/util":275}],72:[function(t,e,r){var n={Int8:"BYTE",Uint8:"UNSIGNED_BYTE",Int16:"SHORT",Uint16:"UNSIGNED_SHORT",Int32:"INT",Uint32:"UNSIGNED_INT",Float32:"FLOAT"},i=function(t,e,r,n){this.length=e.length,this.attributes=r,this.itemSize=e.bytesPerElement,this.dynamicDraw=n,this.context=t;var i=t.gl;this.buffer=i.createBuffer(),t.bindVertexBuffer.set(this.buffer),i.bufferData(i.ARRAY_BUFFER,e.arrayBuffer,this.dynamicDraw?i.DYNAMIC_DRAW:i.STATIC_DRAW),this.dynamicDraw||delete e.arrayBuffer};i.prototype.bind=function(){this.context.bindVertexBuffer.set(this.buffer)},i.prototype.updateData=function(t){var e=this.context.gl;this.bind(),e.bufferSubData(e.ARRAY_BUFFER,0,t.arrayBuffer)},i.prototype.enableAttributes=function(t,e){for(var r=0;r":[24,[4,18,20,9,4,0]],"?":[18,[3,16,3,17,4,19,5,20,7,21,11,21,13,20,14,19,15,17,15,15,14,13,13,12,9,10,9,7,-1,-1,9,2,8,1,9,0,10,1,9,2]],"@":[27,[18,13,17,15,15,16,12,16,10,15,9,14,8,11,8,8,9,6,11,5,14,5,16,6,17,8,-1,-1,12,16,10,14,9,11,9,8,10,6,11,5,-1,-1,18,16,17,8,17,6,19,5,21,5,23,7,24,10,24,12,23,15,22,17,20,19,18,20,15,21,12,21,9,20,7,19,5,17,4,15,3,12,3,9,4,6,5,4,7,2,9,1,12,0,15,0,18,1,20,2,21,3,-1,-1,19,16,18,8,18,6,19,5]],A:[18,[9,21,1,0,-1,-1,9,21,17,0,-1,-1,4,7,14,7]],B:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,15,17,13,16,12,13,11,-1,-1,4,11,13,11,16,10,17,9,18,7,18,4,17,2,16,1,13,0,4,0]],C:[21,[18,16,17,18,15,20,13,21,9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5]],D:[21,[4,21,4,0,-1,-1,4,21,11,21,14,20,16,18,17,16,18,13,18,8,17,5,16,3,14,1,11,0,4,0]],E:[19,[4,21,4,0,-1,-1,4,21,17,21,-1,-1,4,11,12,11,-1,-1,4,0,17,0]],F:[18,[4,21,4,0,-1,-1,4,21,17,21,-1,-1,4,11,12,11]],G:[21,[18,16,17,18,15,20,13,21,9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,18,8,-1,-1,13,8,18,8]],H:[22,[4,21,4,0,-1,-1,18,21,18,0,-1,-1,4,11,18,11]],I:[8,[4,21,4,0]],J:[16,[12,21,12,5,11,2,10,1,8,0,6,0,4,1,3,2,2,5,2,7]],K:[21,[4,21,4,0,-1,-1,18,21,4,7,-1,-1,9,12,18,0]],L:[17,[4,21,4,0,-1,-1,4,0,16,0]],M:[24,[4,21,4,0,-1,-1,4,21,12,0,-1,-1,20,21,12,0,-1,-1,20,21,20,0]],N:[22,[4,21,4,0,-1,-1,4,21,18,0,-1,-1,18,21,18,0]],O:[22,[9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,19,8,19,13,18,16,17,18,15,20,13,21,9,21]],P:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,14,17,12,16,11,13,10,4,10]],Q:[22,[9,21,7,20,5,18,4,16,3,13,3,8,4,5,5,3,7,1,9,0,13,0,15,1,17,3,18,5,19,8,19,13,18,16,17,18,15,20,13,21,9,21,-1,-1,12,4,18,-2]],R:[21,[4,21,4,0,-1,-1,4,21,13,21,16,20,17,19,18,17,18,15,17,13,16,12,13,11,4,11,-1,-1,11,11,18,0]],S:[20,[17,18,15,20,12,21,8,21,5,20,3,18,3,16,4,14,5,13,7,12,13,10,15,9,16,8,17,6,17,3,15,1,12,0,8,0,5,1,3,3]],T:[16,[8,21,8,0,-1,-1,1,21,15,21]],U:[22,[4,21,4,6,5,3,7,1,10,0,12,0,15,1,17,3,18,6,18,21]],V:[18,[1,21,9,0,-1,-1,17,21,9,0]],W:[24,[2,21,7,0,-1,-1,12,21,7,0,-1,-1,12,21,17,0,-1,-1,22,21,17,0]],X:[20,[3,21,17,0,-1,-1,17,21,3,0]],Y:[18,[1,21,9,11,9,0,-1,-1,17,21,9,11]],Z:[20,[17,21,3,0,-1,-1,3,21,17,21,-1,-1,3,0,17,0]],"[":[14,[4,25,4,-7,-1,-1,5,25,5,-7,-1,-1,4,25,11,25,-1,-1,4,-7,11,-7]],"\\":[14,[0,21,14,-3]],"]":[14,[9,25,9,-7,-1,-1,10,25,10,-7,-1,-1,3,25,10,25,-1,-1,3,-7,10,-7]],"^":[16,[6,15,8,18,10,15,-1,-1,3,12,8,17,13,12,-1,-1,8,17,8,0]],_:[16,[0,-2,16,-2]],"`":[10,[6,21,5,20,4,18,4,16,5,15,6,16,5,17]],a:[19,[15,14,15,0,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],b:[19,[4,21,4,0,-1,-1,4,11,6,13,8,14,11,14,13,13,15,11,16,8,16,6,15,3,13,1,11,0,8,0,6,1,4,3]],c:[18,[15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],d:[19,[15,21,15,0,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],e:[18,[3,8,15,8,15,10,14,12,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],f:[12,[10,21,8,21,6,20,5,17,5,0,-1,-1,2,14,9,14]],g:[19,[15,14,15,-2,14,-5,13,-6,11,-7,8,-7,6,-6,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],h:[19,[4,21,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0]],i:[8,[3,21,4,20,5,21,4,22,3,21,-1,-1,4,14,4,0]],j:[10,[5,21,6,20,7,21,6,22,5,21,-1,-1,6,14,6,-3,5,-6,3,-7,1,-7]],k:[17,[4,21,4,0,-1,-1,14,14,4,4,-1,-1,8,8,15,0]],l:[8,[4,21,4,0]],m:[30,[4,14,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0,-1,-1,15,10,18,13,20,14,23,14,25,13,26,10,26,0]],n:[19,[4,14,4,0,-1,-1,4,10,7,13,9,14,12,14,14,13,15,10,15,0]],o:[19,[8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3,16,6,16,8,15,11,13,13,11,14,8,14]],p:[19,[4,14,4,-7,-1,-1,4,11,6,13,8,14,11,14,13,13,15,11,16,8,16,6,15,3,13,1,11,0,8,0,6,1,4,3]],q:[19,[15,14,15,-7,-1,-1,15,11,13,13,11,14,8,14,6,13,4,11,3,8,3,6,4,3,6,1,8,0,11,0,13,1,15,3]],r:[13,[4,14,4,0,-1,-1,4,8,5,11,7,13,9,14,12,14]],s:[17,[14,11,13,13,10,14,7,14,4,13,3,11,4,9,6,8,11,7,13,6,14,4,14,3,13,1,10,0,7,0,4,1,3,3]],t:[12,[5,21,5,4,6,1,8,0,10,0,-1,-1,2,14,9,14]],u:[19,[4,14,4,4,5,1,7,0,10,0,12,1,15,4,-1,-1,15,14,15,0]],v:[16,[2,14,8,0,-1,-1,14,14,8,0]],w:[22,[3,14,7,0,-1,-1,11,14,7,0,-1,-1,11,14,15,0,-1,-1,19,14,15,0]],x:[17,[3,14,14,0,-1,-1,14,14,3,0]],y:[16,[2,14,8,0,-1,-1,14,14,8,0,6,-4,4,-6,2,-7,1,-7]],z:[17,[14,14,3,0,-1,-1,3,14,14,14,-1,-1,3,0,14,0]],"{":[14,[9,25,7,24,6,23,5,21,5,19,6,17,7,16,8,14,8,12,6,10,-1,-1,7,24,6,22,6,20,7,18,8,17,9,15,9,13,8,11,4,9,8,7,9,5,9,3,8,1,7,0,6,-2,6,-4,7,-6,-1,-1,6,8,8,6,8,4,7,2,6,1,5,-1,5,-3,6,-5,7,-6,9,-7]],"|":[8,[4,25,4,-7]],"}":[14,[5,25,7,24,8,23,9,21,9,19,8,17,7,16,6,14,6,12,8,10,-1,-1,7,24,8,22,8,20,7,18,6,17,5,15,5,13,6,11,10,9,6,7,5,5,5,3,6,1,7,0,8,-2,8,-4,7,-6,-1,-1,8,8,6,6,6,4,7,2,8,1,9,-1,9,-3,8,-5,7,-6,5,-7]],"~":[24,[3,6,3,8,4,11,6,12,8,12,10,11,14,8,16,7,18,7,20,8,21,10,-1,-1,3,8,4,10,6,11,8,11,10,10,14,7,16,6,18,6,20,7,21,10,21,12]]}},{"../data/array_types":39,"../data/extent":53,"../data/pos_attributes":57,"../gl/depth_mode":67,"../gl/stencil_mode":70,"../util/browser":252,"./vertex_array_object":95,"@mapbox/gl-matrix":2}],78:[function(t,e,r){function n(t,e,r,n,i){if(!s.isPatternMissing(r.paint.get("fill-pattern"),t))for(var a=!0,o=0,l=n;o0){var l=o.now(),c=(l-t.timeAdded)/s,u=e?(l-e.timeAdded)/s:-1,f=r.getSource(),h=a.coveringZoomLevel({tileSize:f.tileSize,roundZoom:f.roundZoom}),p=!e||Math.abs(e.tileID.overscaledZ-h)>Math.abs(t.tileID.overscaledZ-h),d=p&&t.refreshedUponExpiration?1:i.clamp(p?c:1-u,0,1);return t.refreshedUponExpiration&&c>=1&&(t.refreshedUponExpiration=!1),e?{opacity:1,mix:1-d}:{opacity:d,mix:0}}return{opacity:1,mix:0}}var i=t("../util/util"),a=t("../source/image_source"),o=t("../util/browser"),s=t("../gl/stencil_mode"),l=t("../gl/depth_mode");e.exports=function(t,e,r,i){if("translucent"===t.renderPass&&0!==r.paint.get("raster-opacity")){var o=t.context,c=o.gl,u=e.getSource(),f=t.useProgram("raster");o.setStencilMode(s.disabled),o.setColorMode(t.colorModeForRenderPass()),c.uniform1f(f.uniforms.u_brightness_low,r.paint.get("raster-brightness-min")),c.uniform1f(f.uniforms.u_brightness_high,r.paint.get("raster-brightness-max")),c.uniform1f(f.uniforms.u_saturation_factor,function(t){return t>0?1-1/(1.001-t):-t}(r.paint.get("raster-saturation"))),c.uniform1f(f.uniforms.u_contrast_factor,function(t){return t>0?1/(1-t):1+t}(r.paint.get("raster-contrast"))),c.uniform3fv(f.uniforms.u_spin_weights,function(t){t*=Math.PI/180;var e=Math.sin(t),r=Math.cos(t);return[(2*r+1)/3,(-Math.sqrt(3)*e-r+1)/3,(Math.sqrt(3)*e-r+1)/3]}(r.paint.get("raster-hue-rotate"))),c.uniform1f(f.uniforms.u_buffer_scale,1),c.uniform1i(f.uniforms.u_image0,0),c.uniform1i(f.uniforms.u_image1,1);for(var h=i.length&&i[0].overscaledZ,p=0,d=i;p65535)e(new Error("glyphs > 65535 not supported"));else{var c=o.requests[l];c||(c=o.requests[l]=[],n(i,l,r.url,r.requestTransform,function(t,e){if(e)for(var r in e)o.glyphs[+r]=e[+r];for(var n=0,i=c;nthis.height)return n.warnOnce("LineAtlas out of space"),null;for(var o=0,s=0;s=0;this.currentLayer--){var m=r.style._layers[o[r.currentLayer]];m.source!==(d&&d.id)&&(g=[],(d=r.style.sourceCaches[m.source])&&(r.clearStencil(),g=d.getVisibleCoordinates(),d.getSource().isTileClipped&&r._renderTileClippingMasks(g))),r.renderLayer(r,d,m,g)}this.renderPass="translucent";var v,y=[];for(this.currentLayer=0,this.currentLayer;this.currentLayer0?e.pop():null},T.prototype._createProgramCached=function(t,e){this.cache=this.cache||{};var r=""+t+(e.cacheKey||"")+(this._showOverdrawInspector?"/overdraw":"");return this.cache[r]||(this.cache[r]=new y(this.context,v[t],e,this._showOverdrawInspector)),this.cache[r]},T.prototype.useProgram=function(t,e){var r=this._createProgramCached(t,e||this.emptyProgramConfiguration);return this.context.program.set(r.program),r},e.exports=T},{"../data/array_types":39,"../data/extent":53,"../data/pos_attributes":57,"../data/program_configuration":58,"../data/raster_bounds_attributes":59,"../gl/color_mode":65,"../gl/context":66,"../gl/depth_mode":67,"../gl/stencil_mode":70,"../shaders":97,"../source/pixels_to_tile_units":104,"../source/source_cache":111,"../style-spec/util/color":153,"../symbol/cross_tile_symbol_index":218,"../util/browser":252,"../util/util":275,"./draw_background":74,"./draw_circle":75,"./draw_debug":77,"./draw_fill":78,"./draw_fill_extrusion":79,"./draw_heatmap":80,"./draw_hillshade":81,"./draw_line":82,"./draw_raster":83,"./draw_symbol":84,"./program":92,"./texture":93,"./tile_mask":94,"./vertex_array_object":95,"@mapbox/gl-matrix":2}],91:[function(t,e,r){var n=t("../source/pixels_to_tile_units");r.isPatternMissing=function(t,e){if(!t)return!1;var r=e.imageManager.getPattern(t.from),n=e.imageManager.getPattern(t.to);return!r||!n},r.prepare=function(t,e,r){var n=e.context,i=n.gl,a=e.imageManager.getPattern(t.from),o=e.imageManager.getPattern(t.to);i.uniform1i(r.uniforms.u_image,0),i.uniform2fv(r.uniforms.u_pattern_tl_a,a.tl),i.uniform2fv(r.uniforms.u_pattern_br_a,a.br),i.uniform2fv(r.uniforms.u_pattern_tl_b,o.tl),i.uniform2fv(r.uniforms.u_pattern_br_b,o.br);var s=e.imageManager.getPixelSize(),l=s.width,c=s.height;i.uniform2fv(r.uniforms.u_texsize,[l,c]),i.uniform1f(r.uniforms.u_mix,t.t),i.uniform2fv(r.uniforms.u_pattern_size_a,a.displaySize),i.uniform2fv(r.uniforms.u_pattern_size_b,o.displaySize),i.uniform1f(r.uniforms.u_scale_a,t.fromScale),i.uniform1f(r.uniforms.u_scale_b,t.toScale),n.activeTexture.set(i.TEXTURE0),e.imageManager.bind(e.context)},r.setTile=function(t,e,r){var i=e.context.gl;i.uniform1f(r.uniforms.u_tile_units_to_pixels,1/n(t,1,e.transform.tileZoom));var a=Math.pow(2,t.tileID.overscaledZ),o=t.tileSize*Math.pow(2,e.transform.tileZoom)/a,s=o*(t.tileID.canonical.x+t.tileID.wrap*a),l=o*t.tileID.canonical.y;i.uniform2f(r.uniforms.u_pixel_coord_upper,s>>16,l>>16),i.uniform2f(r.uniforms.u_pixel_coord_lower,65535&s,65535&l)}},{"../source/pixels_to_tile_units":104}],92:[function(t,e,r){var n=t("../util/browser"),i=t("../shaders"),a=(t("../data/program_configuration").ProgramConfiguration,t("./vertex_array_object")),o=(t("../gl/context"),function(t,e,r,a){var o=this,s=t.gl;this.program=s.createProgram();var l=r.defines().concat("#define DEVICE_PIXEL_RATIO "+n.devicePixelRatio.toFixed(1));a&&l.push("#define OVERDRAW_INSPECTOR;");var c=l.concat(i.prelude.fragmentSource,e.fragmentSource).join("\n"),u=l.concat(i.prelude.vertexSource,e.vertexSource).join("\n"),f=s.createShader(s.FRAGMENT_SHADER);s.shaderSource(f,c),s.compileShader(f),s.attachShader(this.program,f);var h=s.createShader(s.VERTEX_SHADER);s.shaderSource(h,u),s.compileShader(h),s.attachShader(this.program,h);for(var p=r.layoutAttributes||[],d=0;d 0.5) {\n gl_FragColor = vec4(0.0, 0.0, 1.0, 0.5) * alpha;\n }\n\n if (v_notUsed > 0.5) {\n // This box not used, fade it out\n gl_FragColor *= .1;\n }\n}",vertexSource:"attribute vec2 a_pos;\nattribute vec2 a_anchor_pos;\nattribute vec2 a_extrude;\nattribute vec2 a_placed;\n\nuniform mat4 u_matrix;\nuniform vec2 u_extrude_scale;\nuniform float u_camera_to_center_distance;\n\nvarying float v_placed;\nvarying float v_notUsed;\n\nvoid main() {\n vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n highp float collision_perspective_ratio = 0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance);\n\n gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);\n gl_Position.xy += a_extrude * u_extrude_scale * gl_Position.w * collision_perspective_ratio;\n\n v_placed = a_placed.x;\n v_notUsed = a_placed.y;\n}\n"},collisionCircle:{fragmentSource:"\nvarying float v_placed;\nvarying float v_notUsed;\nvarying float v_radius;\nvarying vec2 v_extrude;\nvarying vec2 v_extrude_scale;\n\nvoid main() {\n float alpha = 0.5;\n\n // Red = collision, hide label\n vec4 color = vec4(1.0, 0.0, 0.0, 1.0) * alpha;\n\n // Blue = no collision, label is showing\n if (v_placed > 0.5) {\n color = vec4(0.0, 0.0, 1.0, 0.5) * alpha;\n }\n\n if (v_notUsed > 0.5) {\n // This box not used, fade it out\n color *= .2;\n }\n\n float extrude_scale_length = length(v_extrude_scale);\n float extrude_length = length(v_extrude) * extrude_scale_length;\n float stroke_width = 15.0 * extrude_scale_length;\n float radius = v_radius * extrude_scale_length;\n\n float distance_to_edge = abs(extrude_length - radius);\n float opacity_t = smoothstep(-stroke_width, 0.0, -distance_to_edge);\n\n gl_FragColor = opacity_t * color;\n}\n",vertexSource:"attribute vec2 a_pos;\nattribute vec2 a_anchor_pos;\nattribute vec2 a_extrude;\nattribute vec2 a_placed;\n\nuniform mat4 u_matrix;\nuniform vec2 u_extrude_scale;\nuniform float u_camera_to_center_distance;\n\nvarying float v_placed;\nvarying float v_notUsed;\nvarying float v_radius;\n\nvarying vec2 v_extrude;\nvarying vec2 v_extrude_scale;\n\nvoid main() {\n vec4 projectedPoint = u_matrix * vec4(a_anchor_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n highp float collision_perspective_ratio = 0.5 + 0.5 * (u_camera_to_center_distance / camera_to_anchor_distance);\n\n gl_Position = u_matrix * vec4(a_pos, 0.0, 1.0);\n\n highp float padding_factor = 1.2; // Pad the vertices slightly to make room for anti-alias blur\n gl_Position.xy += a_extrude * u_extrude_scale * padding_factor * gl_Position.w * collision_perspective_ratio;\n\n v_placed = a_placed.x;\n v_notUsed = a_placed.y;\n v_radius = abs(a_extrude.y); // We don't pitch the circles, so both units of the extrusion vector are equal in magnitude to the radius\n\n v_extrude = a_extrude * padding_factor;\n v_extrude_scale = u_extrude_scale * u_camera_to_center_distance * collision_perspective_ratio;\n}\n"},debug:{fragmentSource:"uniform highp vec4 u_color;\n\nvoid main() {\n gl_FragColor = u_color;\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n}\n"},fill:{fragmentSource:"#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float opacity\n\n gl_FragColor = color * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n}\n"},fillOutline:{fragmentSource:"#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_pos;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 outline_color\n #pragma mapbox: initialize lowp float opacity\n\n float dist = length(v_pos - gl_FragCoord.xy);\n float alpha = 1.0 - smoothstep(0.0, 1.0, dist);\n gl_FragColor = outline_color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"attribute vec2 a_pos;\n\nuniform mat4 u_matrix;\nuniform vec2 u_world;\n\nvarying vec2 v_pos;\n\n#pragma mapbox: define highp vec4 outline_color\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 outline_color\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;\n}\n"},fillOutlinePattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec2 v_pos;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n // find distance to outline for alpha interpolation\n\n float dist = length(v_pos - gl_FragCoord.xy);\n float alpha = 1.0 - smoothstep(0.0, 1.0, dist);\n\n\n gl_FragColor = mix(color1, color2, u_mix) * alpha * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_world;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\n\nattribute vec2 a_pos;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec2 v_pos;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, a_pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);\n\n v_pos = (gl_Position.xy / gl_Position.w + 1.0) / 2.0 * u_world;\n}\n"},fillPattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n gl_FragColor = mix(color1, color2, u_mix) * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\n\nattribute vec2 a_pos;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\n\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, a_pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, a_pos);\n}\n"},fillExtrusion:{fragmentSource:"varying vec4 v_color;\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n#pragma mapbox: define highp vec4 color\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n #pragma mapbox: initialize highp vec4 color\n\n gl_FragColor = v_color;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec3 u_lightcolor;\nuniform lowp vec3 u_lightpos;\nuniform lowp float u_lightintensity;\n\nattribute vec2 a_pos;\nattribute vec4 a_normal_ed;\n\nvarying vec4 v_color;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\n#pragma mapbox: define highp vec4 color\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n #pragma mapbox: initialize highp vec4 color\n\n vec3 normal = a_normal_ed.xyz;\n\n base = max(0.0, base);\n height = max(0.0, height);\n\n float t = mod(normal.x, 2.0);\n\n gl_Position = u_matrix * vec4(a_pos, t > 0.0 ? height : base, 1);\n\n // Relative luminance (how dark/bright is the surface color?)\n float colorvalue = color.r * 0.2126 + color.g * 0.7152 + color.b * 0.0722;\n\n v_color = vec4(0.0, 0.0, 0.0, 1.0);\n\n // Add slight ambient lighting so no extrusions are totally black\n vec4 ambientlight = vec4(0.03, 0.03, 0.03, 1.0);\n color += ambientlight;\n\n // Calculate cos(theta), where theta is the angle between surface normal and diffuse light ray\n float directional = clamp(dot(normal / 16384.0, u_lightpos), 0.0, 1.0);\n\n // Adjust directional so that\n // the range of values for highlight/shading is narrower\n // with lower light intensity\n // and with lighter/brighter surface colors\n directional = mix((1.0 - u_lightintensity), max((1.0 - colorvalue + u_lightintensity), 1.0), directional);\n\n // Add gradient along z axis of side surfaces\n if (normal.y != 0.0) {\n directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);\n }\n\n // Assign final color based on surface + ambient light color, diffuse light directional, and light color\n // with lower bounds adjusted to hue of light\n // so that shading is tinted with the complementary (opposite) color to the light color\n v_color.r += clamp(color.r * directional * u_lightcolor.r, mix(0.0, 0.3, 1.0 - u_lightcolor.r), 1.0);\n v_color.g += clamp(color.g * directional * u_lightcolor.g, mix(0.0, 0.3, 1.0 - u_lightcolor.g), 1.0);\n v_color.b += clamp(color.b * directional * u_lightcolor.b, mix(0.0, 0.3, 1.0 - u_lightcolor.b), 1.0);\n}\n"},fillExtrusionPattern:{fragmentSource:"uniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_mix;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec4 v_lighting;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n\n vec2 imagecoord = mod(v_pos_a, 1.0);\n vec2 pos = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, imagecoord);\n vec4 color1 = texture2D(u_image, pos);\n\n vec2 imagecoord_b = mod(v_pos_b, 1.0);\n vec2 pos2 = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, imagecoord_b);\n vec4 color2 = texture2D(u_image, pos2);\n\n vec4 mixedColor = mix(color1, color2, u_mix);\n\n gl_FragColor = mixedColor * v_lighting;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pixel_coord_upper;\nuniform vec2 u_pixel_coord_lower;\nuniform float u_scale_a;\nuniform float u_scale_b;\nuniform float u_tile_units_to_pixels;\nuniform float u_height_factor;\n\nuniform vec3 u_lightcolor;\nuniform lowp vec3 u_lightpos;\nuniform lowp float u_lightintensity;\n\nattribute vec2 a_pos;\nattribute vec4 a_normal_ed;\n\nvarying vec2 v_pos_a;\nvarying vec2 v_pos_b;\nvarying vec4 v_lighting;\nvarying float v_directional;\n\n#pragma mapbox: define lowp float base\n#pragma mapbox: define lowp float height\n\nvoid main() {\n #pragma mapbox: initialize lowp float base\n #pragma mapbox: initialize lowp float height\n\n vec3 normal = a_normal_ed.xyz;\n float edgedistance = a_normal_ed.w;\n\n base = max(0.0, base);\n height = max(0.0, height);\n\n float t = mod(normal.x, 2.0);\n float z = t > 0.0 ? height : base;\n\n gl_Position = u_matrix * vec4(a_pos, z, 1);\n\n vec2 pos = normal.x == 1.0 && normal.y == 0.0 && normal.z == 16384.0\n ? a_pos // extrusion top\n : vec2(edgedistance, z * u_height_factor); // extrusion side\n\n v_pos_a = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_a * u_pattern_size_a, u_tile_units_to_pixels, pos);\n v_pos_b = get_pattern_pos(u_pixel_coord_upper, u_pixel_coord_lower, u_scale_b * u_pattern_size_b, u_tile_units_to_pixels, pos);\n\n v_lighting = vec4(0.0, 0.0, 0.0, 1.0);\n float directional = clamp(dot(normal / 16383.0, u_lightpos), 0.0, 1.0);\n directional = mix((1.0 - u_lightintensity), max((0.5 + u_lightintensity), 1.0), directional);\n\n if (normal.y != 0.0) {\n directional *= clamp((t + base) * pow(height / 150.0, 0.5), mix(0.7, 0.98, 1.0 - u_lightintensity), 1.0);\n }\n\n v_lighting.rgb += clamp(directional * u_lightcolor, mix(vec3(0.0), vec3(0.3), 1.0 - u_lightcolor), vec3(1.0));\n}\n"},extrusionTexture:{fragmentSource:"uniform sampler2D u_image;\nuniform float u_opacity;\nvarying vec2 v_pos;\n\nvoid main() {\n gl_FragColor = texture2D(u_image, v_pos) * u_opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(0.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_world;\nattribute vec2 a_pos;\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos * u_world, 0, 1);\n\n v_pos.x = a_pos.x;\n v_pos.y = 1.0 - a_pos.y;\n}\n"},hillshadePrepare:{fragmentSource:"#ifdef GL_ES\nprecision highp float;\n#endif\n\nuniform sampler2D u_image;\nvarying vec2 v_pos;\nuniform vec2 u_dimension;\nuniform float u_zoom;\n\nfloat getElevation(vec2 coord, float bias) {\n // Convert encoded elevation value to meters\n vec4 data = texture2D(u_image, coord) * 255.0;\n return (data.r + data.g * 256.0 + data.b * 256.0 * 256.0) / 4.0;\n}\n\nvoid main() {\n vec2 epsilon = 1.0 / u_dimension;\n\n // queried pixels:\n // +-----------+\n // | | | |\n // | a | b | c |\n // | | | |\n // +-----------+\n // | | | |\n // | d | e | f |\n // | | | |\n // +-----------+\n // | | | |\n // | g | h | i |\n // | | | |\n // +-----------+\n\n float a = getElevation(v_pos + vec2(-epsilon.x, -epsilon.y), 0.0);\n float b = getElevation(v_pos + vec2(0, -epsilon.y), 0.0);\n float c = getElevation(v_pos + vec2(epsilon.x, -epsilon.y), 0.0);\n float d = getElevation(v_pos + vec2(-epsilon.x, 0), 0.0);\n float e = getElevation(v_pos, 0.0);\n float f = getElevation(v_pos + vec2(epsilon.x, 0), 0.0);\n float g = getElevation(v_pos + vec2(-epsilon.x, epsilon.y), 0.0);\n float h = getElevation(v_pos + vec2(0, epsilon.y), 0.0);\n float i = getElevation(v_pos + vec2(epsilon.x, epsilon.y), 0.0);\n\n // here we divide the x and y slopes by 8 * pixel size\n // where pixel size (aka meters/pixel) is:\n // circumference of the world / (pixels per tile * number of tiles)\n // which is equivalent to: 8 * 40075016.6855785 / (512 * pow(2, u_zoom))\n // which can be reduced to: pow(2, 19.25619978527 - u_zoom)\n // we want to vertically exaggerate the hillshading though, because otherwise\n // it is barely noticeable at low zooms. to do this, we multiply this by some\n // scale factor pow(2, (u_zoom - 14) * a) where a is an arbitrary value and 14 is the\n // maxzoom of the tile source. here we use a=0.3 which works out to the\n // expression below. see nickidlugash's awesome breakdown for more info\n // https://github.com/mapbox/mapbox-gl-js/pull/5286#discussion_r148419556\n float exaggeration = u_zoom < 2.0 ? 0.4 : u_zoom < 4.5 ? 0.35 : 0.3;\n\n vec2 deriv = vec2(\n (c + f + f + i) - (a + d + d + g),\n (g + h + h + i) - (a + b + b + c)\n ) / pow(2.0, (u_zoom - 14.0) * exaggeration + 19.2562 - u_zoom);\n\n gl_FragColor = clamp(vec4(\n deriv.x / 2.0 + 0.5,\n deriv.y / 2.0 + 0.5,\n 1.0,\n 1.0), 0.0, 1.0);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = (a_texture_pos / 8192.0) / 2.0 + 0.25;\n}\n"},hillshade:{fragmentSource:"uniform sampler2D u_image;\nvarying vec2 v_pos;\n\nuniform vec2 u_latrange;\nuniform vec2 u_light;\nuniform vec4 u_shadow;\nuniform vec4 u_highlight;\nuniform vec4 u_accent;\n\n#define PI 3.141592653589793\n\nvoid main() {\n vec4 pixel = texture2D(u_image, v_pos);\n\n vec2 deriv = ((pixel.rg * 2.0) - 1.0);\n\n // We divide the slope by a scale factor based on the cosin of the pixel's approximate latitude\n // to account for mercator projection distortion. see #4807 for details\n float scaleFactor = cos(radians((u_latrange[0] - u_latrange[1]) * (1.0 - v_pos.y) + u_latrange[1]));\n // We also multiply the slope by an arbitrary z-factor of 1.25\n float slope = atan(1.25 * length(deriv) / scaleFactor);\n float aspect = deriv.x != 0.0 ? atan(deriv.y, -deriv.x) : PI / 2.0 * (deriv.y > 0.0 ? 1.0 : -1.0);\n\n float intensity = u_light.x;\n // We add PI to make this property match the global light object, which adds PI/2 to the light's azimuthal\n // position property to account for 0deg corresponding to north/the top of the viewport in the style spec\n // and the original shader was written to accept (-illuminationDirection - 90) as the azimuthal.\n float azimuth = u_light.y + PI;\n\n // We scale the slope exponentially based on intensity, using a calculation similar to\n // the exponential interpolation function in the style spec:\n // https://github.com/mapbox/mapbox-gl-js/blob/master/src/style-spec/expression/definitions/interpolate.js#L217-L228\n // so that higher intensity values create more opaque hillshading.\n float base = 1.875 - intensity * 1.75;\n float maxValue = 0.5 * PI;\n float scaledSlope = intensity != 0.5 ? ((pow(base, slope) - 1.0) / (pow(base, maxValue) - 1.0)) * maxValue : slope;\n\n // The accent color is calculated with the cosine of the slope while the shade color is calculated with the sine\n // so that the accent color's rate of change eases in while the shade color's eases out.\n float accent = cos(scaledSlope);\n // We multiply both the accent and shade color by a clamped intensity value\n // so that intensities >= 0.5 do not additionally affect the color values\n // while intensity values < 0.5 make the overall color more transparent.\n vec4 accent_color = (1.0 - accent) * u_accent * clamp(intensity * 2.0, 0.0, 1.0);\n float shade = abs(mod((aspect + azimuth) / PI + 0.5, 2.0) - 1.0);\n vec4 shade_color = mix(u_shadow, u_highlight, shade) * sin(scaledSlope) * clamp(intensity * 2.0, 0.0, 1.0);\n gl_FragColor = accent_color * (1.0 - shade_color.a) + shade_color;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n v_pos = a_texture_pos / 8192.0;\n}\n"},line:{fragmentSource:"#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_width2;\nvarying vec2 v_normal;\nvarying float v_gamma_scale;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n gl_FragColor = color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\n// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float width\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist = outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_width2 = vec2(outset, inset);\n}\n"},linePattern:{fragmentSource:"uniform vec2 u_pattern_size_a;\nuniform vec2 u_pattern_size_b;\nuniform vec2 u_pattern_tl_a;\nuniform vec2 u_pattern_br_a;\nuniform vec2 u_pattern_tl_b;\nuniform vec2 u_pattern_br_b;\nuniform vec2 u_texsize;\nuniform float u_fade;\n\nuniform sampler2D u_image;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_linesofar;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n\nvoid main() {\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n float x_a = mod(v_linesofar / u_pattern_size_a.x, 1.0);\n float x_b = mod(v_linesofar / u_pattern_size_b.x, 1.0);\n float y_a = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_a.y);\n float y_b = 0.5 + (v_normal.y * v_width2.s / u_pattern_size_b.y);\n vec2 pos_a = mix(u_pattern_tl_a / u_texsize, u_pattern_br_a / u_texsize, vec2(x_a, y_a));\n vec2 pos_b = mix(u_pattern_tl_b / u_texsize, u_pattern_br_b / u_texsize, vec2(x_b, y_b));\n\n vec4 color = mix(texture2D(u_image, pos_a), texture2D(u_image, pos_b), u_fade);\n\n gl_FragColor = color * alpha * opacity;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\n// We scale the distance before adding it to the buffers so that we can store\n// long distances for long segments. Use this value to unscale the distance.\n#define LINE_DISTANCE_SCALE 2.0\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying float v_linesofar;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define mediump float width\n\nvoid main() {\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize mediump float width\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n float a_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * LINE_DISTANCE_SCALE;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist = outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_linesofar = a_linesofar;\n v_width2 = vec2(outset, inset);\n}\n"},lineSDF:{fragmentSource:"\nuniform sampler2D u_image;\nuniform float u_sdfgamma;\nuniform float u_mix;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying vec2 v_tex_a;\nvarying vec2 v_tex_b;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float width\n #pragma mapbox: initialize lowp float floorwidth\n\n // Calculate the distance of the pixel from the line in pixels.\n float dist = length(v_normal) * v_width2.s;\n\n // Calculate the antialiasing fade factor. This is either when fading in\n // the line in case of an offset line (v_width2.t) or when fading out\n // (v_width2.s)\n float blur2 = (blur + 1.0 / DEVICE_PIXEL_RATIO) * v_gamma_scale;\n float alpha = clamp(min(dist - (v_width2.t - blur2), v_width2.s - dist) / blur2, 0.0, 1.0);\n\n float sdfdist_a = texture2D(u_image, v_tex_a).a;\n float sdfdist_b = texture2D(u_image, v_tex_b).a;\n float sdfdist = mix(sdfdist_a, sdfdist_b, u_mix);\n alpha *= smoothstep(0.5 - u_sdfgamma / floorwidth, 0.5 + u_sdfgamma / floorwidth, sdfdist);\n\n gl_FragColor = color * (alpha * opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"// floor(127 / 2) == 63.0\n// the maximum allowed miter limit is 2.0 at the moment. the extrude normal is\n// stored in a byte (-128..127). we scale regular normals up to length 63, but\n// there are also \"special\" normals that have a bigger length (of up to 126 in\n// this case).\n// #define scale 63.0\n#define scale 0.015873016\n\n// We scale the distance before adding it to the buffers so that we can store\n// long distances for long segments. Use this value to unscale the distance.\n#define LINE_DISTANCE_SCALE 2.0\n\n// the distance over which the line edge fades out.\n// Retina devices need a smaller distance to avoid aliasing.\n#define ANTIALIASING 1.0 / DEVICE_PIXEL_RATIO / 2.0\n\nattribute vec4 a_pos_normal;\nattribute vec4 a_data;\n\nuniform mat4 u_matrix;\nuniform mediump float u_ratio;\nuniform vec2 u_patternscale_a;\nuniform float u_tex_y_a;\nuniform vec2 u_patternscale_b;\nuniform float u_tex_y_b;\nuniform vec2 u_gl_units_to_pixels;\n\nvarying vec2 v_normal;\nvarying vec2 v_width2;\nvarying vec2 v_tex_a;\nvarying vec2 v_tex_b;\nvarying float v_gamma_scale;\n\n#pragma mapbox: define highp vec4 color\n#pragma mapbox: define lowp float blur\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define mediump float gapwidth\n#pragma mapbox: define lowp float offset\n#pragma mapbox: define mediump float width\n#pragma mapbox: define lowp float floorwidth\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 color\n #pragma mapbox: initialize lowp float blur\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize mediump float gapwidth\n #pragma mapbox: initialize lowp float offset\n #pragma mapbox: initialize mediump float width\n #pragma mapbox: initialize lowp float floorwidth\n\n vec2 a_extrude = a_data.xy - 128.0;\n float a_direction = mod(a_data.z, 4.0) - 1.0;\n float a_linesofar = (floor(a_data.z / 4.0) + a_data.w * 64.0) * LINE_DISTANCE_SCALE;\n\n vec2 pos = a_pos_normal.xy;\n\n // x is 1 if it's a round cap, 0 otherwise\n // y is 1 if the normal points up, and -1 if it points down\n mediump vec2 normal = a_pos_normal.zw;\n v_normal = normal;\n\n // these transformations used to be applied in the JS and native code bases.\n // moved them into the shader for clarity and simplicity.\n gapwidth = gapwidth / 2.0;\n float halfwidth = width / 2.0;\n offset = -1.0 * offset;\n\n float inset = gapwidth + (gapwidth > 0.0 ? ANTIALIASING : 0.0);\n float outset = gapwidth + halfwidth * (gapwidth > 0.0 ? 2.0 : 1.0) + ANTIALIASING;\n\n // Scale the extrusion vector down to a normal and then up by the line width\n // of this vertex.\n mediump vec2 dist =outset * a_extrude * scale;\n\n // Calculate the offset when drawing a line that is to the side of the actual line.\n // We do this by creating a vector that points towards the extrude, but rotate\n // it when we're drawing round end points (a_direction = -1 or 1) since their\n // extrude vector points in another direction.\n mediump float u = 0.5 * a_direction;\n mediump float t = 1.0 - abs(u);\n mediump vec2 offset2 = offset * a_extrude * scale * normal.y * mat2(t, -u, u, t);\n\n vec4 projected_extrude = u_matrix * vec4(dist / u_ratio, 0.0, 0.0);\n gl_Position = u_matrix * vec4(pos + offset2 / u_ratio, 0.0, 1.0) + projected_extrude;\n\n // calculate how much the perspective view squishes or stretches the extrude\n float extrude_length_without_perspective = length(dist);\n float extrude_length_with_perspective = length(projected_extrude.xy / gl_Position.w * u_gl_units_to_pixels);\n v_gamma_scale = extrude_length_without_perspective / extrude_length_with_perspective;\n\n v_tex_a = vec2(a_linesofar * u_patternscale_a.x / floorwidth, normal.y * u_patternscale_a.y + u_tex_y_a);\n v_tex_b = vec2(a_linesofar * u_patternscale_b.x / floorwidth, normal.y * u_patternscale_b.y + u_tex_y_b);\n\n v_width2 = vec2(outset, inset);\n}\n"},raster:{fragmentSource:"uniform float u_fade_t;\nuniform float u_opacity;\nuniform sampler2D u_image0;\nuniform sampler2D u_image1;\nvarying vec2 v_pos0;\nvarying vec2 v_pos1;\n\nuniform float u_brightness_low;\nuniform float u_brightness_high;\n\nuniform float u_saturation_factor;\nuniform float u_contrast_factor;\nuniform vec3 u_spin_weights;\n\nvoid main() {\n\n // read and cross-fade colors from the main and parent tiles\n vec4 color0 = texture2D(u_image0, v_pos0);\n vec4 color1 = texture2D(u_image1, v_pos1);\n if (color0.a > 0.0) {\n color0.rgb = color0.rgb / color0.a;\n }\n if (color1.a > 0.0) {\n color1.rgb = color1.rgb / color1.a;\n }\n vec4 color = mix(color0, color1, u_fade_t);\n color.a *= u_opacity;\n vec3 rgb = color.rgb;\n\n // spin\n rgb = vec3(\n dot(rgb, u_spin_weights.xyz),\n dot(rgb, u_spin_weights.zxy),\n dot(rgb, u_spin_weights.yzx));\n\n // saturation\n float average = (color.r + color.g + color.b) / 3.0;\n rgb += (average - rgb) * u_saturation_factor;\n\n // contrast\n rgb = (rgb - 0.5) * u_contrast_factor + 0.5;\n\n // brightness\n vec3 u_high_vec = vec3(u_brightness_low, u_brightness_low, u_brightness_low);\n vec3 u_low_vec = vec3(u_brightness_high, u_brightness_high, u_brightness_high);\n\n gl_FragColor = vec4(mix(u_high_vec, u_low_vec, rgb) * color.a, color.a);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"uniform mat4 u_matrix;\nuniform vec2 u_tl_parent;\nuniform float u_scale_parent;\nuniform float u_buffer_scale;\n\nattribute vec2 a_pos;\nattribute vec2 a_texture_pos;\n\nvarying vec2 v_pos0;\nvarying vec2 v_pos1;\n\nvoid main() {\n gl_Position = u_matrix * vec4(a_pos, 0, 1);\n // We are using Int16 for texture position coordinates to give us enough precision for\n // fractional coordinates. We use 8192 to scale the texture coordinates in the buffer\n // as an arbitrarily high number to preserve adequate precision when rendering.\n // This is also the same value as the EXTENT we are using for our tile buffer pos coordinates,\n // so math for modifying either is consistent.\n v_pos0 = (((a_texture_pos / 8192.0) - 0.5) / u_buffer_scale ) + 0.5;\n v_pos1 = (v_pos0 * u_scale_parent) + u_tl_parent;\n}\n"},symbolIcon:{fragmentSource:"uniform sampler2D u_texture;\n\n#pragma mapbox: define lowp float opacity\n\nvarying vec2 v_tex;\nvarying float v_fade_opacity;\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n lowp float alpha = opacity * v_fade_opacity;\n gl_FragColor = texture2D(u_texture, v_tex) * alpha;\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"const float PI = 3.141592653589793;\n\nattribute vec4 a_pos_offset;\nattribute vec4 a_data;\nattribute vec3 a_projected_pos;\nattribute float a_fade_opacity;\n\nuniform bool u_is_size_zoom_constant;\nuniform bool u_is_size_feature_constant;\nuniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function\nuniform highp float u_size; // used when size is both zoom and feature constant\nuniform highp float u_camera_to_center_distance;\nuniform highp float u_pitch;\nuniform bool u_rotate_symbol;\nuniform highp float u_aspect_ratio;\nuniform float u_fade_change;\n\n#pragma mapbox: define lowp float opacity\n\nuniform mat4 u_matrix;\nuniform mat4 u_label_plane_matrix;\nuniform mat4 u_gl_coord_matrix;\n\nuniform bool u_is_text;\nuniform bool u_pitch_with_map;\n\nuniform vec2 u_texsize;\n\nvarying vec2 v_tex;\nvarying float v_fade_opacity;\n\nvoid main() {\n #pragma mapbox: initialize lowp float opacity\n\n vec2 a_pos = a_pos_offset.xy;\n vec2 a_offset = a_pos_offset.zw;\n\n vec2 a_tex = a_data.xy;\n vec2 a_size = a_data.zw;\n\n highp float segment_angle = -a_projected_pos[2];\n\n float size;\n if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = mix(a_size[0], a_size[1], u_size_t) / 10.0;\n } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = a_size[0] / 10.0;\n } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {\n size = u_size;\n } else {\n size = u_size;\n }\n\n vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n // See comments in symbol_sdf.vertex\n highp float distance_ratio = u_pitch_with_map ?\n camera_to_anchor_distance / u_camera_to_center_distance :\n u_camera_to_center_distance / camera_to_anchor_distance;\n highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;\n\n size *= perspective_ratio;\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n highp float symbol_rotation = 0.0;\n if (u_rotate_symbol) {\n // See comments in symbol_sdf.vertex\n vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);\n\n vec2 a = projectedPoint.xy / projectedPoint.w;\n vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;\n\n symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);\n }\n\n highp float angle_sin = sin(segment_angle + symbol_rotation);\n highp float angle_cos = cos(segment_angle + symbol_rotation);\n mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);\n\n vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);\n gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);\n\n v_tex = a_tex / u_texsize;\n vec2 fade_opacity = unpack_opacity(a_fade_opacity);\n float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;\n v_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));\n}\n"},symbolSDF:{fragmentSource:"#define SDF_PX 8.0\n#define EDGE_GAMMA 0.105/DEVICE_PIXEL_RATIO\n\nuniform bool u_is_halo;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\n\nuniform sampler2D u_texture;\nuniform highp float u_gamma_scale;\nuniform bool u_is_text;\n\nvarying vec2 v_data0;\nvarying vec3 v_data1;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 fill_color\n #pragma mapbox: initialize highp vec4 halo_color\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float halo_width\n #pragma mapbox: initialize lowp float halo_blur\n\n vec2 tex = v_data0.xy;\n float gamma_scale = v_data1.x;\n float size = v_data1.y;\n float fade_opacity = v_data1[2];\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n lowp vec4 color = fill_color;\n highp float gamma = EDGE_GAMMA / (fontScale * u_gamma_scale);\n lowp float buff = (256.0 - 64.0) / 256.0;\n if (u_is_halo) {\n color = halo_color;\n gamma = (halo_blur * 1.19 / SDF_PX + EDGE_GAMMA) / (fontScale * u_gamma_scale);\n buff = (6.0 - halo_width / fontScale) / SDF_PX;\n }\n\n lowp float dist = texture2D(u_texture, tex).a;\n highp float gamma_scaled = gamma * gamma_scale;\n highp float alpha = smoothstep(buff - gamma_scaled, buff + gamma_scaled, dist);\n\n gl_FragColor = color * (alpha * opacity * fade_opacity);\n\n#ifdef OVERDRAW_INSPECTOR\n gl_FragColor = vec4(1.0);\n#endif\n}\n",vertexSource:"const float PI = 3.141592653589793;\n\nattribute vec4 a_pos_offset;\nattribute vec4 a_data;\nattribute vec3 a_projected_pos;\nattribute float a_fade_opacity;\n\n// contents of a_size vary based on the type of property value\n// used for {text,icon}-size.\n// For constants, a_size is disabled.\n// For source functions, we bind only one value per vertex: the value of {text,icon}-size evaluated for the current feature.\n// For composite functions:\n// [ text-size(lowerZoomStop, feature),\n// text-size(upperZoomStop, feature) ]\nuniform bool u_is_size_zoom_constant;\nuniform bool u_is_size_feature_constant;\nuniform highp float u_size_t; // used to interpolate between zoom stops when size is a composite function\nuniform highp float u_size; // used when size is both zoom and feature constant\n\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\n\nuniform mat4 u_matrix;\nuniform mat4 u_label_plane_matrix;\nuniform mat4 u_gl_coord_matrix;\n\nuniform bool u_is_text;\nuniform bool u_pitch_with_map;\nuniform highp float u_pitch;\nuniform bool u_rotate_symbol;\nuniform highp float u_aspect_ratio;\nuniform highp float u_camera_to_center_distance;\nuniform float u_fade_change;\n\nuniform vec2 u_texsize;\n\nvarying vec2 v_data0;\nvarying vec3 v_data1;\n\nvoid main() {\n #pragma mapbox: initialize highp vec4 fill_color\n #pragma mapbox: initialize highp vec4 halo_color\n #pragma mapbox: initialize lowp float opacity\n #pragma mapbox: initialize lowp float halo_width\n #pragma mapbox: initialize lowp float halo_blur\n\n vec2 a_pos = a_pos_offset.xy;\n vec2 a_offset = a_pos_offset.zw;\n\n vec2 a_tex = a_data.xy;\n vec2 a_size = a_data.zw;\n\n highp float segment_angle = -a_projected_pos[2];\n float size;\n\n if (!u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = mix(a_size[0], a_size[1], u_size_t) / 10.0;\n } else if (u_is_size_zoom_constant && !u_is_size_feature_constant) {\n size = a_size[0] / 10.0;\n } else if (!u_is_size_zoom_constant && u_is_size_feature_constant) {\n size = u_size;\n } else {\n size = u_size;\n }\n\n vec4 projectedPoint = u_matrix * vec4(a_pos, 0, 1);\n highp float camera_to_anchor_distance = projectedPoint.w;\n // If the label is pitched with the map, layout is done in pitched space,\n // which makes labels in the distance smaller relative to viewport space.\n // We counteract part of that effect by multiplying by the perspective ratio.\n // If the label isn't pitched with the map, we do layout in viewport space,\n // which makes labels in the distance larger relative to the features around\n // them. We counteract part of that effect by dividing by the perspective ratio.\n highp float distance_ratio = u_pitch_with_map ?\n camera_to_anchor_distance / u_camera_to_center_distance :\n u_camera_to_center_distance / camera_to_anchor_distance;\n highp float perspective_ratio = 0.5 + 0.5 * distance_ratio;\n\n size *= perspective_ratio;\n\n float fontScale = u_is_text ? size / 24.0 : size;\n\n highp float symbol_rotation = 0.0;\n if (u_rotate_symbol) {\n // Point labels with 'rotation-alignment: map' are horizontal with respect to tile units\n // To figure out that angle in projected space, we draw a short horizontal line in tile\n // space, project it, and measure its angle in projected space.\n vec4 offsetProjectedPoint = u_matrix * vec4(a_pos + vec2(1, 0), 0, 1);\n\n vec2 a = projectedPoint.xy / projectedPoint.w;\n vec2 b = offsetProjectedPoint.xy / offsetProjectedPoint.w;\n\n symbol_rotation = atan((b.y - a.y) / u_aspect_ratio, b.x - a.x);\n }\n\n highp float angle_sin = sin(segment_angle + symbol_rotation);\n highp float angle_cos = cos(segment_angle + symbol_rotation);\n mat2 rotation_matrix = mat2(angle_cos, -1.0 * angle_sin, angle_sin, angle_cos);\n\n vec4 projected_pos = u_label_plane_matrix * vec4(a_projected_pos.xy, 0.0, 1.0);\n gl_Position = u_gl_coord_matrix * vec4(projected_pos.xy / projected_pos.w + rotation_matrix * (a_offset / 64.0 * fontScale), 0.0, 1.0);\n float gamma_scale = gl_Position.w;\n\n vec2 tex = a_tex / u_texsize;\n vec2 fade_opacity = unpack_opacity(a_fade_opacity);\n float fade_change = fade_opacity[1] > 0.5 ? u_fade_change : -u_fade_change;\n float interpolated_fade_opacity = max(0.0, min(1.0, fade_opacity[0] + fade_change));\n\n v_data0 = vec2(tex.x, tex.y);\n v_data1 = vec3(gamma_scale, size, interpolated_fade_opacity);\n}\n"}},i=/#pragma mapbox: ([\w]+) ([\w]+) ([\w]+) ([\w]+)/g,a=function(t){var e=n[t],r={};e.fragmentSource=e.fragmentSource.replace(i,function(t,e,n,i,a){return r[a]=!0,"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nvarying "+n+" "+i+" "+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifdef HAS_UNIFORM_u_"+a+"\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n"}),e.vertexSource=e.vertexSource.replace(i,function(t,e,n,i,a){var o="float"===i?"vec2":"vec4";return r[a]?"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nuniform lowp float a_"+a+"_t;\nattribute "+n+" "+o+" a_"+a+";\nvarying "+n+" "+i+" "+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifndef HAS_UNIFORM_u_"+a+"\n "+a+" = unpack_mix_"+o+"(a_"+a+", a_"+a+"_t);\n#else\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n":"define"===e?"\n#ifndef HAS_UNIFORM_u_"+a+"\nuniform lowp float a_"+a+"_t;\nattribute "+n+" "+o+" a_"+a+";\n#else\nuniform "+n+" "+i+" u_"+a+";\n#endif\n":"\n#ifndef HAS_UNIFORM_u_"+a+"\n "+n+" "+i+" "+a+" = unpack_mix_"+o+"(a_"+a+", a_"+a+"_t);\n#else\n "+n+" "+i+" "+a+" = u_"+a+";\n#endif\n"})};for(var o in n)a(o);e.exports=n},{}],98:[function(t,e,r){var n=t("./image_source"),i=t("../util/window"),a=t("../data/raster_bounds_attributes"),o=t("../render/vertex_array_object"),s=t("../render/texture"),l=function(t){function e(e,r,n,i){t.call(this,e,r,n,i),this.options=r,this.animate=void 0===r.animate||r.animate}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.load=function(){this.canvas=this.canvas||i.document.getElementById(this.options.canvas),this.width=this.canvas.width,this.height=this.canvas.height,this._hasInvalidDimensions()?this.fire("error",new Error("Canvas dimensions cannot be less than or equal to zero.")):(this.play=function(){this._playing=!0,this.map._rerender()},this.pause=function(){this._playing=!1},this._finishLoading())},e.prototype.getCanvas=function(){return this.canvas},e.prototype.onAdd=function(t){this.map=t,this.load(),this.canvas&&this.animate&&this.play()},e.prototype.onRemove=function(){this.pause()},e.prototype.prepare=function(){var t=this,e=!1;if(this.canvas.width!==this.width&&(this.width=this.canvas.width,e=!0),this.canvas.height!==this.height&&(this.height=this.canvas.height,e=!0),!this._hasInvalidDimensions()&&0!==Object.keys(this.tiles).length){var r=this.map.painter.context,n=r.gl;for(var i in this.boundsBuffer||(this.boundsBuffer=r.createVertexBuffer(this._boundsArray,a.members)),this.boundsVAO||(this.boundsVAO=new o),this.texture?e?this.texture.update(this.canvas):this._playing&&(this.texture.bind(n.LINEAR,n.CLAMP_TO_EDGE),n.texSubImage2D(n.TEXTURE_2D,0,0,0,n.RGBA,n.UNSIGNED_BYTE,this.canvas)):(this.texture=new s(r,this.canvas,n.RGBA),this.texture.bind(n.LINEAR,n.CLAMP_TO_EDGE)),t.tiles){var l=t.tiles[i];"loaded"!==l.state&&(l.state="loaded",l.texture=t.texture)}}},e.prototype.serialize=function(){return{type:"canvas",canvas:this.canvas,coordinates:this.coordinates}},e.prototype.hasTransition=function(){return this._playing},e.prototype._hasInvalidDimensions=function(){for(var t=0,e=[this.canvas.width,this.canvas.height];t0&&(r.resourceTiming=t._resourceTiming,t._resourceTiming=[]),t.fire("data",r)}})},e.prototype.onAdd=function(t){this.map=t,this.load()},e.prototype.setData=function(t){var e=this;return this._data=t,this.fire("dataloading",{dataType:"source"}),this._updateWorkerData(function(t){if(t)return e.fire("error",{error:t});var r={dataType:"source",sourceDataType:"content"};e._collectResourceTiming&&e._resourceTiming&&e._resourceTiming.length>0&&(r.resourceTiming=e._resourceTiming,e._resourceTiming=[]),e.fire("data",r)}),this},e.prototype._updateWorkerData=function(t){var e=this,r=i.extend({},this.workerOptions),n=this._data;"string"==typeof n?(r.request=this.map._transformRequest(function(t){var e=a.document.createElement("a");return e.href=t,e.href}(n),s.Source),r.request.collectResourceTiming=this._collectResourceTiming):r.data=JSON.stringify(n),this.workerID=this.dispatcher.send(this.type+".loadData",r,function(r,n){e._loaded=!0,n&&n.resourceTiming&&n.resourceTiming[e.id]&&(e._resourceTiming=n.resourceTiming[e.id].slice(0)),t(r)},this.workerID)},e.prototype.loadTile=function(t,e){var r=this,n=void 0===t.workerID||"expired"===t.state?"loadTile":"reloadTile",i={type:this.type,uid:t.uid,tileID:t.tileID,zoom:t.tileID.overscaledZ,maxZoom:this.maxzoom,tileSize:this.tileSize,source:this.id,pixelRatio:l.devicePixelRatio,overscaling:t.tileID.overscaleFactor(),showCollisionBoxes:this.map.showCollisionBoxes};t.workerID=this.dispatcher.send(n,i,function(i,a){return t.unloadVectorData(),t.aborted?e(null):i?e(i):(t.loadVectorData(a,r.map.painter,"reloadTile"===n),e(null))},this.workerID)},e.prototype.abortTile=function(t){t.aborted=!0},e.prototype.unloadTile=function(t){t.unloadVectorData(),this.dispatcher.send("removeTile",{uid:t.uid,type:this.type,source:this.id},null,t.workerID)},e.prototype.onRemove=function(){this.dispatcher.broadcast("removeSource",{type:this.type,source:this.id})},e.prototype.serialize=function(){return i.extend({},this._options,{type:this.type,data:this._data})},e.prototype.hasTransition=function(){return!1},e}(n);e.exports=c},{"../data/extent":53,"../util/ajax":251,"../util/browser":252,"../util/evented":260,"../util/util":275,"../util/window":254}],100:[function(t,e,r){function n(t,e){var r=t.source,n=t.tileID.canonical;if(!this._geoJSONIndexes[r])return e(null,null);var i=this._geoJSONIndexes[r].getTile(n.z,n.x,n.y);if(!i)return e(null,null);var a=new s(i.features),o=l(a);0===o.byteOffset&&o.byteLength===o.buffer.byteLength||(o=new Uint8Array(o)),e(null,{vectorTile:a,rawData:o.buffer})}var i=t("../util/ajax"),a=t("../util/performance"),o=t("geojson-rewind"),s=t("./geojson_wrapper"),l=t("vt-pbf"),c=t("supercluster"),u=t("geojson-vt"),f=function(t){function e(e,r,i){t.call(this,e,r,n),i&&(this.loadGeoJSON=i),this._geoJSONIndexes={}}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.loadData=function(t,e){var r=this;this.loadGeoJSON(t,function(n,i){if(n||!i)return e(n);if("object"!=typeof i)return e(new Error("Input data is not a valid GeoJSON object."));o(i,!0);try{r._geoJSONIndexes[t.source]=t.cluster?c(t.superclusterOptions).load(i.features):u(i,t.geojsonVtOptions)}catch(n){return e(n)}r.loaded[t.source]={};var s={};if(t.request&&t.request.collectResourceTiming){var l=a.getEntriesByName(t.request.url);l&&(s.resourceTiming={},s.resourceTiming[t.source]=JSON.parse(JSON.stringify(l)))}e(null,s)})},e.prototype.reloadTile=function(e,r){var n=this.loaded[e.source],i=e.uid;return n&&n[i]?t.prototype.reloadTile.call(this,e,r):this.loadTile(e,r)},e.prototype.loadGeoJSON=function(t,e){if(t.request)i.getJSON(t.request,e);else{if("string"!=typeof t.data)return e(new Error("Input data is not a valid GeoJSON object."));try{return e(null,JSON.parse(t.data))}catch(t){return e(new Error("Input data is not a valid GeoJSON object."))}}},e.prototype.removeSource=function(t,e){this._geoJSONIndexes[t.source]&&delete this._geoJSONIndexes[t.source],e()},e}(t("./vector_tile_worker_source"));e.exports=f},{"../util/ajax":251,"../util/performance":268,"./geojson_wrapper":101,"./vector_tile_worker_source":116,"geojson-rewind":15,"geojson-vt":19,supercluster:32,"vt-pbf":34}],101:[function(t,e,r){var n=t("@mapbox/point-geometry"),i=t("@mapbox/vector-tile").VectorTileFeature.prototype.toGeoJSON,a=t("../data/extent"),o=function(t){this._feature=t,this.extent=a,this.type=t.type,this.properties=t.tags,"id"in t&&!isNaN(t.id)&&(this.id=parseInt(t.id,10))};o.prototype.loadGeometry=function(){if(1===this._feature.type){for(var t=[],e=0,r=this._feature.geometry;e0&&(l[new s(t.overscaledZ,i,e.z,n,e.y-1).key]={backfilled:!1},l[new s(t.overscaledZ,t.wrap,e.z,e.x,e.y-1).key]={backfilled:!1},l[new s(t.overscaledZ,o,e.z,a,e.y-1).key]={backfilled:!1}),e.y+11||(Math.abs(r)>1&&(1===Math.abs(r+i)?r+=i:1===Math.abs(r-i)&&(r-=i)),e.dem&&t.dem&&(t.dem.backfillBorder(e.dem,r,n),t.neighboringTiles&&t.neighboringTiles[a]&&(t.neighboringTiles[a].backfilled=!0)))}for(var r=this.getRenderableIds(),n=0;ne)){var s=Math.pow(2,o.tileID.canonical.z-t.canonical.z);if(Math.floor(o.tileID.canonical.x/s)===t.canonical.x&&Math.floor(o.tileID.canonical.y/s)===t.canonical.y)for(r[a]=o.tileID,i=!0;o&&o.tileID.overscaledZ-1>t.overscaledZ;){var l=o.tileID.scaledTo(o.tileID.overscaledZ-1);if(!l)break;(o=n._tiles[l.key])&&o.hasData()&&(delete r[a],r[l.key]=l)}}}return i},e.prototype.findLoadedParent=function(t,e,r){for(var n=this,i=t.overscaledZ-1;i>=e;i--){var a=t.scaledTo(i);if(!a)return;var o=String(a.key),s=n._tiles[o];if(s&&s.hasData())return r[o]=a,s;if(n._cache.has(o))return r[o]=a,n._cache.get(o)}},e.prototype.updateCacheSize=function(t){var e=(Math.ceil(t.width/this._source.tileSize)+1)*(Math.ceil(t.height/this._source.tileSize)+1),r=Math.floor(5*e),n="number"==typeof this._maxTileCacheSize?Math.min(this._maxTileCacheSize,r):r;this._cache.setMaxSize(n)},e.prototype.update=function(t){var r=this;if(this.transform=t,this._sourceLoaded&&!this._paused){var n;this.updateCacheSize(t),this._coveredTiles={},this.used?this._source.tileID?n=t.getVisibleUnwrappedCoordinates(this._source.tileID).map(function(t){return new d(t.canonical.z,t.wrap,t.canonical.z,t.canonical.x,t.canonical.y)}):(n=t.coveringTiles({tileSize:this._source.tileSize,minzoom:this._source.minzoom,maxzoom:this._source.maxzoom,roundZoom:this._source.roundZoom,reparseOverscaled:this._source.reparseOverscaled}),this._source.hasTile&&(n=n.filter(function(t){return r._source.hasTile(t)}))):n=[];var a,o=(this._source.roundZoom?Math.round:Math.floor)(this.getZoom(t)),s=Math.max(o-e.maxOverzooming,this._source.minzoom),l=Math.max(o+e.maxUnderzooming,this._source.minzoom),c=this._updateRetainedTiles(n,o),f={};if(i(this._source.type))for(var h=Object.keys(c),g=0;g=p.now())){r._findLoadedChildren(v,l,c)&&(c[m]=v);var x=r.findLoadedParent(v,s,f);x&&r._addTile(x.tileID)}}for(a in f)c[a]||(r._coveredTiles[a]=!0);for(a in f)c[a]=f[a];for(var b=u.keysDifference(this._tiles,c),_=0;_n._source.maxzoom){var p=c.children(n._source.maxzoom)[0],d=n.getTile(p);d&&d.hasData()?i[p.key]=p:h=!1}else{n._findLoadedChildren(c,s,i);for(var g=c.children(n._source.maxzoom),m=0;m=o;--v){var y=c.scaledTo(v);if(a[y.key])break;if(a[y.key]=!0,!(u=n.getTile(y))&&f&&(u=n._addTile(y)),u&&(i[y.key]=y,f=u.wasRequested(),u.hasData()))break}}}return i},e.prototype._addTile=function(t){var e=this._tiles[t.key];if(e)return e;(e=this._cache.getAndRemove(t.key))&&this._cacheTimers[t.key]&&(clearTimeout(this._cacheTimers[t.key]),delete this._cacheTimers[t.key],this._setTileReloadTimer(t.key,e));var r=Boolean(e);return r||(e=new o(t,this._source.tileSize*t.overscaleFactor()),this._loadTile(e,this._tileLoaded.bind(this,e,t.key,e.state))),e?(e.uses++,this._tiles[t.key]=e,r||this._source.fire("dataloading",{tile:e,coord:e.tileID,dataType:"source"}),e):null},e.prototype._setTileReloadTimer=function(t,e){var r=this;t in this._timers&&(clearTimeout(this._timers[t]),delete this._timers[t]);var n=e.getExpiryTimeout();n&&(this._timers[t]=setTimeout(function(){r._reloadTile(t,"expired"),delete r._timers[t]},n))},e.prototype._setCacheInvalidationTimer=function(t,e){var r=this;t in this._cacheTimers&&(clearTimeout(this._cacheTimers[t]),delete this._cacheTimers[t]);var n=e.getExpiryTimeout();n&&(this._cacheTimers[t]=setTimeout(function(){r._cache.remove(t),delete r._cacheTimers[t]},n))},e.prototype._removeTile=function(t){var e=this._tiles[t];if(e&&(e.uses--,delete this._tiles[t],this._timers[t]&&(clearTimeout(this._timers[t]),delete this._timers[t]),!(e.uses>0)))if(e.hasData()){e.tileID=e.tileID.wrapped();var r=e.tileID.key;this._cache.add(r,e),this._setCacheInvalidationTimer(r,e)}else e.aborted=!0,this._abortTile(e),this._unloadTile(e)},e.prototype.clearTiles=function(){for(var t in this._shouldReloadOnResume=!1,this._paused=!1,this._tiles)this._removeTile(t);this._resetCache()},e.prototype._resetCache=function(){for(var t in this._cacheTimers)clearTimeout(this._cacheTimers[t]);this._cacheTimers={},this._cache.reset()},e.prototype.tilesIn=function(t){for(var e=[],r=this.getIds(),i=1/0,a=1/0,o=-1/0,s=-1/0,l=t[0].zoom,u=0;u=0&&m[1].y>=0){for(var v=[],y=0;y=p.now())return!0}return!1},e}(s);g.maxOverzooming=10,g.maxUnderzooming=3,e.exports=g},{"../data/extent":53,"../geo/coordinate":61,"../gl/context":66,"../util/browser":252,"../util/evented":260,"../util/lru_cache":266,"../util/util":275,"./source":110,"./tile":112,"./tile_id":114,"@mapbox/point-geometry":4}],112:[function(t,e,r){var n=t("../util/util"),i=t("../data/bucket").deserialize,a=(t("../data/feature_index"),t("@mapbox/vector-tile")),o=t("pbf"),s=t("../util/vectortile_to_geojson"),l=t("../style-spec/feature_filter"),c=(t("../symbol/collision_index"),t("../data/bucket/symbol_bucket")),u=t("../data/array_types"),f=u.RasterBoundsArray,h=u.CollisionBoxArray,p=t("../data/raster_bounds_attributes"),d=t("../data/extent"),g=t("@mapbox/point-geometry"),m=t("../render/texture"),v=t("../data/segment").SegmentVector,y=t("../data/index_array_type").TriangleIndexArray,x=t("../util/browser"),b=function(t,e){this.tileID=t,this.uid=n.uniqueId(),this.uses=0,this.tileSize=e,this.buckets={},this.expirationTime=null,this.expiredRequestCount=0,this.state="loading"};b.prototype.registerFadeDuration=function(t){var e=t+this.timeAdded;e>s.z,c=new g(s.x*l,s.y*l),u=new g(c.x+l,c.y+l),h=this.segments.prepareSegment(4,r,i);r.emplaceBack(c.x,c.y,c.x,c.y),r.emplaceBack(u.x,c.y,u.x,c.y),r.emplaceBack(c.x,u.y,c.x,u.y),r.emplaceBack(u.x,u.y,u.x,u.y);var m=h.vertexLength;i.emplaceBack(m,m+1,m+2),i.emplaceBack(m+1,m+2,m+3),h.vertexLength+=4,h.primitiveLength+=2}this.maskedBoundsBuffer=e.createVertexBuffer(r,p.members),this.maskedIndexBuffer=e.createIndexBuffer(i)}},b.prototype.hasData=function(){return"loaded"===this.state||"reloading"===this.state||"expired"===this.state},b.prototype.setExpiryData=function(t){var e=this.expirationTime;if(t.cacheControl){var r=n.parseCacheControl(t.cacheControl);r["max-age"]&&(this.expirationTime=Date.now()+1e3*r["max-age"])}else t.expires&&(this.expirationTime=new Date(t.expires).getTime());if(this.expirationTime){var i=Date.now(),a=!1;if(this.expirationTime>i)a=!1;else if(e)if(this.expirationTime=e&&t.x=r&&t.y0;a--)i+=(e&(n=1<this.canonical.z?new c(t,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y):new c(t,this.wrap,t,this.canonical.x>>e,this.canonical.y>>e)},c.prototype.isChildOf=function(t){var e=this.canonical.z-t.canonical.z;return 0===t.overscaledZ||t.overscaledZ>e&&t.canonical.y===this.canonical.y>>e},c.prototype.children=function(t){if(this.overscaledZ>=t)return[new c(this.overscaledZ+1,this.wrap,this.canonical.z,this.canonical.x,this.canonical.y)];var e=this.canonical.z+1,r=2*this.canonical.x,n=2*this.canonical.y;return[new c(e,this.wrap,e,r,n),new c(e,this.wrap,e,r+1,n),new c(e,this.wrap,e,r,n+1),new c(e,this.wrap,e,r+1,n+1)]},c.prototype.isLessThan=function(t){return this.wrapt.wrap)&&(this.overscaledZt.overscaledZ)&&(this.canonical.xt.canonical.x)&&this.canonical.y=E.maxzoom||"none"===E.visibility||(n(C,d.zoom),(v[E.id]=E.createBucket({index:m.bucketLayerIDs.length,layers:C,zoom:d.zoom,pixelRatio:d.pixelRatio,overscaling:d.overscaling,collisionBoxArray:d.collisionBoxArray})).populate(k,y),m.bucketLayerIDs.push(C.map(function(t){return t.id})))}}}var L,z,P,D=c.mapObject(y.glyphDependencies,function(t){return Object.keys(t).map(Number)});Object.keys(D).length?r.send("getGlyphs",{uid:this.uid,stacks:D},function(t,e){L||(L=t,z=e,p.call(d))}):z={};var O=Object.keys(y.iconDependencies);O.length?r.send("getImages",{icons:O},function(t,e){L||(L=t,P=e,p.call(d))}):P={},p.call(this)},e.exports=d},{"../data/array_types":39,"../data/bucket/symbol_bucket":51,"../data/feature_index":54,"../render/glyph_atlas":85,"../render/image_atlas":87,"../style/evaluation_parameters":182,"../symbol/symbol_layout":227,"../util/dictionary_coder":257,"../util/util":275,"./tile_id":114}],120:[function(t,e,r){function n(t,e){var r={};for(var n in t)"ref"!==n&&(r[n]=t[n]);return i.forEach(function(t){t in e&&(r[t]=e[t])}),r}var i=t("./util/ref_properties");e.exports=function(t){t=t.slice();for(var e=Object.create(null),r=0;r4)return e.error("Expected 1, 2, or 3 arguments, but found "+(t.length-1)+" instead.");var r,n;if(t.length>2){var i=t[1];if("string"!=typeof i||!(i in p))return e.error('The item type argument of "array" must be one of string, number, boolean',1);r=p[i]}else r=o;if(t.length>3){if("number"!=typeof t[2]||t[2]<0||t[2]!==Math.floor(t[2]))return e.error('The length argument to "array" must be a positive integer literal',2);n=t[2]}var s=a(r,n),l=e.parse(t[t.length-1],t.length-1,o);return l?new d(s,l):null},d.prototype.evaluate=function(t){var e=this.input.evaluate(t);if(u(this.type,f(e)))throw new h("Expected value to be of type "+i(this.type)+", but found "+i(f(e))+" instead.");return e},d.prototype.eachChild=function(t){t(this.input)},d.prototype.possibleOutputs=function(){return this.input.possibleOutputs()},e.exports=d},{"../runtime_error":143,"../types":146,"../values":147}],125:[function(t,e,r){var n=t("../types"),i=n.ObjectType,a=n.ValueType,o=n.StringType,s=n.NumberType,l=n.BooleanType,c=t("../runtime_error"),u=t("../types"),f=u.checkSubtype,h=u.toString,p=t("../values").typeOf,d={string:o,number:s,boolean:l,object:i},g=function(t,e){this.type=t,this.args=e};g.parse=function(t,e){if(t.length<2)return e.error("Expected at least one argument.");for(var r=t[0],n=d[r],i=[],o=1;o=r.length)throw new s("Array index out of bounds: "+e+" > "+r.length+".");if(e!==Math.floor(e))throw new s("Array index must be an integer, but found "+e+" instead.");return r[e]},l.prototype.eachChild=function(t){t(this.index),t(this.input)},l.prototype.possibleOutputs=function(){return[void 0]},e.exports=l},{"../runtime_error":143,"../types":146}],127:[function(t,e,r){var n=t("../types").BooleanType,i=function(t,e,r){this.type=t,this.branches=e,this.otherwise=r};i.parse=function(t,e){if(t.length<4)return e.error("Expected at least 3 arguments, but found only "+(t.length-1)+".");if(t.length%2!=0)return e.error("Expected an odd number of arguments.");var r;e.expectedType&&"value"!==e.expectedType.kind&&(r=e.expectedType);for(var a=[],o=1;o4?"Invalid rbga value "+JSON.stringify(e)+": expected an array containing either three or four numeric values.":c(e[0],e[1],e[2],e[3])))return new l(e[0]/255,e[1]/255,e[2]/255,e[3]);throw new u(r||"Could not parse color from value '"+("string"==typeof e?e:JSON.stringify(e))+"'")}for(var o=null,s=0,f=this.args;sn.evaluate(t)}function c(t,e){var r=e[0],n=e[1];return r.evaluate(t)<=n.evaluate(t)}function u(t,e){var r=e[0],n=e[1];return r.evaluate(t)>=n.evaluate(t)}var f=t("../types"),h=f.NumberType,p=f.StringType,d=f.BooleanType,g=f.ColorType,m=f.ObjectType,v=f.ValueType,y=f.ErrorType,x=f.array,b=f.toString,_=t("../values"),w=_.typeOf,k=_.Color,M=_.validateRGBA,A=t("../compound_expression"),T=A.CompoundExpression,S=A.varargs,C=t("../runtime_error"),E=t("./let"),L=t("./var"),z=t("./literal"),P=t("./assertion"),D=t("./array"),O=t("./coercion"),I=t("./at"),R=t("./match"),B=t("./case"),F=t("./step"),N=t("./interpolate"),j=t("./coalesce"),V=t("./equals"),U={"==":V.Equals,"!=":V.NotEquals,array:D,at:I,boolean:P,case:B,coalesce:j,interpolate:N,let:E,literal:z,match:R,number:P,object:P,step:F,string:P,"to-color":O,"to-number":O,var:L};T.register(U,{error:[y,[p],function(t,e){var r=e[0];throw new C(r.evaluate(t))}],typeof:[p,[v],function(t,e){var r=e[0];return b(w(r.evaluate(t)))}],"to-string":[p,[v],function(t,e){var r=e[0],n=typeof(r=r.evaluate(t));return null===r||"string"===n||"number"===n||"boolean"===n?String(r):r instanceof k?r.toString():JSON.stringify(r)}],"to-boolean":[d,[v],function(t,e){var r=e[0];return Boolean(r.evaluate(t))}],"to-rgba":[x(h,4),[g],function(t,e){var r=e[0].evaluate(t),n=r.r,i=r.g,a=r.b,o=r.a;return[255*n/o,255*i/o,255*a/o,o]}],rgb:[g,[h,h,h],n],rgba:[g,[h,h,h,h],n],length:{type:h,overloads:[[[p],o],[[x(v)],o]]},has:{type:d,overloads:[[[p],function(t,e){return i(e[0].evaluate(t),t.properties())}],[[p,m],function(t,e){var r=e[0],n=e[1];return i(r.evaluate(t),n.evaluate(t))}]]},get:{type:v,overloads:[[[p],function(t,e){return a(e[0].evaluate(t),t.properties())}],[[p,m],function(t,e){var r=e[0],n=e[1];return a(r.evaluate(t),n.evaluate(t))}]]},properties:[m,[],function(t){return t.properties()}],"geometry-type":[p,[],function(t){return t.geometryType()}],id:[v,[],function(t){return t.id()}],zoom:[h,[],function(t){return t.globals.zoom}],"heatmap-density":[h,[],function(t){return t.globals.heatmapDensity||0}],"+":[h,S(h),function(t,e){for(var r=0,n=0,i=e;n":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i>a}],"filter-id->":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>i}],"filter-<=":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i<=a}],"filter-id-<=":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n<=i}],"filter->=":[d,[p,v],function(t,e){var r=e[0],n=e[1],i=t.properties()[r.value],a=n.value;return typeof i==typeof a&&i>=a}],"filter-id->=":[d,[v],function(t,e){var r=e[0],n=t.id(),i=r.value;return typeof n==typeof i&&n>=i}],"filter-has":[d,[v],function(t,e){return e[0].value in t.properties()}],"filter-has-id":[d,[],function(t){return null!==t.id()}],"filter-type-in":[d,[x(p)],function(t,e){return e[0].value.indexOf(t.geometryType())>=0}],"filter-id-in":[d,[x(v)],function(t,e){return e[0].value.indexOf(t.id())>=0}],"filter-in-small":[d,[p,x(v)],function(t,e){var r=e[0];return e[1].value.indexOf(t.properties()[r.value])>=0}],"filter-in-large":[d,[p,x(v)],function(t,e){var r=e[0],n=e[1];return function(t,e,r,n){for(;r<=n;){var i=r+n>>1;if(e[i]===t)return!0;e[i]>t?n=i-1:r=i+1}return!1}(t.properties()[r.value],n.value,0,n.value.length-1)}],">":{type:d,overloads:[[[h,h],l],[[p,p],l]]},"<":{type:d,overloads:[[[h,h],s],[[p,p],s]]},">=":{type:d,overloads:[[[h,h],u],[[p,p],u]]},"<=":{type:d,overloads:[[[h,h],c],[[p,p],c]]},all:{type:d,overloads:[[[d,d],function(t,e){var r=e[0],n=e[1];return r.evaluate(t)&&n.evaluate(t)}],[S(d),function(t,e){for(var r=0,n=e;r1}))return e.error("Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.",1);r={name:"cubic-bezier",controlPoints:o}}if(t.length-1<4)return e.error("Expected at least 4 arguments, but found only "+(t.length-1)+".");if((t.length-1)%2!=0)return e.error("Expected an even number of arguments.");if(!(n=e.parse(n,2,l)))return null;var c=[],f=null;e.expectedType&&"value"!==e.expectedType.kind&&(f=e.expectedType);for(var h=0;h=p)return e.error('Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.',g);var v=e.parse(d,m,f);if(!v)return null;f=f||v.type,c.push([p,v])}return"number"===f.kind||"color"===f.kind||"array"===f.kind&&"number"===f.itemType.kind&&"number"==typeof f.N?new u(f,r,n,c):e.error("Type "+s(f)+" is not interpolatable.")},u.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var i=e.length;if(n>=e[i-1])return r[i-1].evaluate(t);var o=c(e,n),s=e[o],l=e[o+1],f=u.interpolationFactor(this.interpolation,n,s,l),h=r[o].evaluate(t),p=r[o+1].evaluate(t);return a[this.type.kind.toLowerCase()](h,p,f)},u.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;eNumber.MAX_SAFE_INTEGER)return f.error("Branch labels must be integers no larger than "+Number.MAX_SAFE_INTEGER+".");if("number"==typeof d&&Math.floor(d)!==d)return f.error("Numeric branch labels must be integer values.");if(r){if(f.checkSubtype(r,n(d)))return null}else r=n(d);if(void 0!==o[String(d)])return f.error("Branch labels must be unique.");o[String(d)]=s.length}var g=e.parse(u,l,a);if(!g)return null;a=a||g.type,s.push(g)}var m=e.parse(t[1],1,r);if(!m)return null;var v=e.parse(t[t.length-1],t.length-1,a);return v?new i(r,a,m,o,s,v):null},i.prototype.evaluate=function(t){var e=this.input.evaluate(t);return(this.outputs[this.cases[e]]||this.otherwise).evaluate(t)},i.prototype.eachChild=function(t){t(this.input),this.outputs.forEach(t),t(this.otherwise)},i.prototype.possibleOutputs=function(){return(t=[]).concat.apply(t,this.outputs.map(function(t){return t.possibleOutputs()})).concat(this.otherwise.possibleOutputs());var t},e.exports=i},{"../values":147}],136:[function(t,e,r){var n=t("../types").NumberType,i=t("../stops").findStopLessThanOrEqualTo,a=function(t,e,r){this.type=t,this.input=e,this.labels=[],this.outputs=[];for(var n=0,i=r;n=c)return e.error('Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.',f);var p=e.parse(u,h,s);if(!p)return null;s=s||p.type,o.push([c,p])}return new a(s,r,o)},a.prototype.evaluate=function(t){var e=this.labels,r=this.outputs;if(1===e.length)return r[0].evaluate(t);var n=this.input.evaluate(t);if(n<=e[0])return r[0].evaluate(t);var a=e.length;return n>=e[a-1]?r[a-1].evaluate(t):r[i(e,n)].evaluate(t)},a.prototype.eachChild=function(t){t(this.input);for(var e=0,r=this.outputs;e0&&"string"==typeof t[0]&&t[0]in g}function i(t,e,r){void 0===r&&(r={});var n=new l(g,[],function(t){var e={color:z,string:P,number:D,enum:P,boolean:O};return"array"===t.type?R(e[t.value]||I,t.length):e[t.type]||null}(e)),i=n.parse(t);return i?x(!1===r.handleErrors?new _(i):new w(i,e)):b(n.errors)}function a(t,e,r){if(void 0===r&&(r={}),"error"===(t=i(t,e,r)).result)return t;var n=t.value.expression,a=m.isFeatureConstant(n);if(!a&&!e["property-function"])return b([new s("","property expressions not supported")]);var o=m.isGlobalPropertyConstant(n,["zoom"]);if(!o&&!1===e["zoom-function"])return b([new s("","zoom expressions not supported")]);var l=function t(e){var r=null;if(e instanceof d)r=t(e.result);else if(e instanceof p)for(var n=0,i=e.args;n=0)return!1;var i=!0;return e.eachChild(function(e){i&&!t(e,r)&&(i=!1)}),i}}},{"./compound_expression":123}],141:[function(t,e,r){var n=t("./scope"),i=t("./types").checkSubtype,a=t("./parsing_error"),o=t("./definitions/literal"),s=t("./definitions/assertion"),l=t("./definitions/array"),c=t("./definitions/coercion"),u=function(t,e,r,i,a){void 0===e&&(e=[]),void 0===i&&(i=new n),void 0===a&&(a=[]),this.registry=t,this.path=e,this.key=e.map(function(t){return"["+t+"]"}).join(""),this.scope=i,this.errors=a,this.expectedType=r};u.prototype.parse=function(e,r,n,i,a){void 0===a&&(a={});var u=this;if(r&&(u=u.concat(r,n,i)),null!==e&&"string"!=typeof e&&"boolean"!=typeof e&&"number"!=typeof e||(e=["literal",e]),Array.isArray(e)){if(0===e.length)return u.error('Expected an array with at least one element. If you wanted a literal array, use ["literal", []].');var f=e[0];if("string"!=typeof f)return u.error("Expression name must be a string, but found "+typeof f+' instead. If you wanted a literal array, use ["literal", [...]].',0),null;var h=u.registry[f];if(h){var p=h.parse(e,u);if(!p)return null;if(u.expectedType){var d=u.expectedType,g=p.type;if("string"!==d.kind&&"number"!==d.kind&&"boolean"!==d.kind||"value"!==g.kind)if("array"===d.kind&&"value"===g.kind)a.omitTypeAnnotations||(p=new l(d,p));else if("color"!==d.kind||"value"!==g.kind&&"string"!==g.kind){if(u.checkSubtype(u.expectedType,p.type))return null}else a.omitTypeAnnotations||(p=new c(d,[p]));else a.omitTypeAnnotations||(p=new s(d,[p]))}if(!(p instanceof o)&&function(e){var r=t("./compound_expression").CompoundExpression,n=t("./is_constant"),i=n.isGlobalPropertyConstant,a=n.isFeatureConstant;if(e instanceof t("./definitions/var"))return!1;if(e instanceof r&&"error"===e.name)return!1;var s=!0;return e.eachChild(function(t){t instanceof o||(s=!1)}),!!s&&a(e)&&i(e,["zoom","heatmap-density"])}(p)){var m=new(t("./evaluation_context"));try{p=new o(p.type,p.evaluate(m))}catch(e){return u.error(e.message),null}}return p}return u.error('Unknown expression "'+f+'". If you wanted a literal array, use ["literal", [...]].',0)}return void 0===e?u.error("'undefined' value invalid. Use null instead."):"object"==typeof e?u.error('Bare objects invalid. Use ["literal", {...}] instead.'):u.error("Expected an array, but found "+typeof e+" instead.")},u.prototype.concat=function(t,e,r){var n="number"==typeof t?this.path.concat(t):this.path,i=r?this.scope.concat(r):this.scope;return new u(this.registry,n,e||null,i,this.errors)},u.prototype.error=function(t){for(var e=arguments,r=[],n=arguments.length-1;n-- >0;)r[n]=e[n+1];var i=""+this.key+r.map(function(t){return"["+t+"]"}).join("");this.errors.push(new a(i,t))},u.prototype.checkSubtype=function(t,e){var r=i(t,e);return r&&this.error(r),r},e.exports=u},{"./compound_expression":123,"./definitions/array":124,"./definitions/assertion":125,"./definitions/coercion":129,"./definitions/literal":134,"./definitions/var":137,"./evaluation_context":138,"./is_constant":140,"./parsing_error":142,"./scope":144,"./types":146}],142:[function(t,e,r){var n=function(t){function e(e,r){t.call(this,r),this.message=r,this.key=e}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(Error);e.exports=n},{}],143:[function(t,e,r){var n=function(t){this.name="ExpressionEvaluationError",this.message=t};n.prototype.toJSON=function(){return this.message},e.exports=n},{}],144:[function(t,e,r){var n=function(t,e){void 0===e&&(e=[]),this.parent=t,this.bindings={};for(var r=0,n=e;rr&&ee))throw new n("Input is not a number.");o=s-1}}return Math.max(s-1,0)}}},{"./runtime_error":143}],146:[function(t,e,r){function n(t,e){return{kind:"array",itemType:t,N:e}}function i(t){if("array"===t.kind){var e=i(t.itemType);return"number"==typeof t.N?"array<"+e+", "+t.N+">":"value"===t.itemType.kind?"array":"array<"+e+">"}return t.kind}var a={kind:"null"},o={kind:"number"},s={kind:"string"},l={kind:"boolean"},c={kind:"color"},u={kind:"object"},f={kind:"value"},h=[a,o,s,l,c,u,n(f)];e.exports={NullType:a,NumberType:o,StringType:s,BooleanType:l,ColorType:c,ObjectType:u,ValueType:f,array:n,ErrorType:{kind:"error"},toString:i,checkSubtype:function t(e,r){if("error"===r.kind)return null;if("array"===e.kind){if("array"===r.kind&&!t(e.itemType,r.itemType)&&("number"!=typeof e.N||e.N===r.N))return null}else{if(e.kind===r.kind)return null;if("value"===e.kind)for(var n=0,a=h;n=0&&t<=255&&"number"==typeof e&&e>=0&&e<=255&&"number"==typeof r&&r>=0&&r<=255?void 0===n||"number"==typeof n&&n>=0&&n<=1?null:"Invalid rgba value ["+[t,e,r,n].join(", ")+"]: 'a' must be between 0 and 1.":"Invalid rgba value ["+("number"==typeof n?[t,e,r,n]:[t,e,r]).join(", ")+"]: 'r', 'g', and 'b' must be between 0 and 255."},isValue:function t(e){if(null===e)return!0;if("string"==typeof e)return!0;if("boolean"==typeof e)return!0;if("number"==typeof e)return!0;if(e instanceof n)return!0;if(Array.isArray(e)){for(var r=0,i=e;r=2&&"$id"!==t[1]&&"$type"!==t[1];case"in":case"!in":case"!has":case"none":return!1;case"==":case"!=":case">":case">=":case"<":case"<=":return 3===t.length&&(Array.isArray(t[1])||Array.isArray(t[2]));case"any":case"all":for(var e=0,r=t.slice(1);ee?1:0}function a(t){if(!t)return!0;var e=t[0];return t.length<=1?"any"!==e:"=="===e?o(t[1],t[2],"=="):"!="===e?c(o(t[1],t[2],"==")):"<"===e||">"===e||"<="===e||">="===e?o(t[1],t[2],e):"any"===e?function(t){return["any"].concat(t.map(a))}(t.slice(1)):"all"===e?["all"].concat(t.slice(1).map(a)):"none"===e?["all"].concat(t.slice(1).map(a).map(c)):"in"===e?s(t[1],t.slice(2)):"!in"===e?c(s(t[1],t.slice(2))):"has"===e?l(t[1]):"!has"!==e||c(l(t[1]))}function o(t,e,r){switch(t){case"$type":return["filter-type-"+r,e];case"$id":return["filter-id-"+r,e];default:return["filter-"+r,t,e]}}function s(t,e){if(0===e.length)return!1;switch(t){case"$type":return["filter-type-in",["literal",e]];case"$id":return["filter-id-in",["literal",e]];default:return e.length>200&&!e.some(function(t){return typeof t!=typeof e[0]})?["filter-in-large",t,["literal",e.sort(i)]]:["filter-in-small",t,["literal",e]]}}function l(t){switch(t){case"$type":return!0;case"$id":return["filter-has-id"];default:return["filter-has",t]}}function c(t){return["!",t]}var u=t("../expression").createExpression;e.exports=function(t){if(!t)return function(){return!0};n(t)||(t=a(t));var e=u(t,f);if("error"===e.result)throw new Error(e.value.map(function(t){return t.key+": "+t.message}).join(", "));return function(t,r){return e.value.evaluate(t,r)}},e.exports.isExpressionFilter=n;var f={type:"boolean",default:!1,function:!0,"property-function":!0,"zoom-function":!0}},{"../expression":139}],149:[function(t,e,r){function n(t){return t}function i(t,e,r){return void 0!==t?t:void 0!==e?e:void 0!==r?r:void 0}function a(t,e,r,n,a){return i(typeof r===a?n[r]:void 0,t.default,e.default)}function o(t,e,r){if("number"!==p(r))return i(t.default,e.default);var n=t.stops.length;if(1===n)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[n-1][0])return t.stops[n-1][1];var a=c(t.stops,r);return t.stops[a][1]}function s(t,e,r){var a=void 0!==t.base?t.base:1;if("number"!==p(r))return i(t.default,e.default);var o=t.stops.length;if(1===o)return t.stops[0][1];if(r<=t.stops[0][0])return t.stops[0][1];if(r>=t.stops[o-1][0])return t.stops[o-1][1];var s=c(t.stops,r),l=function(t,e,r,n){var i=n-r,a=t-r;return 0===i?0:1===e?a/i:(Math.pow(e,a)-1)/(Math.pow(e,i)-1)}(r,a,t.stops[s][0],t.stops[s+1][0]),f=t.stops[s][1],h=t.stops[s+1][1],g=d[e.type]||n;if(t.colorSpace&&"rgb"!==t.colorSpace){var m=u[t.colorSpace];g=function(t,e){return m.reverse(m.interpolate(m.forward(t),m.forward(e),l))}}return"function"==typeof f.evaluate?{evaluate:function(){for(var t=arguments,e=[],r=arguments.length;r--;)e[r]=t[r];var n=f.evaluate.apply(void 0,e),i=h.evaluate.apply(void 0,e);if(void 0!==n&&void 0!==i)return g(n,i,l)}}:g(f,h,l)}function l(t,e,r){return"color"===e.type?r=f.parse(r):p(r)===e.type||"enum"===e.type&&e.values[r]||(r=void 0),i(r,t.default,e.default)}function c(t,e){for(var r,n,i=0,a=t.length-1,o=0;i<=a;){if(r=t[o=Math.floor((i+a)/2)][0],n=t[o+1][0],e===r||e>r&&ee&&(a=o-1)}return Math.max(o-1,0)}var u=t("../util/color_spaces"),f=t("../util/color"),h=t("../util/extend"),p=t("../util/get_type"),d=t("../util/interpolate"),g=t("../expression/definitions/interpolate");e.exports={createFunction:function t(e,r){var n,c,p,d="color"===r.type,m=e.stops&&"object"==typeof e.stops[0][0],v=m||void 0!==e.property,y=m||!v,x=e.type||("interpolated"===r.function?"exponential":"interval");if(d&&((e=h({},e)).stops&&(e.stops=e.stops.map(function(t){return[t[0],f.parse(t[1])]})),e.default?e.default=f.parse(e.default):e.default=f.parse(r.default)),e.colorSpace&&"rgb"!==e.colorSpace&&!u[e.colorSpace])throw new Error("Unknown color space: "+e.colorSpace);if("exponential"===x)n=s;else if("interval"===x)n=o;else if("categorical"===x){n=a,c=Object.create(null);for(var b=0,_=e.stops;b<_.length;b+=1){var w=_[b];c[w[0]]=w[1]}p=typeof e.stops[0][0]}else{if("identity"!==x)throw new Error('Unknown function type "'+x+'"');n=l}if(m){for(var k={},M=[],A=0;A":{},">=":{},"<":{},"<=":{},in:{},"!in":{},all:{},any:{},none:{},has:{},"!has":{}}},geometry_type:{type:"enum",values:{Point:{},LineString:{},Polygon:{}}},function:{expression:{type:"expression"},stops:{type:"array",value:"function_stop"},base:{type:"number",default:1,minimum:0},property:{type:"string",default:"$zoom"},type:{type:"enum",values:{identity:{},exponential:{},interval:{},categorical:{}},default:"exponential"},colorSpace:{type:"enum",values:{rgb:{},lab:{},hcl:{}},default:"rgb"},default:{type:"*",required:!1}},function_stop:{type:"array",minimum:0,maximum:22,value:["number","color"],length:2},expression:{type:"array",value:"*",minimum:1},expression_name:{type:"enum",values:{let:{group:"Variable binding"},var:{group:"Variable binding"},literal:{group:"Types"},array:{group:"Types"},at:{group:"Lookup"},case:{group:"Decision"},match:{group:"Decision"},coalesce:{group:"Decision"},step:{group:"Ramps, scales, curves"},interpolate:{group:"Ramps, scales, curves"},ln2:{group:"Math"},pi:{group:"Math"},e:{group:"Math"},typeof:{group:"Types"},string:{group:"Types"},number:{group:"Types"},boolean:{group:"Types"},object:{group:"Types"},"to-string":{group:"Types"},"to-number":{group:"Types"},"to-boolean":{group:"Types"},"to-rgba":{group:"Color"},"to-color":{group:"Types"},rgb:{group:"Color"},rgba:{group:"Color"},get:{group:"Lookup"},has:{group:"Lookup"},length:{group:"Lookup"},properties:{group:"Feature data"},"geometry-type":{group:"Feature data"},id:{group:"Feature data"},zoom:{group:"Zoom"},"heatmap-density":{group:"Heatmap"},"+":{group:"Math"},"*":{group:"Math"},"-":{group:"Math"},"/":{group:"Math"},"%":{group:"Math"},"^":{group:"Math"},sqrt:{group:"Math"},log10:{group:"Math"},ln:{group:"Math"},log2:{group:"Math"},sin:{group:"Math"},cos:{group:"Math"},tan:{group:"Math"},asin:{group:"Math"},acos:{group:"Math"},atan:{group:"Math"},min:{group:"Math"},max:{group:"Math"},"==":{group:"Decision"},"!=":{group:"Decision"},">":{group:"Decision"},"<":{group:"Decision"},">=":{group:"Decision"},"<=":{group:"Decision"},all:{group:"Decision"},any:{group:"Decision"},"!":{group:"Decision"},upcase:{group:"String"},downcase:{group:"String"},concat:{group:"String"}}},light:{anchor:{type:"enum",default:"viewport",values:{map:{},viewport:{}},transition:!1,"zoom-function":!0,"property-function":!1,function:"piecewise-constant"},position:{type:"array",default:[1.15,210,30],length:3,value:"number",transition:!0,function:"interpolated","zoom-function":!0,"property-function":!1},color:{type:"color",default:"#ffffff",function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},intensity:{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint:["paint_fill","paint_line","paint_circle","paint_heatmap","paint_fill-extrusion","paint_symbol","paint_raster","paint_hillshade","paint_background"],paint_fill:{"fill-antialias":{type:"boolean",function:"piecewise-constant","zoom-function":!0,default:!0},"fill-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"fill-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"}]},"fill-outline-color":{type:"color",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-pattern"},{"fill-antialias":!0}]},"fill-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-translate"]},"fill-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0}},"paint_fill-extrusion":{"fill-extrusion-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!1,default:1,minimum:0,maximum:1,transition:!0},"fill-extrusion-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"fill-extrusion-pattern"}]},"fill-extrusion-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"fill-extrusion-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["fill-extrusion-translate"]},"fill-extrusion-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"fill-extrusion-height":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0},"fill-extrusion-base":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:0,minimum:0,units:"meters",transition:!0,requires:["fill-extrusion-height"]}},paint_line:{"line-opacity":{type:"number",function:"interpolated","zoom-function":!0,"property-function":!0,default:1,minimum:0,maximum:1,transition:!0},"line-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:[{"!":"line-pattern"}]},"line-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"line-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["line-translate"]},"line-width":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-gap-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-offset":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"line-dasharray":{type:"array",value:"number",function:"piecewise-constant","zoom-function":!0,minimum:0,transition:!0,units:"line widths",requires:[{"!":"line-pattern"}]},"line-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0}},paint_circle:{"circle-radius":{type:"number",default:5,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-blur":{type:"number",default:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels"},"circle-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["circle-translate"]},"circle-pitch-scale":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map"},"circle-pitch-alignment":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"circle-stroke-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"circle-stroke-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0},"circle-stroke-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0}},paint_heatmap:{"heatmap-radius":{type:"number",default:30,minimum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels"},"heatmap-weight":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!1},"heatmap-intensity":{type:"number",default:1,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0},"heatmap-color":{type:"color",default:["interpolate",["linear"],["heatmap-density"],0,"rgba(0, 0, 255, 0)",.1,"royalblue",.3,"cyan",.5,"lime",.7,"yellow",1,"red"],function:"interpolated","zoom-function":!1,"property-function":!1,transition:!1},"heatmap-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!1,transition:!0}},paint_symbol:{"icon-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["icon-image"]},"icon-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["icon-image"]},"icon-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["icon-image","icon-translate"]},"text-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-color":{type:"color",default:"rgba(0, 0, 0, 0)",function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,requires:["text-field"]},"text-halo-width":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-halo-blur":{type:"number",default:0,minimum:0,function:"interpolated","zoom-function":!0,"property-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate":{type:"array",value:"number",length:2,default:[0,0],function:"interpolated","zoom-function":!0,transition:!0,units:"pixels",requires:["text-field"]},"text-translate-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"map",requires:["text-field","text-translate"]}},paint_raster:{"raster-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-hue-rotate":{type:"number",default:0,period:360,function:"interpolated","zoom-function":!0,transition:!0,units:"degrees"},"raster-brightness-min":{type:"number",function:"interpolated","zoom-function":!0,default:0,minimum:0,maximum:1,transition:!0},"raster-brightness-max":{type:"number",function:"interpolated","zoom-function":!0,default:1,minimum:0,maximum:1,transition:!0},"raster-saturation":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-contrast":{type:"number",default:0,minimum:-1,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"raster-fade-duration":{type:"number",default:300,minimum:0,function:"interpolated","zoom-function":!0,transition:!1,units:"milliseconds"}},paint_hillshade:{"hillshade-illumination-direction":{type:"number",default:335,minimum:0,maximum:359,function:"interpolated","zoom-function":!0,transition:!1},"hillshade-illumination-anchor":{type:"enum",function:"piecewise-constant","zoom-function":!0,values:{map:{},viewport:{}},default:"viewport"},"hillshade-exaggeration":{type:"number",default:.5,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0},"hillshade-shadow-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-highlight-color":{type:"color",default:"#FFFFFF",function:"interpolated","zoom-function":!0,transition:!0},"hillshade-accent-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0}},paint_background:{"background-color":{type:"color",default:"#000000",function:"interpolated","zoom-function":!0,transition:!0,requires:[{"!":"background-pattern"}]},"background-pattern":{type:"string",function:"piecewise-constant","zoom-function":!0,transition:!0},"background-opacity":{type:"number",default:1,minimum:0,maximum:1,function:"interpolated","zoom-function":!0,transition:!0}},transition:{duration:{type:"number",default:300,minimum:0,units:"milliseconds"},delay:{type:"number",default:0,minimum:0,units:"milliseconds"}}}},{}],153:[function(t,e,r){var n=t("csscolorparser").parseCSSColor,i=function(t,e,r,n){void 0===n&&(n=1),this.r=t,this.g=e,this.b=r,this.a=n};i.parse=function(t){if(t){if(t instanceof i)return t;if("string"==typeof t){var e=n(t);if(e)return new i(e[0]/255*e[3],e[1]/255*e[3],e[2]/255*e[3],e[3])}}},i.prototype.toString=function(){var t=this;return"rgba("+[this.r,this.g,this.b].map(function(e){return Math.round(255*e/t.a)}).concat(this.a).join(",")+")"},i.black=new i(0,0,0,1),i.white=new i(1,1,1,1),i.transparent=new i(0,0,0,0),e.exports=i},{csscolorparser:13}],154:[function(t,e,r){function n(t){return t>v?Math.pow(t,1/3):t/m+d}function i(t){return t>g?t*t*t:m*(t-d)}function a(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function o(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function s(t){var e=o(t.r),r=o(t.g),i=o(t.b),a=n((.4124564*e+.3575761*r+.1804375*i)/f),s=n((.2126729*e+.7151522*r+.072175*i)/h);return{l:116*s-16,a:500*(a-s),b:200*(s-n((.0193339*e+.119192*r+.9503041*i)/p)),alpha:t.a}}function l(t){var e=(t.l+16)/116,r=isNaN(t.a)?e:e+t.a/500,n=isNaN(t.b)?e:e-t.b/200;return e=h*i(e),r=f*i(r),n=p*i(n),new c(a(3.2404542*r-1.5371385*e-.4985314*n),a(-.969266*r+1.8760108*e+.041556*n),a(.0556434*r-.2040259*e+1.0572252*n),t.alpha)}var c=t("./color"),u=t("./interpolate").number,f=.95047,h=1,p=1.08883,d=4/29,g=6/29,m=3*g*g,v=g*g*g,y=Math.PI/180,x=180/Math.PI;e.exports={lab:{forward:s,reverse:l,interpolate:function(t,e,r){return{l:u(t.l,e.l,r),a:u(t.a,e.a,r),b:u(t.b,e.b,r),alpha:u(t.alpha,e.alpha,r)}}},hcl:{forward:function(t){var e=s(t),r=e.l,n=e.a,i=e.b,a=Math.atan2(i,n)*x;return{h:a<0?a+360:a,c:Math.sqrt(n*n+i*i),l:r,alpha:t.a}},reverse:function(t){var e=t.h*y,r=t.c;return l({l:t.l,a:Math.cos(e)*r,b:Math.sin(e)*r,alpha:t.alpha})},interpolate:function(t,e,r){return{h:function(t,e,r){var n=e-t;return t+r*(n>180||n<-180?n-360*Math.round(n/360):n)}(t.h,e.h,r),c:u(t.c,e.c,r),l:u(t.l,e.l,r),alpha:u(t.alpha,e.alpha,r)}}}}},{"./color":153,"./interpolate":158}],155:[function(t,e,r){e.exports=function t(e,r){if(Array.isArray(e)){if(!Array.isArray(r)||e.length!==r.length)return!1;for(var n=0;n0;)r[n]=e[n+1];for(var i=0,a=r;i":case">=":r.length>=2&&"$type"===s(r[1])&&u.push(new n(i,r,'"$type" cannot be use with operator "'+r[0]+'"'));case"==":case"!=":3!==r.length&&u.push(new n(i,r,'filter array for operator "'+r[0]+'" must have 3 elements'));case"in":case"!in":r.length>=2&&"string"!==(l=o(r[1]))&&u.push(new n(i+"[1]",r[1],"string expected, "+l+" found"));for(var f=2;fc(s[0].zoom))return[new n(u,s[0].zoom,"stop zoom values must appear in ascending order")];c(s[0].zoom)!==h&&(h=c(s[0].zoom),f=void 0,g={}),e=e.concat(o({key:u+"[0]",value:s[0],valueSpec:{zoom:{}},style:t.style,styleSpec:t.styleSpec,objectElementValidators:{zoom:l,value:r}}))}else e=e.concat(r({key:u+"[0]",value:s[0],valueSpec:{},style:t.style,styleSpec:t.styleSpec},s));return e.concat(a({key:u+"[1]",value:s[1],valueSpec:p,style:t.style,styleSpec:t.styleSpec}))}function r(t,e){var r=i(t.value),a=c(t.value),o=null!==t.value?t.value:e;if(u){if(r!==u)return[new n(t.key,o,r+" stop domain type must match previous stop domain type "+u)]}else u=r;if("number"!==r&&"string"!==r&&"boolean"!==r)return[new n(t.key,o,"stop domain value must be a number, string, or boolean")];if("number"!==r&&"categorical"!==d){var s="number expected, "+r+" found";return p["property-function"]&&void 0===d&&(s+='\nIf you intended to use a categorical function, specify `"type": "categorical"`.'),[new n(t.key,o,s)]}return"categorical"!==d||"number"!==r||isFinite(a)&&Math.floor(a)===a?"categorical"!==d&&"number"===r&&void 0!==f&&a=8&&(v&&!t.valueSpec["property-function"]?x.push(new n(t.key,t.value,"property functions not supported")):m&&!t.valueSpec["zoom-function"]&&"heatmap-color"!==t.objectKey&&x.push(new n(t.key,t.value,"zoom functions not supported"))),"categorical"!==d&&!y||void 0!==t.value.property||x.push(new n(t.key,t.value,'"property" property is required')),x}},{"../error/validation_error":122,"../util/get_type":157,"../util/unbundle_jsonlint":161,"./validate":162,"./validate_array":163,"./validate_number":175,"./validate_object":176}],171:[function(t,e,r){var n=t("../error/validation_error"),i=t("./validate_string");e.exports=function(t){var e=t.value,r=t.key,a=i(t);return a.length?a:(-1===e.indexOf("{fontstack}")&&a.push(new n(r,e,'"glyphs" url must include a "{fontstack}" token')),-1===e.indexOf("{range}")&&a.push(new n(r,e,'"glyphs" url must include a "{range}" token')),a)}},{"../error/validation_error":122,"./validate_string":180}],172:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/unbundle_jsonlint"),a=t("./validate_object"),o=t("./validate_filter"),s=t("./validate_paint_property"),l=t("./validate_layout_property"),c=t("./validate"),u=t("../util/extend");e.exports=function(t){var e=[],r=t.value,f=t.key,h=t.style,p=t.styleSpec;r.type||r.ref||e.push(new n(f,r,'either "type" or "ref" is required'));var d,g=i(r.type),m=i(r.ref);if(r.id)for(var v=i(r.id),y=0;ya.maximum?[new i(e,r,r+" is greater than the maximum value "+a.maximum)]:[]}},{"../error/validation_error":122,"../util/get_type":157}],176:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/get_type"),a=t("./validate");e.exports=function(t){var e=t.key,r=t.value,o=t.valueSpec||{},s=t.objectElementValidators||{},l=t.style,c=t.styleSpec,u=[],f=i(r);if("object"!==f)return[new n(e,r,"object expected, "+f+" found")];for(var h in r){var p=h.split(".")[0],d=o[p]||o["*"],g=void 0;if(s[p])g=s[p];else if(o[p])g=a;else if(s["*"])g=s["*"];else{if(!o["*"]){u.push(new n(e,r[h],'unknown property "'+h+'"'));continue}g=a}u=u.concat(g({key:(e?e+".":e)+h,value:r[h],valueSpec:d,style:l,styleSpec:c,object:r,objectKey:h},r))}for(var m in o)s[m]||o[m].required&&void 0===o[m].default&&void 0===r[m]&&u.push(new n(e,r,'missing required property "'+m+'"'));return u}},{"../error/validation_error":122,"../util/get_type":157,"./validate":162}],177:[function(t,e,r){var n=t("./validate_property");e.exports=function(t){return n(t,"paint")}},{"./validate_property":178}],178:[function(t,e,r){var n=t("./validate"),i=t("../error/validation_error"),a=t("../util/get_type"),o=t("../function").isFunction,s=t("../util/unbundle_jsonlint");e.exports=function(t,e){var r=t.key,l=t.style,c=t.styleSpec,u=t.value,f=t.objectKey,h=c[e+"_"+t.layerType];if(!h)return[];var p=f.match(/^(.*)-transition$/);if("paint"===e&&p&&h[p[1]]&&h[p[1]].transition)return n({key:r,value:u,valueSpec:c.transition,style:l,styleSpec:c});var d,g=t.valueSpec||h[f];if(!g)return[new i(r,u,'unknown property "'+f+'"')];if("string"===a(u)&&g["property-function"]&&!g.tokens&&(d=/^{([^}]+)}$/.exec(u)))return[new i(r,u,'"'+f+'" does not support interpolation syntax\nUse an identity property function instead: `{ "type": "identity", "property": '+JSON.stringify(d[1])+" }`.")];var m=[];return"symbol"===t.layerType&&("text-field"===f&&l&&!l.glyphs&&m.push(new i(r,u,'use of "text-field" requires a style "glyphs" property')),"text-font"===f&&o(s.deep(u))&&"identity"===s(u.type)&&m.push(new i(r,u,'"text-font" does not support identity functions'))),m.concat(n({key:t.key,value:u,valueSpec:g,style:l,styleSpec:c,expressionContext:"property",propertyKey:f}))}},{"../error/validation_error":122,"../function":149,"../util/get_type":157,"../util/unbundle_jsonlint":161,"./validate":162}],179:[function(t,e,r){var n=t("../error/validation_error"),i=t("../util/unbundle_jsonlint"),a=t("./validate_object"),o=t("./validate_enum");e.exports=function(t){var e=t.value,r=t.key,s=t.styleSpec,l=t.style;if(!e.type)return[new n(r,e,'"type" is required')];var c=i(e.type),u=[];switch(c){case"vector":case"raster":case"raster-dem":if(u=u.concat(a({key:r,value:e,valueSpec:s["source_"+c.replace("-","_")],style:t.style,styleSpec:s})),"url"in e)for(var f in e)["type","url","tileSize"].indexOf(f)<0&&u.push(new n(r+"."+f,e[f],'a source with a "url" property may not include a "'+f+'" property'));return u;case"geojson":return a({key:r,value:e,valueSpec:s.source_geojson,style:l,styleSpec:s});case"video":return a({key:r,value:e,valueSpec:s.source_video,style:l,styleSpec:s});case"image":return a({key:r,value:e,valueSpec:s.source_image,style:l,styleSpec:s});case"canvas":return a({key:r,value:e,valueSpec:s.source_canvas,style:l,styleSpec:s});default:return o({key:r+".type",value:e.type,valueSpec:{values:["vector","raster","raster-dem","geojson","video","image","canvas"]},style:l,styleSpec:s})}}},{"../error/validation_error":122,"../util/unbundle_jsonlint":161,"./validate_enum":167,"./validate_object":176}],180:[function(t,e,r){var n=t("../util/get_type"),i=t("../error/validation_error");e.exports=function(t){var e=t.value,r=t.key,a=n(e);return"string"!==a?[new i(r,e,"string expected, "+a+" found")]:[]}},{"../error/validation_error":122,"../util/get_type":157}],181:[function(t,e,r){function n(t,e){e=e||l;var r=[];return r=r.concat(s({key:"",value:t,valueSpec:e.$root,styleSpec:e,style:t,objectElementValidators:{glyphs:c,"*":function(){return[]}}})),t.constants&&(r=r.concat(o({key:"constants",value:t.constants,style:t,styleSpec:e}))),i(r)}function i(t){return[].concat(t).sort(function(t,e){return t.line-e.line})}function a(t){return function(){return i(t.apply(this,arguments))}}var o=t("./validate/validate_constants"),s=t("./validate/validate"),l=t("./reference/latest"),c=t("./validate/validate_glyphs_url");n.source=a(t("./validate/validate_source")),n.light=a(t("./validate/validate_light")),n.layer=a(t("./validate/validate_layer")),n.filter=a(t("./validate/validate_filter")),n.paintProperty=a(t("./validate/validate_paint_property")),n.layoutProperty=a(t("./validate/validate_layout_property")),e.exports=n},{"./reference/latest":151,"./validate/validate":162,"./validate/validate_constants":166,"./validate/validate_filter":169,"./validate/validate_glyphs_url":171,"./validate/validate_layer":172,"./validate/validate_layout_property":173,"./validate/validate_light":174,"./validate/validate_paint_property":177,"./validate/validate_source":179}],182:[function(t,e,r){var n=t("./zoom_history"),i=function(t,e){this.zoom=t,e?(this.now=e.now,this.fadeDuration=e.fadeDuration,this.zoomHistory=e.zoomHistory,this.transition=e.transition):(this.now=0,this.fadeDuration=0,this.zoomHistory=new n,this.transition={})};i.prototype.crossFadingFactor=function(){return 0===this.fadeDuration?1:Math.min((this.now-this.zoomHistory.lastIntegerZoomTime)/this.fadeDuration,1)},e.exports=i},{"./zoom_history":212}],183:[function(t,e,r){var n=t("../style-spec/reference/latest"),i=t("../util/util"),a=t("../util/evented"),o=t("./validate_style"),s=t("../util/util").sphericalToCartesian,l=(t("../style-spec/util/color"),t("../style-spec/util/interpolate")),c=t("./properties"),u=c.Properties,f=c.Transitionable,h=(c.Transitioning,c.PossiblyEvaluated,c.DataConstantProperty),p=function(){this.specification=n.light.position};p.prototype.possiblyEvaluate=function(t,e){return s(t.expression.evaluate(e))},p.prototype.interpolate=function(t,e,r){return{x:l.number(t.x,e.x,r),y:l.number(t.y,e.y,r),z:l.number(t.z,e.z,r)}};var d=new u({anchor:new h(n.light.anchor),position:new p,color:new h(n.light.color),intensity:new h(n.light.intensity)}),g=function(t){function e(e){t.call(this),this._transitionable=new f(d),this.setLight(e),this._transitioning=this._transitionable.untransitioned()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getLight=function(){return this._transitionable.serialize()},e.prototype.setLight=function(t){if(!this._validate(o.light,t))for(var e in t){var r=t[e];i.endsWith(e,"-transition")?this._transitionable.setTransition(e.slice(0,-"-transition".length),r):this._transitionable.setValue(e,r)}},e.prototype.updateTransitions=function(t){this._transitioning=this._transitionable.transitioned(t,this._transitioning)},e.prototype.hasTransition=function(){return this._transitioning.hasTransition()},e.prototype.recalculate=function(t){this.properties=this._transitioning.possiblyEvaluate(t)},e.prototype._validate=function(t,e){return o.emitErrors(this,t.call(o,i.extend({value:e,style:{glyphs:!0,sprite:!0},styleSpec:n})))},e}(a);e.exports=g},{"../style-spec/reference/latest":151,"../style-spec/util/color":153,"../style-spec/util/interpolate":158,"../util/evented":260,"../util/util":275,"./properties":188,"./validate_style":211}],184:[function(t,e,r){var n=t("../util/mapbox").normalizeGlyphsURL,i=t("../util/ajax"),a=t("./parse_glyph_pbf");e.exports=function(t,e,r,o,s){var l=256*e,c=l+255,u=o(n(r).replace("{fontstack}",t).replace("{range}",l+"-"+c),i.ResourceType.Glyphs);i.getArrayBuffer(u,function(t,e){if(t)s(t);else if(e){for(var r={},n=0,i=a(e.data);n1?"@2x":"";n.getJSON(e(a(t,f,".json"),n.ResourceType.SpriteJSON),function(t,e){u||(u=t,l=e,s())}),n.getImage(e(a(t,f,".png"),n.ResourceType.SpriteImage),function(t,e){u||(u=t,c=e,s())})}},{"../util/ajax":251,"../util/browser":252,"../util/image":263,"../util/mapbox":267}],186:[function(t,e,r){function n(t,e,r){1===t&&r.readMessage(i,e)}function i(t,e,r){if(3===t){var n=r.readMessage(a,{}),i=n.id,s=n.bitmap,c=n.width,u=n.height,f=n.left,h=n.top,p=n.advance;e.push({id:i,bitmap:new o({width:c+2*l,height:u+2*l},s),metrics:{width:c,height:u,left:f,top:h,advance:p}})}}function a(t,e,r){1===t?e.id=r.readVarint():2===t?e.bitmap=r.readBytes():3===t?e.width=r.readVarint():4===t?e.height=r.readVarint():5===t?e.left=r.readSVarint():6===t?e.top=r.readSVarint():7===t&&(e.advance=r.readVarint())}var o=t("../util/image").AlphaImage,s=t("pbf"),l=3;e.exports=function(t){return new s(t).readFields(n,[])},e.exports.GLYPH_PBF_BORDER=l},{"../util/image":263,pbf:30}],187:[function(t,e,r){var n=t("../util/browser"),i=t("../symbol/placement"),a=function(){this._currentTileIndex=0,this._seenCrossTileIDs={}};a.prototype.continuePlacement=function(t,e,r,n,i){for(var a=this;this._currentTileIndex2};this._currentPlacementIndex>=0;){var l=e[t[i._currentPlacementIndex]],c=i.placement.collisionIndex.transform.zoom;if("symbol"===l.type&&(!l.minzoom||l.minzoom<=c)&&(!l.maxzoom||l.maxzoom>c)){if(i._inProgressLayer||(i._inProgressLayer=new a),i._inProgressLayer.continuePlacement(r[l.source],i.placement,i._showCollisionBoxes,l,s))return;delete i._inProgressLayer}i._currentPlacementIndex--}this._done=!0},o.prototype.commit=function(t,e){return this.placement.commit(t,e),this.placement},e.exports=o},{"../symbol/placement":223,"../util/browser":252}],188:[function(t,e,r){var n=t("../util/util"),i=n.clone,a=n.extend,o=n.easeCubicInOut,s=t("../style-spec/util/interpolate"),l=t("../style-spec/expression").normalizePropertyExpression,c=(t("../style-spec/util/color"),t("../util/web_worker_transfer").register),u=function(t,e){this.property=t,this.value=e,this.expression=l(void 0===e?t.specification.default:e,t.specification)};u.prototype.isDataDriven=function(){return"source"===this.expression.kind||"composite"===this.expression.kind},u.prototype.possiblyEvaluate=function(t){return this.property.possiblyEvaluate(this,t)};var f=function(t){this.property=t,this.value=new u(t,void 0)};f.prototype.transitioned=function(t,e){return new p(this.property,this.value,e,a({},t.transition,this.transition),t.now)},f.prototype.untransitioned=function(){return new p(this.property,this.value,null,{},0)};var h=function(t){this._properties=t,this._values=Object.create(t.defaultTransitionablePropertyValues)};h.prototype.getValue=function(t){return i(this._values[t].value.value)},h.prototype.setValue=function(t,e){this._values.hasOwnProperty(t)||(this._values[t]=new f(this._values[t].property)),this._values[t].value=new u(this._values[t].property,null===e?void 0:i(e))},h.prototype.getTransition=function(t){return i(this._values[t].transition)},h.prototype.setTransition=function(t,e){this._values.hasOwnProperty(t)||(this._values[t]=new f(this._values[t].property)),this._values[t].transition=i(e)||void 0},h.prototype.serialize=function(){for(var t=this,e={},r=0,n=Object.keys(t._values);rthis.end)return this.prior=null,r;if(this.value.isDataDriven())return this.prior=null,r;if(en.zoomHistory.lastIntegerZoom?{from:t,to:e,fromScale:2,toScale:1,t:a+(1-a)*o}:{from:r,to:e,fromScale:.5,toScale:1,t:1-(1-o)*a}},b.prototype.interpolate=function(t){return t};var _=function(t){this.specification=t};_.prototype.possiblyEvaluate=function(){},_.prototype.interpolate=function(){};c("DataDrivenProperty",x),c("DataConstantProperty",y),c("CrossFadedProperty",b),c("HeatmapColorProperty",_),e.exports={PropertyValue:u,Transitionable:h,Transitioning:d,Layout:g,PossiblyEvaluatedPropertyValue:m,PossiblyEvaluated:v,DataConstantProperty:y,DataDrivenProperty:x,CrossFadedProperty:b,HeatmapColorProperty:_,Properties:function(t){var e=this;for(var r in this.properties=t,this.defaultPropertyValues={},this.defaultTransitionablePropertyValues={},this.defaultTransitioningPropertyValues={},this.defaultPossiblyEvaluatedValues={},t){var n=t[r],i=e.defaultPropertyValues[r]=new u(n,void 0),a=e.defaultTransitionablePropertyValues[r]=new f(n);e.defaultTransitioningPropertyValues[r]=a.untransitioned(),e.defaultPossiblyEvaluatedValues[r]=i.possiblyEvaluate({})}}}},{"../style-spec/expression":139,"../style-spec/util/color":153,"../style-spec/util/interpolate":158,"../util/util":275,"../util/web_worker_transfer":278}],189:[function(t,e,r){var n=t("@mapbox/point-geometry");e.exports={getMaximumPaintValue:function(t,e,r){var n=e.paint.get(t).value;return"constant"===n.kind?n.value:r.programConfigurations.get(e.id).binders[t].statistics.max},translateDistance:function(t){return Math.sqrt(t[0]*t[0]+t[1]*t[1])},translate:function(t,e,r,i,a){if(!e[0]&&!e[1])return t;var o=n.convert(e);"viewport"===r&&o._rotate(-i);for(var s=[],l=0;l0)throw new Error("Unimplemented: "+n.map(function(t){return t.command}).join(", ")+".");return r.forEach(function(t){"setTransition"!==t.command&&e[t.command].apply(e,t.args)}),this.stylesheet=t,!0},e.prototype.addImage=function(t,e){if(this.getImage(t))return this.fire("error",{error:new Error("An image with this name already exists.")});this.imageManager.addImage(t,e),this.fire("data",{dataType:"style"})},e.prototype.getImage=function(t){return this.imageManager.getImage(t)},e.prototype.removeImage=function(t){if(!this.getImage(t))return this.fire("error",{error:new Error("No image with this name exists.")});this.imageManager.removeImage(t),this.fire("data",{dataType:"style"})},e.prototype.addSource=function(t,e,r){var n=this;if(this._checkLoaded(),void 0!==this.sourceCaches[t])throw new Error("There is already a source with this ID");if(!e.type)throw new Error("The type property must be defined, but the only the following properties were given: "+Object.keys(e).join(", ")+".");if(!(["vector","raster","geojson","video","image","canvas"].indexOf(e.type)>=0&&this._validate(g.source,"sources."+t,e,null,r))){this.map&&this.map._collectResourceTiming&&(e.collectResourceTiming=!0);var i=this.sourceCaches[t]=new x(t,e,this.dispatcher);i.style=this,i.setEventedParent(this,function(){return{isSourceLoaded:n.loaded(),source:i.serialize(),sourceId:t}}),i.onAdd(this.map),this._changed=!0}},e.prototype.removeSource=function(t){var e=this;if(this._checkLoaded(),void 0===this.sourceCaches[t])throw new Error("There is no source with this ID");for(var r in e._layers)if(e._layers[r].source===t)return e.fire("error",{error:new Error('Source "'+t+'" cannot be removed while layer "'+r+'" is using it.')});var n=this.sourceCaches[t];delete this.sourceCaches[t],delete this._updatedSources[t],n.fire("data",{sourceDataType:"metadata",dataType:"source",sourceId:t}),n.setEventedParent(null),n.clearTiles(),n.onRemove&&n.onRemove(this.map),this._changed=!0},e.prototype.setGeoJSONSourceData=function(t,e){this._checkLoaded(),this.sourceCaches[t].getSource().setData(e),this._changed=!0},e.prototype.getSource=function(t){return this.sourceCaches[t]&&this.sourceCaches[t].getSource()},e.prototype.addLayer=function(t,e,r){this._checkLoaded();var n=t.id;if("object"==typeof t.source&&(this.addSource(n,t.source),t=u.clone(t),t=u.extend(t,{source:n})),!this._validate(g.layer,"layers."+n,t,{arrayIndex:-1},r)){var a=i.create(t);this._validateLayer(a),a.setEventedParent(this,{layer:{id:n}});var o=e?this._order.indexOf(e):this._order.length;if(e&&-1===o)return void this.fire("error",{error:new Error('Layer with id "'+e+'" does not exist on this map.')});if(this._order.splice(o,0,n),this._layerOrderChanged=!0,this._layers[n]=a,this._removedLayers[n]&&a.source){var s=this._removedLayers[n];delete this._removedLayers[n],s.type!==a.type?this._updatedSources[a.source]="clear":(this._updatedSources[a.source]="reload",this.sourceCaches[a.source].pause())}this._updateLayer(a)}},e.prototype.moveLayer=function(t,e){if(this._checkLoaded(),this._changed=!0,this._layers[t]){var r=this._order.indexOf(t);this._order.splice(r,1);var n=e?this._order.indexOf(e):this._order.length;e&&-1===n?this.fire("error",{error:new Error('Layer with id "'+e+'" does not exist on this map.')}):(this._order.splice(n,0,t),this._layerOrderChanged=!0)}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be moved.")})},e.prototype.removeLayer=function(t){this._checkLoaded();var e=this._layers[t];if(e){e.setEventedParent(null);var r=this._order.indexOf(t);this._order.splice(r,1),this._layerOrderChanged=!0,this._changed=!0,this._removedLayers[t]=e,delete this._layers[t],delete this._updatedLayers[t],delete this._updatedPaintProps[t]}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be removed.")})},e.prototype.getLayer=function(t){return this._layers[t]},e.prototype.setLayerZoomRange=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);n?n.minzoom===e&&n.maxzoom===r||(null!=e&&(n.minzoom=e),null!=r&&(n.maxzoom=r),this._updateLayer(n)):this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot have zoom extent.")})},e.prototype.setFilter=function(t,e){this._checkLoaded();var r=this.getLayer(t);if(r)return u.deepEqual(r.filter,e)?void 0:null==e?(r.filter=void 0,void this._updateLayer(r)):void(this._validate(g.filter,"layers."+r.id+".filter",e)||(r.filter=u.clone(e),this._updateLayer(r)));this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be filtered.")})},e.prototype.getFilter=function(t){return u.clone(this.getLayer(t).filter)},e.prototype.setLayoutProperty=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);n?u.deepEqual(n.getLayoutProperty(e),r)||(n.setLayoutProperty(e,r),this._updateLayer(n)):this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be styled.")})},e.prototype.getLayoutProperty=function(t,e){return this.getLayer(t).getLayoutProperty(e)},e.prototype.setPaintProperty=function(t,e,r){this._checkLoaded();var n=this.getLayer(t);if(n){if(!u.deepEqual(n.getPaintProperty(e),r)){var i=n._transitionablePaint._values[e].value.isDataDriven();n.setPaintProperty(e,r),(n._transitionablePaint._values[e].value.isDataDriven()||i)&&this._updateLayer(n),this._changed=!0,this._updatedPaintProps[t]=!0}}else this.fire("error",{error:new Error("The layer '"+t+"' does not exist in the map's style and cannot be styled.")})},e.prototype.getPaintProperty=function(t,e){return this.getLayer(t).getPaintProperty(e)},e.prototype.getTransition=function(){return u.extend({duration:300,delay:0},this.stylesheet&&this.stylesheet.transition)},e.prototype.serialize=function(){var t=this;return u.filterObject({version:this.stylesheet.version,name:this.stylesheet.name,metadata:this.stylesheet.metadata,light:this.stylesheet.light,center:this.stylesheet.center,zoom:this.stylesheet.zoom,bearing:this.stylesheet.bearing,pitch:this.stylesheet.pitch,sprite:this.stylesheet.sprite,glyphs:this.stylesheet.glyphs,transition:this.stylesheet.transition,sources:u.mapObject(this.sourceCaches,function(t){return t.serialize()}),layers:this._order.map(function(e){return t._layers[e].serialize()})},function(t){return void 0!==t})},e.prototype._updateLayer=function(t){this._updatedLayers[t.id]=!0,t.source&&!this._updatedSources[t.source]&&(this._updatedSources[t.source]="reload",this.sourceCaches[t.source].pause()),this._changed=!0},e.prototype._flattenRenderedFeatures=function(t){for(var e=[],r=this._order.length-1;r>=0;r--)for(var n=this._order[r],i=0,a=t;i=this.maxzoom)||"none"===this.visibility},e.prototype.updateTransitions=function(t){this._transitioningPaint=this._transitionablePaint.transitioned(t,this._transitioningPaint)},e.prototype.hasTransition=function(){return this._transitioningPaint.hasTransition()},e.prototype.recalculate=function(t){this._unevaluatedLayout&&(this.layout=this._unevaluatedLayout.possiblyEvaluate(t)),this.paint=this._transitioningPaint.possiblyEvaluate(t)},e.prototype.serialize=function(){var t={id:this.id,type:this.type,source:this.source,"source-layer":this.sourceLayer,metadata:this.metadata,minzoom:this.minzoom,maxzoom:this.maxzoom,filter:this.filter,layout:this._unevaluatedLayout&&this._unevaluatedLayout.serialize(),paint:this._transitionablePaint&&this._transitionablePaint.serialize()};return"none"===this.visibility&&(t.layout=t.layout||{},t.layout.visibility="none"),n.filterObject(t,function(t,e){return!(void 0===t||"layout"===e&&!Object.keys(t).length||"paint"===e&&!Object.keys(t).length)})},e.prototype._validate=function(t,e,r,n,o){return(!o||!1!==o.validate)&&a.emitErrors(this,t.call(a,{key:e,layerType:this.type,objectKey:r,value:n,styleSpec:i,style:{glyphs:!0,sprite:!0}}))},e.prototype.hasOffscreenPass=function(){return!1},e.prototype.resize=function(){},e}(o));e.exports=u;var f={circle:t("./style_layer/circle_style_layer"),heatmap:t("./style_layer/heatmap_style_layer"),hillshade:t("./style_layer/hillshade_style_layer"),fill:t("./style_layer/fill_style_layer"),"fill-extrusion":t("./style_layer/fill_extrusion_style_layer"),line:t("./style_layer/line_style_layer"),symbol:t("./style_layer/symbol_style_layer"),background:t("./style_layer/background_style_layer"),raster:t("./style_layer/raster_style_layer")};u.create=function(t){return new f[t.type](t)}},{"../style-spec/reference/latest":151,"../util/evented":260,"../util/util":275,"./properties":188,"./style_layer/background_style_layer":192,"./style_layer/circle_style_layer":194,"./style_layer/fill_extrusion_style_layer":196,"./style_layer/fill_style_layer":198,"./style_layer/heatmap_style_layer":200,"./style_layer/hillshade_style_layer":202,"./style_layer/line_style_layer":204,"./style_layer/raster_style_layer":206,"./style_layer/symbol_style_layer":208,"./validate_style":211}],192:[function(t,e,r){var n=t("../style_layer"),i=t("./background_style_layer_properties"),a=t("../properties"),o=(a.Transitionable,a.Transitioning,a.PossiblyEvaluated,function(t){function e(e){t.call(this,e,i)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(n));e.exports=o},{"../properties":188,"../style_layer":191,"./background_style_layer_properties":193}],193:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=(i.DataDrivenProperty,i.CrossFadedProperty),l=(i.HeatmapColorProperty,new a({"background-color":new o(n.paint_background["background-color"]),"background-pattern":new s(n.paint_background["background-pattern"]),"background-opacity":new o(n.paint_background["background-opacity"])}));e.exports={paint:l}},{"../../style-spec/reference/latest":151,"../properties":188}],194:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/circle_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsBufferedMultiPoint,o=t("../query_utils"),s=o.getMaximumPaintValue,l=o.translateDistance,c=o.translate,u=t("./circle_style_layer_properties"),f=t("../properties"),h=(f.Transitionable,f.Transitioning,f.PossiblyEvaluated,function(t){function e(e){t.call(this,e,u)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(t){var e=t;return s("circle-radius",this,e)+s("circle-stroke-width",this,e)+l(this.paint.get("circle-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=c(t,this.paint.get("circle-translate"),this.paint.get("circle-translate-anchor"),i,o),l=this.paint.get("circle-radius").evaluate(e)*o,u=this.paint.get("circle-stroke-width").evaluate(e)*o;return a(s,r,l+u)},e}(n));e.exports=h},{"../../data/bucket/circle_bucket":42,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./circle_style_layer_properties":195}],195:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=(i.CrossFadedProperty,i.HeatmapColorProperty,new a({"circle-radius":new s(n.paint_circle["circle-radius"]),"circle-color":new s(n.paint_circle["circle-color"]),"circle-blur":new s(n.paint_circle["circle-blur"]),"circle-opacity":new s(n.paint_circle["circle-opacity"]),"circle-translate":new o(n.paint_circle["circle-translate"]),"circle-translate-anchor":new o(n.paint_circle["circle-translate-anchor"]),"circle-pitch-scale":new o(n.paint_circle["circle-pitch-scale"]),"circle-pitch-alignment":new o(n.paint_circle["circle-pitch-alignment"]),"circle-stroke-width":new s(n.paint_circle["circle-stroke-width"]),"circle-stroke-color":new s(n.paint_circle["circle-stroke-color"]),"circle-stroke-opacity":new s(n.paint_circle["circle-stroke-opacity"])}));e.exports={paint:l}},{"../../style-spec/reference/latest":151,"../properties":188}],196:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/fill_extrusion_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsMultiPolygon,o=t("../query_utils"),s=o.translateDistance,l=o.translate,c=t("./fill_extrusion_style_layer_properties"),u=t("../properties"),f=(u.Transitionable,u.Transitioning,u.PossiblyEvaluated,function(t){function e(e){t.call(this,e,c)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(){return s(this.paint.get("fill-extrusion-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=l(t,this.paint.get("fill-extrusion-translate"),this.paint.get("fill-extrusion-translate-anchor"),i,o);return a(s,r)},e.prototype.hasOffscreenPass=function(){return 0!==this.paint.get("fill-extrusion-opacity")&&"none"!==this.visibility},e.prototype.resize=function(){this.viewportFrame&&(this.viewportFrame.destroy(),this.viewportFrame=null)},e}(n));e.exports=f},{"../../data/bucket/fill_extrusion_bucket":46,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./fill_extrusion_style_layer_properties":197}],197:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=i.CrossFadedProperty,c=(i.HeatmapColorProperty,new a({"fill-extrusion-opacity":new o(n["paint_fill-extrusion"]["fill-extrusion-opacity"]),"fill-extrusion-color":new s(n["paint_fill-extrusion"]["fill-extrusion-color"]),"fill-extrusion-translate":new o(n["paint_fill-extrusion"]["fill-extrusion-translate"]),"fill-extrusion-translate-anchor":new o(n["paint_fill-extrusion"]["fill-extrusion-translate-anchor"]),"fill-extrusion-pattern":new l(n["paint_fill-extrusion"]["fill-extrusion-pattern"]),"fill-extrusion-height":new s(n["paint_fill-extrusion"]["fill-extrusion-height"]),"fill-extrusion-base":new s(n["paint_fill-extrusion"]["fill-extrusion-base"])}));e.exports={paint:c}},{"../../style-spec/reference/latest":151,"../properties":188}],198:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/fill_bucket"),a=t("../../util/intersection_tests").multiPolygonIntersectsMultiPolygon,o=t("../query_utils"),s=o.translateDistance,l=o.translate,c=t("./fill_style_layer_properties"),u=t("../properties"),f=(u.Transitionable,u.Transitioning,u.PossiblyEvaluated,function(t){function e(e){t.call(this,e,c)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.recalculate=function(t){this.paint=this._transitioningPaint.possiblyEvaluate(t),void 0===this._transitionablePaint.getValue("fill-outline-color")&&(this.paint._values["fill-outline-color"]=this.paint._values["fill-color"])},e.prototype.createBucket=function(t){return new i(t)},e.prototype.queryRadius=function(){return s(this.paint.get("fill-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,n,i,o){var s=l(t,this.paint.get("fill-translate"),this.paint.get("fill-translate-anchor"),i,o);return a(s,r)},e}(n));e.exports=f},{"../../data/bucket/fill_bucket":44,"../../util/intersection_tests":264,"../properties":188,"../query_utils":189,"../style_layer":191,"./fill_style_layer_properties":199}],199:[function(t,e,r){var n=t("../../style-spec/reference/latest"),i=t("../properties"),a=i.Properties,o=i.DataConstantProperty,s=i.DataDrivenProperty,l=i.CrossFadedProperty,c=(i.HeatmapColorProperty,new a({"fill-antialias":new o(n.paint_fill["fill-antialias"]),"fill-opacity":new s(n.paint_fill["fill-opacity"]),"fill-color":new s(n.paint_fill["fill-color"]),"fill-outline-color":new s(n.paint_fill["fill-outline-color"]),"fill-translate":new o(n.paint_fill["fill-translate"]),"fill-translate-anchor":new o(n.paint_fill["fill-translate-anchor"]),"fill-pattern":new l(n.paint_fill["fill-pattern"])}));e.exports={paint:c}},{"../../style-spec/reference/latest":151,"../properties":188}],200:[function(t,e,r){var n=t("../style_layer"),i=t("../../data/bucket/heatmap_bucket"),a=t("../../util/image").RGBAImage,o=t("./heatmap_style_layer_properties"),s=t("../properties"),l=(s.Transitionable,s.Transitioning,s.PossiblyEvaluated,function(t){function e(e){t.call(this,e,o),this._updateColorRamp()}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.createBucket=function(t){return new i(t)},e.prototype.setPaintProperty=function(e,r,n){t.prototype.setPaintProperty.call(this,e,r,n),"heatmap-color"===e&&this._updateColorRamp()},e.prototype._updateColorRamp=function(){for(var t=this._transitionablePaint._values["heatmap-color"].value.expression,e=new Uint8Array(1024),r=e.length,n=4;n0?e+2*t:t}var i=t("@mapbox/point-geometry"),a=t("../style_layer"),o=t("../../data/bucket/line_bucket"),s=t("../../util/intersection_tests").multiPolygonIntersectsBufferedMultiLine,l=t("../query_utils"),c=l.getMaximumPaintValue,u=l.translateDistance,f=l.translate,h=t("./line_style_layer_properties"),p=t("../../util/util").extend,d=t("../evaluation_parameters"),g=t("../properties"),m=(g.Transitionable,g.Transitioning,g.Layout,g.PossiblyEvaluated,new(function(t){function e(){t.apply(this,arguments)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.possiblyEvaluate=function(e,r){return r=new d(Math.floor(r.zoom),{now:r.now,fadeDuration:r.fadeDuration,zoomHistory:r.zoomHistory,transition:r.transition}),t.prototype.possiblyEvaluate.call(this,e,r)},e.prototype.evaluate=function(e,r,n){return r=p({},r,{zoom:Math.floor(r.zoom)}),t.prototype.evaluate.call(this,e,r,n)},e}(g.DataDrivenProperty))(h.paint.properties["line-width"].specification));m.useIntegerZoom=!0;var v=function(t){function e(e){t.call(this,e,h)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.recalculate=function(e){t.prototype.recalculate.call(this,e),this.paint._values["line-floorwidth"]=m.possiblyEvaluate(this._transitioningPaint._values["line-width"].value,e)},e.prototype.createBucket=function(t){return new o(t)},e.prototype.queryRadius=function(t){var e=t,r=n(c("line-width",this,e),c("line-gap-width",this,e)),i=c("line-offset",this,e);return r/2+Math.abs(i)+u(this.paint.get("line-translate"))},e.prototype.queryIntersectsFeature=function(t,e,r,a,o,l){var c=f(t,this.paint.get("line-translate"),this.paint.get("line-translate-anchor"),o,l),u=l/2*n(this.paint.get("line-width").evaluate(e),this.paint.get("line-gap-width").evaluate(e)),h=this.paint.get("line-offset").evaluate(e);return h&&(r=function(t,e){for(var r=[],n=new i(0,0),a=0;ar?(this.lastIntegerZoom=r+1,this.lastIntegerZoomTime=e):this.lastFloorZoom-r/2;){if(--o<0)return!1;s-=t[o].dist(a),a=t[o]}s+=t[o].dist(t[o+1]),o++;for(var l=[],c=0;sn;)c-=l.shift().angleDelta;if(c>i)return!1;o++,s+=f.dist(h)}return!0}},{}],215:[function(t,e,r){var n=t("@mapbox/point-geometry");e.exports=function(t,e,r,i,a){for(var o=[],s=0;s=i&&h.x>=i||(f.x>=i?f=new n(i,f.y+(h.y-f.y)*((i-f.x)/(h.x-f.x)))._round():h.x>=i&&(h=new n(i,f.y+(h.y-f.y)*((i-f.x)/(h.x-f.x)))._round()),f.y>=a&&h.y>=a||(f.y>=a?f=new n(f.x+(h.x-f.x)*((a-f.y)/(h.y-f.y)),a)._round():h.y>=a&&(h=new n(f.x+(h.x-f.x)*((a-f.y)/(h.y-f.y)),a)._round()),c&&f.equals(c[c.length-1])||(c=[f],o.push(c)),c.push(h)))))}return o}},{"@mapbox/point-geometry":4}],216:[function(t,e,r){var n=function(t,e,r,n,i,a,o,s,l,c,u){var f=o.top*s-l,h=o.bottom*s+l,p=o.left*s-l,d=o.right*s+l;if(this.boxStartIndex=t.length,c){var g=h-f,m=d-p;g>0&&(g=Math.max(10*s,g),this._addLineCollisionCircles(t,e,r,r.segment,m,g,n,i,a,u))}else t.emplaceBack(r.x,r.y,p,f,d,h,n,i,a,0,0);this.boxEndIndex=t.length};n.prototype._addLineCollisionCircles=function(t,e,r,n,i,a,o,s,l,c){var u=a/2,f=Math.floor(i/u),h=1+.4*Math.log(c)/Math.LN2,p=Math.floor(f*h/2),d=-a/2,g=r,m=n+1,v=d,y=-i/2,x=y-i/4;do{if(--m<0){if(v>y)return;m=0;break}v-=e[m].dist(g),g=e[m]}while(v>x);for(var b=e[m].dist(e[m+1]),_=-p;_i&&(k+=w-i),!(k=e.length)return;b=e[m].dist(e[m+1])}var M=k-v,A=e[m],T=e[m+1].sub(A)._unit()._mult(M)._add(A)._round(),S=Math.abs(k-d)L)n(t,z,!1);else{var R=m.projectPoint(h,P,D),B=O*S;if(v.length>0){var F=R.x-v[v.length-4],N=R.y-v[v.length-3];if(B*B*2>F*F+N*N&&z+8-E&&j=this.screenRightBoundary||n<100||e>this.screenBottomBoundary},e.exports=l},{"../symbol/projection":224,"../util/intersection_tests":264,"./grid_index":220,"@mapbox/gl-matrix":2,"@mapbox/point-geometry":4}],218:[function(t,e,r){var n=t("../data/extent"),i=512/n/2,a=function(t,e,r){var n=this;this.tileID=t,this.indexedSymbolInstances={},this.bucketInstanceId=r;for(var i=0,a=e;it.overscaledZ)for(var c in l){var u=l[c];u.tileID.isChildOf(t)&&u.findMatches(e.symbolInstances,t,o)}else{var f=l[t.scaledTo(Number(s)).key];f&&f.findMatches(e.symbolInstances,t,o)}}for(var h=0,p=e.symbolInstances;h=0&&A=0&&T=0&&v+p<=d){var S=new i(A,T,k,x);S._round(),s&&!a(e,S,c,s,l)||y.push(S)}}m+=w}return f||y.length||u||(y=t(e,m/2,o,s,l,c,u,!0,h)),y}(t,d?e/2*u%e:(p/2+2*l)*c*u%e,e,h,r,p*c,d,!1,f)}},{"../style-spec/util/interpolate":158,"../symbol/anchor":213,"./check_max_angle":214}],220:[function(t,e,r){var n=function(t,e,r){var n=this.boxCells=[],i=this.circleCells=[];this.xCellCount=Math.ceil(t/r),this.yCellCount=Math.ceil(e/r);for(var a=0;athis.width||n<0||e>this.height)return!i&&[];var a=[];if(t<=0&&e<=0&&this.width<=r&&this.height<=n)a=Array.prototype.slice.call(this.boxKeys).concat(this.circleKeys);else{var o={hitTest:i,seenUids:{box:{},circle:{}}};this._forEachCell(t,e,r,n,this._queryCell,a,o)}return i?a.length>0:a},n.prototype._queryCircle=function(t,e,r,n){var i=t-r,a=t+r,o=e-r,s=e+r;if(a<0||i>this.width||s<0||o>this.height)return!n&&[];var l=[],c={hitTest:n,circle:{x:t,y:e,radius:r},seenUids:{box:{},circle:{}}};return this._forEachCell(i,o,a,s,this._queryCellCircle,l,c),n?l.length>0:l},n.prototype.query=function(t,e,r,n){return this._query(t,e,r,n,!1)},n.prototype.hitTest=function(t,e,r,n){return this._query(t,e,r,n,!0)},n.prototype.hitTestCircle=function(t,e,r){return this._queryCircle(t,e,r,!0)},n.prototype._queryCell=function(t,e,r,n,i,a,o){var s=this,l=o.seenUids,c=this.boxCells[i];if(null!==c)for(var u=this.bboxes,f=0,h=c;f=u[d+0]&&n>=u[d+1]){if(o.hitTest)return a.push(!0),!0;a.push(s.boxKeys[p])}}}var g=this.circleCells[i];if(null!==g)for(var m=this.circles,v=0,y=g;vo*o+s*s},n.prototype._circleAndRectCollide=function(t,e,r,n,i,a,o){var s=(a-n)/2,l=Math.abs(t-(n+s));if(l>s+r)return!1;var c=(o-i)/2,u=Math.abs(e-(i+c));if(u>c+r)return!1;if(l<=s||u<=c)return!0;var f=l-s,h=u-c;return f*f+h*h<=r*r},e.exports=n},{}],221:[function(t,e,r){e.exports=function(t){function e(e){s.push(t[e]),l++}function r(t,e,r){var n=o[t];return delete o[t],o[e]=n,s[n].geometry[0].pop(),s[n].geometry[0]=s[n].geometry[0].concat(r[0]),n}function n(t,e,r){var n=a[e];return delete a[e],a[t]=n,s[n].geometry[0].shift(),s[n].geometry[0]=r[0].concat(s[n].geometry[0]),n}function i(t,e,r){var n=r?e[0][e[0].length-1]:e[0][0];return t+":"+n.x+":"+n.y}for(var a={},o={},s=[],l=0,c=0;c0,M=M&&A.offscreen);var C=_.collisionArrays.textCircles;if(C){var E=t.text.placedSymbolArray.get(_.placedTextSymbolIndices[0]),L=s.evaluateSizeForFeature(t.textSizeData,m,E);T=d.collisionIndex.placeCollisionCircles(C,g.get("text-allow-overlap"),i,a,_.key,E,t.lineVertexArray,t.glyphOffsetArray,L,e,r,o,"map"===g.get("text-pitch-alignment")),w=g.get("text-allow-overlap")||T.circles.length>0,M=M&&T.offscreen}_.collisionArrays.iconBox&&(k=(S=d.collisionIndex.placeCollisionBox(_.collisionArrays.iconBox,g.get("icon-allow-overlap"),a,e)).box.length>0,M=M&&S.offscreen),v||y?y?v||(k=k&&w):w=k&&w:k=w=k&&w,w&&A&&d.collisionIndex.insertCollisionBox(A.box,g.get("text-ignore-placement"),f,h,t.bucketInstanceId,_.textBoxStartIndex),k&&S&&d.collisionIndex.insertCollisionBox(S.box,g.get("icon-ignore-placement"),f,h,t.bucketInstanceId,_.iconBoxStartIndex),w&&T&&d.collisionIndex.insertCollisionCircles(T.circles,g.get("text-ignore-placement"),f,h,t.bucketInstanceId,_.textBoxStartIndex),d.placements[_.crossTileID]=new p(w,k,M||t.justReloaded),l[_.crossTileID]=!0}}t.justReloaded=!1},d.prototype.commit=function(t,e){var r=this;this.commitTime=e;var n=!1,i=t&&0!==this.fadeDuration?(this.commitTime-t.commitTime)/this.fadeDuration:1,a=t?t.opacities:{};for(var o in r.placements){var s=r.placements[o],l=a[o];l?(r.opacities[o]=new h(l,i,s.text,s.icon),n=n||s.text!==l.text.placed||s.icon!==l.icon.placed):(r.opacities[o]=new h(null,i,s.text,s.icon,s.skipFade),n=n||s.text||s.icon)}for(var c in a){var u=a[c];if(!r.opacities[c]){var f=new h(u,i,!1,!1);f.isHidden()||(r.opacities[c]=f,n=n||u.text.placed||u.icon.placed)}}n?this.lastPlacementChangeTime=e:"number"!=typeof this.lastPlacementChangeTime&&(this.lastPlacementChangeTime=t?t.lastPlacementChangeTime:e)},d.prototype.updateLayerOpacities=function(t,e){for(var r={},n=0,i=e;n0||l.numVerticalGlyphVertices>0,p=l.numIconVertices>0;if(f){for(var d=i(u.text),g=(l.numGlyphVertices+l.numVerticalGlyphVertices)/4,m=0;mt},d.prototype.setStale=function(){this.stale=!0};var g=Math.pow(2,25),m=Math.pow(2,24),v=Math.pow(2,17),y=Math.pow(2,16),x=Math.pow(2,9),b=Math.pow(2,8),_=Math.pow(2,1);e.exports=d},{"../data/extent":53,"../source/pixels_to_tile_units":104,"../style/style_layer/symbol_style_layer_properties":209,"./collision_index":217,"./projection":224,"./symbol_size":228}],224:[function(t,e,r){function n(t,e){var r=[t.x,t.y,0,1];f(r,r,e);var n=r[3];return{point:new h(r[0]/n,r[1]/n),signedDistanceFromCamera:n}}function i(t,e){var r=t[0]/t[3],n=t[1]/t[3];return r>=-e[0]&&r<=e[0]&&n>=-e[1]&&n<=e[1]}function a(t,e,r,n,i,a,o,s,l,u,f,h){var p=s.glyphStartIndex+s.numGlyphs,d=s.lineStartIndex,g=s.lineStartIndex+s.lineLength,m=e.getoffsetX(s.glyphStartIndex),v=e.getoffsetX(p-1),y=c(t*m,r,n,i,a,o,s.segment,d,g,l,u,f,h);if(!y)return null;var x=c(t*v,r,n,i,a,o,s.segment,d,g,l,u,f,h);return x?{first:y,last:x}:null}function o(t,e,r,n){return t===x.horizontal&&Math.abs(r.y-e.y)>Math.abs(r.x-e.x)*n?{useVertical:!0}:(t===x.vertical?e.yr.x)?{needsFlipping:!0}:null}function s(t,e,r,i,s,u,f,p,d,g,m,y,x,b){var _,w=e/24,k=t.lineOffsetX*e,M=t.lineOffsetY*e;if(t.numGlyphs>1){var A=t.glyphStartIndex+t.numGlyphs,T=t.lineStartIndex,S=t.lineStartIndex+t.lineLength,C=a(w,p,k,M,r,m,y,t,d,u,x,!1);if(!C)return{notEnoughRoom:!0};var E=n(C.first.point,f).point,L=n(C.last.point,f).point;if(i&&!r){var z=o(t.writingMode,E,L,b);if(z)return z}_=[C.first];for(var P=t.glyphStartIndex+1;P0?R.point:l(y,I,D,1,s),F=o(t.writingMode,D,B,b);if(F)return F}var N=c(w*p.getoffsetX(t.glyphStartIndex),k,M,r,m,y,t.segment,t.lineStartIndex,t.lineStartIndex+t.lineLength,d,u,x,!1);if(!N)return{notEnoughRoom:!0};_=[N]}for(var j=0,V=_;j0?1:-1,y=0;i&&(v*=-1,y=Math.PI),v<0&&(y+=Math.PI);for(var x=v>0?c+s:c+s+1,b=x,_=a,w=a,k=0,M=0,A=Math.abs(m);k+M<=A;){if((x+=v)=u)return null;if(w=_,void 0===(_=d[x])){var T=new h(f.getx(x),f.gety(x)),S=n(T,p);if(S.signedDistanceFromCamera>0)_=d[x]=S.point;else{var C=x-v;_=l(0===k?o:new h(f.getx(C),f.gety(C)),T,w,A-k+1,p)}}k+=M,M=w.dist(_)}var E=(A-k)/M,L=_.sub(w),z=L.mult(E)._add(w);return z._add(L._unit()._perp()._mult(r*v)),{point:z,angle:y+Math.atan2(_.y-w.y,_.x-w.x),tileDistance:g?{prevTileDistance:x-v===b?0:f.gettileUnitDistanceFromAnchor(x-v),lastSegmentViewportDistance:A-k}:null}}function u(t,e){for(var r=0;r=w||o.y<0||o.y>=w||t.symbolInstances.push(function(t,e,r,n,a,o,s,l,u,f,h,d,g,x,b,_,w,M,A,T,S,C){var E,L,z=t.addToLineVertexArray(e,r),P=0,D=0,O=0,I=n.horizontal?n.horizontal.text:"",R=[];n.horizontal&&(E=new v(s,r,e,l,u,f,n.horizontal,h,d,g,t.overscaling),D+=i(t,e,n.horizontal,o,g,A,T,x,z,n.vertical?p.horizontal:p.horizontalOnly,R,S,C),n.vertical&&(O+=i(t,e,n.vertical,o,g,A,T,x,z,p.vertical,R,S,C)));var B=E?E.boxStartIndex:t.collisionBoxArray.length,F=E?E.boxEndIndex:t.collisionBoxArray.length;if(a){var N=m(e,a,o,w,n.horizontal,A,T);L=new v(s,r,e,l,u,f,a,b,_,!1,t.overscaling),P=4*N.length;var j=t.iconSizeData,V=null;"source"===j.functionType?V=[10*o.layout.get("icon-size").evaluate(T)]:"composite"===j.functionType&&(V=[10*C.compositeIconSizes[0].evaluate(T),10*C.compositeIconSizes[1].evaluate(T)]),t.addSymbols(t.icon,N,V,M,w,T,!1,e,z.lineStartIndex,z.lineLength)}var U=L?L.boxStartIndex:t.collisionBoxArray.length,q=L?L.boxEndIndex:t.collisionBoxArray.length;return t.glyphOffsetArray.length>=k.MAX_GLYPHS&&y.warnOnce("Too many glyphs being rendered in a tile. See https://github.com/mapbox/mapbox-gl-js/issues/2907"),{key:I,textBoxStartIndex:B,textBoxEndIndex:F,iconBoxStartIndex:U,iconBoxEndIndex:q,textOffset:x,iconOffset:M,anchor:e,line:r,featureIndex:l,feature:T,numGlyphVertices:D,numVerticalGlyphVertices:O,numIconVertices:P,textOpacityState:new c,iconOpacityState:new c,isDuplicate:!1,placedTextSymbolIndices:R,crossTileID:0}}(t,o,a,r,n,t.layers[0],t.collisionBoxArray,e.index,e.sourceLayerIndex,t.index,S,z,O,M,E,P,I,A,{zoom:t.zoom},e,u,f))};if("line"===x.get("symbol-placement"))for(var F=0,N=l(e.geometry,0,0,w,w);F=0;o--)if(n.dist(a[o])1||(h?(clearTimeout(h),h=null,o("dblclick",e)):h=setTimeout(r,300))},!1),l.addEventListener("touchend",function(t){s("touchend",t)},!1),l.addEventListener("touchmove",function(t){s("touchmove",t)},!1),l.addEventListener("touchcancel",function(t){s("touchcancel",t)},!1),l.addEventListener("click",function(t){n.mousePos(l,t).equals(f)&&o("click",t)},!1),l.addEventListener("dblclick",function(t){o("dblclick",t),t.preventDefault()},!1),l.addEventListener("contextmenu",function(e){var r=t.dragRotate&&t.dragRotate.isActive();u||r?u&&(c=e):o("contextmenu",e),e.preventDefault()},!1)}},{"../util/dom":259,"./handler/box_zoom":239,"./handler/dblclick_zoom":240,"./handler/drag_pan":241,"./handler/drag_rotate":242,"./handler/keyboard":243,"./handler/scroll_zoom":244,"./handler/touch_zoom_rotate":245,"@mapbox/point-geometry":4}],231:[function(t,e,r){var n=t("../util/util"),i=t("../style-spec/util/interpolate").number,a=t("../util/browser"),o=t("../geo/lng_lat"),s=t("../geo/lng_lat_bounds"),l=t("@mapbox/point-geometry"),c=function(t){function e(e,r){t.call(this),this.moving=!1,this.transform=e,this._bearingSnap=r.bearingSnap}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.getCenter=function(){return this.transform.center},e.prototype.setCenter=function(t,e){return this.jumpTo({center:t},e)},e.prototype.panBy=function(t,e,r){return t=l.convert(t).mult(-1),this.panTo(this.transform.center,n.extend({offset:t},e),r)},e.prototype.panTo=function(t,e,r){return this.easeTo(n.extend({center:t},e),r)},e.prototype.getZoom=function(){return this.transform.zoom},e.prototype.setZoom=function(t,e){return this.jumpTo({zoom:t},e),this},e.prototype.zoomTo=function(t,e,r){return this.easeTo(n.extend({zoom:t},e),r)},e.prototype.zoomIn=function(t,e){return this.zoomTo(this.getZoom()+1,t,e),this},e.prototype.zoomOut=function(t,e){return this.zoomTo(this.getZoom()-1,t,e),this},e.prototype.getBearing=function(){return this.transform.bearing},e.prototype.setBearing=function(t,e){return this.jumpTo({bearing:t},e),this},e.prototype.rotateTo=function(t,e,r){return this.easeTo(n.extend({bearing:t},e),r)},e.prototype.resetNorth=function(t,e){return this.rotateTo(0,n.extend({duration:1e3},t),e),this},e.prototype.snapToNorth=function(t,e){return Math.abs(this.getBearing())e?1:0}),["bottom","left","right","top"]))return n.warnOnce("options.padding must be a positive number, or an Object with keys 'bottom', 'left', 'right', 'top'"),this;t=s.convert(t);var a=[(e.padding.left-e.padding.right)/2,(e.padding.top-e.padding.bottom)/2],o=Math.min(e.padding.right,e.padding.left),c=Math.min(e.padding.top,e.padding.bottom);e.offset=[e.offset[0]+a[0],e.offset[1]+a[1]];var u=l.convert(e.offset),f=this.transform,h=f.project(t.getNorthWest()),p=f.project(t.getSouthEast()),d=p.sub(h),g=(f.width-2*o-2*Math.abs(u.x))/d.x,m=(f.height-2*c-2*Math.abs(u.y))/d.y;return m<0||g<0?(n.warnOnce("Map cannot fit within canvas with the given bounds, padding, and/or offset."),this):(e.center=f.unproject(h.add(p).div(2)),e.zoom=Math.min(f.scaleZoom(f.scale*Math.min(g,m)),e.maxZoom),e.bearing=0,e.linear?this.easeTo(e,r):this.flyTo(e,r))},e.prototype.jumpTo=function(t,e){this.stop();var r=this.transform,n=!1,i=!1,a=!1;return"zoom"in t&&r.zoom!==+t.zoom&&(n=!0,r.zoom=+t.zoom),void 0!==t.center&&(r.center=o.convert(t.center)),"bearing"in t&&r.bearing!==+t.bearing&&(i=!0,r.bearing=+t.bearing),"pitch"in t&&r.pitch!==+t.pitch&&(a=!0,r.pitch=+t.pitch),this.fire("movestart",e).fire("move",e),n&&this.fire("zoomstart",e).fire("zoom",e).fire("zoomend",e),i&&this.fire("rotate",e),a&&this.fire("pitchstart",e).fire("pitch",e).fire("pitchend",e),this.fire("moveend",e)},e.prototype.easeTo=function(t,e){var r=this;this.stop(),!1===(t=n.extend({offset:[0,0],duration:500,easing:n.ease},t)).animate&&(t.duration=0);var a=this.transform,s=this.getZoom(),c=this.getBearing(),u=this.getPitch(),f="zoom"in t?+t.zoom:s,h="bearing"in t?this._normalizeBearing(t.bearing,c):c,p="pitch"in t?+t.pitch:u,d=a.centerPoint.add(l.convert(t.offset)),g=a.pointLocation(d),m=o.convert(t.center||g);this._normalizeCenter(m);var v,y,x=a.project(g),b=a.project(m).sub(x),_=a.zoomScale(f-s);return t.around&&(v=o.convert(t.around),y=a.locationPoint(v)),this.zooming=f!==s,this.rotating=c!==h,this.pitching=p!==u,this._prepareEase(e,t.noMoveStart),clearTimeout(this._onEaseEnd),this._ease(function(t){if(r.zooming&&(a.zoom=i(s,f,t)),r.rotating&&(a.bearing=i(c,h,t)),r.pitching&&(a.pitch=i(u,p,t)),v)a.setLocationAtPoint(v,y);else{var n=a.zoomScale(a.zoom-s),o=f>s?Math.min(2,_):Math.max(.5,_),l=Math.pow(o,1-t),g=a.unproject(x.add(b.mult(t*l)).mult(n));a.setLocationAtPoint(a.renderWorldCopies?g.wrap():g,d)}r._fireMoveEvents(e)},function(){t.delayEndEvents?r._onEaseEnd=setTimeout(function(){return r._afterEase(e)},t.delayEndEvents):r._afterEase(e)},t),this},e.prototype._prepareEase=function(t,e){this.moving=!0,e||this.fire("movestart",t),this.zooming&&this.fire("zoomstart",t),this.pitching&&this.fire("pitchstart",t)},e.prototype._fireMoveEvents=function(t){this.fire("move",t),this.zooming&&this.fire("zoom",t),this.rotating&&this.fire("rotate",t),this.pitching&&this.fire("pitch",t)},e.prototype._afterEase=function(t){var e=this.zooming,r=this.pitching;this.moving=!1,this.zooming=!1,this.rotating=!1,this.pitching=!1,e&&this.fire("zoomend",t),r&&this.fire("pitchend",t),this.fire("moveend",t)},e.prototype.flyTo=function(t,e){function r(t){var e=(A*A-M*M+(t?-1:1)*E*E*T*T)/(2*(t?A:M)*E*T);return Math.log(Math.sqrt(e*e+1)-e)}function a(t){return(Math.exp(t)-Math.exp(-t))/2}function s(t){return(Math.exp(t)+Math.exp(-t))/2}var c=this;this.stop(),t=n.extend({offset:[0,0],speed:1.2,curve:1.42,easing:n.ease},t);var u=this.transform,f=this.getZoom(),h=this.getBearing(),p=this.getPitch(),d="zoom"in t?n.clamp(+t.zoom,u.minZoom,u.maxZoom):f,g="bearing"in t?this._normalizeBearing(t.bearing,h):h,m="pitch"in t?+t.pitch:p,v=u.zoomScale(d-f),y=u.centerPoint.add(l.convert(t.offset)),x=u.pointLocation(y),b=o.convert(t.center||x);this._normalizeCenter(b);var _=u.project(x),w=u.project(b).sub(_),k=t.curve,M=Math.max(u.width,u.height),A=M/v,T=w.mag();if("minZoom"in t){var S=n.clamp(Math.min(t.minZoom,f,d),u.minZoom,u.maxZoom),C=M/u.zoomScale(S-f);k=Math.sqrt(C/T*2)}var E=k*k,L=r(0),z=function(t){return s(L)/s(L+k*t)},P=function(t){return M*((s(L)*function(t){return a(t)/s(t)}(L+k*t)-a(L))/E)/T},D=(r(1)-L)/k;if(Math.abs(T)<1e-6||!isFinite(D)){if(Math.abs(M-A)<1e-6)return this.easeTo(t,e);var O=At.maxDuration&&(t.duration=0),this.zooming=!0,this.rotating=h!==g,this.pitching=m!==p,this._prepareEase(e,!1),this._ease(function(t){var r=t*D,n=1/z(r);u.zoom=f+u.scaleZoom(n),c.rotating&&(u.bearing=i(h,g,t)),c.pitching&&(u.pitch=i(p,m,t));var a=u.unproject(_.add(w.mult(P(r))).mult(n));u.setLocationAtPoint(u.renderWorldCopies?a.wrap():a,y),c._fireMoveEvents(e)},function(){return c._afterEase(e)},t),this},e.prototype.isEasing=function(){return!!this._isEasing},e.prototype.isMoving=function(){return this.moving},e.prototype.stop=function(){return this._onFrame&&this._finishAnimation(),this},e.prototype._ease=function(t,e,r){var n=this;!1===r.animate||0===r.duration?(t(1),e()):(this._easeStart=a.now(),this._isEasing=!0,this._easeOptions=r,this._startAnimation(function(e){var r=Math.min((a.now()-n._easeStart)/n._easeOptions.duration,1);t(n._easeOptions.easing(r)),1===r&&n.stop()},function(){n._isEasing=!1,e()}))},e.prototype._updateCamera=function(){this._onFrame&&this._onFrame(this.transform)},e.prototype._startAnimation=function(t,e){return void 0===e&&(e=function(){}),this.stop(),this._onFrame=t,this._finishFn=e,this._update(),this},e.prototype._finishAnimation=function(){delete this._onFrame;var t=this._finishFn;delete this._finishFn,t.call(this)},e.prototype._normalizeBearing=function(t,e){t=n.wrap(t,-180,180);var r=Math.abs(t-e);return Math.abs(t-360-e)180?-360:r<-180?360:0}},e}(t("../util/evented"));e.exports=c},{"../geo/lng_lat":62,"../geo/lng_lat_bounds":63,"../style-spec/util/interpolate":158,"../util/browser":252,"../util/evented":260,"../util/util":275,"@mapbox/point-geometry":4}],232:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/config"),o=function(t){this.options=t,i.bindAll(["_updateEditLink","_updateData","_updateCompact"],this)};o.prototype.getDefaultPosition=function(){return"bottom-right"},o.prototype.onAdd=function(t){var e=this.options&&this.options.compact;return this._map=t,this._container=n.create("div","mapboxgl-ctrl mapboxgl-ctrl-attrib"),e&&this._container.classList.add("mapboxgl-compact"),this._updateAttributions(),this._updateEditLink(),this._map.on("sourcedata",this._updateData),this._map.on("moveend",this._updateEditLink),void 0===e&&(this._map.on("resize",this._updateCompact),this._updateCompact()),this._container},o.prototype.onRemove=function(){n.remove(this._container),this._map.off("sourcedata",this._updateData),this._map.off("moveend",this._updateEditLink),this._map.off("resize",this._updateCompact),this._map=void 0},o.prototype._updateEditLink=function(){var t=this._editLink;t||(t=this._editLink=this._container.querySelector(".mapbox-improve-map"));var e=[{key:"owner",value:this.styleOwner},{key:"id",value:this.styleId},{key:"access_token",value:a.ACCESS_TOKEN}];if(t){var r=e.reduce(function(t,r,n){return r.value&&(t+=r.key+"="+r.value+(n=0)return!1;return!0})).length?(this._container.innerHTML=t.join(" | "),this._container.classList.remove("mapboxgl-attrib-empty")):this._container.classList.add("mapboxgl-attrib-empty"),this._editLink=null}},o.prototype._updateCompact=function(){this._map.getCanvasContainer().offsetWidth<=640?this._container.classList.add("mapboxgl-compact"):this._container.classList.remove("mapboxgl-compact")},e.exports=o},{"../../util/config":256,"../../util/dom":259,"../../util/util":275}],233:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=function(){this._fullscreen=!1,i.bindAll(["_onClickFullscreen","_changeIcon"],this),"onfullscreenchange"in a.document?this._fullscreenchange="fullscreenchange":"onmozfullscreenchange"in a.document?this._fullscreenchange="mozfullscreenchange":"onwebkitfullscreenchange"in a.document?this._fullscreenchange="webkitfullscreenchange":"onmsfullscreenchange"in a.document&&(this._fullscreenchange="MSFullscreenChange"),this._className="mapboxgl-ctrl"};o.prototype.onAdd=function(t){return this._map=t,this._mapContainer=this._map.getContainer(),this._container=n.create("div",this._className+" mapboxgl-ctrl-group"),this._checkFullscreenSupport()?this._setupUI():(this._container.style.display="none",i.warnOnce("This device does not support fullscreen mode.")),this._container},o.prototype.onRemove=function(){n.remove(this._container),this._map=null,a.document.removeEventListener(this._fullscreenchange,this._changeIcon)},o.prototype._checkFullscreenSupport=function(){return!!(a.document.fullscreenEnabled||a.document.mozFullScreenEnabled||a.document.msFullscreenEnabled||a.document.webkitFullscreenEnabled)},o.prototype._setupUI=function(){var t=this._fullscreenButton=n.create("button",this._className+"-icon "+this._className+"-fullscreen",this._container);t.setAttribute("aria-label","Toggle fullscreen"),t.type="button",this._fullscreenButton.addEventListener("click",this._onClickFullscreen),a.document.addEventListener(this._fullscreenchange,this._changeIcon)},o.prototype._isFullscreen=function(){return this._fullscreen},o.prototype._changeIcon=function(){(a.document.fullscreenElement||a.document.mozFullScreenElement||a.document.webkitFullscreenElement||a.document.msFullscreenElement)===this._mapContainer!==this._fullscreen&&(this._fullscreen=!this._fullscreen,this._fullscreenButton.classList.toggle(this._className+"-shrink"),this._fullscreenButton.classList.toggle(this._className+"-fullscreen"))},o.prototype._onClickFullscreen=function(){this._isFullscreen()?a.document.exitFullscreen?a.document.exitFullscreen():a.document.mozCancelFullScreen?a.document.mozCancelFullScreen():a.document.msExitFullscreen?a.document.msExitFullscreen():a.document.webkitCancelFullScreen&&a.document.webkitCancelFullScreen():this._mapContainer.requestFullscreen?this._mapContainer.requestFullscreen():this._mapContainer.mozRequestFullScreen?this._mapContainer.mozRequestFullScreen():this._mapContainer.msRequestFullscreen?this._mapContainer.msRequestFullscreen():this._mapContainer.webkitRequestFullscreen&&this._mapContainer.webkitRequestFullscreen()},e.exports=o},{"../../util/dom":259,"../../util/util":275,"../../util/window":254}],234:[function(t,e,r){var n,i=t("../../util/evented"),a=t("../../util/dom"),o=t("../../util/window"),s=t("../../util/util"),l=t("../../geo/lng_lat"),c=t("../marker"),u={positionOptions:{enableHighAccuracy:!1,timeout:6e3},fitBoundsOptions:{maxZoom:15},trackUserLocation:!1,showUserLocation:!0},f=function(t){function e(e){t.call(this),this.options=s.extend({},u,e),s.bindAll(["_onSuccess","_onError","_finish","_setupUI","_updateCamera","_updateMarker","_onClickGeolocate"],this)}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e.prototype.onAdd=function(t){return this._map=t,this._container=a.create("div","mapboxgl-ctrl mapboxgl-ctrl-group"),function(t){void 0!==n?t(n):void 0!==o.navigator.permissions?o.navigator.permissions.query({name:"geolocation"}).then(function(e){n="denied"!==e.state,t(n)}):(n=!!o.navigator.geolocation,t(n))}(this._setupUI),this._container},e.prototype.onRemove=function(){void 0!==this._geolocationWatchID&&(o.navigator.geolocation.clearWatch(this._geolocationWatchID),this._geolocationWatchID=void 0),this.options.showUserLocation&&this._userLocationDotMarker.remove(),a.remove(this._container),this._map=void 0},e.prototype._onSuccess=function(t){if(this.options.trackUserLocation)switch(this._lastKnownPosition=t,this._watchState){case"WAITING_ACTIVE":case"ACTIVE_LOCK":case"ACTIVE_ERROR":this._watchState="ACTIVE_LOCK",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"BACKGROUND":case"BACKGROUND_ERROR":this._watchState="BACKGROUND",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background")}this.options.showUserLocation&&"OFF"!==this._watchState&&this._updateMarker(t),this.options.trackUserLocation&&"ACTIVE_LOCK"!==this._watchState||this._updateCamera(t),this.options.showUserLocation&&this._dotElement.classList.remove("mapboxgl-user-location-dot-stale"),this.fire("geolocate",t),this._finish()},e.prototype._updateCamera=function(t){var e=new l(t.coords.longitude,t.coords.latitude),r=t.coords.accuracy;this._map.fitBounds(e.toBounds(r),this.options.fitBoundsOptions,{geolocateSource:!0})},e.prototype._updateMarker=function(t){t?this._userLocationDotMarker.setLngLat([t.coords.longitude,t.coords.latitude]).addTo(this._map):this._userLocationDotMarker.remove()},e.prototype._onError=function(t){if(this.options.trackUserLocation)if(1===t.code)this._watchState="OFF",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),void 0!==this._geolocationWatchID&&this._clearWatch();else switch(this._watchState){case"WAITING_ACTIVE":this._watchState="ACTIVE_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");break;case"ACTIVE_LOCK":this._watchState="ACTIVE_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting");break;case"BACKGROUND":this._watchState="BACKGROUND_ERROR",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting")}"OFF"!==this._watchState&&this.options.showUserLocation&&this._dotElement.classList.add("mapboxgl-user-location-dot-stale"),this.fire("error",t),this._finish()},e.prototype._finish=function(){this._timeoutId&&clearTimeout(this._timeoutId),this._timeoutId=void 0},e.prototype._setupUI=function(t){var e=this;!1!==t&&(this._container.addEventListener("contextmenu",function(t){return t.preventDefault()}),this._geolocateButton=a.create("button","mapboxgl-ctrl-icon mapboxgl-ctrl-geolocate",this._container),this._geolocateButton.type="button",this._geolocateButton.setAttribute("aria-label","Geolocate"),this.options.trackUserLocation&&(this._geolocateButton.setAttribute("aria-pressed","false"),this._watchState="OFF"),this.options.showUserLocation&&(this._dotElement=a.create("div","mapboxgl-user-location-dot"),this._userLocationDotMarker=new c(this._dotElement),this.options.trackUserLocation&&(this._watchState="OFF")),this._geolocateButton.addEventListener("click",this._onClickGeolocate.bind(this)),this.options.trackUserLocation&&this._map.on("movestart",function(t){t.geolocateSource||"ACTIVE_LOCK"!==e._watchState||(e._watchState="BACKGROUND",e._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background"),e._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),e.fire("trackuserlocationend"))}))},e.prototype._onClickGeolocate=function(){if(this.options.trackUserLocation){switch(this._watchState){case"OFF":this._watchState="WAITING_ACTIVE",this.fire("trackuserlocationstart");break;case"WAITING_ACTIVE":case"ACTIVE_LOCK":case"ACTIVE_ERROR":case"BACKGROUND_ERROR":this._watchState="OFF",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-active-error"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background-error"),this.fire("trackuserlocationend");break;case"BACKGROUND":this._watchState="ACTIVE_LOCK",this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-background"),this._lastKnownPosition&&this._updateCamera(this._lastKnownPosition),this.fire("trackuserlocationstart")}switch(this._watchState){case"WAITING_ACTIVE":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"ACTIVE_LOCK":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active");break;case"ACTIVE_ERROR":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-active-error");break;case"BACKGROUND":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background");break;case"BACKGROUND_ERROR":this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-background-error")}"OFF"===this._watchState&&void 0!==this._geolocationWatchID?this._clearWatch():void 0===this._geolocationWatchID&&(this._geolocateButton.classList.add("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.setAttribute("aria-pressed","true"),this._geolocationWatchID=o.navigator.geolocation.watchPosition(this._onSuccess,this._onError,this.options.positionOptions))}else o.navigator.geolocation.getCurrentPosition(this._onSuccess,this._onError,this.options.positionOptions),this._timeoutId=setTimeout(this._finish,1e4)},e.prototype._clearWatch=function(){o.navigator.geolocation.clearWatch(this._geolocationWatchID),this._geolocationWatchID=void 0,this._geolocateButton.classList.remove("mapboxgl-ctrl-geolocate-waiting"),this._geolocateButton.setAttribute("aria-pressed","false"),this.options.showUserLocation&&this._updateMarker(null)},e}(i);e.exports=f},{"../../geo/lng_lat":62,"../../util/dom":259,"../../util/evented":260,"../../util/util":275,"../../util/window":254,"../marker":248}],235:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=function(){i.bindAll(["_updateLogo"],this)};a.prototype.onAdd=function(t){this._map=t,this._container=n.create("div","mapboxgl-ctrl");var e=n.create("a","mapboxgl-ctrl-logo");return e.target="_blank",e.href="https://www.mapbox.com/",e.setAttribute("aria-label","Mapbox logo"),this._container.appendChild(e),this._container.style.display="none",this._map.on("sourcedata",this._updateLogo),this._updateLogo(),this._container},a.prototype.onRemove=function(){n.remove(this._container),this._map.off("sourcedata",this._updateLogo)},a.prototype.getDefaultPosition=function(){return"bottom-left"},a.prototype._updateLogo=function(t){t&&"metadata"!==t.sourceDataType||(this._container.style.display=this._logoRequired()?"block":"none")},a.prototype._logoRequired=function(){if(this._map.style){var t=this._map.style.sourceCaches;for(var e in t)if(t[e].getSource().mapbox_logo)return!0;return!1}},e.exports=a},{"../../util/dom":259,"../../util/util":275}],236:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../handler/drag_rotate"),o={showCompass:!0,showZoom:!0},s=function(t){var e=this;this.options=i.extend({},o,t),this._container=n.create("div","mapboxgl-ctrl mapboxgl-ctrl-group"),this._container.addEventListener("contextmenu",function(t){return t.preventDefault()}),this.options.showZoom&&(this._zoomInButton=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-zoom-in","Zoom In",function(){return e._map.zoomIn()}),this._zoomOutButton=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-zoom-out","Zoom Out",function(){return e._map.zoomOut()})),this.options.showCompass&&(i.bindAll(["_rotateCompassArrow"],this),this._compass=this._createButton("mapboxgl-ctrl-icon mapboxgl-ctrl-compass","Reset North",function(){return e._map.resetNorth()}),this._compassArrow=n.create("span","mapboxgl-ctrl-compass-arrow",this._compass))};s.prototype._rotateCompassArrow=function(){var t="rotate("+this._map.transform.angle*(180/Math.PI)+"deg)";this._compassArrow.style.transform=t},s.prototype.onAdd=function(t){return this._map=t,this.options.showCompass&&(this._map.on("rotate",this._rotateCompassArrow),this._rotateCompassArrow(),this._handler=new a(t,{button:"left",element:this._compass}),this._handler.enable()),this._container},s.prototype.onRemove=function(){n.remove(this._container),this.options.showCompass&&(this._map.off("rotate",this._rotateCompassArrow),this._handler.disable(),delete this._handler),delete this._map},s.prototype._createButton=function(t,e,r){var i=n.create("button",t,this._container);return i.type="button",i.setAttribute("aria-label",e),i.addEventListener("click",r),i},e.exports=s},{"../../util/dom":259,"../../util/util":275,"../handler/drag_rotate":242}],237:[function(t,e,r){function n(t,e,r){var n=r&&r.maxWidth||100,a=t._container.clientHeight/2,o=function(t,e){var r=Math.PI/180,n=t.lat*r,i=e.lat*r,a=Math.sin(n)*Math.sin(i)+Math.cos(n)*Math.cos(i)*Math.cos((e.lng-t.lng)*r);return 6371e3*Math.acos(Math.min(a,1))}(t.unproject([0,a]),t.unproject([n,a]));if(r&&"imperial"===r.unit){var s=3.2808*o;s>5280?i(e,n,s/5280,"mi"):i(e,n,s,"ft")}else if(r&&"nautical"===r.unit){i(e,n,o/1852,"nm")}else i(e,n,o,"m")}function i(t,e,r,n){var i=function(t){var e=Math.pow(10,(""+Math.floor(t)).length-1),r=t/e;return e*(r=r>=10?10:r>=5?5:r>=3?3:r>=2?2:1)}(r),a=i/r;"m"===n&&i>=1e3&&(i/=1e3,n="km"),t.style.width=e*a+"px",t.innerHTML=i+n}var a=t("../../util/dom"),o=t("../../util/util"),s=function(t){this.options=t,o.bindAll(["_onMove"],this)};s.prototype.getDefaultPosition=function(){return"bottom-left"},s.prototype._onMove=function(){n(this._map,this._container,this.options)},s.prototype.onAdd=function(t){return this._map=t,this._container=a.create("div","mapboxgl-ctrl mapboxgl-ctrl-scale",t.getContainer()),this._map.on("move",this._onMove),this._onMove(),this._container},s.prototype.onRemove=function(){a.remove(this._container),this._map.off("move",this._onMove),this._map=void 0},e.exports=s},{"../../util/dom":259,"../../util/util":275}],238:[function(t,e,r){},{}],239:[function(t,e,r){var n=t("../../util/dom"),i=t("../../geo/lng_lat_bounds"),a=t("../../util/util"),o=t("../../util/window"),s=function(t){this._map=t,this._el=t.getCanvasContainer(),this._container=t.getContainer(),a.bindAll(["_onMouseDown","_onMouseMove","_onMouseUp","_onKeyDown"],this)};s.prototype.isEnabled=function(){return!!this._enabled},s.prototype.isActive=function(){return!!this._active},s.prototype.enable=function(){this.isEnabled()||(this._map.dragPan&&this._map.dragPan.disable(),this._el.addEventListener("mousedown",this._onMouseDown,!1),this._map.dragPan&&this._map.dragPan.enable(),this._enabled=!0)},s.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("mousedown",this._onMouseDown),this._enabled=!1)},s.prototype._onMouseDown=function(t){t.shiftKey&&0===t.button&&(o.document.addEventListener("mousemove",this._onMouseMove,!1),o.document.addEventListener("keydown",this._onKeyDown,!1),o.document.addEventListener("mouseup",this._onMouseUp,!1),n.disableDrag(),this._startPos=n.mousePos(this._el,t),this._active=!0)},s.prototype._onMouseMove=function(t){var e=this._startPos,r=n.mousePos(this._el,t);this._box||(this._box=n.create("div","mapboxgl-boxzoom",this._container),this._container.classList.add("mapboxgl-crosshair"),this._fireEvent("boxzoomstart",t));var i=Math.min(e.x,r.x),a=Math.max(e.x,r.x),o=Math.min(e.y,r.y),s=Math.max(e.y,r.y);n.setTransform(this._box,"translate("+i+"px,"+o+"px)"),this._box.style.width=a-i+"px",this._box.style.height=s-o+"px"},s.prototype._onMouseUp=function(t){if(0===t.button){var e=this._startPos,r=n.mousePos(this._el,t),a=(new i).extend(this._map.unproject(e)).extend(this._map.unproject(r));this._finish(),e.x===r.x&&e.y===r.y?this._fireEvent("boxzoomcancel",t):this._map.fitBounds(a,{linear:!0}).fire("boxzoomend",{originalEvent:t,boxZoomBounds:a})}},s.prototype._onKeyDown=function(t){27===t.keyCode&&(this._finish(),this._fireEvent("boxzoomcancel",t))},s.prototype._finish=function(){this._active=!1,o.document.removeEventListener("mousemove",this._onMouseMove,!1),o.document.removeEventListener("keydown",this._onKeyDown,!1),o.document.removeEventListener("mouseup",this._onMouseUp,!1),this._container.classList.remove("mapboxgl-crosshair"),this._box&&(n.remove(this._box),this._box=null),n.enableDrag()},s.prototype._fireEvent=function(t,e){return this._map.fire(t,{originalEvent:e})},e.exports=s},{"../../geo/lng_lat_bounds":63,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],240:[function(t,e,r){var n=t("../../util/util"),i=function(t){this._map=t,n.bindAll(["_onDblClick","_onZoomEnd"],this)};i.prototype.isEnabled=function(){return!!this._enabled},i.prototype.isActive=function(){return!!this._active},i.prototype.enable=function(){this.isEnabled()||(this._map.on("dblclick",this._onDblClick),this._enabled=!0)},i.prototype.disable=function(){this.isEnabled()&&(this._map.off("dblclick",this._onDblClick),this._enabled=!1)},i.prototype._onDblClick=function(t){this._active=!0,this._map.on("zoomend",this._onZoomEnd),this._map.zoomTo(this._map.getZoom()+(t.originalEvent.shiftKey?-1:1),{around:t.lngLat},t)},i.prototype._onZoomEnd=function(){this._active=!1,this._map.off("zoomend",this._onZoomEnd)},e.exports=i},{"../../util/util":275}],241:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.3,1),l=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onDown","_onMove","_onUp","_onTouchEnd","_onMouseUp","_onDragFrame","_onDragFinished"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.isActive=function(){return!!this._active},l.prototype.enable=function(){this.isEnabled()||(this._el.classList.add("mapboxgl-touch-drag-pan"),this._el.addEventListener("mousedown",this._onDown),this._el.addEventListener("touchstart",this._onDown),this._enabled=!0)},l.prototype.disable=function(){this.isEnabled()&&(this._el.classList.remove("mapboxgl-touch-drag-pan"),this._el.removeEventListener("mousedown",this._onDown),this._el.removeEventListener("touchstart",this._onDown),this._enabled=!1)},l.prototype._onDown=function(t){this._ignoreEvent(t)||this.isActive()||(t.touches?(a.document.addEventListener("touchmove",this._onMove),a.document.addEventListener("touchend",this._onTouchEnd)):(a.document.addEventListener("mousemove",this._onMove),a.document.addEventListener("mouseup",this._onMouseUp)),a.addEventListener("blur",this._onMouseUp),this._active=!1,this._previousPos=n.mousePos(this._el,t),this._inertia=[[o.now(),this._previousPos]])},l.prototype._onMove=function(t){if(!this._ignoreEvent(t)){this._lastMoveEvent=t,t.preventDefault();var e=n.mousePos(this._el,t);if(this._drainInertiaBuffer(),this._inertia.push([o.now(),e]),!this._previousPos)return void(this._previousPos=e);this._pos=e,this.isActive()||(this._active=!0,this._map.moving=!0,this._fireEvent("dragstart",t),this._fireEvent("movestart",t),this._map._startAnimation(this._onDragFrame,this._onDragFinished)),this._map._update()}},l.prototype._onDragFrame=function(t){var e=this._lastMoveEvent;e&&(t.setLocationAtPoint(t.pointLocation(this._previousPos),this._pos),this._fireEvent("drag",e),this._fireEvent("move",e),this._previousPos=this._pos,delete this._lastMoveEvent)},l.prototype._onDragFinished=function(t){var e=this;if(this.isActive()){this._active=!1,delete this._lastMoveEvent,delete this._previousPos,delete this._pos,this._fireEvent("dragend",t),this._drainInertiaBuffer();var r=function(){e._map.moving=!1,e._fireEvent("moveend",t)},n=this._inertia;if(n.length<2)return void r();var i=n[n.length-1],a=n[0],o=i[1].sub(a[1]),l=(i[0]-a[0])/1e3;if(0===l||i[1].equals(a[1]))return void r();var c=o.mult(.3/l),u=c.mag();u>1400&&(u=1400,c._unit()._mult(u));var f=u/750,h=c.mult(-f/2);this._map.panBy(h,{duration:1e3*f,easing:s,noMoveStart:!0},{originalEvent:t})}},l.prototype._onUp=function(t){this._onDragFinished(t)},l.prototype._onMouseUp=function(t){this._ignoreEvent(t)||(this._onUp(t),a.document.removeEventListener("mousemove",this._onMove),a.document.removeEventListener("mouseup",this._onMouseUp),a.removeEventListener("blur",this._onMouseUp))},l.prototype._onTouchEnd=function(t){this._ignoreEvent(t)||(this._onUp(t),a.document.removeEventListener("touchmove",this._onMove),a.document.removeEventListener("touchend",this._onTouchEnd))},l.prototype._fireEvent=function(t,e){return this._map.fire(t,e?{originalEvent:e}:{})},l.prototype._ignoreEvent=function(t){var e=this._map;return!(!e.boxZoom||!e.boxZoom.isActive())||!(!e.dragRotate||!e.dragRotate.isActive())||(t.touches?t.touches.length>1:!!t.ctrlKey||"mousemove"!==t.type&&t.button&&0!==t.button)},l.prototype._drainInertiaBuffer=function(){for(var t=this._inertia,e=o.now();t.length>0&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],242:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.25,1),l=function(t,e){this._map=t,this._el=e.element||t.getCanvasContainer(),this._button=e.button||"right",this._bearingSnap=e.bearingSnap||0,this._pitchWithRotate=!1!==e.pitchWithRotate,i.bindAll(["_onDown","_onMove","_onUp","_onDragFrame","_onDragFinished"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.isActive=function(){return!!this._active},l.prototype.enable=function(){this.isEnabled()||(this._el.addEventListener("mousedown",this._onDown),this._enabled=!0)},l.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("mousedown",this._onDown),this._enabled=!1)},l.prototype._onDown=function(t){if(!(this._map.boxZoom&&this._map.boxZoom.isActive()||this._map.dragPan&&this._map.dragPan.isActive()||this.isActive())){if("right"===this._button){var e=t.ctrlKey?0:2,r=t.button;if(void 0!==a.InstallTrigger&&2===t.button&&t.ctrlKey&&a.navigator.platform.toUpperCase().indexOf("MAC")>=0&&(r=0),r!==e)return}else if(t.ctrlKey||0!==t.button)return;n.disableDrag(),a.document.addEventListener("mousemove",this._onMove,{capture:!0}),a.document.addEventListener("mouseup",this._onUp),a.addEventListener("blur",this._onUp),this._active=!1,this._inertia=[[o.now(),this._map.getBearing()]],this._previousPos=n.mousePos(this._el,t),this._center=this._map.transform.centerPoint,t.preventDefault()}},l.prototype._onMove=function(t){this._lastMoveEvent=t;var e=n.mousePos(this._el,t);this._previousPos?(this._pos=e,this.isActive()||(this._active=!0,this._map.moving=!0,this._fireEvent("rotatestart",t),this._fireEvent("movestart",t),this._pitchWithRotate&&this._fireEvent("pitchstart",t),this._map._startAnimation(this._onDragFrame,this._onDragFinished)),this._map._update()):this._previousPos=e},l.prototype._onUp=function(t){a.document.removeEventListener("mousemove",this._onMove,{capture:!0}),a.document.removeEventListener("mouseup",this._onUp),a.removeEventListener("blur",this._onUp),n.enableDrag(),this._onDragFinished(t)},l.prototype._onDragFrame=function(t){var e=this._lastMoveEvent;if(e){var r=this._previousPos,n=this._pos,i=.8*(r.x-n.x),a=-.5*(r.y-n.y),s=t.bearing-i,l=t.pitch-a,c=this._inertia,u=c[c.length-1];this._drainInertiaBuffer(),c.push([o.now(),this._map._normalizeBearing(s,u[1])]),t.bearing=s,this._pitchWithRotate&&(this._fireEvent("pitch",e),t.pitch=l),this._fireEvent("rotate",e),this._fireEvent("move",e),delete this._lastMoveEvent,this._previousPos=this._pos}},l.prototype._onDragFinished=function(t){var e=this;if(this.isActive()){this._active=!1,delete this._lastMoveEvent,delete this._previousPos,this._fireEvent("rotateend",t),this._drainInertiaBuffer();var r=this._map,n=r.getBearing(),i=this._inertia,a=function(){Math.abs(n)180&&(d=180);var g=d/180;u+=h*d*(g/2),Math.abs(r._normalizeBearing(u,0))0&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],243:[function(t,e,r){function n(t){return t*(2-t)}var i=t("../../util/util"),a=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onKeyDown"],this)};a.prototype.isEnabled=function(){return!!this._enabled},a.prototype.enable=function(){this.isEnabled()||(this._el.addEventListener("keydown",this._onKeyDown,!1),this._enabled=!0)},a.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("keydown",this._onKeyDown),this._enabled=!1)},a.prototype._onKeyDown=function(t){if(!(t.altKey||t.ctrlKey||t.metaKey)){var e=0,r=0,i=0,a=0,o=0;switch(t.keyCode){case 61:case 107:case 171:case 187:e=1;break;case 189:case 109:case 173:e=-1;break;case 37:t.shiftKey?r=-1:(t.preventDefault(),a=-1);break;case 39:t.shiftKey?r=1:(t.preventDefault(),a=1);break;case 38:t.shiftKey?i=1:(t.preventDefault(),o=-1);break;case 40:t.shiftKey?i=-1:(o=1,t.preventDefault());break;default:return}var s=this._map,l=s.getZoom(),c={duration:300,delayEndEvents:500,easing:n,zoom:e?Math.round(l)+e*(t.shiftKey?2:1):l,bearing:s.getBearing()+15*r,pitch:s.getPitch()+10*i,offset:[100*-a,100*-o],center:s.getCenter()};s.easeTo(c,{originalEvent:t})}},e.exports=a},{"../../util/util":275}],244:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/browser"),o=t("../../util/window"),s=t("../../style-spec/util/interpolate").number,l=t("../../geo/lng_lat"),c=o.navigator.userAgent.toLowerCase(),u=-1!==c.indexOf("firefox"),f=-1!==c.indexOf("safari")&&-1===c.indexOf("chrom"),h=function(t){this._map=t,this._el=t.getCanvasContainer(),this._delta=0,i.bindAll(["_onWheel","_onTimeout","_onScrollFrame","_onScrollFinished"],this)};h.prototype.isEnabled=function(){return!!this._enabled},h.prototype.isActive=function(){return!!this._active},h.prototype.enable=function(t){this.isEnabled()||(this._el.addEventListener("wheel",this._onWheel,!1),this._el.addEventListener("mousewheel",this._onWheel,!1),this._enabled=!0,this._aroundCenter=t&&"center"===t.around)},h.prototype.disable=function(){this.isEnabled()&&(this._el.removeEventListener("wheel",this._onWheel),this._el.removeEventListener("mousewheel",this._onWheel),this._enabled=!1)},h.prototype._onWheel=function(t){var e=0;"wheel"===t.type?(e=t.deltaY,u&&t.deltaMode===o.WheelEvent.DOM_DELTA_PIXEL&&(e/=a.devicePixelRatio),t.deltaMode===o.WheelEvent.DOM_DELTA_LINE&&(e*=40)):"mousewheel"===t.type&&(e=-t.wheelDeltaY,f&&(e/=3));var r=a.now(),n=r-(this._lastWheelEventTime||0);this._lastWheelEventTime=r,0!==e&&e%4.000244140625==0?this._type="wheel":0!==e&&Math.abs(e)<4?this._type="trackpad":n>400?(this._type=null,this._lastValue=e,this._timeout=setTimeout(this._onTimeout,40,t)):this._type||(this._type=Math.abs(n*e)<200?"trackpad":"wheel",this._timeout&&(clearTimeout(this._timeout),this._timeout=null,e+=this._lastValue)),t.shiftKey&&e&&(e/=4),this._type&&(this._lastWheelEvent=t,this._delta-=e,this.isActive()||this._start(t)),t.preventDefault()},h.prototype._onTimeout=function(t){this._type="wheel",this._delta-=this._lastValue,this.isActive()||this._start(t)},h.prototype._start=function(t){if(this._delta){this._active=!0,this._map.moving=!0,this._map.zooming=!0,this._map.fire("movestart",{originalEvent:t}),this._map.fire("zoomstart",{originalEvent:t}),clearTimeout(this._finishTimeout);var e=n.mousePos(this._el,t);this._around=l.convert(this._aroundCenter?this._map.getCenter():this._map.unproject(e)),this._aroundPoint=this._map.transform.locationPoint(this._around),this._map._startAnimation(this._onScrollFrame,this._onScrollFinished)}},h.prototype._onScrollFrame=function(t){if(this.isActive()){if(0!==this._delta){var e="wheel"===this._type&&Math.abs(this._delta)>4.000244140625?1/450:.01,r=2/(1+Math.exp(-Math.abs(this._delta*e)));this._delta<0&&0!==r&&(r=1/r);var n="number"==typeof this._targetZoom?t.zoomScale(this._targetZoom):t.scale;this._targetZoom=Math.min(t.maxZoom,Math.max(t.minZoom,t.scaleZoom(n*r))),"wheel"===this._type&&(this._startZoom=t.zoom,this._easing=this._smoothOutEasing(200)),this._delta=0}if("wheel"===this._type){var i=Math.min((a.now()-this._lastWheelEventTime)/200,1),o=this._easing(i);t.zoom=s(this._startZoom,this._targetZoom,o),1===i&&this._map.stop()}else t.zoom=this._targetZoom,this._map.stop();t.setLocationAtPoint(this._around,this._aroundPoint),this._map.fire("move",{originalEvent:this._lastWheelEvent}),this._map.fire("zoom",{originalEvent:this._lastWheelEvent})}},h.prototype._onScrollFinished=function(){var t=this;this.isActive()&&(this._active=!1,this._finishTimeout=setTimeout(function(){t._map.moving=!1,t._map.zooming=!1,t._map.fire("zoomend"),t._map.fire("moveend"),delete t._targetZoom},200))},h.prototype._smoothOutEasing=function(t){var e=i.ease;if(this._prevEase){var r=this._prevEase,n=(a.now()-r.start)/r.duration,o=r.easing(n+.01)-r.easing(n),s=.27/Math.sqrt(o*o+1e-4)*.01,l=Math.sqrt(.0729-s*s);e=i.bezier(s,l,.25,1)}return this._prevEase={start:a.now(),duration:t,easing:e},e},e.exports=h},{"../../geo/lng_lat":62,"../../style-spec/util/interpolate":158,"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],245:[function(t,e,r){var n=t("../../util/dom"),i=t("../../util/util"),a=t("../../util/window"),o=t("../../util/browser"),s=i.bezier(0,0,.15,1),l=function(t){this._map=t,this._el=t.getCanvasContainer(),i.bindAll(["_onStart","_onMove","_onEnd"],this)};l.prototype.isEnabled=function(){return!!this._enabled},l.prototype.enable=function(t){this.isEnabled()||(this._el.classList.add("mapboxgl-touch-zoom-rotate"),this._el.addEventListener("touchstart",this._onStart,!1),this._enabled=!0,this._aroundCenter=t&&"center"===t.around)},l.prototype.disable=function(){this.isEnabled()&&(this._el.classList.remove("mapboxgl-touch-zoom-rotate"),this._el.removeEventListener("touchstart",this._onStart),this._enabled=!1)},l.prototype.disableRotation=function(){this._rotationDisabled=!0},l.prototype.enableRotation=function(){this._rotationDisabled=!1},l.prototype._onStart=function(t){if(2===t.touches.length){var e=n.mousePos(this._el,t.touches[0]),r=n.mousePos(this._el,t.touches[1]);this._startVec=e.sub(r),this._startScale=this._map.transform.scale,this._startBearing=this._map.transform.bearing,this._gestureIntent=void 0,this._inertia=[],a.document.addEventListener("touchmove",this._onMove,!1),a.document.addEventListener("touchend",this._onEnd,!1)}},l.prototype._onMove=function(t){if(2===t.touches.length){var e=n.mousePos(this._el,t.touches[0]),r=n.mousePos(this._el,t.touches[1]),i=e.add(r).div(2),a=e.sub(r),s=a.mag()/this._startVec.mag(),l=this._rotationDisabled?0:180*a.angleWith(this._startVec)/Math.PI,c=this._map;if(this._gestureIntent){var u={duration:0,around:c.unproject(i)};"rotate"===this._gestureIntent&&(u.bearing=this._startBearing+l),"zoom"!==this._gestureIntent&&"rotate"!==this._gestureIntent||(u.zoom=c.transform.scaleZoom(this._startScale*s)),c.stop(),this._drainInertiaBuffer(),this._inertia.push([o.now(),s,i]),c.easeTo(u,{originalEvent:t})}else{var f=Math.abs(1-s)>.15;Math.abs(l)>10?this._gestureIntent="rotate":f&&(this._gestureIntent="zoom"),this._gestureIntent&&(this._startVec=a,this._startScale=c.transform.scale,this._startBearing=c.transform.bearing)}t.preventDefault()}},l.prototype._onEnd=function(t){a.document.removeEventListener("touchmove",this._onMove),a.document.removeEventListener("touchend",this._onEnd),this._drainInertiaBuffer();var e=this._inertia,r=this._map;if(e.length<2)r.snapToNorth({},{originalEvent:t});else{var n=e[e.length-1],i=e[0],o=r.transform.scaleZoom(this._startScale*n[1]),l=r.transform.scaleZoom(this._startScale*i[1]),c=o-l,u=(n[0]-i[0])/1e3,f=n[2];if(0!==u&&o!==l){var h=.15*c/u;Math.abs(h)>2.5&&(h=h>0?2.5:-2.5);var p=1e3*Math.abs(h/(12*.15)),d=o+h*p/2e3;d<0&&(d=0),r.easeTo({zoom:d,duration:p,easing:s,around:this._aroundCenter?r.getCenter():r.unproject(f)},{originalEvent:t})}else r.snapToNorth({},{originalEvent:t})}},l.prototype._drainInertiaBuffer=function(){for(var t=this._inertia,e=o.now();t.length>2&&e-t[0][0]>160;)t.shift()},e.exports=l},{"../../util/browser":252,"../../util/dom":259,"../../util/util":275,"../../util/window":254}],246:[function(t,e,r){var n=t("../util/util"),i=t("../util/window"),a=t("../util/throttle"),o=function(){n.bindAll(["_onHashChange","_updateHash"],this),this._updateHash=a(this._updateHashUnthrottled.bind(this),300)};o.prototype.addTo=function(t){return this._map=t,i.addEventListener("hashchange",this._onHashChange,!1),this._map.on("moveend",this._updateHash),this},o.prototype.remove=function(){return i.removeEventListener("hashchange",this._onHashChange,!1),this._map.off("moveend",this._updateHash),delete this._map,this},o.prototype.getHashString=function(t){var e=this._map.getCenter(),r=Math.round(100*this._map.getZoom())/100,n=Math.ceil((r*Math.LN2+Math.log(512/360/.5))/Math.LN10),i=Math.pow(10,n),a=Math.round(e.lng*i)/i,o=Math.round(e.lat*i)/i,s=this._map.getBearing(),l=this._map.getPitch(),c="";return c+=t?"#/"+a+"/"+o+"/"+r:"#"+r+"/"+o+"/"+a,(s||l)&&(c+="/"+Math.round(10*s)/10),l&&(c+="/"+Math.round(l)),c},o.prototype._onHashChange=function(){var t=i.location.hash.replace("#","").split("/");return t.length>=3&&(this._map.jumpTo({center:[+t[2],+t[1]],zoom:+t[0],bearing:+(t[3]||0),pitch:+(t[4]||0)}),!0)},o.prototype._updateHashUnthrottled=function(){var t=this.getHashString();i.history.replaceState("","",t)},e.exports=o},{"../util/throttle":272,"../util/util":275,"../util/window":254}],247:[function(t,e,r){function n(t){t.parentNode&&t.parentNode.removeChild(t)}var i=t("../util/util"),a=t("../util/browser"),o=t("../util/window"),s=t("../util/window"),l=s.HTMLImageElement,c=s.HTMLElement,u=t("../util/dom"),f=t("../util/ajax"),h=t("../style/style"),p=t("../style/evaluation_parameters"),d=t("../render/painter"),g=t("../geo/transform"),m=t("./hash"),v=t("./bind_handlers"),y=t("./camera"),x=t("../geo/lng_lat"),b=t("../geo/lng_lat_bounds"),_=t("@mapbox/point-geometry"),w=t("./control/attribution_control"),k=t("./control/logo_control"),M=t("@mapbox/mapbox-gl-supported"),A=t("../util/image").RGBAImage;t("./events");var T={center:[0,0],zoom:0,bearing:0,pitch:0,minZoom:0,maxZoom:22,interactive:!0,scrollZoom:!0,boxZoom:!0,dragRotate:!0,dragPan:!0,keyboard:!0,doubleClickZoom:!0,touchZoomRotate:!0,bearingSnap:7,hash:!1,attributionControl:!0,failIfMajorPerformanceCaveat:!1,preserveDrawingBuffer:!1,trackResize:!0,renderWorldCopies:!0,refreshExpiredTiles:!0,maxTileCacheSize:null,transformRequest:null,fadeDuration:300},S=function(t){function e(e){if(null!=(e=i.extend({},T,e)).minZoom&&null!=e.maxZoom&&e.minZoom>e.maxZoom)throw new Error("maxZoom must be greater than minZoom");var r=new g(e.minZoom,e.maxZoom,e.renderWorldCopies);t.call(this,r,e),this._interactive=e.interactive,this._maxTileCacheSize=e.maxTileCacheSize,this._failIfMajorPerformanceCaveat=e.failIfMajorPerformanceCaveat,this._preserveDrawingBuffer=e.preserveDrawingBuffer,this._trackResize=e.trackResize,this._bearingSnap=e.bearingSnap,this._refreshExpiredTiles=e.refreshExpiredTiles,this._fadeDuration=e.fadeDuration,this._crossFadingFactor=1,this._collectResourceTiming=e.collectResourceTiming;var n=e.transformRequest;if(this._transformRequest=n?function(t,e){return n(t,e)||{url:t}}:function(t){return{url:t}},"string"==typeof e.container){var a=o.document.getElementById(e.container);if(!a)throw new Error("Container '"+e.container+"' not found.");this._container=a}else{if(!(e.container instanceof c))throw new Error("Invalid type: 'container' must be a String or HTMLElement.");this._container=e.container}e.maxBounds&&this.setMaxBounds(e.maxBounds),i.bindAll(["_onWindowOnline","_onWindowResize","_contextLost","_contextRestored","_update","_render","_onData","_onDataLoading"],this),this._setupContainer(),this._setupPainter(),this.on("move",this._update.bind(this,!1)),this.on("zoom",this._update.bind(this,!0)),void 0!==o&&(o.addEventListener("online",this._onWindowOnline,!1),o.addEventListener("resize",this._onWindowResize,!1)),v(this,e),this._hash=e.hash&&(new m).addTo(this),this._hash&&this._hash._onHashChange()||this.jumpTo({center:e.center,zoom:e.zoom,bearing:e.bearing,pitch:e.pitch}),this.resize(),e.style&&this.setStyle(e.style,{localIdeographFontFamily:e.localIdeographFontFamily}),e.attributionControl&&this.addControl(new w),this.addControl(new k,e.logoPosition),this.on("style.load",function(){this.transform.unmodified&&this.jumpTo(this.style.stylesheet)}),this.on("data",this._onData),this.on("dataloading",this._onDataLoading)}t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e;var r={showTileBoundaries:{},showCollisionBoxes:{},showOverdrawInspector:{},repaint:{},vertices:{}};return e.prototype.addControl=function(t,e){void 0===e&&t.getDefaultPosition&&(e=t.getDefaultPosition()),void 0===e&&(e="top-right");var r=t.onAdd(this),n=this._controlPositions[e];return-1!==e.indexOf("bottom")?n.insertBefore(r,n.firstChild):n.appendChild(r),this},e.prototype.removeControl=function(t){return t.onRemove(this),this},e.prototype.resize=function(){var t=this._containerDimensions(),e=t[0],r=t[1];return this._resizeCanvas(e,r),this.transform.resize(e,r),this.painter.resize(e,r),this.fire("movestart").fire("move").fire("resize").fire("moveend")},e.prototype.getBounds=function(){var t=new b(this.transform.pointLocation(new _(0,this.transform.height)),this.transform.pointLocation(new _(this.transform.width,0)));return(this.transform.angle||this.transform.pitch)&&(t.extend(this.transform.pointLocation(new _(this.transform.size.x,0))),t.extend(this.transform.pointLocation(new _(0,this.transform.size.y)))),t},e.prototype.getMaxBounds=function(){return this.transform.latRange&&2===this.transform.latRange.length&&this.transform.lngRange&&2===this.transform.lngRange.length?new b([this.transform.lngRange[0],this.transform.latRange[0]],[this.transform.lngRange[1],this.transform.latRange[1]]):null},e.prototype.setMaxBounds=function(t){if(t){var e=b.convert(t);this.transform.lngRange=[e.getWest(),e.getEast()],this.transform.latRange=[e.getSouth(),e.getNorth()],this.transform._constrain(),this._update()}else null!=t||(this.transform.lngRange=null,this.transform.latRange=null,this._update());return this},e.prototype.setMinZoom=function(t){if((t=null==t?0:t)>=0&&t<=this.transform.maxZoom)return this.transform.minZoom=t,this._update(),this.getZoom()=this.transform.minZoom)return this.transform.maxZoom=t,this._update(),this.getZoom()>t&&this.setZoom(t),this;throw new Error("maxZoom must be greater than the current minZoom")},e.prototype.getMaxZoom=function(){return this.transform.maxZoom},e.prototype.project=function(t){return this.transform.locationPoint(x.convert(t))},e.prototype.unproject=function(t){return this.transform.pointLocation(_.convert(t))},e.prototype.on=function(e,r,n){var a=this;if(void 0===n)return t.prototype.on.call(this,e,r);var o=function(){if("mouseenter"===e||"mouseover"===e){var t=!1;return{layer:r,listener:n,delegates:{mousemove:function(o){var s=a.getLayer(r)?a.queryRenderedFeatures(o.point,{layers:[r]}):[];s.length?t||(t=!0,n.call(a,i.extend({features:s},o,{type:e}))):t=!1},mouseout:function(){t=!1}}}}if("mouseleave"===e||"mouseout"===e){var o=!1;return{layer:r,listener:n,delegates:{mousemove:function(t){(a.getLayer(r)?a.queryRenderedFeatures(t.point,{layers:[r]}):[]).length?o=!0:o&&(o=!1,n.call(a,i.extend({},t,{type:e})))},mouseout:function(t){o&&(o=!1,n.call(a,i.extend({},t,{type:e})))}}}}var s;return{layer:r,listener:n,delegates:(s={},s[e]=function(t){var e=a.getLayer(r)?a.queryRenderedFeatures(t.point,{layers:[r]}):[];e.length&&n.call(a,i.extend({features:e},t))},s)}}();for(var s in this._delegatedListeners=this._delegatedListeners||{},this._delegatedListeners[e]=this._delegatedListeners[e]||[],this._delegatedListeners[e].push(o),o.delegates)a.on(s,o.delegates[s]);return this},e.prototype.off=function(e,r,n){if(void 0===n)return t.prototype.off.call(this,e,r);if(this._delegatedListeners&&this._delegatedListeners[e])for(var i=this._delegatedListeners[e],a=0;athis._map.transform.height-i?["bottom"]:[],t.xthis._map.transform.width-n/2&&e.push("right"),e=0===e.length?"bottom":e.join("-")}var o=t.add(r[e]).round(),l={top:"translate(-50%,0)","top-left":"translate(0,0)","top-right":"translate(-100%,0)",bottom:"translate(-50%,-100%)","bottom-left":"translate(0,-100%)","bottom-right":"translate(-100%,-100%)",left:"translate(0,-50%)",right:"translate(-100%,-50%)"},u=this._container.classList;for(var f in l)u.remove("mapboxgl-popup-anchor-"+f);u.add("mapboxgl-popup-anchor-"+e),a.setTransform(this._container,l[e]+" translate("+o.x+"px,"+o.y+"px)")}},e.prototype._onClickClose=function(){this.remove()},e}(i);e.exports=f},{"../geo/lng_lat":62,"../util/dom":259,"../util/evented":260,"../util/smart_wrap":270,"../util/util":275,"../util/window":254,"@mapbox/point-geometry":4}],250:[function(t,e,r){var n=t("./util"),i=t("./web_worker_transfer"),a=i.serialize,o=i.deserialize,s=function(t,e,r){this.target=t,this.parent=e,this.mapId=r,this.callbacks={},this.callbackID=0,n.bindAll(["receive"],this),this.target.addEventListener("message",this.receive,!1)};s.prototype.send=function(t,e,r,n){var i=r?this.mapId+":"+this.callbackID++:null;r&&(this.callbacks[i]=r);var o=[];this.target.postMessage({targetMapId:n,sourceMapId:this.mapId,type:t,id:String(i),data:a(e,o)},o)},s.prototype.receive=function(t){var e,r=this,n=t.data,i=n.id;if(!n.targetMapId||this.mapId===n.targetMapId){var s=function(t,e){var n=[];r.target.postMessage({sourceMapId:r.mapId,type:"",id:String(i),error:t?String(t):null,data:a(e,n)},n)};if(""===n.type)e=this.callbacks[n.id],delete this.callbacks[n.id],e&&n.error?e(new Error(n.error)):e&&e(null,o(n.data));else if(void 0!==n.id&&this.parent[n.type])this.parent[n.type](n.sourceMapId,o(n.data),s);else if(void 0!==n.id&&this.parent.getWorkerSource){var l=n.type.split(".");this.parent.getWorkerSource(n.sourceMapId,l[0])[l[1]](o(n.data),s)}else this.parent[n.type](o(n.data))}},s.prototype.remove=function(){this.target.removeEventListener("message",this.receive,!1)},e.exports=s},{"./util":275,"./web_worker_transfer":278}],251:[function(t,e,r){function n(t){var e=new a.XMLHttpRequest;for(var r in e.open("GET",t.url,!0),t.headers)e.setRequestHeader(r,t.headers[r]);return e.withCredentials="include"===t.credentials,e}function i(t){var e=a.document.createElement("a");return e.href=t,e.protocol===a.document.location.protocol&&e.host===a.document.location.host}var a=t("./window"),o={Unknown:"Unknown",Style:"Style",Source:"Source",Tile:"Tile",Glyphs:"Glyphs",SpriteImage:"SpriteImage",SpriteJSON:"SpriteJSON",Image:"Image"};r.ResourceType=o,"function"==typeof Object.freeze&&Object.freeze(o);var s=function(t){function e(e,r){t.call(this,e),this.status=r}return t&&(e.__proto__=t),e.prototype=Object.create(t&&t.prototype),e.prototype.constructor=e,e}(Error);r.getJSON=function(t,e){var r=n(t);return r.setRequestHeader("Accept","application/json"),r.onerror=function(){e(new Error(r.statusText))},r.onload=function(){if(r.status>=200&&r.status<300&&r.response){var t;try{t=JSON.parse(r.response)}catch(t){return e(t)}e(null,t)}else e(new s(r.statusText,r.status))},r.send(),r},r.getArrayBuffer=function(t,e){var r=n(t);return r.responseType="arraybuffer",r.onerror=function(){e(new Error(r.statusText))},r.onload=function(){var t=r.response;if(0===t.byteLength&&200===r.status)return e(new Error("http status 200 returned without content."));r.status>=200&&r.status<300&&r.response?e(null,{data:t,cacheControl:r.getResponseHeader("Cache-Control"),expires:r.getResponseHeader("Expires")}):e(new s(r.statusText,r.status))},r.send(),r};r.getImage=function(t,e){return r.getArrayBuffer(t,function(t,r){if(t)e(t);else if(r){var n=new a.Image,i=a.URL||a.webkitURL;n.onload=function(){e(null,n),i.revokeObjectURL(n.src)};var o=new a.Blob([new Uint8Array(r.data)],{type:"image/png"});n.cacheControl=r.cacheControl,n.expires=r.expires,n.src=r.data.byteLength?i.createObjectURL(o):"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQYV2NgAAIAAAUAAarVyFEAAAAASUVORK5CYII="}})},r.getVideo=function(t,e){var r=a.document.createElement("video");r.onloadstart=function(){e(null,r)};for(var n=0;n1)for(var f=0;f0||this._oneTimeListeners&&this._oneTimeListeners[t]&&this._oneTimeListeners[t].length>0||this._eventedParent&&this._eventedParent.listens(t)},o.prototype.setEventedParent=function(t,e){return this._eventedParent=t,this._eventedParentData=e,this},e.exports=o},{"./util":275}],261:[function(t,e,r){function n(t,e){return e.max-t.max}function i(t,e,r,n){this.p=new o(t,e),this.h=r,this.d=function(t,e){for(var r=!1,n=1/0,i=0;it.y!=f.y>t.y&&t.x<(f.x-u.x)*(t.y-u.y)/(f.y-u.y)+u.x&&(r=!r),n=Math.min(n,s(t,u,f))}return(r?1:-1)*Math.sqrt(n)}(this.p,n),this.max=this.d+this.h*Math.SQRT2}var a=t("tinyqueue"),o=t("@mapbox/point-geometry"),s=t("./intersection_tests").distToSegmentSquared;e.exports=function(t,e,r){void 0===e&&(e=1),void 0===r&&(r=!1);for(var s=1/0,l=1/0,c=-1/0,u=-1/0,f=t[0],h=0;hc)&&(c=p.x),(!h||p.y>u)&&(u=p.y)}var d=c-s,g=u-l,m=Math.min(d,g),v=m/2,y=new a(null,n);if(0===m)return new o(s,l);for(var x=s;x_.d||!_.d)&&(_=k,r&&console.log("found best %d after %d probes",Math.round(1e4*k.d)/1e4,w)),k.max-_.d<=e||(v=k.h/2,y.push(new i(k.p.x-v,k.p.y-v,v,t)),y.push(new i(k.p.x+v,k.p.y-v,v,t)),y.push(new i(k.p.x-v,k.p.y+v,v,t)),y.push(new i(k.p.x+v,k.p.y+v,v,t)),w+=4)}return r&&(console.log("num probes: "+w),console.log("best distance: "+_.d)),_.p}},{"./intersection_tests":264,"@mapbox/point-geometry":4,tinyqueue:33}],262:[function(t,e,r){var n,i=t("./worker_pool");e.exports=function(){return n||(n=new i),n}},{"./worker_pool":279}],263:[function(t,e,r){function n(t,e,r,n){var i=e.width,a=e.height;if(n){if(n.length!==i*a*r)throw new RangeError("mismatched image size")}else n=new Uint8Array(i*a*r);return t.width=i,t.height=a,t.data=n,t}function i(t,e,r){var i=e.width,o=e.height;if(i!==t.width||o!==t.height){var s=n({},{width:i,height:o},r);a(t,s,{x:0,y:0},{x:0,y:0},{width:Math.min(t.width,i),height:Math.min(t.height,o)},r),t.width=i,t.height=o,t.data=s.data}}function a(t,e,r,n,i,a){if(0===i.width||0===i.height)return e;if(i.width>t.width||i.height>t.height||r.x>t.width-i.width||r.y>t.height-i.height)throw new RangeError("out of range source coordinates for image copy");if(i.width>e.width||i.height>e.height||n.x>e.width-i.width||n.y>e.height-i.height)throw new RangeError("out of range destination coordinates for image copy");for(var o=t.data,s=e.data,l=0;l1){if(i(t,e))return!0;for(var n=0;n1?t.distSqr(r):t.distSqr(r.sub(e)._mult(i)._add(e))}function l(t,e){for(var r,n,i,a=!1,o=0;oe.y!=i.y>e.y&&e.x<(i.x-n.x)*(e.y-n.y)/(i.y-n.y)+n.x&&(a=!a);return a}function c(t,e){for(var r=!1,n=0,i=t.length-1;ne.y!=o.y>e.y&&e.x<(o.x-a.x)*(e.y-a.y)/(o.y-a.y)+a.x&&(r=!r)}return r}var u=t("./util").isCounterClockwise;e.exports={multiPolygonIntersectsBufferedMultiPoint:function(t,e,r){for(var n=0;n=3)for(var l=0;l=128&&t<=255},Arabic:function(t){return t>=1536&&t<=1791},"Arabic Supplement":function(t){return t>=1872&&t<=1919},"Arabic Extended-A":function(t){return t>=2208&&t<=2303},"Hangul Jamo":function(t){return t>=4352&&t<=4607},"Unified Canadian Aboriginal Syllabics":function(t){return t>=5120&&t<=5759},"Unified Canadian Aboriginal Syllabics Extended":function(t){return t>=6320&&t<=6399},"General Punctuation":function(t){return t>=8192&&t<=8303},"Letterlike Symbols":function(t){return t>=8448&&t<=8527},"Number Forms":function(t){return t>=8528&&t<=8591},"Miscellaneous Technical":function(t){return t>=8960&&t<=9215},"Control Pictures":function(t){return t>=9216&&t<=9279},"Optical Character Recognition":function(t){return t>=9280&&t<=9311},"Enclosed Alphanumerics":function(t){return t>=9312&&t<=9471},"Geometric Shapes":function(t){return t>=9632&&t<=9727},"Miscellaneous Symbols":function(t){return t>=9728&&t<=9983},"Miscellaneous Symbols and Arrows":function(t){return t>=11008&&t<=11263},"CJK Radicals Supplement":function(t){return t>=11904&&t<=12031},"Kangxi Radicals":function(t){return t>=12032&&t<=12255},"Ideographic Description Characters":function(t){return t>=12272&&t<=12287},"CJK Symbols and Punctuation":function(t){return t>=12288&&t<=12351},Hiragana:function(t){return t>=12352&&t<=12447},Katakana:function(t){return t>=12448&&t<=12543},Bopomofo:function(t){return t>=12544&&t<=12591},"Hangul Compatibility Jamo":function(t){return t>=12592&&t<=12687},Kanbun:function(t){return t>=12688&&t<=12703},"Bopomofo Extended":function(t){return t>=12704&&t<=12735},"CJK Strokes":function(t){return t>=12736&&t<=12783},"Katakana Phonetic Extensions":function(t){return t>=12784&&t<=12799},"Enclosed CJK Letters and Months":function(t){return t>=12800&&t<=13055},"CJK Compatibility":function(t){return t>=13056&&t<=13311},"CJK Unified Ideographs Extension A":function(t){return t>=13312&&t<=19903},"Yijing Hexagram Symbols":function(t){return t>=19904&&t<=19967},"CJK Unified Ideographs":function(t){return t>=19968&&t<=40959},"Yi Syllables":function(t){return t>=40960&&t<=42127},"Yi Radicals":function(t){return t>=42128&&t<=42191},"Hangul Jamo Extended-A":function(t){return t>=43360&&t<=43391},"Hangul Syllables":function(t){return t>=44032&&t<=55215},"Hangul Jamo Extended-B":function(t){return t>=55216&&t<=55295},"Private Use Area":function(t){return t>=57344&&t<=63743},"CJK Compatibility Ideographs":function(t){return t>=63744&&t<=64255},"Arabic Presentation Forms-A":function(t){return t>=64336&&t<=65023},"Vertical Forms":function(t){return t>=65040&&t<=65055},"CJK Compatibility Forms":function(t){return t>=65072&&t<=65103},"Small Form Variants":function(t){return t>=65104&&t<=65135},"Arabic Presentation Forms-B":function(t){return t>=65136&&t<=65279},"Halfwidth and Fullwidth Forms":function(t){return t>=65280&&t<=65519}}},{}],266:[function(t,e,r){var n=function(t,e){this.max=t,this.onRemove=e,this.reset()};n.prototype.reset=function(){var t=this;for(var e in t.data)t.onRemove(t.data[e]);return this.data={},this.order=[],this},n.prototype.add=function(t,e){if(this.has(t))this.order.splice(this.order.indexOf(t),1),this.data[t]=e,this.order.push(t);else if(this.data[t]=e,this.order.push(t),this.order.length>this.max){var r=this.getAndRemove(this.order[0]);r&&this.onRemove(r)}return this},n.prototype.has=function(t){return t in this.data},n.prototype.keys=function(){return this.order},n.prototype.getAndRemove=function(t){if(!this.has(t))return null;var e=this.data[t];return delete this.data[t],this.order.splice(this.order.indexOf(t),1),e},n.prototype.get=function(t){return this.has(t)?this.data[t]:null},n.prototype.remove=function(t){if(!this.has(t))return this;var e=this.data[t];return delete this.data[t],this.onRemove(e),this.order.splice(this.order.indexOf(t),1),this},n.prototype.setMaxSize=function(t){var e=this;for(this.max=t;this.order.length>this.max;){var r=e.getAndRemove(e.order[0]);r&&e.onRemove(r)}return this},e.exports=n},{}],267:[function(t,e,r){function n(t,e){var r=a(s.API_URL);if(t.protocol=r.protocol,t.authority=r.authority,"/"!==r.path&&(t.path=""+r.path+t.path),!s.REQUIRE_ACCESS_TOKEN)return o(t);if(!(e=e||s.ACCESS_TOKEN))throw new Error("An API access token is required to use Mapbox GL. "+c);if("s"===e[0])throw new Error("Use a public access token (pk.*) with Mapbox GL, not a secret access token (sk.*). "+c);return t.params.push("access_token="+e),o(t)}function i(t){return 0===t.indexOf("mapbox:")}function a(t){var e=t.match(f);if(!e)throw new Error("Unable to parse URL object");return{protocol:e[1],authority:e[2],path:e[3]||"/",params:e[4]?e[4].split("&"):[]}}function o(t){var e=t.params.length?"?"+t.params.join("&"):"";return t.protocol+"://"+t.authority+t.path+e}var s=t("./config"),l=t("./browser"),c="See https://www.mapbox.com/api-documentation/#access-tokens";r.isMapboxURL=i,r.normalizeStyleURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/styles/v1"+r.path,n(r,e)},r.normalizeGlyphsURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/fonts/v1"+r.path,n(r,e)},r.normalizeSourceURL=function(t,e){if(!i(t))return t;var r=a(t);return r.path="/v4/"+r.authority+".json",r.params.push("secure"),n(r,e)},r.normalizeSpriteURL=function(t,e,r,s){var l=a(t);return i(t)?(l.path="/styles/v1"+l.path+"/sprite"+e+r,n(l,s)):(l.path+=""+e+r,o(l))};var u=/(\.(png|jpg)\d*)(?=$)/;r.normalizeTileURL=function(t,e,r){if(!e||!i(e))return t;var n=a(t),c=l.devicePixelRatio>=2||512===r?"@2x":"",f=l.supportsWebp?".webp":"$1";return n.path=n.path.replace(u,""+c+f),function(t){for(var e=0;e=65097&&t<=65103)||n["CJK Compatibility Ideographs"](t)||n["CJK Compatibility"](t)||n["CJK Radicals Supplement"](t)||n["CJK Strokes"](t)||!(!n["CJK Symbols and Punctuation"](t)||t>=12296&&t<=12305||t>=12308&&t<=12319||12336===t)||n["CJK Unified Ideographs Extension A"](t)||n["CJK Unified Ideographs"](t)||n["Enclosed CJK Letters and Months"](t)||n["Hangul Compatibility Jamo"](t)||n["Hangul Jamo Extended-A"](t)||n["Hangul Jamo Extended-B"](t)||n["Hangul Jamo"](t)||n["Hangul Syllables"](t)||n.Hiragana(t)||n["Ideographic Description Characters"](t)||n.Kanbun(t)||n["Kangxi Radicals"](t)||n["Katakana Phonetic Extensions"](t)||n.Katakana(t)&&12540!==t||!(!n["Halfwidth and Fullwidth Forms"](t)||65288===t||65289===t||65293===t||t>=65306&&t<=65310||65339===t||65341===t||65343===t||t>=65371&&t<=65503||65507===t||t>=65512&&t<=65519)||!(!n["Small Form Variants"](t)||t>=65112&&t<=65118||t>=65123&&t<=65126)||n["Unified Canadian Aboriginal Syllabics"](t)||n["Unified Canadian Aboriginal Syllabics Extended"](t)||n["Vertical Forms"](t)||n["Yijing Hexagram Symbols"](t)||n["Yi Syllables"](t)||n["Yi Radicals"](t)))},r.charHasNeutralVerticalOrientation=function(t){return!!(n["Latin-1 Supplement"](t)&&(167===t||169===t||174===t||177===t||188===t||189===t||190===t||215===t||247===t)||n["General Punctuation"](t)&&(8214===t||8224===t||8225===t||8240===t||8241===t||8251===t||8252===t||8258===t||8263===t||8264===t||8265===t||8273===t)||n["Letterlike Symbols"](t)||n["Number Forms"](t)||n["Miscellaneous Technical"](t)&&(t>=8960&&t<=8967||t>=8972&&t<=8991||t>=8996&&t<=9e3||9003===t||t>=9085&&t<=9114||t>=9150&&t<=9165||9167===t||t>=9169&&t<=9179||t>=9186&&t<=9215)||n["Control Pictures"](t)&&9251!==t||n["Optical Character Recognition"](t)||n["Enclosed Alphanumerics"](t)||n["Geometric Shapes"](t)||n["Miscellaneous Symbols"](t)&&!(t>=9754&&t<=9759)||n["Miscellaneous Symbols and Arrows"](t)&&(t>=11026&&t<=11055||t>=11088&&t<=11097||t>=11192&&t<=11243)||n["CJK Symbols and Punctuation"](t)||n.Katakana(t)||n["Private Use Area"](t)||n["CJK Compatibility Forms"](t)||n["Small Form Variants"](t)||n["Halfwidth and Fullwidth Forms"](t)||8734===t||8756===t||8757===t||t>=9984&&t<=10087||t>=10102&&t<=10131||65532===t||65533===t)},r.charHasRotatedVerticalOrientation=function(t){return!(r.charHasUprightVerticalOrientation(t)||r.charHasNeutralVerticalOrientation(t))}},{"./is_char_in_unicode_block":265}],270:[function(t,e,r){var n=t("../geo/lng_lat");e.exports=function(t,e,r){if(t=new n(t.lng,t.lat),e){var i=new n(t.lng-360,t.lat),a=new n(t.lng+360,t.lat),o=r.locationPoint(t).distSqr(e);r.locationPoint(i).distSqr(e)180;){var s=r.locationPoint(t);if(s.x>=0&&s.y>=0&&s.x<=r.width&&s.y<=r.height)break;t.lng>r.center.lng?t.lng-=360:t.lng+=360}return t}},{"../geo/lng_lat":62}],271:[function(t,e,r){function n(t,e){return Math.ceil(t/e)*e}var i={Int8:Int8Array,Uint8:Uint8Array,Int16:Int16Array,Uint16:Uint16Array,Int32:Int32Array,Uint32:Uint32Array,Float32:Float32Array},a=function(){this.isTransferred=!1,this.capacity=-1,this.resize(0)};a.serialize=function(t,e){return t._trim(),e&&(t.isTransferred=!0,e.push(t.arrayBuffer)),{length:t.length,arrayBuffer:t.arrayBuffer}},a.deserialize=function(t){var e=Object.create(this.prototype);return e.arrayBuffer=t.arrayBuffer,e.length=t.length,e.capacity=t.arrayBuffer.byteLength/e.bytesPerElement,e._refreshViews(),e},a.prototype._trim=function(){this.length!==this.capacity&&(this.capacity=this.length,this.arrayBuffer=this.arrayBuffer.slice(0,this.length*this.bytesPerElement),this._refreshViews())},a.prototype.clear=function(){this.length=0},a.prototype.resize=function(t){this.reserve(t),this.length=t},a.prototype.reserve=function(t){if(t>this.capacity){this.capacity=Math.max(t,Math.floor(5*this.capacity),128),this.arrayBuffer=new ArrayBuffer(this.capacity*this.bytesPerElement);var e=this.uint8;this._refreshViews(),e&&this.uint8.set(e)}},a.prototype._refreshViews=function(){throw new Error("_refreshViews() must be implemented by each concrete StructArray layout")},e.exports.StructArray=a,e.exports.Struct=function(t,e){this._structArray=t,this._pos1=e*this.size,this._pos2=this._pos1/2,this._pos4=this._pos1/4,this._pos8=this._pos1/8},e.exports.viewTypes=i,e.exports.createLayout=function(t,e){void 0===e&&(e=1);var r=0,a=0;return{members:t.map(function(t){var o=function(t){return i[t].BYTES_PER_ELEMENT}(t.type),s=r=n(r,Math.max(e,o)),l=t.components||1;return a=Math.max(a,o),r+=o*l,{name:t.name,type:t.type,components:l,offset:s}}),size:n(r,Math.max(a,e)),alignment:e}}},{}],272:[function(t,e,r){e.exports=function(t,e){var r=!1,n=0,i=function(){n=0,r&&(t(),n=setTimeout(i,e),r=!1)};return function(){return r=!0,n||i(),n}}},{}],273:[function(t,e,r){function n(t,e){if(t.row>e.row){var r=t;t=e,e=r}return{x0:t.column,y0:t.row,x1:e.column,y1:e.row,dx:e.column-t.column,dy:e.row-t.row}}function i(t,e,r,n,i){var a=Math.max(r,Math.floor(e.y0)),o=Math.min(n,Math.ceil(e.y1));if(t.x0===e.x0&&t.y0===e.y0?t.x0+e.dy/t.dy*t.dx0,f=e.dx<0,h=a;hu.dy&&(l=c,c=u,u=l),c.dy>f.dy&&(l=c,c=f,f=l),u.dy>f.dy&&(l=u,u=f,f=l),c.dy&&i(f,c,a,o,s),u.dy&&i(f,u,a,o,s)}t("../geo/coordinate");var o=t("../source/tile_id").OverscaledTileID;e.exports=function(t,e,r,n){function i(e,i,a){var c,u,f;if(a>=0&&a<=s)for(c=e;c=1)return 1;var e=t*t,r=e*t;return 4*(t<.5?r:3*(t-e)+r-.75)},r.bezier=function(t,e,r,i){var a=new n(t,e,r,i);return function(t){return a.solve(t)}},r.ease=r.bezier(.25,.1,.25,1),r.clamp=function(t,e,r){return Math.min(r,Math.max(e,t))},r.wrap=function(t,e,r){var n=r-e,i=((t-e)%n+n)%n+e;return i===e?r:i},r.asyncAll=function(t,e,r){if(!t.length)return r(null,[]);var n=t.length,i=new Array(t.length),a=null;t.forEach(function(t,o){e(t,function(t,e){t&&(a=t),i[o]=e,0==--n&&r(a,i)})})},r.values=function(t){var e=[];for(var r in t)e.push(t[r]);return e},r.keysDifference=function(t,e){var r=[];for(var n in t)n in e||r.push(n);return r},r.extend=function(t){for(var e=arguments,r=[],n=arguments.length-1;n-- >0;)r[n]=e[n+1];for(var i=0,a=r;i=0)return!0;return!1};var o={};r.warnOnce=function(t){o[t]||("undefined"!=typeof console&&console.warn(t),o[t]=!0)},r.isCounterClockwise=function(t,e,r){return(r.y-t.y)*(e.x-t.x)>(e.y-t.y)*(r.x-t.x)},r.calculateSignedArea=function(t){for(var e=0,r=0,n=t.length,i=n-1,a=void 0,o=void 0;r0||Math.abs(e.y-n.y)>0)&&Math.abs(r.calculateSignedArea(t))>.01},r.sphericalToCartesian=function(t){var e=t[0],r=t[1],n=t[2];return r+=90,r*=Math.PI/180,n*=Math.PI/180,{x:e*Math.cos(r)*Math.sin(n),y:e*Math.sin(r)*Math.sin(n),z:e*Math.cos(n)}},r.parseCacheControl=function(t){var e={};if(t.replace(/(?:^|(?:\s*\,\s*))([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)(?:\=(?:([^\x00-\x20\(\)<>@\,;\:\\"\/\[\]\?\=\{\}\x7F]+)|(?:\"((?:[^"\\]|\\.)*)\")))?/g,function(t,r,n,i){var a=n||i;return e[r]=!a||a.toLowerCase(),""}),e["max-age"]){var r=parseInt(e["max-age"],10);isNaN(r)?delete e["max-age"]:e["max-age"]=r}return e}},{"../geo/coordinate":61,"../style-spec/util/deep_equal":155,"@mapbox/point-geometry":4,"@mapbox/unitbezier":7}],276:[function(t,e,r){var n=function(t,e,r,n){this.type="Feature",this._vectorTileFeature=t,t._z=e,t._x=r,t._y=n,this.properties=t.properties,null!=t.id&&(this.id=t.id)},i={geometry:{}};i.geometry.get=function(){return void 0===this._geometry&&(this._geometry=this._vectorTileFeature.toGeoJSON(this._vectorTileFeature._x,this._vectorTileFeature._y,this._vectorTileFeature._z).geometry),this._geometry},i.geometry.set=function(t){this._geometry=t},n.prototype.toJSON=function(){var t={geometry:this.geometry};for(var e in this)"_geometry"!==e&&"_vectorTileFeature"!==e&&(t[e]=this[e]);return t},Object.defineProperties(n.prototype,i),e.exports=n},{}],277:[function(t,e,r){var n=t("./script_detection");e.exports=function(t){for(var r="",i=0;i":"\ufe40","?":"\ufe16","@":"\uff20","[":"\ufe47","\\":"\uff3c","]":"\ufe48","^":"\uff3e",_:"\ufe33","`":"\uff40","{":"\ufe37","|":"\u2015","}":"\ufe38","~":"\uff5e","\xa2":"\uffe0","\xa3":"\uffe1","\xa5":"\uffe5","\xa6":"\uffe4","\xac":"\uffe2","\xaf":"\uffe3","\u2013":"\ufe32","\u2014":"\ufe31","\u2018":"\ufe43","\u2019":"\ufe44","\u201c":"\ufe41","\u201d":"\ufe42","\u2026":"\ufe19","\u2027":"\u30fb","\u20a9":"\uffe6","\u3001":"\ufe11","\u3002":"\ufe12","\u3008":"\ufe3f","\u3009":"\ufe40","\u300a":"\ufe3d","\u300b":"\ufe3e","\u300c":"\ufe41","\u300d":"\ufe42","\u300e":"\ufe43","\u300f":"\ufe44","\u3010":"\ufe3b","\u3011":"\ufe3c","\u3014":"\ufe39","\u3015":"\ufe3a","\u3016":"\ufe17","\u3017":"\ufe18","\uff01":"\ufe15","\uff08":"\ufe35","\uff09":"\ufe36","\uff0c":"\ufe10","\uff0d":"\ufe32","\uff0e":"\u30fb","\uff1a":"\ufe13","\uff1b":"\ufe14","\uff1c":"\ufe3f","\uff1e":"\ufe40","\uff1f":"\ufe16","\uff3b":"\ufe47","\uff3d":"\ufe48","\uff3f":"\ufe33","\uff5b":"\ufe37","\uff5c":"\u2015","\uff5d":"\ufe38","\uff5f":"\ufe35","\uff60":"\ufe36","\uff61":"\ufe12","\uff62":"\ufe41","\uff63":"\ufe42"}},{"./script_detection":269}],278:[function(t,e,r){function n(t,e,r){void 0===r&&(r={}),Object.defineProperty(e,"_classRegistryKey",{value:t,writeable:!1}),g[t]={klass:e,omit:r.omit||[],shallow:r.shallow||[]}}var i=t("grid-index"),a=t("../style-spec/util/color"),o=t("../style-spec/expression"),s=o.StylePropertyFunction,l=o.StyleExpression,c=o.StyleExpressionWithErrorHandling,u=o.ZoomDependentExpression,f=o.ZoomConstantExpression,h=t("../style-spec/expression/compound_expression").CompoundExpression,p=t("../style-spec/expression/definitions"),d=t("./window").ImageData,g={};for(var m in n("Object",Object),i.serialize=function(t,e){var r=t.toArrayBuffer();return e&&e.push(r),r},i.deserialize=function(t){return new i(t)},n("Grid",i),n("Color",a),n("StylePropertyFunction",s),n("StyleExpression",l,{omit:["_evaluator"]}),n("StyleExpressionWithErrorHandling",c,{omit:["_evaluator"]}),n("ZoomDependentExpression",u),n("ZoomConstantExpression",f),n("CompoundExpression",h,{omit:["_evaluate"]}),p)p[m]._classRegistryKey||n("Expression_"+m,p[m]);e.exports={register:n,serialize:function t(e,r){if(null==e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||e instanceof Boolean||e instanceof Number||e instanceof String||e instanceof Date||e instanceof RegExp)return e;if(e instanceof ArrayBuffer)return r&&r.push(e),e;if(ArrayBuffer.isView(e)){var n=e;return r&&r.push(n.buffer),n}if(e instanceof d)return r&&r.push(e.data.buffer),e;if(Array.isArray(e)){for(var i=[],a=0,o=e;a=0)){var h=e[f];u[f]=g[c].shallow.indexOf(f)>=0?h:t(h,r)}return{name:c,properties:u}}throw new Error("can't serialize object of type "+typeof e)},deserialize:function t(e){if(null==e||"boolean"==typeof e||"number"==typeof e||"string"==typeof e||e instanceof Boolean||e instanceof Number||e instanceof String||e instanceof Date||e instanceof RegExp||e instanceof ArrayBuffer||ArrayBuffer.isView(e)||e instanceof d)return e;if(Array.isArray(e))return e.map(function(e){return t(e)});if("object"==typeof e){var r=e,n=r.name,i=r.properties;if(!n)throw new Error("can't deserialize object of anonymous class");var a=g[n].klass;if(!a)throw new Error("can't deserialize unregistered class "+n);if(a.deserialize)return a.deserialize(i._serialized);for(var o=Object.create(a.prototype),s=0,l=Object.keys(i);s=0?i[c]:t(i[c])}return o}throw new Error("can't deserialize object of type "+typeof e)}}},{"../style-spec/expression":139,"../style-spec/expression/compound_expression":123,"../style-spec/expression/definitions":131,"../style-spec/util/color":153,"./window":254,"grid-index":24}],279:[function(t,e,r){var n=t("./web_worker"),i=function(){this.active={}};i.prototype.acquire=function(e){if(!this.workers){var r=t("../").workerCount;for(this.workers=[];this.workers.lengthp[1][2]&&(v[0]=-v[0]),p[0][2]>p[2][0]&&(v[1]=-v[1]),p[1][0]>p[0][1]&&(v[2]=-v[2]),!0}},{"./normalize":372,"gl-mat4/clone":229,"gl-mat4/create":230,"gl-mat4/determinant":231,"gl-mat4/invert":235,"gl-mat4/transpose":245,"gl-vec3/cross":290,"gl-vec3/dot":293,"gl-vec3/length":298,"gl-vec3/normalize":304}],372:[function(t,e,r){e.exports=function(t,e){var r=e[15];if(0===r)return!1;for(var n=1/r,i=0;i<16;i++)t[i]=e[i]*n;return!0}},{}],373:[function(t,e,r){var n=t("gl-vec3/lerp"),i=t("mat4-recompose"),a=t("mat4-decompose"),o=t("gl-mat4/determinant"),s=t("quat-slerp"),l=f(),c=f(),u=f();function f(){return{translate:h(),scale:h(1),skew:h(),perspective:[0,0,0,1],quaternion:[0,0,0,1]}}function h(t){return[t||0,t||0,t||0]}e.exports=function(t,e,r,f){if(0===o(e)||0===o(r))return!1;var h=a(e,l.translate,l.scale,l.skew,l.perspective,l.quaternion),p=a(r,c.translate,c.scale,c.skew,c.perspective,c.quaternion);return!(!h||!p||(n(u.translate,l.translate,c.translate,f),n(u.skew,l.skew,c.skew,f),n(u.scale,l.scale,c.scale,f),n(u.perspective,l.perspective,c.perspective,f),s(u.quaternion,l.quaternion,c.quaternion,f),i(t,u.translate,u.scale,u.skew,u.perspective,u.quaternion),0))}},{"gl-mat4/determinant":231,"gl-vec3/lerp":299,"mat4-decompose":371,"mat4-recompose":374,"quat-slerp":425}],374:[function(t,e,r){var n={identity:t("gl-mat4/identity"),translate:t("gl-mat4/translate"),multiply:t("gl-mat4/multiply"),create:t("gl-mat4/create"),scale:t("gl-mat4/scale"),fromRotationTranslation:t("gl-mat4/fromRotationTranslation")},i=(n.create(),n.create());e.exports=function(t,e,r,a,o,s){return n.identity(t),n.fromRotationTranslation(t,s,e),t[3]=o[0],t[7]=o[1],t[11]=o[2],t[15]=o[3],n.identity(i),0!==a[2]&&(i[9]=a[2],n.multiply(t,t,i)),0!==a[1]&&(i[9]=0,i[8]=a[1],n.multiply(t,t,i)),0!==a[0]&&(i[8]=0,i[4]=a[0],n.multiply(t,t,i)),n.scale(t,t,r),t}},{"gl-mat4/create":230,"gl-mat4/fromRotationTranslation":233,"gl-mat4/identity":234,"gl-mat4/multiply":237,"gl-mat4/scale":243,"gl-mat4/translate":244}],375:[function(t,e,r){"use strict";e.exports=Math.log2||function(t){return Math.log(t)*Math.LOG2E}},{}],376:[function(t,e,r){"use strict";var n=t("binary-search-bounds"),i=t("mat4-interpolate"),a=t("gl-mat4/invert"),o=t("gl-mat4/rotateX"),s=t("gl-mat4/rotateY"),l=t("gl-mat4/rotateZ"),c=t("gl-mat4/lookAt"),u=t("gl-mat4/translate"),f=(t("gl-mat4/scale"),t("gl-vec3/normalize")),h=[0,0,0];function p(t){this._components=t.slice(),this._time=[0],this.prevMatrix=t.slice(),this.nextMatrix=t.slice(),this.computedMatrix=t.slice(),this.computedInverse=t.slice(),this.computedEye=[0,0,0],this.computedUp=[0,0,0],this.computedCenter=[0,0,0],this.computedRadius=[0],this._limits=[-1/0,1/0]}e.exports=function(t){return new p((t=t||{}).matrix||[1,0,0,0,0,1,0,0,0,0,1,0,0,0,0,1])};var d=p.prototype;d.recalcMatrix=function(t){var e=this._time,r=n.le(e,t),o=this.computedMatrix;if(!(r<0)){var s=this._components;if(r===e.length-1)for(var l=16*r,c=0;c<16;++c)o[c]=s[l++];else{var u=e[r+1]-e[r],h=(l=16*r,this.prevMatrix),p=!0;for(c=0;c<16;++c)h[c]=s[l++];var d=this.nextMatrix;for(c=0;c<16;++c)d[c]=s[l++],p=p&&h[c]===d[c];if(u<1e-6||p)for(c=0;c<16;++c)o[c]=h[c];else i(o,h,d,(t-e[r])/u)}var g=this.computedUp;g[0]=o[1],g[1]=o[5],g[2]=o[9],f(g,g);var m=this.computedInverse;a(m,o);var v=this.computedEye,y=m[15];v[0]=m[12]/y,v[1]=m[13]/y,v[2]=m[14]/y;var x=this.computedCenter,b=Math.exp(this.computedRadius[0]);for(c=0;c<3;++c)x[c]=v[c]-o[2+4*c]*b}},d.idle=function(t){if(!(t1&&n(t[o[u-2]],t[o[u-1]],c)<=0;)u-=1,o.pop();for(o.push(l),u=s.length;u>1&&n(t[s[u-2]],t[s[u-1]],c)>=0;)u-=1,s.pop();s.push(l)}for(var r=new Array(s.length+o.length-2),f=0,i=0,h=o.length;i0;--p)r[f++]=s[p];return r};var n=t("robust-orientation")[3]},{"robust-orientation":446}],378:[function(t,e,r){"use strict";e.exports=function(t,e){e||(e=t,t=window);var r=0,i=0,a=0,o={shift:!1,alt:!1,control:!1,meta:!1},s=!1;function l(t){var e=!1;return"altKey"in t&&(e=e||t.altKey!==o.alt,o.alt=!!t.altKey),"shiftKey"in t&&(e=e||t.shiftKey!==o.shift,o.shift=!!t.shiftKey),"ctrlKey"in t&&(e=e||t.ctrlKey!==o.control,o.control=!!t.ctrlKey),"metaKey"in t&&(e=e||t.metaKey!==o.meta,o.meta=!!t.metaKey),e}function c(t,s){var c=n.x(s),u=n.y(s);"buttons"in s&&(t=0|s.buttons),(t!==r||c!==i||u!==a||l(s))&&(r=0|t,i=c||0,a=u||0,e&&e(r,i,a,o))}function u(t){c(0,t)}function f(){(r||i||a||o.shift||o.alt||o.meta||o.control)&&(i=a=0,r=0,o.shift=o.alt=o.control=o.meta=!1,e&&e(0,0,0,o))}function h(t){l(t)&&e&&e(r,i,a,o)}function p(t){0===n.buttons(t)?c(0,t):c(r,t)}function d(t){c(r|n.buttons(t),t)}function g(t){c(r&~n.buttons(t),t)}function m(){s||(s=!0,t.addEventListener("mousemove",p),t.addEventListener("mousedown",d),t.addEventListener("mouseup",g),t.addEventListener("mouseleave",u),t.addEventListener("mouseenter",u),t.addEventListener("mouseout",u),t.addEventListener("mouseover",u),t.addEventListener("blur",f),t.addEventListener("keyup",h),t.addEventListener("keydown",h),t.addEventListener("keypress",h),t!==window&&(window.addEventListener("blur",f),window.addEventListener("keyup",h),window.addEventListener("keydown",h),window.addEventListener("keypress",h)))}m();var v={element:t};return Object.defineProperties(v,{enabled:{get:function(){return s},set:function(e){e?m():s&&(s=!1,t.removeEventListener("mousemove",p),t.removeEventListener("mousedown",d),t.removeEventListener("mouseup",g),t.removeEventListener("mouseleave",u),t.removeEventListener("mouseenter",u),t.removeEventListener("mouseout",u),t.removeEventListener("mouseover",u),t.removeEventListener("blur",f),t.removeEventListener("keyup",h),t.removeEventListener("keydown",h),t.removeEventListener("keypress",h),t!==window&&(window.removeEventListener("blur",f),window.removeEventListener("keyup",h),window.removeEventListener("keydown",h),window.removeEventListener("keypress",h)))},enumerable:!0},buttons:{get:function(){return r},enumerable:!0},x:{get:function(){return i},enumerable:!0},y:{get:function(){return a},enumerable:!0},mods:{get:function(){return o},enumerable:!0}}),v};var n=t("mouse-event")},{"mouse-event":380}],379:[function(t,e,r){var n={left:0,top:0};e.exports=function(t,e,r){e=e||t.currentTarget||t.srcElement,Array.isArray(r)||(r=[0,0]);var i=t.clientX||0,a=t.clientY||0,o=(s=e,s===window||s===document||s===document.body?n:s.getBoundingClientRect());var s;return r[0]=i-o.left,r[1]=a-o.top,r}},{}],380:[function(t,e,r){"use strict";function n(t){return t.target||t.srcElement||window}r.buttons=function(t){if("object"==typeof t){if("buttons"in t)return t.buttons;if("which"in t){if(2===(e=t.which))return 4;if(3===e)return 2;if(e>0)return 1<=0)return 1< 0");"function"!=typeof t.vertex&&e("Must specify vertex creation function");"function"!=typeof t.cell&&e("Must specify cell creation function");"function"!=typeof t.phase&&e("Must specify phase function");for(var C=t.getters||[],E=new Array(T),L=0;L=0?E[L]=!0:E[L]=!1;return function(t,e,r,T,S,C){var E=C.length,L=S.length;if(L<2)throw new Error("ndarray-extract-contour: Dimension must be at least 2");for(var z="extractContour"+S.join("_"),P=[],D=[],O=[],I=0;I0&&N.push(l(I,S[R-1])+"*"+s(S[R-1])),D.push(d(I,S[R])+"=("+N.join("-")+")|0")}for(var I=0;I=0;--I)j.push(s(S[I]));D.push(w+"=("+j.join("*")+")|0",b+"=mallocUint32("+w+")",x+"=mallocUint32("+w+")",k+"=0"),D.push(g(0)+"=0");for(var R=1;R<1<0;M=M-1&d)w.push(x+"["+k+"+"+v(M)+"]");w.push(y(0));for(var M=0;M=0;--e)G(e,0);for(var r=[],e=0;e0){",p(S[e]),"=1;");t(e-1,r|1<=0?s.push("0"):e.indexOf(-(l+1))>=0?s.push("s["+l+"]-1"):(s.push("-1"),a.push("1"),o.push("s["+l+"]-2"));var c=".lo("+a.join()+").hi("+o.join()+")";if(0===a.length&&(c=""),i>0){n.push("if(1");for(var l=0;l=0||e.indexOf(-(l+1))>=0||n.push("&&s[",l,"]>2");n.push("){grad",i,"(src.pick(",s.join(),")",c);for(var l=0;l=0||e.indexOf(-(l+1))>=0||n.push(",dst.pick(",s.join(),",",l,")",c);n.push(");")}for(var l=0;l1){dst.set(",s.join(),",",u,",0.5*(src.get(",h.join(),")-src.get(",p.join(),")))}else{dst.set(",s.join(),",",u,",0)};"):n.push("if(s[",u,"]>1){diff(",f,",src.pick(",h.join(),")",c,",src.pick(",p.join(),")",c,");}else{zero(",f,");};");break;case"mirror":0===i?n.push("dst.set(",s.join(),",",u,",0);"):n.push("zero(",f,");");break;case"wrap":var d=s.slice(),g=s.slice();e[l]<0?(d[u]="s["+u+"]-2",g[u]="0"):(d[u]="s["+u+"]-1",g[u]="1"),0===i?n.push("if(s[",u,"]>2){dst.set(",s.join(),",",u,",0.5*(src.get(",d.join(),")-src.get(",g.join(),")))}else{dst.set(",s.join(),",",u,",0)};"):n.push("if(s[",u,"]>2){diff(",f,",src.pick(",d.join(),")",c,",src.pick(",g.join(),")",c,");}else{zero(",f,");};");break;default:throw new Error("ndarray-gradient: Invalid boundary condition")}}i>0&&n.push("};")}for(var s=0;s<1<>",rrshift:">>>"};!function(){for(var t in s){var e=s[t];r[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),r[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a"+e+"=b"},rvalue:!0,funcName:t+"eq"}),r[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),r[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a"+e+"=s"},rvalue:!0,funcName:t+"seq"})}}();var l={not:"!",bnot:"~",neg:"-",recip:"1.0/"};!function(){for(var t in l){var e=l[t];r[t]=o({args:["array","array"],body:{args:["a","b"],body:"a="+e+"b"},funcName:t}),r[t+"eq"]=o({args:["array"],body:{args:["a"],body:"a="+e+"a"},rvalue:!0,count:2,funcName:t+"eq"})}}();var c={and:"&&",or:"||",eq:"===",neq:"!==",lt:"<",gt:">",leq:"<=",geq:">="};!function(){for(var t in c){var e=c[t];r[t]=o({args:["array","array","array"],body:{args:["a","b","c"],body:"a=b"+e+"c"},funcName:t}),r[t+"s"]=o({args:["array","array","scalar"],body:{args:["a","b","s"],body:"a=b"+e+"s"},funcName:t+"s"}),r[t+"eq"]=o({args:["array","array"],body:{args:["a","b"],body:"a=a"+e+"b"},rvalue:!0,count:2,funcName:t+"eq"}),r[t+"seq"]=o({args:["array","scalar"],body:{args:["a","s"],body:"a=a"+e+"s"},rvalue:!0,count:2,funcName:t+"seq"})}}();var u=["abs","acos","asin","atan","ceil","cos","exp","floor","log","round","sin","sqrt","tan"];!function(){for(var t=0;tthis_s){this_s=-a}else if(a>this_s){this_s=a}",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norminf"}),r.norm1=n({args:["array"],pre:{args:[],localVars:[],thisVars:["this_s"],body:"this_s=0"},body:{args:[{name:"a",lvalue:!1,rvalue:!0,count:3}],body:"this_s+=a<0?-a:a",localVars:[],thisVars:["this_s"]},post:{args:[],localVars:[],thisVars:["this_s"],body:"return this_s"},funcName:"norm1"}),r.sup=n({args:["array"],pre:{body:"this_h=-Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_>this_h)this_h=_inline_1_arg0_",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_h"],localVars:[]},post:{body:"return this_h",args:[],thisVars:["this_h"],localVars:[]}}),r.inf=n({args:["array"],pre:{body:"this_h=Infinity",args:[],thisVars:["this_h"],localVars:[]},body:{body:"if(_inline_1_arg0_this_v){this_v=_inline_1_arg1_;for(var _inline_1_k=0;_inline_1_k<_inline_1_arg0_.length;++_inline_1_k){this_i[_inline_1_k]=_inline_1_arg0_[_inline_1_k]}}}",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:2}],thisVars:["this_i","this_v"],localVars:["_inline_1_k"]},post:{body:"{return this_i}",args:[],thisVars:["this_i"],localVars:[]}}),r.random=o({args:["array"],pre:{args:[],body:"this_f=Math.random",thisVars:["this_f"]},body:{args:["a"],body:"a=this_f()",thisVars:["this_f"]},funcName:"random"}),r.assign=o({args:["array","array"],body:{args:["a","b"],body:"a=b"},funcName:"assign"}),r.assigns=o({args:["array","scalar"],body:{args:["a","b"],body:"a=b"},funcName:"assigns"}),r.equals=n({args:["array","array"],pre:i,body:{args:[{name:"x",lvalue:!1,rvalue:!0,count:1},{name:"y",lvalue:!1,rvalue:!0,count:1}],body:"if(x!==y){return false}",localVars:[],thisVars:[]},post:{args:[],localVars:[],thisVars:[],body:"return true"},funcName:"equals"})},{"cwise-compiler":117}],388:[function(t,e,r){"use strict";var n=t("ndarray"),i=t("./doConvert.js");e.exports=function(t,e){for(var r=[],a=t,o=1;Array.isArray(a);)r.push(a.length),o*=a.length,a=a[0];return 0===r.length?n():(e||(e=n(new Float64Array(o),r)),i(e,t),e)}},{"./doConvert.js":389,ndarray:393}],389:[function(t,e,r){e.exports=t("cwise-compiler")({args:["array","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\nvar _inline_1_v=_inline_1_arg1_,_inline_1_i\nfor(_inline_1_i=0;_inline_1_i<_inline_1_arg2_.length-1;++_inline_1_i) {\n_inline_1_v=_inline_1_v[_inline_1_arg2_[_inline_1_i]]\n}\n_inline_1_arg0_=_inline_1_v[_inline_1_arg2_[_inline_1_arg2_.length-1]]\n}",args:[{name:"_inline_1_arg0_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:4}],thisVars:[],localVars:["_inline_1_i","_inline_1_v"]},post:{body:"{}",args:[],thisVars:[],localVars:[]},funcName:"convert",blockSize:64})},{"cwise-compiler":117}],390:[function(t,e,r){"use strict";var n=t("typedarray-pool"),i=32;function a(t){switch(t){case"uint8":return[n.mallocUint8,n.freeUint8];case"uint16":return[n.mallocUint16,n.freeUint16];case"uint32":return[n.mallocUint32,n.freeUint32];case"int8":return[n.mallocInt8,n.freeInt8];case"int16":return[n.mallocInt16,n.freeInt16];case"int32":return[n.mallocInt32,n.freeInt32];case"float32":return[n.mallocFloat,n.freeFloat];case"float64":return[n.mallocDouble,n.freeDouble];default:return null}}function o(t){for(var e=[],r=0;r0?s.push(["d",d,"=s",d,"-d",f,"*n",f].join("")):s.push(["d",d,"=s",d].join("")),f=d),0!=(p=t.length-1-l)&&(h>0?s.push(["e",p,"=s",p,"-e",h,"*n",h,",f",p,"=",c[p],"-f",h,"*n",h].join("")):s.push(["e",p,"=s",p,",f",p,"=",c[p]].join("")),h=p)}r.push("var "+s.join(","));var g=["0","n0-1","data","offset"].concat(o(t.length));r.push(["if(n0<=",i,"){","insertionSort(",g.join(","),")}else{","quickSort(",g.join(","),")}"].join("")),r.push("}return "+n);var m=new Function("insertionSort","quickSort",r.join("\n")),v=function(t,e){var r=["'use strict'"],n=["ndarrayInsertionSort",t.join("d"),e].join(""),i=["left","right","data","offset"].concat(o(t.length)),s=a(e),l=["i,j,cptr,ptr=left*s0+offset"];if(t.length>1){for(var c=[],u=1;u1){for(r.push("dptr=0;sptr=ptr"),u=t.length-1;u>=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"b){break __l}"].join("")),u=t.length-1;u>=1;--u)r.push("sptr+=e"+u,"dptr+=f"+u,"}");for(r.push("dptr=cptr;sptr=cptr-s0"),u=t.length-1;u>=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"=0;--u)0!==(p=t[u])&&r.push(["for(i",p,"=0;i",p,"scratch)){",h("cptr",f("cptr-s0")),"cptr-=s0","}",h("cptr","scratch"));return r.push("}"),t.length>1&&s&&r.push("free(scratch)"),r.push("} return "+n),s?new Function("malloc","free",r.join("\n"))(s[0],s[1]):new Function(r.join("\n"))()}(t,e),y=function(t,e,r){var n=["'use strict'"],s=["ndarrayQuickSort",t.join("d"),e].join(""),l=["left","right","data","offset"].concat(o(t.length)),c=a(e),u=0;n.push(["function ",s,"(",l.join(","),"){"].join(""));var f=["sixth=((right-left+1)/6)|0","index1=left+sixth","index5=right-sixth","index3=(left+right)>>1","index2=index3-sixth","index4=index3+sixth","el1=index1","el2=index2","el3=index3","el4=index4","el5=index5","less=left+1","great=right-1","pivots_are_equal=true","tmp","tmp0","x","y","z","k","ptr0","ptr1","ptr2","comp_pivot1=0","comp_pivot2=0","comp=0"];if(t.length>1){for(var h=[],p=1;p=0;--a)0!==(o=t[a])&&n.push(["for(i",o,"=0;i",o,"1)for(a=0;a1?n.push("ptr_shift+=d"+o):n.push("ptr0+=d"+o),n.push("}"))}}function y(e,r,i,a){if(1===r.length)n.push("ptr0="+d(r[0]));else{for(var o=0;o1)for(o=0;o=1;--o)i&&n.push("pivot_ptr+=f"+o),r.length>1?n.push("ptr_shift+=e"+o):n.push("ptr0+=e"+o),n.push("}")}function x(){t.length>1&&c&&n.push("free(pivot1)","free(pivot2)")}function b(e,r){var i="el"+e,a="el"+r;if(t.length>1){var o="__l"+ ++u;y(o,[i,a],!1,["comp=",g("ptr0"),"-",g("ptr1"),"\n","if(comp>0){tmp0=",i,";",i,"=",a,";",a,"=tmp0;break ",o,"}\n","if(comp<0){break ",o,"}"].join(""))}else n.push(["if(",g(d(i)),">",g(d(a)),"){tmp0=",i,";",i,"=",a,";",a,"=tmp0}"].join(""))}function _(e,r){t.length>1?v([e,r],!1,m("ptr0",g("ptr1"))):n.push(m(d(e),g(d(r))))}function w(e,r,i){if(t.length>1){var a="__l"+ ++u;y(a,[r],!0,[e,"=",g("ptr0"),"-pivot",i,"[pivot_ptr]\n","if(",e,"!==0){break ",a,"}"].join(""))}else n.push([e,"=",g(d(r)),"-pivot",i].join(""))}function k(e,r){t.length>1?v([e,r],!1,["tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1","tmp")].join("")):n.push(["ptr0=",d(e),"\n","ptr1=",d(r),"\n","tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1","tmp")].join(""))}function M(e,r,i){t.length>1?(v([e,r,i],!1,["tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1",g("ptr2")),"\n",m("ptr2","tmp")].join("")),n.push("++"+r,"--"+i)):n.push(["ptr0=",d(e),"\n","ptr1=",d(r),"\n","ptr2=",d(i),"\n","++",r,"\n","--",i,"\n","tmp=",g("ptr0"),"\n",m("ptr0",g("ptr1")),"\n",m("ptr1",g("ptr2")),"\n",m("ptr2","tmp")].join(""))}function A(t,e){k(t,e),n.push("--"+e)}function T(e,r,i){t.length>1?v([e,r],!0,[m("ptr0",g("ptr1")),"\n",m("ptr1",["pivot",i,"[pivot_ptr]"].join(""))].join("")):n.push(m(d(e),g(d(r))),m(d(r),"pivot"+i))}function S(e,r){n.push(["if((",r,"-",e,")<=",i,"){\n","insertionSort(",e,",",r,",data,offset,",o(t.length).join(","),")\n","}else{\n",s,"(",e,",",r,",data,offset,",o(t.length).join(","),")\n","}"].join(""))}function C(e,r,i){t.length>1?(n.push(["__l",++u,":while(true){"].join("")),v([e],!0,["if(",g("ptr0"),"!==pivot",r,"[pivot_ptr]){break __l",u,"}"].join("")),n.push(i,"}")):n.push(["while(",g(d(e)),"===pivot",r,"){",i,"}"].join(""))}return n.push("var "+f.join(",")),b(1,2),b(4,5),b(1,3),b(2,3),b(1,4),b(3,4),b(2,5),b(2,3),b(4,5),t.length>1?v(["el1","el2","el3","el4","el5","index1","index3","index5"],!0,["pivot1[pivot_ptr]=",g("ptr1"),"\n","pivot2[pivot_ptr]=",g("ptr3"),"\n","pivots_are_equal=pivots_are_equal&&(pivot1[pivot_ptr]===pivot2[pivot_ptr])\n","x=",g("ptr0"),"\n","y=",g("ptr2"),"\n","z=",g("ptr4"),"\n",m("ptr5","x"),"\n",m("ptr6","y"),"\n",m("ptr7","z")].join("")):n.push(["pivot1=",g(d("el2")),"\n","pivot2=",g(d("el4")),"\n","pivots_are_equal=pivot1===pivot2\n","x=",g(d("el1")),"\n","y=",g(d("el3")),"\n","z=",g(d("el5")),"\n",m(d("index1"),"x"),"\n",m(d("index3"),"y"),"\n",m(d("index5"),"z")].join("")),_("index2","left"),_("index4","right"),n.push("if(pivots_are_equal){"),n.push("for(k=less;k<=great;++k){"),w("comp","k",1),n.push("if(comp===0){continue}"),n.push("if(comp<0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),n.push("while(true){"),w("comp","great",1),n.push("if(comp>0){"),n.push("great--"),n.push("}else if(comp<0){"),M("k","less","great"),n.push("break"),n.push("}else{"),A("k","great"),n.push("break"),n.push("}"),n.push("}"),n.push("}"),n.push("}"),n.push("}else{"),n.push("for(k=less;k<=great;++k){"),w("comp_pivot1","k",1),n.push("if(comp_pivot1<0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),w("comp_pivot2","k",2),n.push("if(comp_pivot2>0){"),n.push("while(true){"),w("comp","great",2),n.push("if(comp>0){"),n.push("if(--greatindex5){"),C("less",1,"++less"),C("great",2,"--great"),n.push("for(k=less;k<=great;++k){"),w("comp_pivot1","k",1),n.push("if(comp_pivot1===0){"),n.push("if(k!==less){"),k("k","less"),n.push("}"),n.push("++less"),n.push("}else{"),w("comp_pivot2","k",2),n.push("if(comp_pivot2===0){"),n.push("while(true){"),w("comp","great",2),n.push("if(comp===0){"),n.push("if(--great1&&c?new Function("insertionSort","malloc","free",n.join("\n"))(r,c[0],c[1]):new Function("insertionSort",n.join("\n"))(r)}(t,e,v);return m(v,y)}},{"typedarray-pool":481}],391:[function(t,e,r){"use strict";var n=t("./lib/compile_sort.js"),i={};e.exports=function(t){var e=t.order,r=t.dtype,a=[e,r].join(":"),o=i[a];return o||(i[a]=o=n(e,r)),o(t),t}},{"./lib/compile_sort.js":390}],392:[function(t,e,r){"use strict";var n=t("ndarray-linear-interpolate"),i=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=new Array(_inline_3_arg4_)}",args:[{name:"_inline_3_arg0_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg1_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg2_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg3_",lvalue:!1,rvalue:!1,count:0},{name:"_inline_3_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_4_arg2_(this_warped,_inline_4_arg0_),_inline_4_arg1_=_inline_4_arg3_.apply(void 0,this_warped)}",args:[{name:"_inline_4_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_4_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_4_arg4_",lvalue:!1,rvalue:!1,count:0}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warpND",blockSize:64}),a=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_7_arg2_(this_warped,_inline_7_arg0_),_inline_7_arg1_=_inline_7_arg3_(_inline_7_arg4_,this_warped[0])}",args:[{name:"_inline_7_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_7_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_7_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp1D",blockSize:64}),o=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0,0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_10_arg2_(this_warped,_inline_10_arg0_),_inline_10_arg1_=_inline_10_arg3_(_inline_10_arg4_,this_warped[0],this_warped[1])}",args:[{name:"_inline_10_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_10_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_10_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp2D",blockSize:64}),s=t("cwise/lib/wrapper")({args:["index","array","scalar","scalar","scalar"],pre:{body:"{this_warped=[0,0,0]}",args:[],thisVars:["this_warped"],localVars:[]},body:{body:"{_inline_13_arg2_(this_warped,_inline_13_arg0_),_inline_13_arg1_=_inline_13_arg3_(_inline_13_arg4_,this_warped[0],this_warped[1],this_warped[2])}",args:[{name:"_inline_13_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg1_",lvalue:!0,rvalue:!1,count:1},{name:"_inline_13_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg3_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_13_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:["this_warped"],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},debug:!1,funcName:"warp3D",blockSize:64});e.exports=function(t,e,r){switch(e.shape.length){case 1:a(t,r,n.d1,e);break;case 2:o(t,r,n.d2,e);break;case 3:s(t,r,n.d3,e);break;default:i(t,r,n.bind(void 0,e),e.shape.length)}return t}},{"cwise/lib/wrapper":120,"ndarray-linear-interpolate":386}],393:[function(t,e,r){var n=t("iota-array"),i=t("is-buffer"),a="undefined"!=typeof Float64Array;function o(t,e){return t[0]-e[0]}function s(){var t,e=this.stride,r=new Array(e.length);for(t=0;tMath.abs(this.stride[1]))?[1,0]:[0,1]}})"):3===e&&a.push("var s0=Math.abs(this.stride[0]),s1=Math.abs(this.stride[1]),s2=Math.abs(this.stride[2]);if(s0>s1){if(s1>s2){return [2,1,0];}else if(s0>s2){return [1,2,0];}else{return [1,0,2];}}else if(s0>s2){return [2,0,1];}else if(s2>s1){return [0,1,2];}else{return [0,2,1];}}})")):a.push("ORDER})")),a.push("proto.set=function "+r+"_set("+l.join(",")+",v){"),i?a.push("return this.data.set("+u+",v)}"):a.push("return this.data["+u+"]=v}"),a.push("proto.get=function "+r+"_get("+l.join(",")+"){"),i?a.push("return this.data.get("+u+")}"):a.push("return this.data["+u+"]}"),a.push("proto.index=function "+r+"_index(",l.join(),"){return "+u+"}"),a.push("proto.hi=function "+r+"_hi("+l.join(",")+"){return new "+r+"(this.data,"+o.map(function(t){return["(typeof i",t,"!=='number'||i",t,"<0)?this.shape[",t,"]:i",t,"|0"].join("")}).join(",")+","+o.map(function(t){return"this.stride["+t+"]"}).join(",")+",this.offset)}");var p=o.map(function(t){return"a"+t+"=this.shape["+t+"]"}),d=o.map(function(t){return"c"+t+"=this.stride["+t+"]"});a.push("proto.lo=function "+r+"_lo("+l.join(",")+"){var b=this.offset,d=0,"+p.join(",")+","+d.join(","));for(var g=0;g=0){d=i"+g+"|0;b+=c"+g+"*d;a"+g+"-=d}");a.push("return new "+r+"(this.data,"+o.map(function(t){return"a"+t}).join(",")+","+o.map(function(t){return"c"+t}).join(",")+",b)}"),a.push("proto.step=function "+r+"_step("+l.join(",")+"){var "+o.map(function(t){return"a"+t+"=this.shape["+t+"]"}).join(",")+","+o.map(function(t){return"b"+t+"=this.stride["+t+"]"}).join(",")+",c=this.offset,d=0,ceil=Math.ceil");for(g=0;g=0){c=(c+this.stride["+g+"]*i"+g+")|0}else{a.push(this.shape["+g+"]);b.push(this.stride["+g+"])}");return a.push("var ctor=CTOR_LIST[a.length+1];return ctor(this.data,a,b,c)}"),a.push("return function construct_"+r+"(data,shape,stride,offset){return new "+r+"(data,"+o.map(function(t){return"shape["+t+"]"}).join(",")+","+o.map(function(t){return"stride["+t+"]"}).join(",")+",offset)}"),new Function("CTOR_LIST","ORDER",a.join("\n"))(c[t],s)}var c={float32:[],float64:[],int8:[],int16:[],int32:[],uint8:[],uint16:[],uint32:[],array:[],uint8_clamped:[],buffer:[],generic:[]};e.exports=function(t,e,r,n){if(void 0===t)return(0,c.array[0])([]);"number"==typeof t&&(t=[t]),void 0===e&&(e=[t.length]);var o=e.length;if(void 0===r){r=new Array(o);for(var s=o-1,u=1;s>=0;--s)r[s]=u,u*=e[s]}if(void 0===n)for(n=0,s=0;s>>0;e.exports=function(t,e){if(isNaN(t)||isNaN(e))return NaN;if(t===e)return t;if(0===t)return e<0?-i:i;var r=n.hi(t),o=n.lo(t);e>t==t>0?o===a?(r+=1,o=0):o+=1:0===o?(o=a,r-=1):o-=1;return n.pack(o,r)}},{"double-bits":134}],395:[function(t,e,r){var n=Math.PI,i=c(120);function a(t,e,r,n){return["C",t,e,r,n,r,n]}function o(t,e,r,n,i,a){return["C",t/3+2/3*r,e/3+2/3*n,i/3+2/3*r,a/3+2/3*n,i,a]}function s(t,e,r,a,o,c,u,f,h,p){if(p)k=p[0],M=p[1],_=p[2],w=p[3];else{var d=l(t,e,-o);t=d.x,e=d.y;var g=(t-(f=(d=l(f,h,-o)).x))/2,m=(e-(h=d.y))/2,v=g*g/(r*r)+m*m/(a*a);v>1&&(r*=v=Math.sqrt(v),a*=v);var y=r*r,x=a*a,b=(c==u?-1:1)*Math.sqrt(Math.abs((y*x-y*m*m-x*g*g)/(y*m*m+x*g*g)));b==1/0&&(b=1);var _=b*r*m/a+(t+f)/2,w=b*-a*g/r+(e+h)/2,k=Math.asin(((e-w)/a).toFixed(9)),M=Math.asin(((h-w)/a).toFixed(9));(k=t<_?n-k:k)<0&&(k=2*n+k),(M=f<_?n-M:M)<0&&(M=2*n+M),u&&k>M&&(k-=2*n),!u&&M>k&&(M-=2*n)}if(Math.abs(M-k)>i){var A=M,T=f,S=h;M=k+i*(u&&M>k?1:-1);var C=s(f=_+r*Math.cos(M),h=w+a*Math.sin(M),r,a,o,0,u,T,S,[M,A,_,w])}var E=Math.tan((M-k)/4),L=4/3*r*E,z=4/3*a*E,P=[2*t-(t+L*Math.sin(k)),2*e-(e-z*Math.cos(k)),f+L*Math.sin(M),h-z*Math.cos(M),f,h];if(p)return P;C&&(P=P.concat(C));for(var D=0;D7&&(r.push(v.splice(0,7)),v.unshift("C"));break;case"S":var x=p,b=d;"C"!=e&&"S"!=e||(x+=x-n,b+=b-i),v=["C",x,b,v[1],v[2],v[3],v[4]];break;case"T":"Q"==e||"T"==e?(f=2*p-f,h=2*d-h):(f=p,h=d),v=o(p,d,f,h,v[1],v[2]);break;case"Q":f=v[1],h=v[2],v=o(p,d,v[1],v[2],v[3],v[4]);break;case"L":v=a(p,d,v[1],v[2]);break;case"H":v=a(p,d,v[1],d);break;case"V":v=a(p,d,p,v[1]);break;case"Z":v=a(p,d,l,u)}e=y,p=v[v.length-2],d=v[v.length-1],v.length>4?(n=v[v.length-4],i=v[v.length-3]):(n=p,i=d),r.push(v)}return r}},{}],396:[function(t,e,r){r.vertexNormals=function(t,e,r){for(var n=e.length,i=new Array(n),a=void 0===r?1e-6:r,o=0;oa){var b=i[c],_=1/Math.sqrt(m*y);for(x=0;x<3;++x){var w=(x+1)%3,k=(x+2)%3;b[x]+=_*(v[w]*g[k]-v[k]*g[w])}}}for(o=0;oa)for(_=1/Math.sqrt(M),x=0;x<3;++x)b[x]*=_;else for(x=0;x<3;++x)b[x]=0}return i},r.faceNormals=function(t,e,r){for(var n=t.length,i=new Array(n),a=void 0===r?1e-6:r,o=0;oa?1/Math.sqrt(p):0;for(c=0;c<3;++c)h[c]*=p;i[o]=h}return i}},{}],397:[function(t,e,r){"use strict";var n=Object.getOwnPropertySymbols,i=Object.prototype.hasOwnProperty,a=Object.prototype.propertyIsEnumerable;e.exports=function(){try{if(!Object.assign)return!1;var t=new String("abc");if(t[5]="de","5"===Object.getOwnPropertyNames(t)[0])return!1;for(var e={},r=0;r<10;r++)e["_"+String.fromCharCode(r)]=r;if("0123456789"!==Object.getOwnPropertyNames(e).map(function(t){return e[t]}).join(""))return!1;var n={};return"abcdefghijklmnopqrst".split("").forEach(function(t){n[t]=t}),"abcdefghijklmnopqrst"===Object.keys(Object.assign({},n)).join("")}catch(t){return!1}}()?Object.assign:function(t,e){for(var r,o,s=function(t){if(null==t)throw new TypeError("Object.assign cannot be called with null or undefined");return Object(t)}(t),l=1;l0){var f=Math.sqrt(u+1);t[0]=.5*(o-l)/f,t[1]=.5*(s-n)/f,t[2]=.5*(r-a)/f,t[3]=.5*f}else{var h=Math.max(e,a,c),f=Math.sqrt(2*h-u+1);e>=h?(t[0]=.5*f,t[1]=.5*(i+r)/f,t[2]=.5*(s+n)/f,t[3]=.5*(o-l)/f):a>=h?(t[0]=.5*(r+i)/f,t[1]=.5*f,t[2]=.5*(l+o)/f,t[3]=.5*(s-n)/f):(t[0]=.5*(n+s)/f,t[1]=.5*(o+l)/f,t[2]=.5*f,t[3]=.5*(r-i)/f)}return t}},{}],399:[function(t,e,r){"use strict";e.exports=function(t){var e=(t=t||{}).center||[0,0,0],r=t.rotation||[0,0,0,1],n=t.radius||1;e=[].slice.call(e,0,3),u(r=[].slice.call(r,0,4),r);var i=new f(r,e,Math.log(n));i.setDistanceLimits(t.zoomMin,t.zoomMax),("eye"in t||"up"in t)&&i.lookAt(0,t.eye,t.center,t.up);return i};var n=t("filtered-vector"),i=t("gl-mat4/lookAt"),a=t("gl-mat4/fromQuat"),o=t("gl-mat4/invert"),s=t("./lib/quatFromFrame");function l(t,e,r){return Math.sqrt(Math.pow(t,2)+Math.pow(e,2)+Math.pow(r,2))}function c(t,e,r,n){return Math.sqrt(Math.pow(t,2)+Math.pow(e,2)+Math.pow(r,2)+Math.pow(n,2))}function u(t,e){var r=e[0],n=e[1],i=e[2],a=e[3],o=c(r,n,i,a);o>1e-6?(t[0]=r/o,t[1]=n/o,t[2]=i/o,t[3]=a/o):(t[0]=t[1]=t[2]=0,t[3]=1)}function f(t,e,r){this.radius=n([r]),this.center=n(e),this.rotation=n(t),this.computedRadius=this.radius.curve(0),this.computedCenter=this.center.curve(0),this.computedRotation=this.rotation.curve(0),this.computedUp=[.1,0,0],this.computedEye=[.1,0,0],this.computedMatrix=[.1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],this.recalcMatrix(0)}var h=f.prototype;h.lastT=function(){return Math.max(this.radius.lastT(),this.center.lastT(),this.rotation.lastT())},h.recalcMatrix=function(t){this.radius.curve(t),this.center.curve(t),this.rotation.curve(t);var e=this.computedRotation;u(e,e);var r=this.computedMatrix;a(r,e);var n=this.computedCenter,i=this.computedEye,o=this.computedUp,s=Math.exp(this.computedRadius[0]);i[0]=n[0]+s*r[2],i[1]=n[1]+s*r[6],i[2]=n[2]+s*r[10],o[0]=r[1],o[1]=r[5],o[2]=r[9];for(var l=0;l<3;++l){for(var c=0,f=0;f<3;++f)c+=r[l+4*f]*i[f];r[12+l]=-c}},h.getMatrix=function(t,e){this.recalcMatrix(t);var r=this.computedMatrix;if(e){for(var n=0;n<16;++n)e[n]=r[n];return e}return r},h.idle=function(t){this.center.idle(t),this.radius.idle(t),this.rotation.idle(t)},h.flush=function(t){this.center.flush(t),this.radius.flush(t),this.rotation.flush(t)},h.pan=function(t,e,r,n){e=e||0,r=r||0,n=n||0,this.recalcMatrix(t);var i=this.computedMatrix,a=i[1],o=i[5],s=i[9],c=l(a,o,s);a/=c,o/=c,s/=c;var u=i[0],f=i[4],h=i[8],p=u*a+f*o+h*s,d=l(u-=a*p,f-=o*p,h-=s*p);u/=d,f/=d,h/=d;var g=i[2],m=i[6],v=i[10],y=g*a+m*o+v*s,x=g*u+m*f+v*h,b=l(g-=y*a+x*u,m-=y*o+x*f,v-=y*s+x*h);g/=b,m/=b,v/=b;var _=u*e+a*r,w=f*e+o*r,k=h*e+s*r;this.center.move(t,_,w,k);var M=Math.exp(this.computedRadius[0]);M=Math.max(1e-4,M+n),this.radius.set(t,Math.log(M))},h.rotate=function(t,e,r,n){this.recalcMatrix(t),e=e||0,r=r||0;var i=this.computedMatrix,a=i[0],o=i[4],s=i[8],u=i[1],f=i[5],h=i[9],p=i[2],d=i[6],g=i[10],m=e*a+r*u,v=e*o+r*f,y=e*s+r*h,x=-(d*y-g*v),b=-(g*m-p*y),_=-(p*v-d*m),w=Math.sqrt(Math.max(0,1-Math.pow(x,2)-Math.pow(b,2)-Math.pow(_,2))),k=c(x,b,_,w);k>1e-6?(x/=k,b/=k,_/=k,w/=k):(x=b=_=0,w=1);var M=this.computedRotation,A=M[0],T=M[1],S=M[2],C=M[3],E=A*w+C*x+T*_-S*b,L=T*w+C*b+S*x-A*_,z=S*w+C*_+A*b-T*x,P=C*w-A*x-T*b-S*_;if(n){x=p,b=d,_=g;var D=Math.sin(n)/l(x,b,_);x*=D,b*=D,_*=D,P=P*(w=Math.cos(e))-(E=E*w+P*x+L*_-z*b)*x-(L=L*w+P*b+z*x-E*_)*b-(z=z*w+P*_+E*b-L*x)*_}var O=c(E,L,z,P);O>1e-6?(E/=O,L/=O,z/=O,P/=O):(E=L=z=0,P=1),this.rotation.set(t,E,L,z,P)},h.lookAt=function(t,e,r,n){this.recalcMatrix(t),r=r||this.computedCenter,e=e||this.computedEye,n=n||this.computedUp;var a=this.computedMatrix;i(a,e,r,n);var o=this.computedRotation;s(o,a[0],a[1],a[2],a[4],a[5],a[6],a[8],a[9],a[10]),u(o,o),this.rotation.set(t,o[0],o[1],o[2],o[3]);for(var l=0,c=0;c<3;++c)l+=Math.pow(r[c]-e[c],2);this.radius.set(t,.5*Math.log(Math.max(l,1e-6))),this.center.set(t,r[0],r[1],r[2])},h.translate=function(t,e,r,n){this.center.move(t,e||0,r||0,n||0)},h.setMatrix=function(t,e){var r=this.computedRotation;s(r,e[0],e[1],e[2],e[4],e[5],e[6],e[8],e[9],e[10]),u(r,r),this.rotation.set(t,r[0],r[1],r[2],r[3]);var n=this.computedMatrix;o(n,e);var i=n[15];if(Math.abs(i)>1e-6){var a=n[12]/i,l=n[13]/i,c=n[14]/i;this.recalcMatrix(t);var f=Math.exp(this.computedRadius[0]);this.center.set(t,a-n[2]*f,l-n[6]*f,c-n[10]*f),this.radius.idle(t)}else this.center.idle(t),this.radius.idle(t)},h.setDistance=function(t,e){e>0&&this.radius.set(t,Math.log(e))},h.setDistanceLimits=function(t,e){t=t>0?Math.log(t):-1/0,e=e>0?Math.log(e):1/0,e=Math.max(e,t),this.radius.bounds[0][0]=t,this.radius.bounds[1][0]=e},h.getDistanceLimits=function(t){var e=this.radius.bounds;return t?(t[0]=Math.exp(e[0][0]),t[1]=Math.exp(e[1][0]),t):[Math.exp(e[0][0]),Math.exp(e[1][0])]},h.toJSON=function(){return this.recalcMatrix(this.lastT()),{center:this.computedCenter.slice(),rotation:this.computedRotation.slice(),distance:Math.log(this.computedRadius[0]),zoomMin:this.radius.bounds[0][0],zoomMax:this.radius.bounds[1][0]}},h.fromJSON=function(t){var e=this.lastT(),r=t.center;r&&this.center.set(e,r[0],r[1],r[2]);var n=t.rotation;n&&this.rotation.set(e,n[0],n[1],n[2],n[3]);var i=t.distance;i&&i>0&&this.radius.set(e,Math.log(i)),this.setDistanceLimits(t.zoomMin,t.zoomMax)}},{"./lib/quatFromFrame":398,"filtered-vector":198,"gl-mat4/fromQuat":232,"gl-mat4/invert":235,"gl-mat4/lookAt":236}],400:[function(t,e,r){"use strict";var n=t("repeat-string");e.exports=function(t,e,r){return n(r=void 0!==r?r+"":" ",e)+t}},{"repeat-string":439}],401:[function(t,e,r){"use strict";var n=t("pick-by-alias");e.exports=function(t){var e;arguments.length>1&&(t=arguments);"string"==typeof t?t=t.split(/\s/).map(parseFloat):"number"==typeof t&&(t=[t]);t.length&&"number"==typeof t[0]?e=1===t.length?{width:t[0],height:t[0],x:0,y:0}:2===t.length?{width:t[0],height:t[1],x:0,y:0}:{x:t[0],y:t[1],width:t[2]-t[0]||0,height:t[3]-t[1]||0}:t&&(t=n(t,{left:"x l left Left",top:"y t top Top",width:"w width W Width",height:"h height W Width",bottom:"b bottom Bottom",right:"r right Right"}),e={x:t.left||0,y:t.top||0},null==t.width?t.right?e.width=t.right-e.x:e.width=0:e.width=t.width,null==t.height?t.bottom?e.height=t.bottom-e.y:e.height=0:e.height=t.height);return e}},{"pick-by-alias":407}],402:[function(t,e,r){e.exports=function(t){var e=[];return t.replace(i,function(t,r,i){var o=r.toLowerCase();for(i=function(t){var e=t.match(a);return e?e.map(Number):[]}(i),"m"==o&&i.length>2&&(e.push([r].concat(i.splice(0,2))),o="l",r="m"==r?"l":"L");;){if(i.length==n[o])return i.unshift(r),e.push(i);if(i.length0;--o)a=l[o],r=s[o],s[o]=s[a],s[a]=r,l[o]=l[r],l[r]=a,c=(c+r)*o;return n.freeUint32(l),n.freeUint32(s),c},r.unrank=function(t,e,r){switch(t){case 0:return r||[];case 1:return r?(r[0]=0,r):[0];case 2:return r?(e?(r[0]=0,r[1]=1):(r[0]=1,r[1]=0),r):e?[0,1]:[1,0]}var n,i,a,o=1;for((r=r||new Array(t))[0]=0,a=1;a0;--a)e=e-(n=e/o|0)*o|0,o=o/a|0,i=0|r[a],r[a]=0|r[n],r[n]=0|i;return r}},{"invert-permutation":359,"typedarray-pool":481}],407:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n,a,o={};if("string"==typeof e&&(e=i(e)),Array.isArray(e)){var s={};for(a=0;a0){o=a[u][r][0],l=u;break}s=o[1^l];for(var f=0;f<2;++f)for(var h=a[f][r],p=0;p0&&(o=d,s=g,l=f)}return i?s:(o&&c(o,l),s)}function f(t,r){var i=a[r][t][0],o=[t];c(i,r);for(var s=i[1^r];;){for(;s!==t;)o.push(s),s=u(o[o.length-2],s,!1);if(a[0][t].length+a[1][t].length===0)break;var l=o[o.length-1],f=t,h=o[1],p=u(l,f,!0);if(n(e[l],e[f],e[h],e[p])<0)break;o.push(t),s=u(l,f)}return o}function h(t,e){return e[1]===e[e.length-1]}for(var o=0;o0;){a[0][o].length;var g=f(o,p);h(d,g)?d.push.apply(d,g):(d.length>0&&l.push(d),d=g)}d.length>0&&l.push(d)}return l};var n=t("compare-angle")},{"compare-angle":108}],409:[function(t,e,r){"use strict";e.exports=function(t,e){for(var r=n(t,e.length),i=new Array(e.length),a=new Array(e.length),o=[],s=0;s0;){var c=o.pop();i[c]=!1;for(var u=r[c],s=0;s0})).length,m=new Array(g),v=new Array(g),p=0;p0;){var N=B.pop(),j=E[N];l(j,function(t,e){return t-e});var V,U=j.length,q=F[N];if(0===q){var k=d[N];V=[k]}for(var p=0;p=0)&&(F[H]=1^q,B.push(H),0===q)){var k=d[H];R(k)||(k.reverse(),V.push(k))}}0===q&&r.push(V)}return r};var n=t("edges-to-adjacency-list"),i=t("planar-dual"),a=t("point-in-big-polygon"),o=t("two-product"),s=t("robust-sum"),l=t("uniq"),c=t("./lib/trim-leaves");function u(t,e){for(var r=new Array(t),n=0;n>>1;e.dtype||(e.dtype="array"),"string"==typeof e.dtype?d=new(f(e.dtype))(m):e.dtype&&(d=e.dtype,Array.isArray(d)&&(d.length=m));for(var v=0;vr){for(var h=0;hl||A>c||T=E||o===s)){var u=y[a];void 0===s&&(s=u.length);for(var f=o;f=g&&p<=v&&d>=m&&d<=w&&z.push(h)}var b=x[a],_=b[4*o+0],k=b[4*o+1],C=b[4*o+2],L=b[4*o+3],P=function(t,e){for(var r=null,n=0;null===r;)if(r=t[4*e+n],++n>t.length)return null;return r}(b,o+1),D=.5*i,O=a+1;e(r,n,D,O,_,k||C||L||P),e(r,n+D,D,O,k,C||L||P),e(r+D,n,D,O,C,L||P),e(r+D,n+D,D,O,L,P)}}}(0,0,1,0,0,1),z},d;function C(t,e,r){for(var n=1,i=.5,a=.5,o=.5,s=0;s0&&e[i]===r[0]))return 1;a=t[i-1]}for(var s=1;a;){var l=a.key,c=n(r,l[0],l[1]);if(l[0][0]0))return 0;s=-1,a=a.right}else if(c>0)a=a.left;else{if(!(c<0))return 0;s=1,a=a.right}}return s}}(v.slabs,v.coordinates);return 0===a.length?y:function(t,e){return function(r){return t(r[0],r[1])?0:e(r)}}(l(a),y)};var n=t("robust-orientation")[3],i=t("slab-decomposition"),a=t("interval-tree-1d"),o=t("binary-search-bounds");function s(){return!0}function l(t){for(var e={},r=0;r=-t},pointBetween:function(e,r,n){var i=e[1]-r[1],a=n[0]-r[0],o=e[0]-r[0],s=n[1]-r[1],l=o*a+i*s;return!(l-t)},pointsSameX:function(e,r){return Math.abs(e[0]-r[0])t!=o-i>t&&(a-c)*(i-u)/(o-u)+c-n>t&&(s=!s),a=c,o=u}return s}};return e}},{}],418:[function(t,e,r){var n={toPolygon:function(t,e){function r(e){if(e.length<=0)return t.segments({inverted:!1,regions:[]});function r(e){var r=e.slice(0,e.length-1);return t.segments({inverted:!1,regions:[r]})}for(var n=r(e[0]),i=1;i0})}function u(t,n){var i=t.seg,a=n.seg,o=i.start,s=i.end,c=a.start,u=a.end;r&&r.checkIntersection(i,a);var f=e.linesIntersect(o,s,c,u);if(!1===f){if(!e.pointsCollinear(o,s,c))return!1;if(e.pointsSame(o,u)||e.pointsSame(s,c))return!1;var h=e.pointsSame(o,c),p=e.pointsSame(s,u);if(h&&p)return n;var d=!h&&e.pointBetween(o,c,u),g=!p&&e.pointBetween(s,c,u);if(h)return g?l(n,s):l(t,u),n;d&&(p||(g?l(n,s):l(t,u)),l(n,o))}else 0===f.alongA&&(-1===f.alongB?l(t,c):0===f.alongB?l(t,f.pt):1===f.alongB&&l(t,u)),0===f.alongB&&(-1===f.alongA?l(n,o):0===f.alongA?l(n,f.pt):1===f.alongA&&l(n,s));return!1}for(var f=[];!a.isEmpty();){var h=a.getHead();if(r&&r.vert(h.pt[0]),h.isStart){r&&r.segmentNew(h.seg,h.primary);var p=c(h),d=p.before?p.before.ev:null,g=p.after?p.after.ev:null;function m(){if(d){var t=u(h,d);if(t)return t}return!!g&&u(h,g)}r&&r.tempStatus(h.seg,!!d&&d.seg,!!g&&g.seg);var v,y,x=m();if(x)t?(y=null===h.seg.myFill.below||h.seg.myFill.above!==h.seg.myFill.below)&&(x.seg.myFill.above=!x.seg.myFill.above):x.seg.otherFill=h.seg.myFill,r&&r.segmentUpdate(x.seg),h.other.remove(),h.remove();if(a.getHead()!==h){r&&r.rewind(h.seg);continue}t?(y=null===h.seg.myFill.below||h.seg.myFill.above!==h.seg.myFill.below,h.seg.myFill.below=g?g.seg.myFill.above:i,h.seg.myFill.above=y?!h.seg.myFill.below:h.seg.myFill.below):null===h.seg.otherFill&&(v=g?h.primary===g.primary?g.seg.otherFill.above:g.seg.myFill.above:h.primary?o:i,h.seg.otherFill={above:v,below:v}),r&&r.status(h.seg,!!d&&d.seg,!!g&&g.seg),h.other.status=p.insert(n.node({ev:h}))}else{var b=h.status;if(null===b)throw new Error("PolyBool: Zero-length segment detected; your epsilon is probably too small or too large");if(s.exists(b.prev)&&s.exists(b.next)&&u(b.prev.ev,b.next.ev),r&&r.statusRemove(b.ev.seg),b.remove(),!h.primary){var _=h.seg.myFill;h.seg.myFill=h.seg.otherFill,h.seg.otherFill=_}f.push(h.seg)}a.getHead().remove()}return r&&r.done(),f}return t?{addRegion:function(t){for(var n,i,a,o=t[t.length-1],l=0;l=c?(M=1,y=c+2*h+d):y=h*(M=-h/c)+d):(M=0,p>=0?(A=0,y=d):-p>=f?(A=1,y=f+2*p+d):y=p*(A=-p/f)+d);else if(A<0)A=0,h>=0?(M=0,y=d):-h>=c?(M=1,y=c+2*h+d):y=h*(M=-h/c)+d;else{var T=1/k;y=(M*=T)*(c*M+u*(A*=T)+2*h)+A*(u*M+f*A+2*p)+d}else M<0?(b=f+p)>(x=u+h)?(_=b-x)>=(w=c-2*u+f)?(M=1,A=0,y=c+2*h+d):y=(M=_/w)*(c*M+u*(A=1-M)+2*h)+A*(u*M+f*A+2*p)+d:(M=0,b<=0?(A=1,y=f+2*p+d):p>=0?(A=0,y=d):y=p*(A=-p/f)+d):A<0?(b=c+h)>(x=u+p)?(_=b-x)>=(w=c-2*u+f)?(A=1,M=0,y=f+2*p+d):y=(M=1-(A=_/w))*(c*M+u*A+2*h)+A*(u*M+f*A+2*p)+d:(A=0,b<=0?(M=1,y=c+2*h+d):h>=0?(M=0,y=d):y=h*(M=-h/c)+d):(_=f+p-u-h)<=0?(M=0,A=1,y=f+2*p+d):_>=(w=c-2*u+f)?(M=1,A=0,y=c+2*h+d):y=(M=_/w)*(c*M+u*(A=1-M)+2*h)+A*(u*M+f*A+2*p)+d;var S=1-M-A;for(l=0;l1)for(var r=1;r0){var c=t[r-1];if(0===n(s,c)&&a(c)!==l){r-=1;continue}}t[r++]=s}}return t.length=r,t}},{"cell-orientation":93,"compare-cell":109,"compare-oriented-cell":110}],432:[function(t,e,r){"use strict";var n=t("array-bounds"),i=t("color-normalize"),a=t("update-diff"),o=t("pick-by-alias"),s=t("object-assign"),l=t("flatten-vertex-data"),c=t("to-float32"),u=c.float32,f=c.fract32;e.exports=function(t,e){"function"==typeof t?(e||(e={}),e.regl=t):e=t;e.length&&(e.positions=e);if(!(t=e.regl).hasExtension("ANGLE_instanced_arrays"))throw Error("regl-error2d: `ANGLE_instanced_arrays` extension should be enabled");var r,c,p,d,g,m,v=t._gl,y={color:"black",capSize:5,lineWidth:1,opacity:1,viewport:null,range:null,offset:0,count:0,bounds:null,positions:[],errors:[]},x=[];return d=t.buffer({usage:"dynamic",type:"uint8",data:new Uint8Array(0)}),c=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),p=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),g=t.buffer({usage:"dynamic",type:"float",data:new Uint8Array(0)}),m=t.buffer({usage:"static",type:"float",data:h}),k(e),r=t({vert:"\n\t\tprecision highp float;\n\n\t\tattribute vec2 position, positionFract;\n\t\tattribute vec4 error;\n\t\tattribute vec4 color;\n\n\t\tattribute vec2 direction, lineOffset, capOffset;\n\n\t\tuniform vec4 viewport;\n\t\tuniform float lineWidth, capSize;\n\t\tuniform vec2 scale, scaleFract, translate, translateFract;\n\n\t\tvarying vec4 fragColor;\n\n\t\tvoid main() {\n\t\t\tfragColor = color / 255.;\n\n\t\t\tvec2 pixelOffset = lineWidth * lineOffset + (capSize + lineWidth) * capOffset;\n\n\t\t\tvec2 dxy = -step(.5, direction.xy) * error.xz + step(direction.xy, vec2(-.5)) * error.yw;\n\n\t\t\tvec2 position = position + dxy;\n\n\t\t\tvec2 pos = (position + translate) * scale\n\t\t\t\t+ (positionFract + translateFract) * scale\n\t\t\t\t+ (position + translate) * scaleFract\n\t\t\t\t+ (positionFract + translateFract) * scaleFract;\n\n\t\t\tpos += pixelOffset / viewport.zw;\n\n\t\t\tgl_Position = vec4(pos * 2. - 1., 0, 1);\n\t\t}\n\t\t",frag:"\n\t\tprecision mediump float;\n\n\t\tvarying vec4 fragColor;\n\n\t\tuniform float opacity;\n\n\t\tvoid main() {\n\t\t\tgl_FragColor = fragColor;\n\t\t\tgl_FragColor.a *= opacity;\n\t\t}\n\t\t",uniforms:{range:t.prop("range"),lineWidth:t.prop("lineWidth"),capSize:t.prop("capSize"),opacity:t.prop("opacity"),scale:t.prop("scale"),translate:t.prop("translate"),scaleFract:t.prop("scaleFract"),translateFract:t.prop("translateFract"),viewport:function(t,e){return[e.viewport.x,e.viewport.y,t.viewportWidth,t.viewportHeight]}},attributes:{color:{buffer:d,offset:function(t,e){return 4*e.offset},divisor:1},position:{buffer:c,offset:function(t,e){return 8*e.offset},divisor:1},positionFract:{buffer:p,offset:function(t,e){return 8*e.offset},divisor:1},error:{buffer:g,offset:function(t,e){return 16*e.offset},divisor:1},direction:{buffer:m,stride:24,offset:0},lineOffset:{buffer:m,stride:24,offset:8},capOffset:{buffer:m,stride:24,offset:16}},primitive:"triangles",blend:{enable:!0,color:[0,0,0,0],equation:{rgb:"add",alpha:"add"},func:{srcRGB:"src alpha",dstRGB:"one minus src alpha",srcAlpha:"one minus dst alpha",dstAlpha:"one"}},depth:{enable:!1},scissor:{enable:!0,box:t.prop("viewport")},viewport:t.prop("viewport"),stencil:!1,instances:t.prop("count"),count:h.length}),s(b,{update:k,draw:_,destroy:M,regl:t,gl:v,canvas:v.canvas,groups:x}),b;function b(t){t?k(t):null===t&&M(),_()}function _(e){if("number"==typeof e)return w(e);e&&!Array.isArray(e)&&(e=[e]),t._refresh(),x.forEach(function(t,r){t&&(e&&(e[r]?t.draw=!0:t.draw=!1),t.draw?w(r):t.draw=!0)})}function w(t){"number"==typeof t&&(t=x[t]),null!=t&&t&&t.count&&t.color&&t.opacity&&t.positions&&t.positions.length>1&&(t.scaleRatio=[t.scale[0]*t.viewport.width,t.scale[1]*t.viewport.height],r(t),t.after&&t.after(t))}function k(t){if(t){null!=t.length?"number"==typeof t[0]&&(t=[{positions:t}]):Array.isArray(t)||(t=[t]);var e=0,r=0;if(b.groups=x=t.map(function(t,c){var u=x[c];return t?("function"==typeof t?t={after:t}:"number"==typeof t[0]&&(t={positions:t}),t=o(t,{color:"color colors fill",capSize:"capSize cap capsize cap-size",lineWidth:"lineWidth line-width width line thickness",opacity:"opacity alpha",range:"range dataBox",viewport:"viewport viewBox",errors:"errors error",positions:"positions position data points"}),u||(x[c]=u={id:c,scale:null,translate:null,scaleFract:null,translateFract:null,draw:!0},t=s({},y,t)),a(u,t,[{lineWidth:function(t){return.5*+t},capSize:function(t){return.5*+t},opacity:parseFloat,errors:function(t){return t=l(t),r+=t.length,t},positions:function(t,r){return t=l(t,"float64"),r.count=Math.floor(t.length/2),r.bounds=n(t,2),r.offset=e,e+=r.count,t}},{color:function(t,e){var r=e.count;if(t||(t="transparent"),!Array.isArray(t)||"number"==typeof t[0]){var n=t;t=Array(r);for(var a=0;a 0. && baClipping < length(normalWidth * endBotJoin)) {\n\t\t//handle miter clipping\n\t\tbTopCoord -= normalWidth * endTopJoin;\n\t\tbTopCoord += normalize(endTopJoin * normalWidth) * baClipping;\n\t}\n\n\tif (nextReverse) {\n\t\t//make join rectangular\n\t\tvec2 miterShift = normalWidth * endJoinDirection * miterLimit * .5;\n\t\tfloat normalAdjust = 1. - min(miterLimit / endMiterRatio, 1.);\n\t\tbBotCoord = bCoord + miterShift - normalAdjust * normalWidth * currNormal * .5;\n\t\tbTopCoord = bCoord + miterShift + normalAdjust * normalWidth * currNormal * .5;\n\t}\n\telse if (!prevReverse && abClipping > 0. && abClipping < length(normalWidth * startBotJoin)) {\n\t\t//handle miter clipping\n\t\taBotCoord -= normalWidth * startBotJoin;\n\t\taBotCoord += normalize(startBotJoin * normalWidth) * abClipping;\n\t}\n\n\tvec2 aTopPosition = (aTopCoord) * scale + translate;\n\tvec2 aBotPosition = (aBotCoord) * scale + translate;\n\n\tvec2 bTopPosition = (bTopCoord) * scale + translate;\n\tvec2 bBotPosition = (bBotCoord) * scale + translate;\n\n\t//position is normalized 0..1 coord on the screen\n\tvec2 position = (aTopPosition * lineTop + aBotPosition * lineBot) * lineStart + (bTopPosition * lineTop + bBotPosition * lineBot) * lineEnd;\n\n\tstartCoord = aCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n\tendCoord = bCoord * scaleRatio + translate * viewport.zw + viewport.xy;\n\n\tgl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n\tenableStartMiter = step(dot(currTangent, prevTangent), .5);\n\tenableEndMiter = step(dot(currTangent, nextTangent), .5);\n\n\t//bevel miter cutoffs\n\tif (miterMode == 1.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tvec2 startMiterWidth = vec2(startJoinDirection) * thickness * miterLimit * .5;\n\t\t\tstartCutoff = vec4(aCoord, aCoord);\n\t\t\tstartCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n\t\t\tstartCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tstartCutoff += viewport.xyxy;\n\t\t\tstartCutoff += startMiterWidth.xyxy;\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tvec2 endMiterWidth = vec2(endJoinDirection) * thickness * miterLimit * .5;\n\t\t\tendCutoff = vec4(bCoord, bCoord);\n\t\t\tendCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x) / scaleRatio;\n\t\t\tendCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tendCutoff += viewport.xyxy;\n\t\t\tendCutoff += endMiterWidth.xyxy;\n\t\t}\n\t}\n\n\t//round miter cutoffs\n\telse if (miterMode == 2.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tvec2 startMiterWidth = vec2(startJoinDirection) * thickness * abs(dot(startJoinDirection, currNormal)) * .5;\n\t\t\tstartCutoff = vec4(aCoord, aCoord);\n\t\t\tstartCutoff.zw += vec2(-startJoinDirection.y, startJoinDirection.x) / scaleRatio;\n\t\t\tstartCutoff = startCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tstartCutoff += viewport.xyxy;\n\t\t\tstartCutoff += startMiterWidth.xyxy;\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tvec2 endMiterWidth = vec2(endJoinDirection) * thickness * abs(dot(endJoinDirection, currNormal)) * .5;\n\t\t\tendCutoff = vec4(bCoord, bCoord);\n\t\t\tendCutoff.zw += vec2(-endJoinDirection.y, endJoinDirection.x) / scaleRatio;\n\t\t\tendCutoff = endCutoff * scaleRatio.xyxy + translate.xyxy * viewport.zwzw;\n\t\t\tendCutoff += viewport.xyxy;\n\t\t\tendCutoff += endMiterWidth.xyxy;\n\t\t}\n\t}\n}\n"]),frag:o(["precision highp float;\n#define GLSLIFY 1\n\nuniform sampler2D dashPattern;\nuniform float dashSize, pixelRatio, thickness, opacity, id, miterMode;\n\nvarying vec4 fragColor;\nvarying vec2 tangent;\nvarying vec4 startCutoff, endCutoff;\nvarying vec2 startCoord, endCoord;\nvarying float enableStartMiter, enableEndMiter;\n\nfloat distToLine(vec2 p, vec2 a, vec2 b) {\n\tvec2 diff = b - a;\n\tvec2 perp = normalize(vec2(-diff.y, diff.x));\n\treturn dot(p - a, perp);\n}\n\nvoid main() {\n\tfloat alpha = 1., distToStart, distToEnd;\n\tfloat cutoff = thickness * .5;\n\n\t//bevel miter\n\tif (miterMode == 1.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tdistToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n\t\t\tif (distToStart < -1.) {\n\t\t\t\tdiscard;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\talpha *= min(max(distToStart + 1., 0.), 1.);\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tdistToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n\t\t\tif (distToEnd < -1.) {\n\t\t\t\tdiscard;\n\t\t\t\treturn;\n\t\t\t}\n\t\t\talpha *= min(max(distToEnd + 1., 0.), 1.);\n\t\t}\n\t}\n\n\t// round miter\n\telse if (miterMode == 2.) {\n\t\tif (enableStartMiter == 1.) {\n\t\t\tdistToStart = distToLine(gl_FragCoord.xy, startCutoff.xy, startCutoff.zw);\n\t\t\tif (distToStart < 0.) {\n\t\t\t\tfloat radius = length(gl_FragCoord.xy - startCoord);\n\n\t\t\t\tif(radius > cutoff + .5) {\n\t\t\t\t\tdiscard;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\talpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n\t\t\t}\n\t\t}\n\n\t\tif (enableEndMiter == 1.) {\n\t\t\tdistToEnd = distToLine(gl_FragCoord.xy, endCutoff.xy, endCutoff.zw);\n\t\t\tif (distToEnd < 0.) {\n\t\t\t\tfloat radius = length(gl_FragCoord.xy - endCoord);\n\n\t\t\t\tif(radius > cutoff + .5) {\n\t\t\t\t\tdiscard;\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\talpha -= smoothstep(cutoff - .5, cutoff + .5, radius);\n\t\t\t}\n\t\t}\n\t}\n\n\tfloat t = fract(dot(tangent, gl_FragCoord.xy) / dashSize) * .5 + .25;\n\tfloat dash = texture2D(dashPattern, vec2(t, .5)).r;\n\n\tgl_FragColor = fragColor;\n\tgl_FragColor.a *= alpha * opacity * dash;\n}\n"]),attributes:{lineEnd:{buffer:r,divisor:0,stride:8,offset:0},lineTop:{buffer:r,divisor:0,stride:8,offset:4},aColor:{buffer:t.prop("colorBuffer"),stride:4,offset:0,divisor:1},bColor:{buffer:t.prop("colorBuffer"),stride:4,offset:4,divisor:1},prevCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:0,divisor:1},aCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:8,divisor:1},bCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:16,divisor:1},nextCoord:{buffer:t.prop("positionBuffer"),stride:8,offset:24,divisor:1}}},n))}catch(t){e=i}return{fill:t({primitive:"triangle",elements:function(t,e){return e.triangles},offset:0,vert:o(["precision highp float;\n#define GLSLIFY 1\n\nattribute vec2 position, positionFract;\n\nuniform vec4 color;\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float pixelRatio, id;\nuniform vec4 viewport;\nuniform float opacity;\n\nvarying vec4 fragColor;\n\nconst float MAX_LINES = 256.;\n\nvoid main() {\n\tfloat depth = (MAX_LINES - 4. - id) / (MAX_LINES);\n\n\tvec2 position = position * scale + translate\n + positionFract * scale + translateFract\n + position * scaleFract\n + positionFract * scaleFract;\n\n\tgl_Position = vec4(position * 2.0 - 1.0, depth, 1);\n\n\tfragColor = color / 255.;\n\tfragColor.a *= opacity;\n}\n"]),frag:o(["precision highp float;\n#define GLSLIFY 1\n\nvarying vec4 fragColor;\n\nvoid main() {\n\tgl_FragColor = fragColor;\n}\n"]),uniforms:{scale:t.prop("scale"),color:t.prop("fill"),scaleFract:t.prop("scaleFract"),translateFract:t.prop("translateFract"),translate:t.prop("translate"),opacity:t.prop("opacity"),pixelRatio:t.context("pixelRatio"),id:t.prop("id"),viewport:function(t,e){return[e.viewport.x,e.viewport.y,t.viewportWidth,t.viewportHeight]}},attributes:{position:{buffer:t.prop("positionBuffer"),stride:8,offset:8},positionFract:{buffer:t.prop("positionFractBuffer"),stride:8,offset:8}},blend:n.blend,depth:{enable:!1},scissor:n.scissor,stencil:n.stencil,viewport:n.viewport}),rect:i,miter:e}},m.defaults={dashes:null,join:"miter",miterLimit:1,thickness:10,cap:"square",color:"black",opacity:1,overlay:!1,viewport:null,range:null,close:!1,fill:null},m.prototype.render=function(){for(var t,e=[],r=arguments.length;r--;)e[r]=arguments[r];e.length&&(t=this).update.apply(t,e),this.draw()},m.prototype.draw=function(){for(var t=this,e=[],r=arguments.length;r--;)e[r]=arguments[r];return(e.length?e:this.passes).forEach(function(e,r){if(e&&Array.isArray(e))return(n=t).draw.apply(n,e);var n;("number"==typeof e&&(e=t.passes[e]),e&&e.count>1&&e.opacity)&&(t.regl._refresh(),e.fill&&e.triangles&&e.triangles.length>2&&t.shaders.fill(e),e.thickness&&(e.scale[0]*e.viewport.width>m.precisionThreshold||e.scale[1]*e.viewport.height>m.precisionThreshold?t.shaders.rect(e):"rect"===e.join||!e.join&&(e.thickness<=2||e.count>=m.maxPoints)?t.shaders.rect(e):t.shaders.miter(e)))}),this},m.prototype.update=function(t){var e=this;if(t){null!=t.length?"number"==typeof t[0]&&(t=[{positions:t}]):Array.isArray(t)||(t=[t]);var r=this.regl,o=this.gl;if(t.forEach(function(t,f){var d=e.passes[f];if(void 0!==t)if(null!==t){if("number"==typeof t[0]&&(t={positions:t}),t=s(t,{positions:"positions points data coords",thickness:"thickness lineWidth lineWidths line-width linewidth width stroke-width strokewidth strokeWidth",join:"lineJoin linejoin join type mode",miterLimit:"miterlimit miterLimit",dashes:"dash dashes dasharray dash-array dashArray",color:"color colour stroke colors colours stroke-color strokeColor",fill:"fill fill-color fillColor",opacity:"alpha opacity",overlay:"overlay crease overlap intersect",close:"closed close closed-path closePath",range:"range dataBox",viewport:"viewport viewBox",hole:"holes hole hollow"}),d||(e.passes[f]=d={id:f,scale:null,scaleFract:null,translate:null,translateFract:null,count:0,hole:[],depth:0,dashLength:1,dashTexture:r.texture({channels:1,data:new Uint8Array([255]),width:1,height:1,mag:"linear",min:"linear"}),colorBuffer:r.buffer({usage:"dynamic",type:"uint8",data:new Uint8Array}),positionBuffer:r.buffer({usage:"dynamic",type:"float",data:new Uint8Array}),positionFractBuffer:r.buffer({usage:"dynamic",type:"float",data:new Uint8Array})},t=a({},m.defaults,t)),null!=t.thickness&&(d.thickness=parseFloat(t.thickness)),null!=t.opacity&&(d.opacity=parseFloat(t.opacity)),null!=t.miterLimit&&(d.miterLimit=parseFloat(t.miterLimit)),null!=t.overlay&&(d.overlay=!!t.overlay,f 1.0 + delta) {\n\t\tdiscard;\n\t}\n\n\talpha -= smoothstep(1.0 - delta, 1.0 + delta, radius);\n\n\tfloat borderRadius = fragBorderRadius;\n\tfloat ratio = smoothstep(borderRadius - delta, borderRadius + delta, radius);\n\tvec4 color = mix(fragColor, fragBorderColor, ratio);\n\tcolor.a *= alpha * opacity;\n\tgl_FragColor = color;\n}\n"]),u.vert=l(["precision highp float;\n#define GLSLIFY 1\n\nattribute float x, y, xFract, yFract;\nattribute float size, borderSize;\nattribute vec4 colorId, borderColorId;\nattribute float isActive;\n\nuniform vec2 scale, scaleFract, translate, translateFract;\nuniform float pixelRatio;\nuniform sampler2D palette;\nuniform vec2 paletteSize;\n\nconst float maxSize = 100.;\n\nvarying vec4 fragColor, fragBorderColor;\nvarying float fragBorderRadius, fragWidth;\n\nvec2 paletteCoord(float id) {\n return vec2(\n (mod(id, paletteSize.x) + .5) / paletteSize.x,\n (floor(id / paletteSize.x) + .5) / paletteSize.y\n );\n}\nvec2 paletteCoord(vec2 id) {\n return vec2(\n (id.x + .5) / paletteSize.x,\n (id.y + .5) / paletteSize.y\n );\n}\n\nvec4 getColor(vec4 id) {\n // zero-palette means we deal with direct buffer\n if (paletteSize.x == 0.) return id / 255.;\n return texture2D(palette, paletteCoord(id.xy));\n}\n\nvoid main() {\n // ignore inactive points\n if (isActive == 0.) return;\n\n vec2 position = vec2(x, y);\n vec2 positionFract = vec2(xFract, yFract);\n\n vec4 color = getColor(colorId);\n vec4 borderColor = getColor(borderColorId);\n\n float size = size * maxSize / 255.;\n float borderSize = borderSize * maxSize / 255.;\n\n gl_PointSize = (size + borderSize) * pixelRatio;\n\n vec2 pos = (position + translate) * scale\n + (positionFract + translateFract) * scale\n + (position + translate) * scaleFract\n + (positionFract + translateFract) * scaleFract;\n\n gl_Position = vec4(pos * 2. - 1., 0, 1);\n\n fragBorderRadius = 1. - 2. * borderSize / (size + borderSize);\n fragColor = color;\n fragBorderColor = borderColor.a == 0. || borderSize == 0. ? vec4(color.rgb, 0.) : borderColor;\n fragWidth = 1. / gl_PointSize;\n}\n"]),h&&(u.frag=u.frag.replace("smoothstep","smoothStep")),this.drawCircle=t(u)}e.exports=v,v.defaults={color:"black",borderColor:"transparent",borderSize:0,size:12,opacity:1,marker:void 0,viewport:null,range:null,pixelSize:null,count:0,offset:0,bounds:null,positions:[],snap:1e4},v.prototype.render=function(){for(var t,e=[],r=arguments.length;r--;)e[r]=arguments[r];return e.length&&(t=this).update.apply(t,e),this.draw(),this},v.prototype.draw=function(){for(var t=this,e=[],r=arguments.length;r--;)e[r]=arguments[r];var n=this.groups;if(1===e.length&&Array.isArray(e[0])&&(null===e[0][0]||Array.isArray(e[0][0]))&&(e=e[0]),this.regl._refresh(),e.length)for(var i=0;in)?e.tree=o(t,{bounds:h}):n&&n.length&&(e.tree=n),e.tree){var p={primitive:"points",usage:"static",data:e.tree,type:"uint32"};e.elements?e.elements(p):e.elements=l.elements(p)}return a({data:d(t),usage:"dynamic"}),s({data:g(t),usage:"dynamic"}),c({data:new Uint8Array(u),type:"uint8",usage:"stream"}),t}},{marker:function(e,r,n){var i=r.activation;if(i.forEach(function(t){return t&&t.destroy&&t.destroy()}),i.length=0,e&&"number"!=typeof e[0]){for(var a=[],o=0,s=Math.min(e.length,r.count);o=0)return a;if(t instanceof Uint8Array||t instanceof Uint8ClampedArray)e=t;else{e=new Uint8Array(t.length);for(var o=0,s=t.length;oi*i*4&&(this.tooManyColors=!0),this.updatePalette(r),1===o.length?o[0]:o},v.prototype.updatePalette=function(t){if(!this.tooManyColors){var e=this.maxColors,r=this.paletteTexture,n=Math.ceil(.25*t.length/e);if(n>1)for(var i=.25*(t=t.slice()).length%e;i2?(s[0],s[2],n=s[1],i=s[3]):s.length?(n=s[0],i=s[1]):(s.x,n=s.y,s.x+s.width,i=s.y+s.height),l.length>2?(a=l[0],o=l[2],l[1],l[3]):l.length?(a=l[0],o=l[1]):(a=l.x,l.y,o=l.x+l.width,l.y+l.height),[a,n,o,i]}function p(t){if("number"==typeof t)return[t,t,t,t];if(2===t.length)return[t[0],t[1],t[0],t[1]];var e=l(t);return[e.x,e.y,e.x+e.width,e.y+e.height]}e.exports=u,u.prototype.render=function(){for(var t,e=this,r=[],n=arguments.length;n--;)r[n]=arguments[n];return r.length&&(t=this).update.apply(t,r),this.regl.attributes.preserveDrawingBuffer?this.draw():(this.dirty?null==this.planned&&(this.planned=o(function(){e.draw(),e.dirty=!0,e.planned=null})):(this.draw(),this.dirty=!0,o(function(){e.dirty=!1})),this)},u.prototype.update=function(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];if(t.length){for(var r=0;rM))&&(s.lower||!(k>>=e))<<3,(e|=r=(15<(t>>>=r))<<2)|(r=(3<(t>>>=r))<<1)|t>>>r>>1}function l(t){t:{for(var e=16;268435456>=e;e*=16)if(t<=e){t=e;break t}t=0}return 0<(e=Y[s(t)>>2]).length?e.pop():new ArrayBuffer(t)}function c(t){Y[s(t.byteLength)>>2].push(t)}function u(t,e,r,n,i,a){for(var o=0;o(i=l)&&(i=n.buffer.byteLength,5123===f?i>>=1:5125===f&&(i>>=2)),n.vertCount=i,i=s,0>s&&(i=4,1===(s=n.buffer.dimension)&&(i=0),2===s&&(i=1),3===s&&(i=4)),n.primType=i}function s(t){n.elementsCount--,delete l[t.id],t.buffer.destroy(),t.buffer=null}var l={},c=0,u={uint8:5121,uint16:5123};e.oes_element_index_uint&&(u.uint32=5125),i.prototype.bind=function(){this.buffer.bind()};var f=[];return{create:function(t,e){function l(t){if(t)if("number"==typeof t)c(t),f.primType=4,f.vertCount=0|t,f.type=5121;else{var e=null,r=35044,n=-1,i=-1,s=0,h=0;Array.isArray(t)||G(t)||a(t)?e=t:("data"in t&&(e=t.data),"usage"in t&&(r=Q[t.usage]),"primitive"in t&&(n=rt[t.primitive]),"count"in t&&(i=0|t.count),"type"in t&&(h=u[t.type]),"length"in t?s=0|t.length:(s=i,5123===h||5122===h?s*=2:5125!==h&&5124!==h||(s*=4))),o(f,e,r,n,i,s,h)}else c(),f.primType=4,f.vertCount=0,f.type=5121;return l}var c=r.create(null,34963,!0),f=new i(c._buffer);return n.elementsCount++,l(t),l._reglType="elements",l._elements=f,l.subdata=function(t,e){return c.subdata(t,e),l},l.destroy=function(){s(f)},l},createStream:function(t){var e=f.pop();return e||(e=new i(r.create(null,34963,!0,!1)._buffer)),o(e,t,35040,-1,-1,0,0),e},destroyStream:function(t){f.push(t)},getElements:function(t){return"function"==typeof t&&t._elements instanceof i?t._elements:null},clear:function(){W(l).forEach(s)}}}function m(t){for(var e=X.allocType(5123,t.length),r=0;r>>31<<15,i=(a<<1>>>24)-127,a=a>>13&1023;e[r]=-24>i?n:-14>i?n+(a+1024>>-14-i):15>=i,r.height>>=i,p(r,n[i]),t.mipmask|=1<e;++e)t.images[e]=null;return t}function L(t){for(var e=t.images,r=0;re){for(var r=0;r=--this.refCount&&B(this)}}),s.profile&&(o.getTotalTextureSize=function(){var t=0;return Object.keys(ht).forEach(function(e){t+=ht[e].stats.size}),t}),{create2D:function(e,r){function n(t,e){var r=i.texInfo;z.call(r);var a=E();return"number"==typeof t?T(a,0|t,"number"==typeof e?0|e:0|t):t?(P(r,t),S(a,t)):T(a,1,1),r.genMipmaps&&(a.mipmask=(a.width<<1)-1),i.mipmask=a.mipmask,c(i,a),i.internalformat=a.internalformat,n.width=a.width,n.height=a.height,I(i),C(a,3553),D(r,3553),R(),L(a),s.profile&&(i.stats.size=k(i.internalformat,i.type,a.width,a.height,r.genMipmaps,!1)),n.format=tt[i.internalformat],n.type=et[i.type],n.mag=rt[r.magFilter],n.min=nt[r.minFilter],n.wrapS=it[r.wrapS],n.wrapT=it[r.wrapT],n}var i=new O(3553);return ht[i.id]=i,o.textureCount++,n(e,r),n.subimage=function(t,e,r,a){e|=0,r|=0,a|=0;var o=g();return c(o,i),o.width=0,o.height=0,p(o,t),o.width=o.width||(i.width>>a)-e,o.height=o.height||(i.height>>a)-r,I(i),d(o,3553,e,r,a),R(),M(o),n},n.resize=function(e,r){var a=0|e,o=0|r||a;if(a===i.width&&o===i.height)return n;n.width=i.width=a,n.height=i.height=o,I(i);for(var l=0;i.mipmask>>l;++l)t.texImage2D(3553,l,i.format,a>>l,o>>l,0,i.format,i.type,null);return R(),s.profile&&(i.stats.size=k(i.internalformat,i.type,a,o,!1,!1)),n},n._reglType="texture2d",n._texture=i,s.profile&&(n.stats=i.stats),n.destroy=function(){i.decRef()},n},createCube:function(e,r,n,i,a,l){function f(t,e,r,n,i,a){var o,l=h.texInfo;for(z.call(l),o=0;6>o;++o)m[o]=E();if("number"!=typeof t&&t){if("object"==typeof t)if(e)S(m[0],t),S(m[1],e),S(m[2],r),S(m[3],n),S(m[4],i),S(m[5],a);else if(P(l,t),u(h,t),"faces"in t)for(t=t.faces,o=0;6>o;++o)c(m[o],h),S(m[o],t[o]);else for(o=0;6>o;++o)S(m[o],t)}else for(t=0|t||1,o=0;6>o;++o)T(m[o],t,t);for(c(h,m[0]),h.mipmask=l.genMipmaps?(m[0].width<<1)-1:m[0].mipmask,h.internalformat=m[0].internalformat,f.width=m[0].width,f.height=m[0].height,I(h),o=0;6>o;++o)C(m[o],34069+o);for(D(l,34067),R(),s.profile&&(h.stats.size=k(h.internalformat,h.type,f.width,f.height,l.genMipmaps,!0)),f.format=tt[h.internalformat],f.type=et[h.type],f.mag=rt[l.magFilter],f.min=nt[l.minFilter],f.wrapS=it[l.wrapS],f.wrapT=it[l.wrapT],o=0;6>o;++o)L(m[o]);return f}var h=new O(34067);ht[h.id]=h,o.cubeCount++;var m=Array(6);return f(e,r,n,i,a,l),f.subimage=function(t,e,r,n,i){r|=0,n|=0,i|=0;var a=g();return c(a,h),a.width=0,a.height=0,p(a,e),a.width=a.width||(h.width>>i)-r,a.height=a.height||(h.height>>i)-n,I(h),d(a,34069+t,r,n,i),R(),M(a),f},f.resize=function(e){if((e|=0)!==h.width){f.width=h.width=e,f.height=h.height=e,I(h);for(var r=0;6>r;++r)for(var n=0;h.mipmask>>n;++n)t.texImage2D(34069+r,n,h.format,e>>n,e>>n,0,h.format,h.type,null);return R(),s.profile&&(h.stats.size=k(h.internalformat,h.type,f.width,f.height,!1,!0)),f}},f._reglType="textureCube",f._texture=h,s.profile&&(f.stats=h.stats),f.destroy=function(){h.decRef()},f},clear:function(){for(var e=0;er;++r)if(0!=(e.mipmask&1<>r,e.height>>r,0,e.internalformat,e.type,null);else for(var n=0;6>n;++n)t.texImage2D(34069+n,r,e.internalformat,e.width>>r,e.height>>r,0,e.internalformat,e.type,null);D(e.texInfo,e.target)})}}}function A(t,e,r,n,i,a){function o(t,e,r){this.target=t,this.texture=e,this.renderbuffer=r;var n=t=0;e?(t=e.width,n=e.height):r&&(t=r.width,n=r.height),this.width=t,this.height=n}function s(t){t&&(t.texture&&t.texture._texture.decRef(),t.renderbuffer&&t.renderbuffer._renderbuffer.decRef())}function l(t,e,r){t&&(t.texture?t.texture._texture.refCount+=1:t.renderbuffer._renderbuffer.refCount+=1)}function c(e,r){r&&(r.texture?t.framebufferTexture2D(36160,e,r.target,r.texture._texture.texture,0):t.framebufferRenderbuffer(36160,e,36161,r.renderbuffer._renderbuffer.renderbuffer))}function u(t){var e=3553,r=null,n=null,i=t;return"object"==typeof t&&(i=t.data,"target"in t&&(e=0|t.target)),"texture2d"===(t=i._reglType)?r=i:"textureCube"===t?r=i:"renderbuffer"===t&&(n=i,e=36161),new o(e,r,n)}function f(t,e,r,a,s){return r?((t=n.create2D({width:t,height:e,format:a,type:s}))._texture.refCount=0,new o(3553,t,null)):((t=i.create({width:t,height:e,format:a}))._renderbuffer.refCount=0,new o(36161,null,t))}function h(t){return t&&(t.texture||t.renderbuffer)}function p(t,e,r){t&&(t.texture?t.texture.resize(e,r):t.renderbuffer&&t.renderbuffer.resize(e,r))}function d(){this.id=k++,M[this.id]=this,this.framebuffer=t.createFramebuffer(),this.height=this.width=0,this.colorAttachments=[],this.depthStencilAttachment=this.stencilAttachment=this.depthAttachment=null}function g(t){t.colorAttachments.forEach(s),s(t.depthAttachment),s(t.stencilAttachment),s(t.depthStencilAttachment)}function m(e){t.deleteFramebuffer(e.framebuffer),e.framebuffer=null,a.framebufferCount--,delete M[e.id]}function v(e){var n;t.bindFramebuffer(36160,e.framebuffer);var i=e.colorAttachments;for(n=0;ni;++i){for(c=0;ct;++t)r[t].resize(n);return e.width=e.height=n,e},_reglType:"framebufferCube",destroy:function(){r.forEach(function(t){t.destroy()})}})},clear:function(){W(M).forEach(m)},restore:function(){W(M).forEach(function(e){e.framebuffer=t.createFramebuffer(),v(e)})}})}function T(){this.w=this.z=this.y=this.x=this.state=0,this.buffer=null,this.size=0,this.normalized=!1,this.type=5126,this.divisor=this.stride=this.offset=0}function S(t,e,r,n){function i(t,e,r,n){this.name=t,this.id=e,this.location=r,this.info=n}function a(t,e){for(var r=0;rt&&(t=e.stats.uniformsCount)}),t},r.getMaxAttributesCount=function(){var t=0;return h.forEach(function(e){e.stats.attributesCount>t&&(t=e.stats.attributesCount)}),t}),{clear:function(){var e=t.deleteShader.bind(t);W(c).forEach(e),c={},W(u).forEach(e),u={},h.forEach(function(e){t.deleteProgram(e.program)}),h.length=0,f={},r.shaderCount=0},program:function(t,e,n){var i=f[e];i||(i=f[e]={});var a=i[t];return a||(a=new s(e,t),r.shaderCount++,l(a),i[t]=a,h.push(a)),a},restore:function(){c={},u={};for(var t=0;t="+e+"?"+i+".constant["+e+"]:0;"}).join(""),"}}else{","if(",o,"(",i,".buffer)){",u,"=",s,".createStream(",34962,",",i,".buffer);","}else{",u,"=",s,".getBuffer(",i,".buffer);","}",f,'="type" in ',i,"?",a.glTypes,"[",i,".type]:",u,".dtype;",l.normalized,"=!!",i,".normalized;"),n("size"),n("offset"),n("stride"),n("divisor"),r("}}"),r.exit("if(",l.isStream,"){",s,".destroyStream(",u,");","}"),l})}),o}function A(t,e,r,n,i){var a=_(t),s=function(t,e,r){function n(t){if(t in i){var r=i[t];t=!0;var n,o,s=0|r.x,l=0|r.y;return"width"in r?n=0|r.width:t=!1,"height"in r?o=0|r.height:t=!1,new O(!t&&e&&e.thisDep,!t&&e&&e.contextDep,!t&&e&&e.propDep,function(t,e){var i=t.shared.context,a=n;"width"in r||(a=e.def(i,".","framebufferWidth","-",s));var c=o;return"height"in r||(c=e.def(i,".","framebufferHeight","-",l)),[s,l,a,c]})}if(t in a){var c=a[t];return t=B(c,function(t,e){var r=t.invoke(e,c),n=t.shared.context,i=e.def(r,".x|0"),a=e.def(r,".y|0");return[i,a,e.def('"width" in ',r,"?",r,".width|0:","(",n,".","framebufferWidth","-",i,")"),r=e.def('"height" in ',r,"?",r,".height|0:","(",n,".","framebufferHeight","-",a,")")]}),e&&(t.thisDep=t.thisDep||e.thisDep,t.contextDep=t.contextDep||e.contextDep,t.propDep=t.propDep||e.propDep),t}return e?new O(e.thisDep,e.contextDep,e.propDep,function(t,e){var r=t.shared.context;return[0,0,e.def(r,".","framebufferWidth"),e.def(r,".","framebufferHeight")]}):null}var i=t.static,a=t.dynamic;if(t=n("viewport")){var o=t;t=new O(t.thisDep,t.contextDep,t.propDep,function(t,e){var r=o.append(t,e),n=t.shared.context;return e.set(n,".viewportWidth",r[2]),e.set(n,".viewportHeight",r[3]),r})}return{viewport:t,scissor_box:n("scissor.box")}}(t,a),l=k(t),c=function(t,e){var r=t.static,n=t.dynamic,i={};return nt.forEach(function(t){function e(e,o){if(t in r){var s=e(r[t]);i[a]=R(function(){return s})}else if(t in n){var l=n[t];i[a]=B(l,function(t,e){return o(t,e,t.invoke(e,l))})}}var a=m(t);switch(t){case"cull.enable":case"blend.enable":case"dither":case"stencil.enable":case"depth.enable":case"scissor.enable":case"polygonOffset.enable":case"sample.alpha":case"sample.enable":case"depth.mask":return e(function(t){return t},function(t,e,r){return r});case"depth.func":return e(function(t){return yt[t]},function(t,e,r){return e.def(t.constants.compareFuncs,"[",r,"]")});case"depth.range":return e(function(t){return t},function(t,e,r){return[e.def("+",r,"[0]"),e=e.def("+",r,"[1]")]});case"blend.func":return e(function(t){return[vt["srcRGB"in t?t.srcRGB:t.src],vt["dstRGB"in t?t.dstRGB:t.dst],vt["srcAlpha"in t?t.srcAlpha:t.src],vt["dstAlpha"in t?t.dstAlpha:t.dst]]},function(t,e,r){function n(t,n){return e.def('"',t,n,'" in ',r,"?",r,".",t,n,":",r,".",t)}t=t.constants.blendFuncs;var i=n("src","RGB"),a=n("dst","RGB"),o=(i=e.def(t,"[",i,"]"),e.def(t,"[",n("src","Alpha"),"]"));return[i,a=e.def(t,"[",a,"]"),o,t=e.def(t,"[",n("dst","Alpha"),"]")]});case"blend.equation":return e(function(t){return"string"==typeof t?[J[t],J[t]]:"object"==typeof t?[J[t.rgb],J[t.alpha]]:void 0},function(t,e,r){var n=t.constants.blendEquations,i=e.def(),a=e.def();return(t=t.cond("typeof ",r,'==="string"')).then(i,"=",a,"=",n,"[",r,"];"),t.else(i,"=",n,"[",r,".rgb];",a,"=",n,"[",r,".alpha];"),e(t),[i,a]});case"blend.color":return e(function(t){return o(4,function(e){return+t[e]})},function(t,e,r){return o(4,function(t){return e.def("+",r,"[",t,"]")})});case"stencil.mask":return e(function(t){return 0|t},function(t,e,r){return e.def(r,"|0")});case"stencil.func":return e(function(t){return[yt[t.cmp||"keep"],t.ref||0,"mask"in t?t.mask:-1]},function(t,e,r){return[t=e.def('"cmp" in ',r,"?",t.constants.compareFuncs,"[",r,".cmp]",":",7680),e.def(r,".ref|0"),e=e.def('"mask" in ',r,"?",r,".mask|0:-1")]});case"stencil.opFront":case"stencil.opBack":return e(function(e){return["stencil.opBack"===t?1029:1028,xt[e.fail||"keep"],xt[e.zfail||"keep"],xt[e.zpass||"keep"]]},function(e,r,n){function i(t){return r.def('"',t,'" in ',n,"?",a,"[",n,".",t,"]:",7680)}var a=e.constants.stencilOps;return["stencil.opBack"===t?1029:1028,i("fail"),i("zfail"),i("zpass")]});case"polygonOffset.offset":return e(function(t){return[0|t.factor,0|t.units]},function(t,e,r){return[e.def(r,".factor|0"),e=e.def(r,".units|0")]});case"cull.face":return e(function(t){var e=0;return"front"===t?e=1028:"back"===t&&(e=1029),e},function(t,e,r){return e.def(r,'==="front"?',1028,":",1029)});case"lineWidth":return e(function(t){return t},function(t,e,r){return r});case"frontFace":return e(function(t){return bt[t]},function(t,e,r){return e.def(r+'==="cw"?2304:2305')});case"colorMask":return e(function(t){return t.map(function(t){return!!t})},function(t,e,r){return o(4,function(t){return"!!"+r+"["+t+"]"})});case"sample.coverage":return e(function(t){return["value"in t?t.value:1,!!t.invert]},function(t,e,r){return[e.def('"value" in ',r,"?+",r,".value:1"),e=e.def("!!",r,".invert")]})}}),i}(t),u=w(t),f=s.viewport;return f&&(c.viewport=f),(s=s[f=m("scissor.box")])&&(c[f]=s),(a={framebuffer:a,draw:l,shader:u,state:c,dirty:s=0>1)",s],");")}function e(){r(l,".drawArraysInstancedANGLE(",[d,g,m,s],");")}p?y?t():(r("if(",p,"){"),t(),r("}else{"),e(),r("}")):e()}function o(){function t(){r(u+".drawElements("+[d,m,v,g+"<<(("+v+"-5121)>>1)"]+");")}function e(){r(u+".drawArrays("+[d,g,m]+");")}p?y?t():(r("if(",p,"){"),t(),r("}else{"),e(),r("}")):e()}var s,l,c=t.shared,u=c.gl,f=c.draw,h=n.draw,p=function(){var i=h.elements,a=e;return i?((i.contextDep&&n.contextDynamic||i.propDep)&&(a=r),i=i.append(t,a)):i=a.def(f,".","elements"),i&&a("if("+i+")"+u+".bindBuffer(34963,"+i+".buffer.buffer);"),i}(),d=i("primitive"),g=i("offset"),m=function(){var i=h.count,a=e;return i?((i.contextDep&&n.contextDynamic||i.propDep)&&(a=r),i=i.append(t,a)):i=a.def(f,".","count"),i}();if("number"==typeof m){if(0===m)return}else r("if(",m,"){"),r.exit("}");Q&&(s=i("instances"),l=t.instancing);var v=p+".type",y=h.elements&&I(h.elements);Q&&("number"!=typeof s||0<=s)?"string"==typeof s?(r("if(",s,">0){"),a(),r("}else if(",s,"<0){"),o(),r("}")):a():o()}function q(t,e,r,n,i){return i=(e=b()).proc("body",i),Q&&(e.instancing=i.def(e.shared.extensions,".angle_instanced_arrays")),t(e,i,r,n),e.compile().body}function H(t,e,r,n){L(t,e),N(t,e,r,n.attributes,function(){return!0}),j(t,e,r,n.uniforms,function(){return!0}),V(t,e,e,r)}function G(t,e,r,n){function i(){return!0}t.batchId="a1",L(t,e),N(t,e,r,n.attributes,i),j(t,e,r,n.uniforms,i),V(t,e,e,r)}function W(t,e,r,n){function i(t){return t.contextDep&&o||t.propDep}function a(t){return!i(t)}L(t,e);var o=r.contextDep,s=e.def(),l=e.def();t.shared.props=l,t.batchId=s;var c=t.scope(),u=t.scope();e(c.entry,"for(",s,"=0;",s,"<","a1",";++",s,"){",l,"=","a0","[",s,"];",u,"}",c.exit),r.needsContext&&T(t,u,r.context),r.needsFramebuffer&&S(t,u,r.framebuffer),E(t,u,r.state,i),r.profile&&i(r.profile)&&F(t,u,r,!1,!0),n?(N(t,c,r,n.attributes,a),N(t,u,r,n.attributes,i),j(t,c,r,n.uniforms,a),j(t,u,r,n.uniforms,i),V(t,c,u,r)):(e=t.global.def("{}"),n=r.shader.progVar.append(t,u),l=u.def(n,".id"),c=u.def(e,"[",l,"]"),u(t.shared.gl,".useProgram(",n,".program);","if(!",c,"){",c,"=",e,"[",l,"]=",t.link(function(e){return q(G,t,r,e,2)}),"(",n,");}",c,".call(this,a0[",s,"],",s,");"))}function Y(t,r){function n(e){var n=r.shader[e];n&&i.set(a.shader,"."+e,n.append(t,i))}var i=t.proc("scope",3);t.batchId="a2";var a=t.shared,o=a.current;T(t,i,r.context),r.framebuffer&&r.framebuffer.append(t,i),D(Object.keys(r.state)).forEach(function(e){var n=r.state[e].append(t,i);v(n)?n.forEach(function(r,n){i.set(t.next[e],"["+n+"]",r)}):i.set(a.next,"."+e,n)}),F(t,i,r,!0,!0),["elements","offset","count","instances","primitive"].forEach(function(e){var n=r.draw[e];n&&i.set(a.draw,"."+e,""+n.append(t,i))}),Object.keys(r.uniforms).forEach(function(n){i.set(a.uniforms,"["+e.id(n)+"]",r.uniforms[n].append(t,i))}),Object.keys(r.attributes).forEach(function(e){var n=r.attributes[e].append(t,i),a=t.scopeAttrib(e);Object.keys(new Z).forEach(function(t){i.set(a,"."+t,n[t])})}),n("vert"),n("frag"),0=--this.refCount&&o(this)},i.profile&&(n.getTotalRenderbufferSize=function(){var t=0;return Object.keys(u).forEach(function(e){t+=u[e].stats.size}),t}),{create:function(e,r){function o(e,r){var n=0,a=0,u=32854;if("object"==typeof e&&e?("shape"in e?(n=0|(a=e.shape)[0],a=0|a[1]):("radius"in e&&(n=a=0|e.radius),"width"in e&&(n=0|e.width),"height"in e&&(a=0|e.height)),"format"in e&&(u=s[e.format])):"number"==typeof e?(n=0|e,a="number"==typeof r?0|r:n):e||(n=a=1),n!==c.width||a!==c.height||u!==c.format)return o.width=c.width=n,o.height=c.height=a,c.format=u,t.bindRenderbuffer(36161,c.renderbuffer),t.renderbufferStorage(36161,u,n,a),i.profile&&(c.stats.size=ft[c.format]*c.width*c.height),o.format=l[c.format],o}var c=new a(t.createRenderbuffer());return u[c.id]=c,n.renderbufferCount++,o(e,r),o.resize=function(e,r){var n=0|e,a=0|r||n;return n===c.width&&a===c.height?o:(o.width=c.width=n,o.height=c.height=a,t.bindRenderbuffer(36161,c.renderbuffer),t.renderbufferStorage(36161,c.format,n,a),i.profile&&(c.stats.size=ft[c.format]*c.width*c.height),o)},o._reglType="renderbuffer",o._renderbuffer=c,i.profile&&(o.stats=c.stats),o.destroy=function(){c.decRef()},o},clear:function(){W(u).forEach(o)},restore:function(){W(u).forEach(function(e){e.renderbuffer=t.createRenderbuffer(),t.bindRenderbuffer(36161,e.renderbuffer),t.renderbufferStorage(36161,e.format,e.width,e.height)}),t.bindRenderbuffer(36161,null)}}},pt=[];pt[6408]=4;var dt=[];dt[5121]=1,dt[5126]=4,dt[36193]=2;var gt=["x","y","z","w"],mt="blend.func blend.equation stencil.func stencil.opFront stencil.opBack sample.coverage viewport scissor.box polygonOffset.offset".split(" "),vt={0:0,1:1,zero:0,one:1,"src color":768,"one minus src color":769,"src alpha":770,"one minus src alpha":771,"dst color":774,"one minus dst color":775,"dst alpha":772,"one minus dst alpha":773,"constant color":32769,"one minus constant color":32770,"constant alpha":32771,"one minus constant alpha":32772,"src alpha saturate":776},yt={never:512,less:513,"<":513,equal:514,"=":514,"==":514,"===":514,lequal:515,"<=":515,greater:516,">":516,notequal:517,"!=":517,"!==":517,gequal:518,">=":518,always:519},xt={0:0,zero:0,keep:7680,replace:7681,increment:7682,decrement:7683,"increment wrap":34055,"decrement wrap":34056,invert:5386},bt={cw:2304,ccw:2305},_t=new O(!1,!1,!1,function(){});return function(t){function e(){if(0===X.length)w&&w.update(),Q=null;else{Q=q.next(e),f();for(var t=X.length-1;0<=t;--t){var r=X[t];r&&r(z,null,0)}m.flush(),w&&w.update()}}function r(){!Q&&0=X.length&&n()}}}}function u(){var t=W.viewport,e=W.scissor_box;t[0]=t[1]=e[0]=e[1]=0,z.viewportWidth=z.framebufferWidth=z.drawingBufferWidth=t[2]=e[2]=m.drawingBufferWidth,z.viewportHeight=z.framebufferHeight=z.drawingBufferHeight=t[3]=e[3]=m.drawingBufferHeight}function f(){z.tick+=1,z.time=p(),u(),G.procs.poll()}function h(){u(),G.procs.refresh(),w&&w.update()}function p(){return(H()-k)/1e3}if(!(t=i(t)))return null;var m=t.gl,v=m.getContextAttributes();m.isContextLost();var y=function(t,e){function r(e){var r;e=e.toLowerCase();try{r=n[e]=t.getExtension(e)}catch(t){}return!!r}for(var n={},i=0;ie;++e)$(j({framebuffer:t.framebuffer.faces[e]},t),l);else $(t,l);else l(0,t)},prop:U.define.bind(null,1),context:U.define.bind(null,2),this:U.define.bind(null,3),draw:s({}),buffer:function(t){return D.create(t,34962,!1,!1)},elements:function(t){return O.create(t,!1)},texture:R.create2D,cube:R.createCube,renderbuffer:B.create,framebuffer:V.create,framebufferCube:V.createCube,attributes:v,frame:c,on:function(t,e){var r;switch(t){case"frame":return c(e);case"lost":r=Z;break;case"restore":r=J;break;case"destroy":r=K}return r.push(e),{cancel:function(){for(var t=0;t=r)return i.substr(0,r);for(;r>i.length&&e>1;)1&e&&(i+=t),e>>=1,t+=t;return i=(i+=t).substr(0,r)}},{}],440:[function(t,e,r){(function(t){e.exports=t.performance&&t.performance.now?function(){return performance.now()}:Date.now||function(){return+new Date}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}],441:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.length,r=t[t.length-1],n=e,i=e-2;i>=0;--i){var a=r,o=t[i],s=(r=a+o)-a,l=o-s;l&&(t[--n]=r,r=l)}for(var c=0,i=n;i>1;return["sum(",t(e.slice(0,r)),",",t(e.slice(r)),")"].join("")}(e);var n}function u(t){return new Function("sum","scale","prod","compress",["function robustDeterminant",t,"(m){return compress(",c(function(t){for(var e=new Array(t),r=0;r>1;return["sum(",c(t.slice(0,e)),",",c(t.slice(e)),")"].join("")}function u(t,e){if("m"===t.charAt(0)){if("w"===e.charAt(0)){var r=t.split("[");return["w",e.substr(1),"m",r[0].substr(1)].join("")}return["prod(",t,",",e,")"].join("")}return u(e,t)}function f(t){if(2===t.length)return[["diff(",u(t[0][0],t[1][1]),",",u(t[1][0],t[0][1]),")"].join("")];for(var e=[],r=0;r0&&r.push(","),r.push("[");for(var o=0;o0&&r.push(","),o===i?r.push("+b[",a,"]"):r.push("+A[",a,"][",o,"]");r.push("]")}r.push("]),")}r.push("det(A)]}return ",e);var s=new Function("det",r.join(""));return s(t<6?n[t]:n)}var o=[function(){return[0]},function(t,e){return[[e[0]],[t[0][0]]]}];!function(){for(;o.length>1;return["sum(",c(t.slice(0,e)),",",c(t.slice(e)),")"].join("")}function u(t){if(2===t.length)return[["sum(prod(",t[0][0],",",t[1][1],"),prod(-",t[0][1],",",t[1][0],"))"].join("")];for(var e=[],r=0;r0){if(a<=0)return o;n=i+a}else{if(!(i<0))return o;if(a>=0)return o;n=-(i+a)}var s=3.3306690738754716e-16*n;return o>=s||o<=-s?o:h(t,e,r)},function(t,e,r,n){var i=t[0]-n[0],a=e[0]-n[0],o=r[0]-n[0],s=t[1]-n[1],l=e[1]-n[1],c=r[1]-n[1],u=t[2]-n[2],f=e[2]-n[2],h=r[2]-n[2],d=a*c,g=o*l,m=o*s,v=i*c,y=i*l,x=a*s,b=u*(d-g)+f*(m-v)+h*(y-x),_=7.771561172376103e-16*((Math.abs(d)+Math.abs(g))*Math.abs(u)+(Math.abs(m)+Math.abs(v))*Math.abs(f)+(Math.abs(y)+Math.abs(x))*Math.abs(h));return b>_||-b>_?b:p(t,e,r,n)}];!function(){for(;d.length<=s;)d.push(f(d.length));for(var t=[],r=["slow"],n=0;n<=s;++n)t.push("a"+n),r.push("o"+n);var i=["function getOrientation(",t.join(),"){switch(arguments.length){case 0:case 1:return 0;"];for(n=2;n<=s;++n)i.push("case ",n,":return o",n,"(",t.slice(0,n).join(),");");i.push("}var s=new Array(arguments.length);for(var i=0;i0&&o>0||a<0&&o<0)return!1;var s=n(r,t,e),l=n(i,t,e);if(s>0&&l>0||s<0&&l<0)return!1;if(0===a&&0===o&&0===s&&0===l)return function(t,e,r,n){for(var i=0;i<2;++i){var a=t[i],o=e[i],s=Math.min(a,o),l=Math.max(a,o),c=r[i],u=n[i],f=Math.min(c,u),h=Math.max(c,u);if(h=n?(i=f,(l+=1)=n?(i=f,(l+=1)0?1:0}},{}],453:[function(t,e,r){"use strict";e.exports=function(t){return i(n(t))};var n=t("boundary-cells"),i=t("reduce-simplicial-complex")},{"boundary-cells":77,"reduce-simplicial-complex":431}],454:[function(t,e,r){"use strict";e.exports=function(t,e,r,s){r=r||0,void 0===s&&(s=function(t){for(var e=t.length,r=0,n=0;n>1,v=E[2*m+1];","if(v===b){return m}","if(b0&&l.push(","),l.push("[");for(var n=0;n0&&l.push(","),l.push("B(C,E,c[",i[0],"],c[",i[1],"])")}l.push("]")}l.push(");")}}for(var a=t+1;a>1;--a){a>1,s=a(t[o],e);s<=0?(0===s&&(i=o),r=o+1):s>0&&(n=o-1)}return i}function u(t,e){for(var r=new Array(t.length),i=0,o=r.length;i=t.length||0!==a(t[m],s)););}return r}function f(t,e){if(e<0)return[];for(var r=[],i=(1<>>u&1&&c.push(i[u]);e.push(c)}return s(e)},r.skeleton=f,r.boundary=function(t){for(var e=[],r=0,n=t.length;r>1:(t>>1)-1}function x(t){for(var e=v(t);;){var r=e,n=2*t+1,i=2*(t+1),a=t;if(n0;){var r=y(t);if(r>=0){var n=v(r);if(e0){var t=M[0];return m(0,S-1),S-=1,x(0),t}return-1}function w(t,e){var r=M[t];return c[r]===e?t:(c[r]=-1/0,b(t),_(),c[r]=e,b((S+=1)-1))}function k(t){if(!u[t]){u[t]=!0;var e=s[t],r=l[t];s[r]>=0&&(s[r]=e),l[e]>=0&&(l[e]=r),A[e]>=0&&w(A[e],g(e)),A[r]>=0&&w(A[r],g(r))}}for(var M=[],A=new Array(a),f=0;f>1;f>=0;--f)x(f);for(;;){var C=_();if(C<0||c[C]>r)break;k(C)}for(var E=[],f=0;f=0&&r>=0&&e!==r){var n=A[e],i=A[r];n!==i&&z.push([n,i])}}),i.unique(i.normalize(z)),{positions:E,edges:z}};var n=t("robust-orientation"),i=t("simplicial-complex")},{"robust-orientation":446,"simplicial-complex":458}],461:[function(t,e,r){"use strict";e.exports=function(t,e){var r,a,o,s;if(e[0][0]e[1][0]))return i(e,t);r=e[1],a=e[0]}if(t[0][0]t[1][0]))return-i(t,e);o=t[1],s=t[0]}var l=n(r,a,s),c=n(r,a,o);if(l<0){if(c<=0)return l}else if(l>0){if(c>=0)return l}else if(c)return c;if(l=n(s,o,a),c=n(s,o,r),l<0){if(c<=0)return l}else if(l>0){if(c>=0)return l}else if(c)return c;return a[0]-s[0]};var n=t("robust-orientation");function i(t,e){var r,i,a,o;if(e[0][0]e[1][0])){var s=Math.min(t[0][1],t[1][1]),l=Math.max(t[0][1],t[1][1]),c=Math.min(e[0][1],e[1][1]),u=Math.max(e[0][1],e[1][1]);return lu?s-u:l-u}r=e[1],i=e[0]}t[0][1]0)if(e[0]!==o[1][0])r=t,t=t.right;else{if(l=c(t.right,e))return l;t=t.left}else{if(e[0]!==o[1][0])return t;var l;if(l=c(t.right,e))return l;t=t.left}}return r}function u(t,e,r,n){this.y=t,this.index=e,this.start=r,this.closed=n}function f(t,e,r,n){this.x=t,this.segment=e,this.create=r,this.index=n}s.prototype.castUp=function(t){var e=n.le(this.coordinates,t[0]);if(e<0)return-1;this.slabs[e];var r=c(this.slabs[e],t),i=-1;if(r&&(i=r.value),this.coordinates[e]===t[0]){var s=null;if(r&&(s=r.key),e>0){var u=c(this.slabs[e-1],t);u&&(s?o(u.key,s)>0&&(s=u.key,i=u.value):(i=u.value,s=u.key))}var f=this.horizontal[e];if(f.length>0){var h=n.ge(f,t[1],l);if(h=f.length)return i;p=f[h]}}if(p.start)if(s){var d=a(s[0],s[1],[t[0],p.y]);s[0][0]>s[1][0]&&(d=-d),d>0&&(i=p.index)}else i=p.index;else p.y!==t[1]&&(i=p.index)}}}return i}},{"./lib/order-segments":461,"binary-search-bounds":73,"functional-red-black-tree":200,"robust-orientation":446}],463:[function(t,e,r){"use strict";var n=t("robust-dot-product"),i=t("robust-sum");function a(t,e){var r=i(n(t,e),[e[e.length-1]]);return r[r.length-1]}function o(t,e,r,n){var i=-e/(n-e);i<0?i=0:i>1&&(i=1);for(var a=1-i,o=t.length,s=new Array(o),l=0;l0||i>0&&u<0){var f=o(s,u,l,i);r.push(f),n.push(f.slice())}u<0?n.push(l.slice()):u>0?r.push(l.slice()):(r.push(l.slice()),n.push(l.slice())),i=u}return{positive:r,negative:n}},e.exports.positive=function(t,e){for(var r=[],n=a(t[t.length-1],e),i=t[t.length-1],s=t[0],l=0;l0||n>0&&c<0)&&r.push(o(i,c,s,n)),c>=0&&r.push(s.slice()),n=c}return r},e.exports.negative=function(t,e){for(var r=[],n=a(t[t.length-1],e),i=t[t.length-1],s=t[0],l=0;l0||n>0&&c<0)&&r.push(o(i,c,s,n)),c<=0&&r.push(s.slice()),n=c}return r}},{"robust-dot-product":443,"robust-sum":451}],464:[function(t,e,r){!function(){"use strict";var t={not_string:/[^s]/,not_bool:/[^t]/,not_type:/[^T]/,not_primitive:/[^v]/,number:/[diefg]/,numeric_arg:/[bcdiefguxX]/,json:/[j]/,not_json:/[^j]/,text:/^[^\x25]+/,modulo:/^\x25{2}/,placeholder:/^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-gijostTuvxX])/,key:/^([a-z_][a-z_\d]*)/i,key_access:/^\.([a-z_][a-z_\d]*)/i,index_access:/^\[(\d+)\]/,sign:/^[\+\-]/};function e(r){return function(r,n){var i,a,o,s,l,c,u,f,h,p=1,d=r.length,g="";for(a=0;a=0),s[8]){case"b":i=parseInt(i,10).toString(2);break;case"c":i=String.fromCharCode(parseInt(i,10));break;case"d":case"i":i=parseInt(i,10);break;case"j":i=JSON.stringify(i,null,s[6]?parseInt(s[6]):0);break;case"e":i=s[7]?parseFloat(i).toExponential(s[7]):parseFloat(i).toExponential();break;case"f":i=s[7]?parseFloat(i).toFixed(s[7]):parseFloat(i);break;case"g":i=s[7]?String(Number(i.toPrecision(s[7]))):parseFloat(i);break;case"o":i=(parseInt(i,10)>>>0).toString(8);break;case"s":i=String(i),i=s[7]?i.substring(0,s[7]):i;break;case"t":i=String(!!i),i=s[7]?i.substring(0,s[7]):i;break;case"T":i=Object.prototype.toString.call(i).slice(8,-1).toLowerCase(),i=s[7]?i.substring(0,s[7]):i;break;case"u":i=parseInt(i,10)>>>0;break;case"v":i=i.valueOf(),i=s[7]?i.substring(0,s[7]):i;break;case"x":i=(parseInt(i,10)>>>0).toString(16);break;case"X":i=(parseInt(i,10)>>>0).toString(16).toUpperCase()}t.json.test(s[8])?g+=i:(!t.number.test(s[8])||f&&!s[3]?h="":(h=f?"+":"-",i=i.toString().replace(t.sign,"")),c=s[4]?"0"===s[4]?"0":s[4].charAt(1):" ",u=s[6]-(h+i).length,l=s[6]&&u>0?c.repeat(u):"",g+=s[5]?h+i+l:"0"===c?h+l+i:l+h+i)}return g}(function(e){if(i[e])return i[e];var r,n=e,a=[],o=0;for(;n;){if(null!==(r=t.text.exec(n)))a.push(r[0]);else if(null!==(r=t.modulo.exec(n)))a.push("%");else{if(null===(r=t.placeholder.exec(n)))throw new SyntaxError("[sprintf] unexpected placeholder");if(r[2]){o|=1;var s=[],l=r[2],c=[];if(null===(c=t.key.exec(l)))throw new SyntaxError("[sprintf] failed to parse named argument key");for(s.push(c[1]);""!==(l=l.substring(c[0].length));)if(null!==(c=t.key_access.exec(l)))s.push(c[1]);else{if(null===(c=t.index_access.exec(l)))throw new SyntaxError("[sprintf] failed to parse named argument key");s.push(c[1])}r[2]=s}else o|=2;if(3===o)throw new Error("[sprintf] mixing positional and named placeholders is not (yet) supported");a.push(r)}n=n.substring(r[0].length)}return i[e]=a}(r),arguments)}function n(t,r){return e.apply(null,[t].concat(r||[]))}var i=Object.create(null);void 0!==r&&(r.sprintf=e,r.vsprintf=n),"undefined"!=typeof window&&(window.sprintf=e,window.vsprintf=n)}()},{}],465:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.length,r=new Array(e),n=new Array(e),i=new Array(e),a=new Array(e),o=new Array(e),s=new Array(e),l=0;l0;){e=c[c.length-1];var p=t[e];if(a[e]=0&&s[e].push(o[g])}a[e]=d}else{if(n[e]===r[e]){for(var m=[],v=[],y=0,d=l.length-1;d>=0;--d){var x=l[d];if(i[x]=!1,m.push(x),v.push(s[x]),y+=s[x].length,o[x]=f.length,x===e){l.length=d;break}}f.push(m);for(var b=new Array(y),d=0;d c)|0 },"),"generic"===e&&a.push("getters:[0],");for(var s=[],l=[],c=0;c>>7){");for(var c=0;c<1<<(1<128&&c%128==0){f.length>0&&h.push("}}");var p="vExtra"+f.length;a.push("case ",c>>>7,":",p,"(m&0x7f,",l.join(),");break;"),h=["function ",p,"(m,",l.join(),"){switch(m){"],f.push(h)}h.push("case ",127&c,":");for(var d=new Array(r),g=new Array(r),m=new Array(r),v=new Array(r),y=0,x=0;xx)&&!(c&1<<_)!=!(c&1<0&&(A="+"+m[b]+"*c");var T=d[b].length/y*.5,S=.5+v[b]/y*.5;M.push("d"+b+"-"+S+"-"+T+"*("+d[b].join("+")+A+")/("+g[b].join("+")+")")}h.push("a.push([",M.join(),"]);","break;")}a.push("}},"),f.length>0&&h.push("}}");for(var C=[],c=0;c<1<1&&(a=1),a<-1&&(a=-1),i*Math.acos(a)};r.default=function(t){var e=t.px,r=t.py,l=t.cx,c=t.cy,u=t.rx,f=t.ry,h=t.xAxisRotation,p=void 0===h?0:h,d=t.largeArcFlag,g=void 0===d?0:d,m=t.sweepFlag,v=void 0===m?0:m,y=[];if(0===u||0===f)return[];var x=Math.sin(p*i/360),b=Math.cos(p*i/360),_=b*(e-l)/2+x*(r-c)/2,w=-x*(e-l)/2+b*(r-c)/2;if(0===_&&0===w)return[];u=Math.abs(u),f=Math.abs(f);var k=Math.pow(_,2)/Math.pow(u,2)+Math.pow(w,2)/Math.pow(f,2);k>1&&(u*=Math.sqrt(k),f*=Math.sqrt(k));var M=function(t,e,r,n,a,o,l,c,u,f,h,p){var d=Math.pow(a,2),g=Math.pow(o,2),m=Math.pow(h,2),v=Math.pow(p,2),y=d*g-d*v-g*m;y<0&&(y=0),y/=d*v+g*m;var x=(y=Math.sqrt(y)*(l===c?-1:1))*a/o*p,b=y*-o/a*h,_=f*x-u*b+(t+r)/2,w=u*x+f*b+(e+n)/2,k=(h-x)/a,M=(p-b)/o,A=(-h-x)/a,T=(-p-b)/o,S=s(1,0,k,M),C=s(k,M,A,T);return 0===c&&C>0&&(C-=i),1===c&&C<0&&(C+=i),[_,w,S,C]}(e,r,l,c,u,f,g,v,x,b,_,w),A=n(M,4),T=A[0],S=A[1],C=A[2],E=A[3],L=Math.max(Math.ceil(Math.abs(E)/(i/4)),1);E/=L;for(var z=0;ze[2]&&(e[2]=c[u+0]),c[u+1]>e[3]&&(e[3]=c[u+1]);return e}},{"abs-svg-path":45,assert:53,"is-svg-path":367,"normalize-svg-path":470,"parse-svg-path":402}],470:[function(t,e,r){"use strict";e.exports=function(t){for(var e,r=[],o=0,s=0,l=0,c=0,u=null,f=null,h=0,p=0,d=0,g=t.length;d4?(o=m[m.length-4],s=m[m.length-3]):(o=h,s=p),r.push(m)}return r};var n=t("svg-arc-to-cubic-bezier");function i(t,e,r,n){return["C",t,e,r,n,r,n]}function a(t,e,r,n,i,a){return["C",t/3+2/3*r,e/3+2/3*n,i/3+2/3*r,a/3+2/3*n,i,a]}},{"svg-arc-to-cubic-bezier":468}],471:[function(t,e,r){(function(r){"use strict";var n=t("svg-path-bounds"),i=t("parse-svg-path"),a=t("draw-svg-path"),o=t("is-svg-path"),s=t("bitmap-sdf"),l=document.createElement("canvas"),c=l.getContext("2d");e.exports=function(t,e){if(!o(t))throw Error("Argument should be valid svg path string");e||(e={});var u,f;e.shape?(u=e.shape[0],f=e.shape[1]):(u=l.width=e.w||e.width||200,f=l.height=e.h||e.height||200);var h=Math.min(u,f),p=e.stroke||0,d=e.viewbox||e.viewBox||n(t),g=[u/(d[2]-d[0]),f/(d[3]-d[1])],m=Math.min(g[0]||0,g[1]||0)/2;c.fillStyle="black",c.fillRect(0,0,u,f),c.fillStyle="white",p&&("number"!=typeof p&&(p=1),c.strokeStyle=p>0?"white":"black",c.lineWidth=Math.abs(p));if(c.translate(.5*u,.5*f),c.scale(m,m),r.Path2D){var v=new Path2D(t);c.fill(v),p&&c.stroke(v)}else{var y=i(t);a(c,y),c.fill(),p&&c.stroke()}return c.setTransform(1,0,0,1,0,0),s(c,{cutoff:null!=e.cutoff?e.cutoff:.5,radius:null!=e.radius?e.radius:.5*h})}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"bitmap-sdf":75,"draw-svg-path":135,"is-svg-path":367,"parse-svg-path":402,"svg-path-bounds":469}],472:[function(t,e,r){(function(r){"use strict";e.exports=function t(e,r,i){var i=i||{};var o=a[e];o||(o=a[e]={" ":{data:new Float32Array(0),shape:.2}});var s=o[r];if(!s)if(r.length<=1||!/\d/.test(r))s=o[r]=function(t){for(var e=t.cells,r=t.positions,n=new Float32Array(6*e.length),i=0,a=0,o=0;o0&&(f+=.02);for(var p=new Float32Array(u),d=0,g=-.5*f,h=0;h1&&(r-=1),r<1/6?t+6*(e-t)*r:r<.5?e:r<2/3?t+(e-t)*(2/3-r)*6:t}if(t=L(t,360),e=L(e,100),r=L(r,100),0===e)n=i=a=r;else{var s=r<.5?r*(1+e):r+e-r*e,l=2*r-s;n=o(l,s,t+1/3),i=o(l,s,t),a=o(l,s,t-1/3)}return{r:255*n,g:255*i,b:255*a}}(e.h,l,u),f=!0,h="hsl"),e.hasOwnProperty("a")&&(a=e.a));var p,d,g;return a=E(a),{ok:f,format:e.format||h,r:o(255,s(i.r,0)),g:o(255,s(i.g,0)),b:o(255,s(i.b,0)),a:a}}(e);this._originalInput=e,this._r=u.r,this._g=u.g,this._b=u.b,this._a=u.a,this._roundA=a(100*this._a)/100,this._format=l.format||u.format,this._gradientType=l.gradientType,this._r<1&&(this._r=a(this._r)),this._g<1&&(this._g=a(this._g)),this._b<1&&(this._b=a(this._b)),this._ok=u.ok,this._tc_id=i++}function u(t,e,r){t=L(t,255),e=L(e,255),r=L(r,255);var n,i,a=s(t,e,r),l=o(t,e,r),c=(a+l)/2;if(a==l)n=i=0;else{var u=a-l;switch(i=c>.5?u/(2-a-l):u/(a+l),a){case t:n=(e-r)/u+(e>1)+720)%360;--e;)n.h=(n.h+i)%360,a.push(c(n));return a}function T(t,e){e=e||6;for(var r=c(t).toHsv(),n=r.h,i=r.s,a=r.v,o=[],s=1/e;e--;)o.push(c({h:n,s:i,v:a})),a=(a+s)%1;return o}c.prototype={isDark:function(){return this.getBrightness()<128},isLight:function(){return!this.isDark()},isValid:function(){return this._ok},getOriginalInput:function(){return this._originalInput},getFormat:function(){return this._format},getAlpha:function(){return this._a},getBrightness:function(){var t=this.toRgb();return(299*t.r+587*t.g+114*t.b)/1e3},getLuminance:function(){var e,r,n,i=this.toRgb();return e=i.r/255,r=i.g/255,n=i.b/255,.2126*(e<=.03928?e/12.92:t.pow((e+.055)/1.055,2.4))+.7152*(r<=.03928?r/12.92:t.pow((r+.055)/1.055,2.4))+.0722*(n<=.03928?n/12.92:t.pow((n+.055)/1.055,2.4))},setAlpha:function(t){return this._a=E(t),this._roundA=a(100*this._a)/100,this},toHsv:function(){var t=f(this._r,this._g,this._b);return{h:360*t.h,s:t.s,v:t.v,a:this._a}},toHsvString:function(){var t=f(this._r,this._g,this._b),e=a(360*t.h),r=a(100*t.s),n=a(100*t.v);return 1==this._a?"hsv("+e+", "+r+"%, "+n+"%)":"hsva("+e+", "+r+"%, "+n+"%, "+this._roundA+")"},toHsl:function(){var t=u(this._r,this._g,this._b);return{h:360*t.h,s:t.s,l:t.l,a:this._a}},toHslString:function(){var t=u(this._r,this._g,this._b),e=a(360*t.h),r=a(100*t.s),n=a(100*t.l);return 1==this._a?"hsl("+e+", "+r+"%, "+n+"%)":"hsla("+e+", "+r+"%, "+n+"%, "+this._roundA+")"},toHex:function(t){return h(this._r,this._g,this._b,t)},toHexString:function(t){return"#"+this.toHex(t)},toHex8:function(t){return function(t,e,r,n,i){var o=[D(a(t).toString(16)),D(a(e).toString(16)),D(a(r).toString(16)),D(I(n))];if(i&&o[0].charAt(0)==o[0].charAt(1)&&o[1].charAt(0)==o[1].charAt(1)&&o[2].charAt(0)==o[2].charAt(1)&&o[3].charAt(0)==o[3].charAt(1))return o[0].charAt(0)+o[1].charAt(0)+o[2].charAt(0)+o[3].charAt(0);return o.join("")}(this._r,this._g,this._b,this._a,t)},toHex8String:function(t){return"#"+this.toHex8(t)},toRgb:function(){return{r:a(this._r),g:a(this._g),b:a(this._b),a:this._a}},toRgbString:function(){return 1==this._a?"rgb("+a(this._r)+", "+a(this._g)+", "+a(this._b)+")":"rgba("+a(this._r)+", "+a(this._g)+", "+a(this._b)+", "+this._roundA+")"},toPercentageRgb:function(){return{r:a(100*L(this._r,255))+"%",g:a(100*L(this._g,255))+"%",b:a(100*L(this._b,255))+"%",a:this._a}},toPercentageRgbString:function(){return 1==this._a?"rgb("+a(100*L(this._r,255))+"%, "+a(100*L(this._g,255))+"%, "+a(100*L(this._b,255))+"%)":"rgba("+a(100*L(this._r,255))+"%, "+a(100*L(this._g,255))+"%, "+a(100*L(this._b,255))+"%, "+this._roundA+")"},toName:function(){return 0===this._a?"transparent":!(this._a<1)&&(C[h(this._r,this._g,this._b,!0)]||!1)},toFilter:function(t){var e="#"+p(this._r,this._g,this._b,this._a),r=e,n=this._gradientType?"GradientType = 1, ":"";if(t){var i=c(t);r="#"+p(i._r,i._g,i._b,i._a)}return"progid:DXImageTransform.Microsoft.gradient("+n+"startColorstr="+e+",endColorstr="+r+")"},toString:function(t){var e=!!t;t=t||this._format;var r=!1,n=this._a<1&&this._a>=0;return e||!n||"hex"!==t&&"hex6"!==t&&"hex3"!==t&&"hex4"!==t&&"hex8"!==t&&"name"!==t?("rgb"===t&&(r=this.toRgbString()),"prgb"===t&&(r=this.toPercentageRgbString()),"hex"!==t&&"hex6"!==t||(r=this.toHexString()),"hex3"===t&&(r=this.toHexString(!0)),"hex4"===t&&(r=this.toHex8String(!0)),"hex8"===t&&(r=this.toHex8String()),"name"===t&&(r=this.toName()),"hsl"===t&&(r=this.toHslString()),"hsv"===t&&(r=this.toHsvString()),r||this.toHexString()):"name"===t&&0===this._a?this.toName():this.toRgbString()},clone:function(){return c(this.toString())},_applyModification:function(t,e){var r=t.apply(null,[this].concat([].slice.call(e)));return this._r=r._r,this._g=r._g,this._b=r._b,this.setAlpha(r._a),this},lighten:function(){return this._applyModification(v,arguments)},brighten:function(){return this._applyModification(y,arguments)},darken:function(){return this._applyModification(x,arguments)},desaturate:function(){return this._applyModification(d,arguments)},saturate:function(){return this._applyModification(g,arguments)},greyscale:function(){return this._applyModification(m,arguments)},spin:function(){return this._applyModification(b,arguments)},_applyCombination:function(t,e){return t.apply(null,[this].concat([].slice.call(e)))},analogous:function(){return this._applyCombination(A,arguments)},complement:function(){return this._applyCombination(_,arguments)},monochromatic:function(){return this._applyCombination(T,arguments)},splitcomplement:function(){return this._applyCombination(M,arguments)},triad:function(){return this._applyCombination(w,arguments)},tetrad:function(){return this._applyCombination(k,arguments)}},c.fromRatio=function(t,e){if("object"==typeof t){var r={};for(var n in t)t.hasOwnProperty(n)&&(r[n]="a"===n?t[n]:O(t[n]));t=r}return c(t,e)},c.equals=function(t,e){return!(!t||!e)&&c(t).toRgbString()==c(e).toRgbString()},c.random=function(){return c.fromRatio({r:l(),g:l(),b:l()})},c.mix=function(t,e,r){r=0===r?0:r||50;var n=c(t).toRgb(),i=c(e).toRgb(),a=r/100;return c({r:(i.r-n.r)*a+n.r,g:(i.g-n.g)*a+n.g,b:(i.b-n.b)*a+n.b,a:(i.a-n.a)*a+n.a})},c.readability=function(e,r){var n=c(e),i=c(r);return(t.max(n.getLuminance(),i.getLuminance())+.05)/(t.min(n.getLuminance(),i.getLuminance())+.05)},c.isReadable=function(t,e,r){var n,i,a=c.readability(t,e);switch(i=!1,(n=function(t){var e,r;e=((t=t||{level:"AA",size:"small"}).level||"AA").toUpperCase(),r=(t.size||"small").toLowerCase(),"AA"!==e&&"AAA"!==e&&(e="AA");"small"!==r&&"large"!==r&&(r="small");return{level:e,size:r}}(r)).level+n.size){case"AAsmall":case"AAAlarge":i=a>=4.5;break;case"AAlarge":i=a>=3;break;case"AAAsmall":i=a>=7}return i},c.mostReadable=function(t,e,r){var n,i,a,o,s=null,l=0;i=(r=r||{}).includeFallbackColors,a=r.level,o=r.size;for(var u=0;ul&&(l=n,s=c(e[u]));return c.isReadable(t,s,{level:a,size:o})||!i?s:(r.includeFallbackColors=!1,c.mostReadable(t,["#fff","#000"],r))};var S=c.names={aliceblue:"f0f8ff",antiquewhite:"faebd7",aqua:"0ff",aquamarine:"7fffd4",azure:"f0ffff",beige:"f5f5dc",bisque:"ffe4c4",black:"000",blanchedalmond:"ffebcd",blue:"00f",blueviolet:"8a2be2",brown:"a52a2a",burlywood:"deb887",burntsienna:"ea7e5d",cadetblue:"5f9ea0",chartreuse:"7fff00",chocolate:"d2691e",coral:"ff7f50",cornflowerblue:"6495ed",cornsilk:"fff8dc",crimson:"dc143c",cyan:"0ff",darkblue:"00008b",darkcyan:"008b8b",darkgoldenrod:"b8860b",darkgray:"a9a9a9",darkgreen:"006400",darkgrey:"a9a9a9",darkkhaki:"bdb76b",darkmagenta:"8b008b",darkolivegreen:"556b2f",darkorange:"ff8c00",darkorchid:"9932cc",darkred:"8b0000",darksalmon:"e9967a",darkseagreen:"8fbc8f",darkslateblue:"483d8b",darkslategray:"2f4f4f",darkslategrey:"2f4f4f",darkturquoise:"00ced1",darkviolet:"9400d3",deeppink:"ff1493",deepskyblue:"00bfff",dimgray:"696969",dimgrey:"696969",dodgerblue:"1e90ff",firebrick:"b22222",floralwhite:"fffaf0",forestgreen:"228b22",fuchsia:"f0f",gainsboro:"dcdcdc",ghostwhite:"f8f8ff",gold:"ffd700",goldenrod:"daa520",gray:"808080",green:"008000",greenyellow:"adff2f",grey:"808080",honeydew:"f0fff0",hotpink:"ff69b4",indianred:"cd5c5c",indigo:"4b0082",ivory:"fffff0",khaki:"f0e68c",lavender:"e6e6fa",lavenderblush:"fff0f5",lawngreen:"7cfc00",lemonchiffon:"fffacd",lightblue:"add8e6",lightcoral:"f08080",lightcyan:"e0ffff",lightgoldenrodyellow:"fafad2",lightgray:"d3d3d3",lightgreen:"90ee90",lightgrey:"d3d3d3",lightpink:"ffb6c1",lightsalmon:"ffa07a",lightseagreen:"20b2aa",lightskyblue:"87cefa",lightslategray:"789",lightslategrey:"789",lightsteelblue:"b0c4de",lightyellow:"ffffe0",lime:"0f0",limegreen:"32cd32",linen:"faf0e6",magenta:"f0f",maroon:"800000",mediumaquamarine:"66cdaa",mediumblue:"0000cd",mediumorchid:"ba55d3",mediumpurple:"9370db",mediumseagreen:"3cb371",mediumslateblue:"7b68ee",mediumspringgreen:"00fa9a",mediumturquoise:"48d1cc",mediumvioletred:"c71585",midnightblue:"191970",mintcream:"f5fffa",mistyrose:"ffe4e1",moccasin:"ffe4b5",navajowhite:"ffdead",navy:"000080",oldlace:"fdf5e6",olive:"808000",olivedrab:"6b8e23",orange:"ffa500",orangered:"ff4500",orchid:"da70d6",palegoldenrod:"eee8aa",palegreen:"98fb98",paleturquoise:"afeeee",palevioletred:"db7093",papayawhip:"ffefd5",peachpuff:"ffdab9",peru:"cd853f",pink:"ffc0cb",plum:"dda0dd",powderblue:"b0e0e6",purple:"800080",rebeccapurple:"663399",red:"f00",rosybrown:"bc8f8f",royalblue:"4169e1",saddlebrown:"8b4513",salmon:"fa8072",sandybrown:"f4a460",seagreen:"2e8b57",seashell:"fff5ee",sienna:"a0522d",silver:"c0c0c0",skyblue:"87ceeb",slateblue:"6a5acd",slategray:"708090",slategrey:"708090",snow:"fffafa",springgreen:"00ff7f",steelblue:"4682b4",tan:"d2b48c",teal:"008080",thistle:"d8bfd8",tomato:"ff6347",turquoise:"40e0d0",violet:"ee82ee",wheat:"f5deb3",white:"fff",whitesmoke:"f5f5f5",yellow:"ff0",yellowgreen:"9acd32"},C=c.hexNames=function(t){var e={};for(var r in t)t.hasOwnProperty(r)&&(e[t[r]]=r);return e}(S);function E(t){return t=parseFloat(t),(isNaN(t)||t<0||t>1)&&(t=1),t}function L(e,r){(function(t){return"string"==typeof t&&-1!=t.indexOf(".")&&1===parseFloat(t)})(e)&&(e="100%");var n=function(t){return"string"==typeof t&&-1!=t.indexOf("%")}(e);return e=o(r,s(0,parseFloat(e))),n&&(e=parseInt(e*r,10)/100),t.abs(e-r)<1e-6?1:e%r/parseFloat(r)}function z(t){return o(1,s(0,t))}function P(t){return parseInt(t,16)}function D(t){return 1==t.length?"0"+t:""+t}function O(t){return t<=1&&(t=100*t+"%"),t}function I(e){return t.round(255*parseFloat(e)).toString(16)}function R(t){return P(t)/255}var B,F,N,j=(F="[\\s|\\(]+("+(B="(?:[-\\+]?\\d*\\.\\d+%?)|(?:[-\\+]?\\d+%?)")+")[,|\\s]+("+B+")[,|\\s]+("+B+")\\s*\\)?",N="[\\s|\\(]+("+B+")[,|\\s]+("+B+")[,|\\s]+("+B+")[,|\\s]+("+B+")\\s*\\)?",{CSS_UNIT:new RegExp(B),rgb:new RegExp("rgb"+F),rgba:new RegExp("rgba"+N),hsl:new RegExp("hsl"+F),hsla:new RegExp("hsla"+N),hsv:new RegExp("hsv"+F),hsva:new RegExp("hsva"+N),hex3:/^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex6:/^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,hex4:/^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,hex8:/^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/});function V(t){return!!j.CSS_UNIT.exec(t)}void 0!==e&&e.exports?e.exports=c:window.tinycolor=c}(Math)},{}],474:[function(t,e,r){"use strict";function n(t){if(t instanceof Float32Array)return t;if("number"==typeof t)return new Float32Array([t])[0];var e=new Float32Array(t);return e.set(t),e}e.exports=n,e.exports.float32=e.exports.float=n,e.exports.fract32=e.exports.fract=function(t){if("number"==typeof t)return n(t-n(t));for(var e=n(t),r=0,i=e.length;rf&&(f=l[0]),l[1]h&&(h=l[1])}function i(t){switch(t.type){case"GeometryCollection":t.geometries.forEach(i);break;case"Point":n(t.coordinates);break;case"MultiPoint":t.coordinates.forEach(n)}}if(!e){var a,o,s=r(t),l=new Array(2),c=1/0,u=c,f=-c,h=-c;for(o in t.arcs.forEach(function(t){for(var e=-1,r=t.length;++ef&&(f=l[0]),l[1]h&&(h=l[1])}),t.objects)i(t.objects[o]);e=t.bbox=[c,u,f,h]}return e},i=function(t,e){for(var r,n=t.length,i=n-e;i<--n;)r=t[i],t[i++]=t[n],t[n]=r};function a(t,e){var r=e.id,n=e.bbox,i=null==e.properties?{}:e.properties,a=o(t,e);return null==r&&null==n?{type:"Feature",properties:i,geometry:a}:null==n?{type:"Feature",id:r,properties:i,geometry:a}:{type:"Feature",id:r,bbox:n,properties:i,geometry:a}}function o(t,e){var n=r(t),a=t.arcs;function o(t,e){e.length&&e.pop();for(var r=a[t<0?~t:t],o=0,s=r.length;o1)n=function(t,e,r){var n,i=[],a=[];function o(t){var e=t<0?~t:t;(a[e]||(a[e]=[])).push({i:t,g:n})}function s(t){t.forEach(o)}function l(t){t.forEach(s)}return function t(e){switch(n=e,e.type){case"GeometryCollection":e.geometries.forEach(t);break;case"LineString":s(e.arcs);break;case"MultiLineString":case"Polygon":l(e.arcs);break;case"MultiPolygon":e.arcs.forEach(l)}}(e),a.forEach(null==r?function(t){i.push(t[0].i)}:function(t){r(t[0].g,t[t.length-1].g)&&i.push(t[0].i)}),i}(0,e,r);else for(i=0,n=new Array(a=t.arcs.length);i1)for(var a,o,c=1,u=l(i[0]);cu&&(o=i[0],i[0]=i[c],i[c]=o,u=a);return i})}}var u=function(t,e){for(var r=0,n=t.length;r>>1;t[i]=2))throw new Error("n must be \u22652");if(t.transform)throw new Error("already quantized");var r,i=n(t),a=i[0],o=(i[2]-a)/(e-1)||1,s=i[1],l=(i[3]-s)/(e-1)||1;function c(t){t[0]=Math.round((t[0]-a)/o),t[1]=Math.round((t[1]-s)/l)}function u(t){switch(t.type){case"GeometryCollection":t.geometries.forEach(u);break;case"Point":c(t.coordinates);break;case"MultiPoint":t.coordinates.forEach(c)}}for(r in t.arcs.forEach(function(t){for(var e,r,n,i=1,c=1,u=t.length,f=t[0],h=f[0]=Math.round((f[0]-a)/o),p=f[1]=Math.round((f[1]-s)/l);iMath.max(r,n)?i[2]=1:r>Math.max(e,n)?i[0]=1:i[1]=1;for(var a=0,o=0,l=0;l<3;++l)a+=t[l]*t[l],o+=i[l]*t[l];for(l=0;l<3;++l)i[l]-=o/a*t[l];return s(i,i),i}function h(t,e,r,i,a,o,s,l){this.center=n(r),this.up=n(i),this.right=n(a),this.radius=n([o]),this.angle=n([s,l]),this.angle.bounds=[[-1/0,-Math.PI/2],[1/0,Math.PI/2]],this.setDistanceLimits(t,e),this.computedCenter=this.center.curve(0),this.computedUp=this.up.curve(0),this.computedRight=this.right.curve(0),this.computedRadius=this.radius.curve(0),this.computedAngle=this.angle.curve(0),this.computedToward=[0,0,0],this.computedEye=[0,0,0],this.computedMatrix=new Array(16);for(var c=0;c<16;++c)this.computedMatrix[c]=.5;this.recalcMatrix(0)}var p=h.prototype;p.setDistanceLimits=function(t,e){t=t>0?Math.log(t):-1/0,e=e>0?Math.log(e):1/0,e=Math.max(e,t),this.radius.bounds[0][0]=t,this.radius.bounds[1][0]=e},p.getDistanceLimits=function(t){var e=this.radius.bounds[0];return t?(t[0]=Math.exp(e[0][0]),t[1]=Math.exp(e[1][0]),t):[Math.exp(e[0][0]),Math.exp(e[1][0])]},p.recalcMatrix=function(t){this.center.curve(t),this.up.curve(t),this.right.curve(t),this.radius.curve(t),this.angle.curve(t);for(var e=this.computedUp,r=this.computedRight,n=0,i=0,a=0;a<3;++a)i+=e[a]*r[a],n+=e[a]*e[a];var l=Math.sqrt(n),u=0;for(a=0;a<3;++a)r[a]-=e[a]*i/n,u+=r[a]*r[a],e[a]/=l;var f=Math.sqrt(u);for(a=0;a<3;++a)r[a]/=f;var h=this.computedToward;o(h,e,r),s(h,h);var p=Math.exp(this.computedRadius[0]),d=this.computedAngle[0],g=this.computedAngle[1],m=Math.cos(d),v=Math.sin(d),y=Math.cos(g),x=Math.sin(g),b=this.computedCenter,_=m*y,w=v*y,k=x,M=-m*x,A=-v*x,T=y,S=this.computedEye,C=this.computedMatrix;for(a=0;a<3;++a){var E=_*r[a]+w*h[a]+k*e[a];C[4*a+1]=M*r[a]+A*h[a]+T*e[a],C[4*a+2]=E,C[4*a+3]=0}var L=C[1],z=C[5],P=C[9],D=C[2],O=C[6],I=C[10],R=z*I-P*O,B=P*D-L*I,F=L*O-z*D,N=c(R,B,F);R/=N,B/=N,F/=N,C[0]=R,C[4]=B,C[8]=F;for(a=0;a<3;++a)S[a]=b[a]+C[2+4*a]*p;for(a=0;a<3;++a){u=0;for(var j=0;j<3;++j)u+=C[a+4*j]*S[j];C[12+a]=-u}C[15]=1},p.getMatrix=function(t,e){this.recalcMatrix(t);var r=this.computedMatrix;if(e){for(var n=0;n<16;++n)e[n]=r[n];return e}return r};var d=[0,0,0];p.rotate=function(t,e,r,n){if(this.angle.move(t,e,r),n){this.recalcMatrix(t);var i=this.computedMatrix;d[0]=i[2],d[1]=i[6],d[2]=i[10];for(var o=this.computedUp,s=this.computedRight,l=this.computedToward,c=0;c<3;++c)i[4*c]=o[c],i[4*c+1]=s[c],i[4*c+2]=l[c];a(i,i,n,d);for(c=0;c<3;++c)o[c]=i[4*c],s[c]=i[4*c+1];this.up.set(t,o[0],o[1],o[2]),this.right.set(t,s[0],s[1],s[2])}},p.pan=function(t,e,r,n){e=e||0,r=r||0,n=n||0,this.recalcMatrix(t);var i=this.computedMatrix,a=(Math.exp(this.computedRadius[0]),i[1]),o=i[5],s=i[9],l=c(a,o,s);a/=l,o/=l,s/=l;var u=i[0],f=i[4],h=i[8],p=u*a+f*o+h*s,d=c(u-=a*p,f-=o*p,h-=s*p),g=(u/=d)*e+a*r,m=(f/=d)*e+o*r,v=(h/=d)*e+s*r;this.center.move(t,g,m,v);var y=Math.exp(this.computedRadius[0]);y=Math.max(1e-4,y+n),this.radius.set(t,Math.log(y))},p.translate=function(t,e,r,n){this.center.move(t,e||0,r||0,n||0)},p.setMatrix=function(t,e,r,n){var a=1;"number"==typeof r&&(a=0|r),(a<0||a>3)&&(a=1);var o=(a+2)%3;e||(this.recalcMatrix(t),e=this.computedMatrix);var s=e[a],l=e[a+4],f=e[a+8];if(n){var h=Math.abs(s),p=Math.abs(l),d=Math.abs(f),g=Math.max(h,p,d);h===g?(s=s<0?-1:1,l=f=0):d===g?(f=f<0?-1:1,s=l=0):(l=l<0?-1:1,s=f=0)}else{var m=c(s,l,f);s/=m,l/=m,f/=m}var v,y,x=e[o],b=e[o+4],_=e[o+8],w=x*s+b*l+_*f,k=c(x-=s*w,b-=l*w,_-=f*w),M=l*(_/=k)-f*(b/=k),A=f*(x/=k)-s*_,T=s*b-l*x,S=c(M,A,T);if(M/=S,A/=S,T/=S,this.center.jump(t,H,G,W),this.radius.idle(t),this.up.jump(t,s,l,f),this.right.jump(t,x,b,_),2===a){var C=e[1],E=e[5],L=e[9],z=C*x+E*b+L*_,P=C*M+E*A+L*T;v=R<0?-Math.PI/2:Math.PI/2,y=Math.atan2(P,z)}else{var D=e[2],O=e[6],I=e[10],R=D*s+O*l+I*f,B=D*x+O*b+I*_,F=D*M+O*A+I*T;v=Math.asin(u(R)),y=Math.atan2(F,B)}this.angle.jump(t,y,v),this.recalcMatrix(t);var N=e[2],j=e[6],V=e[10],U=this.computedMatrix;i(U,e);var q=U[15],H=U[12]/q,G=U[13]/q,W=U[14]/q,Y=Math.exp(this.computedRadius[0]);this.center.jump(t,H-N*Y,G-j*Y,W-V*Y)},p.lastT=function(){return Math.max(this.center.lastT(),this.up.lastT(),this.right.lastT(),this.radius.lastT(),this.angle.lastT())},p.idle=function(t){this.center.idle(t),this.up.idle(t),this.right.idle(t),this.radius.idle(t),this.angle.idle(t)},p.flush=function(t){this.center.flush(t),this.up.flush(t),this.right.flush(t),this.radius.flush(t),this.angle.flush(t)},p.setDistance=function(t,e){e>0&&this.radius.set(t,Math.log(e))},p.lookAt=function(t,e,r,n){this.recalcMatrix(t),e=e||this.computedEye,r=r||this.computedCenter;var i=(n=n||this.computedUp)[0],a=n[1],o=n[2],s=c(i,a,o);if(!(s<1e-6)){i/=s,a/=s,o/=s;var l=e[0]-r[0],f=e[1]-r[1],h=e[2]-r[2],p=c(l,f,h);if(!(p<1e-6)){l/=p,f/=p,h/=p;var d=this.computedRight,g=d[0],m=d[1],v=d[2],y=i*g+a*m+o*v,x=c(g-=y*i,m-=y*a,v-=y*o);if(!(x<.01&&(x=c(g=a*h-o*f,m=o*l-i*h,v=i*f-a*l))<1e-6)){g/=x,m/=x,v/=x,this.up.set(t,i,a,o),this.right.set(t,g,m,v),this.center.set(t,r[0],r[1],r[2]),this.radius.set(t,Math.log(p));var b=a*v-o*m,_=o*g-i*v,w=i*m-a*g,k=c(b,_,w),M=i*l+a*f+o*h,A=g*l+m*f+v*h,T=(b/=k)*l+(_/=k)*f+(w/=k)*h,S=Math.asin(u(M)),C=Math.atan2(T,A),E=this.angle._state,L=E[E.length-1],z=E[E.length-2];L%=2*Math.PI;var P=Math.abs(L+2*Math.PI-C),D=Math.abs(L-C),O=Math.abs(L-2*Math.PI-C);P0?r.pop():new ArrayBuffer(t)}function h(t){return new Uint8Array(f(t),0,t)}function p(t){return new Uint16Array(f(2*t),0,t)}function d(t){return new Uint32Array(f(4*t),0,t)}function g(t){return new Int8Array(f(t),0,t)}function m(t){return new Int16Array(f(2*t),0,t)}function v(t){return new Int32Array(f(4*t),0,t)}function y(t){return new Float32Array(f(4*t),0,t)}function x(t){return new Float64Array(f(8*t),0,t)}function b(t){return o?new Uint8ClampedArray(f(t),0,t):h(t)}function _(t){return new DataView(f(t),0,t)}function w(t){t=i.nextPow2(t);var e=i.log2(t),r=c[e];return r.length>0?r.pop():new n(t)}r.free=function(t){if(n.isBuffer(t))c[i.log2(t.length)].push(t);else{if("[object ArrayBuffer]"!==Object.prototype.toString.call(t)&&(t=t.buffer),!t)return;var e=t.length||t.byteLength,r=0|i.log2(e);l[r].push(t)}},r.freeUint8=r.freeUint16=r.freeUint32=r.freeInt8=r.freeInt16=r.freeInt32=r.freeFloat32=r.freeFloat=r.freeFloat64=r.freeDouble=r.freeUint8Clamped=r.freeDataView=function(t){u(t.buffer)},r.freeArrayBuffer=u,r.freeBuffer=function(t){c[i.log2(t.length)].push(t)},r.malloc=function(t,e){if(void 0===e||"arraybuffer"===e)return f(t);switch(e){case"uint8":return h(t);case"uint16":return p(t);case"uint32":return d(t);case"int8":return g(t);case"int16":return m(t);case"int32":return v(t);case"float":case"float32":return y(t);case"double":case"float64":return x(t);case"uint8_clamped":return b(t);case"buffer":return w(t);case"data":case"dataview":return _(t);default:return null}return null},r.mallocArrayBuffer=f,r.mallocUint8=h,r.mallocUint16=p,r.mallocUint32=d,r.mallocInt8=g,r.mallocInt16=m,r.mallocInt32=v,r.mallocFloat32=r.mallocFloat=y,r.mallocFloat64=r.mallocDouble=x,r.mallocUint8Clamped=b,r.mallocDataView=_,r.mallocBuffer=w,r.clearCache=function(){for(var t=0;t<32;++t)s.UINT8[t].length=0,s.UINT16[t].length=0,s.UINT32[t].length=0,s.INT8[t].length=0,s.INT16[t].length=0,s.INT32[t].length=0,s.FLOAT[t].length=0,s.DOUBLE[t].length=0,s.UINT8C[t].length=0,l[t].length=0,c[t].length=0}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{},t("buffer").Buffer)},{"bit-twiddle":74,buffer:86,dup:137}],482:[function(t,e,r){"use strict";"use restrict";function n(t){this.roots=new Array(t),this.ranks=new Array(t);for(var e=0;e=a)return t;switch(t){case"%s":return String(n[r++]);case"%d":return Number(n[r++]);case"%j":try{return JSON.stringify(n[r++])}catch(t){return"[Circular]"}default:return t}}),l=n[r];r=3&&(n.depth=arguments[2]),arguments.length>=4&&(n.colors=arguments[3]),d(e)?n.showHidden=e:e&&r._extend(n,e),y(n.showHidden)&&(n.showHidden=!1),y(n.depth)&&(n.depth=2),y(n.colors)&&(n.colors=!1),y(n.customInspect)&&(n.customInspect=!0),n.colors&&(n.stylize=l),u(n,t,n.depth)}function l(t,e){var r=s.styles[e];return r?"\x1b["+s.colors[r][0]+"m"+t+"\x1b["+s.colors[r][1]+"m":t}function c(t,e){return t}function u(t,e,n){if(t.customInspect&&e&&k(e.inspect)&&e.inspect!==r.inspect&&(!e.constructor||e.constructor.prototype!==e)){var i=e.inspect(n,t);return v(i)||(i=u(t,i,n)),i}var a=function(t,e){if(y(e))return t.stylize("undefined","undefined");if(v(e)){var r="'"+JSON.stringify(e).replace(/^"|"$/g,"").replace(/'/g,"\\'").replace(/\\"/g,'"')+"'";return t.stylize(r,"string")}if(m(e))return t.stylize(""+e,"number");if(d(e))return t.stylize(""+e,"boolean");if(g(e))return t.stylize("null","null")}(t,e);if(a)return a;var o=Object.keys(e),s=function(t){var e={};return t.forEach(function(t,r){e[t]=!0}),e}(o);if(t.showHidden&&(o=Object.getOwnPropertyNames(e)),w(e)&&(o.indexOf("message")>=0||o.indexOf("description")>=0))return f(e);if(0===o.length){if(k(e)){var l=e.name?": "+e.name:"";return t.stylize("[Function"+l+"]","special")}if(x(e))return t.stylize(RegExp.prototype.toString.call(e),"regexp");if(_(e))return t.stylize(Date.prototype.toString.call(e),"date");if(w(e))return f(e)}var c,b="",M=!1,A=["{","}"];(p(e)&&(M=!0,A=["[","]"]),k(e))&&(b=" [Function"+(e.name?": "+e.name:"")+"]");return x(e)&&(b=" "+RegExp.prototype.toString.call(e)),_(e)&&(b=" "+Date.prototype.toUTCString.call(e)),w(e)&&(b=" "+f(e)),0!==o.length||M&&0!=e.length?n<0?x(e)?t.stylize(RegExp.prototype.toString.call(e),"regexp"):t.stylize("[Object]","special"):(t.seen.push(e),c=M?function(t,e,r,n,i){for(var a=[],o=0,s=e.length;o=0&&0,t+e.replace(/\u001b\[\d\d?m/g,"").length+1},0)>60)return r[0]+(""===e?"":e+"\n ")+" "+t.join(",\n ")+" "+r[1];return r[0]+e+" "+t.join(", ")+" "+r[1]}(c,b,A)):A[0]+b+A[1]}function f(t){return"["+Error.prototype.toString.call(t)+"]"}function h(t,e,r,n,i,a){var o,s,l;if((l=Object.getOwnPropertyDescriptor(e,i)||{value:e[i]}).get?s=l.set?t.stylize("[Getter/Setter]","special"):t.stylize("[Getter]","special"):l.set&&(s=t.stylize("[Setter]","special")),S(n,i)||(o="["+i+"]"),s||(t.seen.indexOf(l.value)<0?(s=g(r)?u(t,l.value,null):u(t,l.value,r-1)).indexOf("\n")>-1&&(s=a?s.split("\n").map(function(t){return" "+t}).join("\n").substr(2):"\n"+s.split("\n").map(function(t){return" "+t}).join("\n")):s=t.stylize("[Circular]","special")),y(o)){if(a&&i.match(/^\d+$/))return s;(o=JSON.stringify(""+i)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)?(o=o.substr(1,o.length-2),o=t.stylize(o,"name")):(o=o.replace(/'/g,"\\'").replace(/\\"/g,'"').replace(/(^"|"$)/g,"'"),o=t.stylize(o,"string"))}return o+": "+s}function p(t){return Array.isArray(t)}function d(t){return"boolean"==typeof t}function g(t){return null===t}function m(t){return"number"==typeof t}function v(t){return"string"==typeof t}function y(t){return void 0===t}function x(t){return b(t)&&"[object RegExp]"===M(t)}function b(t){return"object"==typeof t&&null!==t}function _(t){return b(t)&&"[object Date]"===M(t)}function w(t){return b(t)&&("[object Error]"===M(t)||t instanceof Error)}function k(t){return"function"==typeof t}function M(t){return Object.prototype.toString.call(t)}function A(t){return t<10?"0"+t.toString(10):t.toString(10)}r.debuglog=function(t){if(y(a)&&(a=e.env.NODE_DEBUG||""),t=t.toUpperCase(),!o[t])if(new RegExp("\\b"+t+"\\b","i").test(a)){var n=e.pid;o[t]=function(){var e=r.format.apply(r,arguments);console.error("%s %d: %s",t,n,e)}}else o[t]=function(){};return o[t]},r.inspect=s,s.colors={bold:[1,22],italic:[3,23],underline:[4,24],inverse:[7,27],white:[37,39],grey:[90,39],black:[30,39],blue:[34,39],cyan:[36,39],green:[32,39],magenta:[35,39],red:[31,39],yellow:[33,39]},s.styles={special:"cyan",number:"yellow",boolean:"yellow",undefined:"grey",null:"bold",string:"green",date:"magenta",regexp:"red"},r.isArray=p,r.isBoolean=d,r.isNull=g,r.isNullOrUndefined=function(t){return null==t},r.isNumber=m,r.isString=v,r.isSymbol=function(t){return"symbol"==typeof t},r.isUndefined=y,r.isRegExp=x,r.isObject=b,r.isDate=_,r.isError=w,r.isFunction=k,r.isPrimitive=function(t){return null===t||"boolean"==typeof t||"number"==typeof t||"string"==typeof t||"symbol"==typeof t||void 0===t},r.isBuffer=t("./support/isBuffer");var T=["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"];function S(t,e){return Object.prototype.hasOwnProperty.call(t,e)}r.log=function(){var t,e;console.log("%s - %s",(t=new Date,e=[A(t.getHours()),A(t.getMinutes()),A(t.getSeconds())].join(":"),[t.getDate(),T[t.getMonth()],e].join(" ")),r.format.apply(r,arguments))},r.inherits=t("inherits"),r._extend=function(t,e){if(!e||!b(e))return t;for(var r=Object.keys(e),n=r.length;n--;)t[r[n]]=e[r[n]];return t}}).call(this,t("_process"),"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{"./support/isBuffer":486,_process:424,inherits:485}],488:[function(t,e,r){"use strict";e.exports=function(t,e){"object"==typeof e&&null!==e||(e={});return n(t,e.canvas||i,e.context||a,e)};var n=t("./lib/vtext"),i=null,a=null;"undefined"!=typeof document&&((i=document.createElement("canvas")).width=8192,i.height=1024,a=i.getContext("2d"))},{"./lib/vtext":489}],489:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var a=n.size||64,o=n.font||"normal";return r.font=a+"px "+o,r.textAlign="start",r.textBaseline="alphabetic",r.direction="ltr",f(function(t,e,r,n){var a=0|Math.ceil(e.measureText(r).width+2*n);if(a>8192)throw new Error("vectorize-text: String too long (sorry, this will get fixed later)");var o=3*n;t.height=0?e[a]:i})},has___:{value:x(function(e){var n=y(e);return n?r in n:t.indexOf(e)>=0})},set___:{value:x(function(n,i){var a,o=y(n);return o?o[r]=i:(a=t.indexOf(n))>=0?e[a]=i:(a=t.length,e[a]=i,t[a]=n),this})},delete___:{value:x(function(n){var i,a,o=y(n);return o?r in o&&delete o[r]:!((i=t.indexOf(n))<0||(a=t.length-1,t[i]=void 0,e[i]=e[a],t[i]=t[a],t.length=a,e.length=a,0))})}})};g.prototype=Object.create(Object.prototype,{get:{value:function(t,e){return this.get___(t,e)},writable:!0,configurable:!0},has:{value:function(t){return this.has___(t)},writable:!0,configurable:!0},set:{value:function(t,e){return this.set___(t,e)},writable:!0,configurable:!0},delete:{value:function(t){return this.delete___(t)},writable:!0,configurable:!0}}),"function"==typeof r?function(){function n(){this instanceof g||b();var e,n=new r,i=void 0,a=!1;return e=t?function(t,e){return n.set(t,e),n.has(t)||(i||(i=new g),i.set(t,e)),this}:function(t,e){if(a)try{n.set(t,e)}catch(r){i||(i=new g),i.set___(t,e)}else n.set(t,e);return this},Object.create(g.prototype,{get___:{value:x(function(t,e){return i?n.has(t)?n.get(t):i.get___(t,e):n.get(t,e)})},has___:{value:x(function(t){return n.has(t)||!!i&&i.has___(t)})},set___:{value:x(e)},delete___:{value:x(function(t){var e=!!n.delete(t);return i&&i.delete___(t)||e})},permitHostObjects___:{value:x(function(t){if(t!==m)throw new Error("bogus call to permitHostObjects___");a=!0})}})}t&&"undefined"!=typeof Proxy&&(Proxy=void 0),n.prototype=g.prototype,e.exports=n,Object.defineProperty(WeakMap.prototype,"constructor",{value:WeakMap,enumerable:!1,configurable:!0,writable:!0})}():("undefined"!=typeof Proxy&&(Proxy=void 0),e.exports=g)}function m(t){t.permitHostObjects___&&t.permitHostObjects___(m)}function v(t){return!(t.substr(0,l.length)==l&&"___"===t.substr(t.length-3))}function y(t){if(t!==Object(t))throw new TypeError("Not an object: "+t);var e=t[c];if(e&&e.key===t)return e;if(s(t)){e={key:t};try{return o(t,c,{value:e,writable:!1,enumerable:!1,configurable:!1}),e}catch(t){return}}}function x(t){return t.prototype=null,Object.freeze(t)}function b(){p||"undefined"==typeof console||(p=!0,console.warn("WeakMap should be invoked as new WeakMap(), not WeakMap(). This will be an error in the future."))}}()},{}],491:[function(t,e,r){var n=t("./hidden-store.js");e.exports=function(){var t={};return function(e){if(("object"!=typeof e||null===e)&&"function"!=typeof e)throw new Error("Weakmap-shim: Key must be object");var r=e.valueOf(t);return r&&r.identity===t?r:n(e,t)}}},{"./hidden-store.js":492}],492:[function(t,e,r){e.exports=function(t,e){var r={identity:e},n=t.valueOf;return Object.defineProperty(t,"valueOf",{value:function(t){return t!==e?n.apply(this,arguments):r},writable:!0}),r}},{}],493:[function(t,e,r){var n=t("./create-store.js");e.exports=function(){var t=n();return{get:function(e,r){var n=t(e);return n.hasOwnProperty("value")?n.value:r},set:function(e,r){return t(e).value=r,this},has:function(e){return"value"in t(e)},delete:function(e){return delete t(e).value}}}},{"./create-store.js":491}],494:[function(t,e,r){var n=t("get-canvas-context");e.exports=function(t){return n("webgl",t)}},{"get-canvas-context":202}],495:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Chinese",jdEpoch:1721425.5,hasYearZero:!1,minMonth:0,firstMonth:0,minDay:1,regionalOptions:{"":{name:"Chinese",epochs:["BEC","EC"],monthNumbers:function(t,e){if("string"==typeof t){var r=t.match(l);return r?r[0]:""}var n=this._validateYear(t),i=t.month(),a=""+this.toChineseMonth(n,i);return e&&a.length<2&&(a="0"+a),this.isIntercalaryMonth(n,i)&&(a+="i"),a},monthNames:function(t){if("string"==typeof t){var e=t.match(c);return e?e[0]:""}var r=this._validateYear(t),n=t.month(),i=["\u4e00\u6708","\u4e8c\u6708","\u4e09\u6708","\u56db\u6708","\u4e94\u6708","\u516d\u6708","\u4e03\u6708","\u516b\u6708","\u4e5d\u6708","\u5341\u6708","\u5341\u4e00\u6708","\u5341\u4e8c\u6708"][this.toChineseMonth(r,n)-1];return this.isIntercalaryMonth(r,n)&&(i="\u95f0"+i),i},monthNamesShort:function(t){if("string"==typeof t){var e=t.match(u);return e?e[0]:""}var r=this._validateYear(t),n=t.month(),i=["\u4e00","\u4e8c","\u4e09","\u56db","\u4e94","\u516d","\u4e03","\u516b","\u4e5d","\u5341","\u5341\u4e00","\u5341\u4e8c"][this.toChineseMonth(r,n)-1];return this.isIntercalaryMonth(r,n)&&(i="\u95f0"+i),i},parseMonth:function(t,e){t=this._validateYear(t);var r,n=parseInt(e);if(isNaN(n))"\u95f0"===e[0]&&(r=!0,e=e.substring(1)),"\u6708"===e[e.length-1]&&(e=e.substring(0,e.length-1)),n=1+["\u4e00","\u4e8c","\u4e09","\u56db","\u4e94","\u516d","\u4e03","\u516b","\u4e5d","\u5341","\u5341\u4e00","\u5341\u4e8c"].indexOf(e);else{var i=e[e.length-1];r="i"===i||"I"===i}return this.toMonthIndex(t,n,r)},dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:1,isRTL:!1}},_validateYear:function(t,e){if(t.year&&(t=t.year()),"number"!=typeof t||t<1888||t>2111)throw e.replace(/\{0\}/,this.local.name);return t},toMonthIndex:function(t,e,r){var i=this.intercalaryMonth(t);if(r&&e!==i||e<1||e>12)throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return i?!r&&e<=i?e-1:e:e-1},toChineseMonth:function(t,e){t.year&&(e=(t=t.year()).month());var r=this.intercalaryMonth(t);if(e<0||e>(r?12:11))throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return r?e>13},isIntercalaryMonth:function(t,e){t.year&&(e=(t=t.year()).month());var r=this.intercalaryMonth(t);return!!r&&r===e},leapYear:function(t){return 0!==this.intercalaryMonth(t)},weekOfYear:function(t,e,r){var i,o=this._validateYear(t,n.local.invalidyear),s=h[o-h[0]],l=s>>9&4095,c=s>>5&15,u=31&s;(i=a.newDate(l,c,u)).add(4-(i.dayOfWeek()||7),"d");var f=this.toJD(t,e,r)-i.toJD();return 1+Math.floor(f/7)},monthsInYear:function(t){return this.leapYear(t)?13:12},daysInMonth:function(t,e){t.year&&(e=t.month(),t=t.year()),t=this._validateYear(t);var r=f[t-f[0]];if(e>(r>>13?12:11))throw n.local.invalidMonth.replace(/\{0\}/,this.local.name);return r&1<<12-e?30:29},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,s,r,n.local.invalidDate);t=this._validateYear(i.year()),e=i.month(),r=i.day();var o=this.isIntercalaryMonth(t,e),s=this.toChineseMonth(t,e),l=function(t,e,r,n,i){var a,o,s;if("object"==typeof t)o=t,a=e||{};else{var l="number"==typeof t&&t>=1888&&t<=2111;if(!l)throw new Error("Lunar year outside range 1888-2111");var c="number"==typeof e&&e>=1&&e<=12;if(!c)throw new Error("Lunar month outside range 1 - 12");var u,p="number"==typeof r&&r>=1&&r<=30;if(!p)throw new Error("Lunar day outside range 1 - 30");"object"==typeof n?(u=!1,a=n):(u=!!n,a=i||{}),o={year:t,month:e,day:r,isIntercalary:u}}s=o.day-1;var d,g=f[o.year-f[0]],m=g>>13;d=m?o.month>m?o.month:o.isIntercalary?o.month:o.month-1:o.month-1;for(var v=0;v>9&4095,(x>>5&15)-1,(31&x)+s);return a.year=b.getFullYear(),a.month=1+b.getMonth(),a.day=b.getDate(),a}(t,s,r,o);return a.toJD(l.year,l.month,l.day)},fromJD:function(t){var e=a.fromJD(t),r=function(t,e,r,n){var i,a;if("object"==typeof t)i=t,a=e||{};else{var o="number"==typeof t&&t>=1888&&t<=2111;if(!o)throw new Error("Solar year outside range 1888-2111");var s="number"==typeof e&&e>=1&&e<=12;if(!s)throw new Error("Solar month outside range 1 - 12");var l="number"==typeof r&&r>=1&&r<=31;if(!l)throw new Error("Solar day outside range 1 - 31");i={year:t,month:e,day:r},a=n||{}}var c=h[i.year-h[0]],u=i.year<<9|i.month<<5|i.day;a.year=u>=c?i.year:i.year-1,c=h[a.year-h[0]];var p,d=new Date(c>>9&4095,(c>>5&15)-1,31&c),g=new Date(i.year,i.month-1,i.day);p=Math.round((g-d)/864e5);var m,v=f[a.year-f[0]];for(m=0;m<13;m++){var y=v&1<<12-m?30:29;if(p>13;!x||m=2&&n<=6},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return{century:o[Math.floor((i.year()-1)/100)+1]||""}},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year()+(i.year()<0?1:0),e=i.month(),(r=i.day())+(e>1?16:0)+(e>2?32*(e-2):0)+400*(t-1)+this.jdEpoch-1},fromJD:function(t){t=Math.floor(t+.5)-Math.floor(this.jdEpoch)-1;var e=Math.floor(t/400)+1;t-=400*(e-1),t+=t>15?16:0;var r=Math.floor(t/32)+1,n=t-32*(r-1)+1;return this.newDate(e<=0?e-1:e,r,n)}});var o={20:"Fruitbat",21:"Anchovy"};n.calendars.discworld=a},{"../main":509,"object-assign":397}],498:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Ethiopian",jdEpoch:1724220.5,daysPerMonth:[30,30,30,30,30,30,30,30,30,30,30,30,5],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Ethiopian",epochs:["BEE","EE"],monthNames:["Meskerem","Tikemet","Hidar","Tahesas","Tir","Yekatit","Megabit","Miazia","Genbot","Sene","Hamle","Nehase","Pagume"],monthNamesShort:["Mes","Tik","Hid","Tah","Tir","Yek","Meg","Mia","Gen","Sen","Ham","Neh","Pag"],dayNames:["Ehud","Segno","Maksegno","Irob","Hamus","Arb","Kidame"],dayNamesShort:["Ehu","Seg","Mak","Iro","Ham","Arb","Kid"],dayNamesMin:["Eh","Se","Ma","Ir","Ha","Ar","Ki"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return(t=e.year()+(e.year()<0?1:0))%4==3||t%4==-1},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear||n.regionalOptions[""].invalidYear),13},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(13===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return(t=i.year())<0&&t++,i.day()+30*(i.month()-1)+365*(t-1)+Math.floor(t/4)+this.jdEpoch-1},fromJD:function(t){var e=Math.floor(t)+.5-this.jdEpoch,r=Math.floor((e-Math.floor((e+366)/1461))/365)+1;r<=0&&r--,e=Math.floor(t)+.5-this.newDate(r,1,1).toJD();var n=Math.floor(e/30)+1,i=e-30*(n-1)+1;return this.newDate(r,n,i)}}),n.calendars.ethiopian=a},{"../main":509,"object-assign":397}],499:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}function o(t,e){return t-e*Math.floor(t/e)}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Hebrew",jdEpoch:347995.5,daysPerMonth:[30,29,30,29,30,29,30,29,30,29,30,29,29],hasYearZero:!1,minMonth:1,firstMonth:7,minDay:1,regionalOptions:{"":{name:"Hebrew",epochs:["BAM","AM"],monthNames:["Nisan","Iyar","Sivan","Tammuz","Av","Elul","Tishrei","Cheshvan","Kislev","Tevet","Shevat","Adar","Adar II"],monthNamesShort:["Nis","Iya","Siv","Tam","Av","Elu","Tis","Che","Kis","Tev","She","Ada","Ad2"],dayNames:["Yom Rishon","Yom Sheni","Yom Shlishi","Yom Revi'i","Yom Chamishi","Yom Shishi","Yom Shabbat"],dayNamesShort:["Ris","She","Shl","Rev","Cha","Shi","Sha"],dayNamesMin:["Ri","She","Shl","Re","Ch","Shi","Sha"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return this._leapYear(e.year())},_leapYear:function(t){return o(7*(t=t<0?t+1:t)+1,19)<7},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),this._leapYear(t.year?t.year():t)?13:12},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){return t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year(),this.toJD(-1===t?1:t+1,7,1)-this.toJD(t,7,1)},daysInMonth:function(t,e){return t.year&&(e=t.month(),t=t.year()),this._validate(t,e,this.minDay,n.local.invalidMonth),12===e&&this.leapYear(t)?30:8===e&&5===o(this.daysInYear(t),10)?30:9===e&&3===o(this.daysInYear(t),10)?29:this.daysPerMonth[e-1]},weekDay:function(t,e,r){return 6!==this.dayOfWeek(t,e,r)},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return{yearType:(this.leapYear(i)?"embolismic":"common")+" "+["deficient","regular","complete"][this.daysInYear(i)%10-3]}},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=t<=0?t+1:t,o=this.jdEpoch+this._delay1(a)+this._delay2(a)+r+1;if(e<7){for(var s=7;s<=this.monthsInYear(t);s++)o+=this.daysInMonth(t,s);for(s=1;s=this.toJD(-1===e?1:e+1,7,1);)e++;for(var r=tthis.toJD(e,r,this.daysInMonth(e,r));)r++;var n=t-this.toJD(e,r,1)+1;return this.newDate(e,r,n)}}),n.calendars.hebrew=a},{"../main":509,"object-assign":397}],500:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Islamic",jdEpoch:1948439.5,daysPerMonth:[30,29,30,29,30,29,30,29,30,29,30,29],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Islamic",epochs:["BH","AH"],monthNames:["Muharram","Safar","Rabi' al-awwal","Rabi' al-thani","Jumada al-awwal","Jumada al-thani","Rajab","Sha'aban","Ramadan","Shawwal","Dhu al-Qi'dah","Dhu al-Hijjah"],monthNamesShort:["Muh","Saf","Rab1","Rab2","Jum1","Jum2","Raj","Sha'","Ram","Shaw","DhuQ","DhuH"],dayNames:["Yawm al-ahad","Yawm al-ithnayn","Yawm ath-thulaathaa'","Yawm al-arbi'aa'","Yawm al-kham\u012bs","Yawm al-jum'a","Yawm as-sabt"],dayNamesShort:["Aha","Ith","Thu","Arb","Kha","Jum","Sab"],dayNamesMin:["Ah","It","Th","Ar","Kh","Ju","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:6,isRTL:!1}},leapYear:function(t){return(11*this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year()+14)%30<11},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){return this.leapYear(t)?355:354},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year(),e=i.month(),t=t<=0?t+1:t,(r=i.day())+Math.ceil(29.5*(e-1))+354*(t-1)+Math.floor((3+11*t)/30)+this.jdEpoch-1},fromJD:function(t){t=Math.floor(t)+.5;var e=Math.floor((30*(t-this.jdEpoch)+10646)/10631);e=e<=0?e-1:e;var r=Math.min(12,Math.ceil((t-29-this.toJD(e,1,1))/29.5)+1),n=t-this.toJD(e,r,1)+1;return this.newDate(e,r,n)}}),n.calendars.islamic=a},{"../main":509,"object-assign":397}],501:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Julian",jdEpoch:1721423.5,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Julian",epochs:["BC","AD"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"mm/dd/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return(t=e.year()<0?e.year()+1:e.year())%4==0},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(4-(n.dayOfWeek()||7),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return t=i.year(),e=i.month(),r=i.day(),t<0&&t++,e<=2&&(t--,e+=12),Math.floor(365.25*(t+4716))+Math.floor(30.6001*(e+1))+r-1524.5},fromJD:function(t){var e=Math.floor(t+.5)+1524,r=Math.floor((e-122.1)/365.25),n=Math.floor(365.25*r),i=Math.floor((e-n)/30.6001),a=i-Math.floor(i<14?1:13),o=r-Math.floor(a>2?4716:4715),s=e-n-Math.floor(30.6001*i);return o<=0&&o--,this.newDate(o,a,s)}}),n.calendars.julian=a},{"../main":509,"object-assign":397}],502:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}function o(t,e){return t-e*Math.floor(t/e)}function s(t,e){return o(t-1,e)+1}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Mayan",jdEpoch:584282.5,hasYearZero:!0,minMonth:0,firstMonth:0,minDay:0,regionalOptions:{"":{name:"Mayan",epochs:["",""],monthNames:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17"],monthNamesShort:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17"],dayNames:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],dayNamesShort:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],dayNamesMin:["0","1","2","3","4","5","6","7","8","9","10","11","12","13","14","15","16","17","18","19"],digits:null,dateFormat:"YYYY.m.d",firstDay:0,isRTL:!1,haabMonths:["Pop","Uo","Zip","Zotz","Tzec","Xul","Yaxkin","Mol","Chen","Yax","Zac","Ceh","Mac","Kankin","Muan","Pax","Kayab","Cumku","Uayeb"],tzolkinMonths:["Imix","Ik","Akbal","Kan","Chicchan","Cimi","Manik","Lamat","Muluc","Oc","Chuen","Eb","Ben","Ix","Men","Cib","Caban","Etznab","Cauac","Ahau"]}},leapYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),!1},formatYear:function(t){t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year();var e=Math.floor(t/400);return t%=400,t+=t<0?400:0,e+"."+Math.floor(t/20)+"."+t%20},forYear:function(t){if((t=t.split(".")).length<3)throw"Invalid Mayan year";for(var e=0,r=0;r19||r>0&&n<0)throw"Invalid Mayan year";e=20*e+n}return e},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),18},weekOfYear:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate),0},daysInYear:function(t){return this._validate(t,this.minMonth,this.minDay,n.local.invalidYear),360},daysInMonth:function(t,e){return this._validate(t,e,this.minDay,n.local.invalidMonth),20},daysInWeek:function(){return 5},dayOfWeek:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate).day()},weekDay:function(t,e,r){return this._validate(t,e,r,n.local.invalidDate),!0},extraInfo:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate).toJD(),a=this._toHaab(i),o=this._toTzolkin(i);return{haabMonthName:this.local.haabMonths[a[0]-1],haabMonth:a[0],haabDay:a[1],tzolkinDayName:this.local.tzolkinMonths[o[0]-1],tzolkinDay:o[0],tzolkinTrecena:o[1]}},_toHaab:function(t){var e=o((t-=this.jdEpoch)+8+340,365);return[Math.floor(e/20)+1,o(e,20)]},_toTzolkin:function(t){return[s((t-=this.jdEpoch)+20,20),s(t+4,13)]},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);return i.day()+20*i.month()+360*i.year()+this.jdEpoch},fromJD:function(t){t=Math.floor(t)+.5-this.jdEpoch;var e=Math.floor(t/360);t%=360,t+=t<0?360:0;var r=Math.floor(t/20),n=t%20;return this.newDate(e,r,n)}}),n.calendars.mayan=a},{"../main":509,"object-assign":397}],503:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar;var o=n.instance("gregorian");i(a.prototype,{name:"Nanakshahi",jdEpoch:2257673.5,daysPerMonth:[31,31,31,31,31,30,30,30,30,30,30,30],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Nanakshahi",epochs:["BN","AN"],monthNames:["Chet","Vaisakh","Jeth","Harh","Sawan","Bhadon","Assu","Katak","Maghar","Poh","Magh","Phagun"],monthNamesShort:["Che","Vai","Jet","Har","Saw","Bha","Ass","Kat","Mgr","Poh","Mgh","Pha"],dayNames:["Somvaar","Mangalvar","Budhvaar","Veervaar","Shukarvaar","Sanicharvaar","Etvaar"],dayNamesShort:["Som","Mangal","Budh","Veer","Shukar","Sanichar","Et"],dayNamesMin:["So","Ma","Bu","Ve","Sh","Sa","Et"],digits:null,dateFormat:"dd-mm-yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear||n.regionalOptions[""].invalidYear);return o.leapYear(e.year()+(e.year()<1?1:0)+1469)},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(1-(n.dayOfWeek()||7),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidMonth);(t=i.year())<0&&t++;for(var a=i.day(),s=1;s=this.toJD(e+1,1,1);)e++;for(var r=t-Math.floor(this.toJD(e,1,1)+.5)+1,n=1;r>this.daysInMonth(e,n);)r-=this.daysInMonth(e,n),n++;return this.newDate(e,n,r)}}),n.calendars.nanakshahi=a},{"../main":509,"object-assign":397}],504:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"Nepali",jdEpoch:1700709.5,daysPerMonth:[31,31,32,32,31,30,30,29,30,29,30,30],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,daysPerYear:365,regionalOptions:{"":{name:"Nepali",epochs:["BBS","ABS"],monthNames:["Baisakh","Jestha","Ashadh","Shrawan","Bhadra","Ashwin","Kartik","Mangsir","Paush","Mangh","Falgun","Chaitra"],monthNamesShort:["Bai","Je","As","Shra","Bha","Ash","Kar","Mang","Pau","Ma","Fal","Chai"],dayNames:["Aaitabaar","Sombaar","Manglbaar","Budhabaar","Bihibaar","Shukrabaar","Shanibaar"],dayNamesShort:["Aaita","Som","Mangl","Budha","Bihi","Shukra","Shani"],dayNamesMin:["Aai","So","Man","Bu","Bi","Shu","Sha"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:1,isRTL:!1}},leapYear:function(t){return this.daysInYear(t)!==this.daysPerYear},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){if(t=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear).year(),void 0===this.NEPALI_CALENDAR_DATA[t])return this.daysPerYear;for(var e=0,r=this.minMonth;r<=12;r++)e+=this.NEPALI_CALENDAR_DATA[t][r];return e},daysInMonth:function(t,e){return t.year&&(e=t.month(),t=t.year()),this._validate(t,e,this.minDay,n.local.invalidMonth),void 0===this.NEPALI_CALENDAR_DATA[t]?this.daysPerMonth[e-1]:this.NEPALI_CALENDAR_DATA[t][e]},weekDay:function(t,e,r){return 6!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=n.instance(),o=0,s=e,l=t;this._createMissingCalendarData(t);var c=t-(s>9||9===s&&r>=this.NEPALI_CALENDAR_DATA[l][0]?56:57);for(9!==e&&(o=r,s--);9!==s;)s<=0&&(s=12,l--),o+=this.NEPALI_CALENDAR_DATA[l][s],s--;return 9===e?(o+=r-this.NEPALI_CALENDAR_DATA[l][0])<0&&(o+=a.daysInYear(c)):o+=this.NEPALI_CALENDAR_DATA[l][9]-this.NEPALI_CALENDAR_DATA[l][0],a.newDate(c,1,1).add(o,"d").toJD()},fromJD:function(t){var e=n.instance().fromJD(t),r=e.year(),i=e.dayOfYear(),a=r+56;this._createMissingCalendarData(a);for(var o=9,s=this.NEPALI_CALENDAR_DATA[a][0],l=this.NEPALI_CALENDAR_DATA[a][o]-s+1;i>l;)++o>12&&(o=1,a++),l+=this.NEPALI_CALENDAR_DATA[a][o];var c=this.NEPALI_CALENDAR_DATA[a][o]-(l-i);return this.newDate(a,o,c)},_createMissingCalendarData:function(t){var e=this.daysPerMonth.slice(0);e.unshift(17);for(var r=t-1;r0?474:473))%2820+474+38)%2816<682},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-(n.dayOfWeek()+1)%7,"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(12===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=i.year(),e=i.month(),r=i.day();var a=t-(t>=0?474:473),s=474+o(a,2820);return r+(e<=7?31*(e-1):30*(e-1)+6)+Math.floor((682*s-110)/2816)+365*(s-1)+1029983*Math.floor(a/2820)+this.jdEpoch-1},fromJD:function(t){var e=(t=Math.floor(t)+.5)-this.toJD(475,1,1),r=Math.floor(e/1029983),n=o(e,1029983),i=2820;if(1029982!==n){var a=Math.floor(n/366),s=o(n,366);i=Math.floor((2134*a+2816*s+2815)/1028522)+a+1}var l=i+2820*r+474;l=l<=0?l-1:l;var c=t-this.toJD(l,1,1)+1,u=c<=186?Math.ceil(c/31):Math.ceil((c-6)/30),f=t-this.toJD(l,u,1)+1;return this.newDate(l,u,f)}}),n.calendars.persian=a,n.calendars.jalali=a},{"../main":509,"object-assign":397}],506:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Taiwan",jdEpoch:2419402.5,yearsOffset:1911,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Taiwan",epochs:["BROC","ROC"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:1,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(e.year());return a.leapYear(t)},weekOfYear:function(t,e,r){var i=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(i.year());return a.weekOfYear(t,i.month(),i.day())},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=this._t2gYear(i.year());return a.toJD(t,i.month(),i.day())},fromJD:function(t){var e=a.fromJD(t),r=this._g2tYear(e.year());return this.newDate(r,e.month(),e.day())},_t2gYear:function(t){return t+this.yearsOffset+(t>=-this.yearsOffset&&t<=-1?1:0)},_g2tYear:function(t){return t-this.yearsOffset-(t>=1&&t<=this.yearsOffset?1:0)}}),n.calendars.taiwan=o},{"../main":509,"object-assign":397}],507:[function(t,e,r){var n=t("../main"),i=t("object-assign"),a=n.instance();function o(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}o.prototype=new n.baseCalendar,i(o.prototype,{name:"Thai",jdEpoch:1523098.5,yearsOffset:543,daysPerMonth:[31,28,31,30,31,30,31,31,30,31,30,31],hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Thai",epochs:["BBE","BE"],monthNames:["January","February","March","April","May","June","July","August","September","October","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],dayNames:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],dayNamesShort:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],dayNamesMin:["Su","Mo","Tu","We","Th","Fr","Sa"],digits:null,dateFormat:"dd/mm/yyyy",firstDay:0,isRTL:!1}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(e.year());return a.leapYear(t)},weekOfYear:function(t,e,r){var i=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);t=this._t2gYear(i.year());return a.weekOfYear(t,i.month(),i.day())},daysInMonth:function(t,e){var r=this._validate(t,e,this.minDay,n.local.invalidMonth);return this.daysPerMonth[r.month()-1]+(2===r.month()&&this.leapYear(r.year())?1:0)},weekDay:function(t,e,r){return(this.dayOfWeek(t,e,r)||7)<6},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate);t=this._t2gYear(i.year());return a.toJD(t,i.month(),i.day())},fromJD:function(t){var e=a.fromJD(t),r=this._g2tYear(e.year());return this.newDate(r,e.month(),e.day())},_t2gYear:function(t){return t-this.yearsOffset-(t>=1&&t<=this.yearsOffset?1:0)},_g2tYear:function(t){return t+this.yearsOffset+(t>=-this.yearsOffset&&t<=-1?1:0)}}),n.calendars.thai=o},{"../main":509,"object-assign":397}],508:[function(t,e,r){var n=t("../main"),i=t("object-assign");function a(t){this.local=this.regionalOptions[t||""]||this.regionalOptions[""]}a.prototype=new n.baseCalendar,i(a.prototype,{name:"UmmAlQura",hasYearZero:!1,minMonth:1,firstMonth:1,minDay:1,regionalOptions:{"":{name:"Umm al-Qura",epochs:["BH","AH"],monthNames:["Al-Muharram","Safar","Rabi' al-awwal","Rabi' Al-Thani","Jumada Al-Awwal","Jumada Al-Thani","Rajab","Sha'aban","Ramadan","Shawwal","Dhu al-Qi'dah","Dhu al-Hijjah"],monthNamesShort:["Muh","Saf","Rab1","Rab2","Jum1","Jum2","Raj","Sha'","Ram","Shaw","DhuQ","DhuH"],dayNames:["Yawm al-Ahad","Yawm al-Ithnain","Yawm al-Thal\u0101th\u0101\u2019","Yawm al-Arba\u2018\u0101\u2019","Yawm al-Kham\u012bs","Yawm al-Jum\u2018a","Yawm al-Sabt"],dayNamesMin:["Ah","Ith","Th","Ar","Kh","Ju","Sa"],digits:null,dateFormat:"yyyy/mm/dd",firstDay:6,isRTL:!0}},leapYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,n.local.invalidYear);return 355===this.daysInYear(e.year())},weekOfYear:function(t,e,r){var n=this.newDate(t,e,r);return n.add(-n.dayOfWeek(),"d"),Math.floor((n.dayOfYear()-1)/7)+1},daysInYear:function(t){for(var e=0,r=1;r<=12;r++)e+=this.daysInMonth(t,r);return e},daysInMonth:function(t,e){for(var r=this._validate(t,e,this.minDay,n.local.invalidMonth).toJD()-24e5+.5,i=0,a=0;ar)return o[i]-o[i-1];i++}return 30},weekDay:function(t,e,r){return 5!==this.dayOfWeek(t,e,r)},toJD:function(t,e,r){var i=this._validate(t,e,r,n.local.invalidDate),a=12*(i.year()-1)+i.month()-15292;return i.day()+o[a-1]-1+24e5-.5},fromJD:function(t){for(var e=t-24e5+.5,r=0,n=0;ne);n++)r++;var i=r+15292,a=Math.floor((i-1)/12),s=a+1,l=i-12*a,c=e-o[r-1]+1;return this.newDate(s,l,c)},isValid:function(t,e,r){var i=n.baseCalendar.prototype.isValid.apply(this,arguments);return i&&(i=(t=null!=t.year?t.year:t)>=1276&&t<=1500),i},_validate:function(t,e,r,i){var a=n.baseCalendar.prototype._validate.apply(this,arguments);if(a.year<1276||a.year>1500)throw i.replace(/\{0\}/,this.local.name);return a}}),n.calendars.ummalqura=a;var o=[20,50,79,109,138,168,197,227,256,286,315,345,374,404,433,463,492,522,551,581,611,641,670,700,729,759,788,818,847,877,906,936,965,995,1024,1054,1083,1113,1142,1172,1201,1231,1260,1290,1320,1350,1379,1409,1438,1468,1497,1527,1556,1586,1615,1645,1674,1704,1733,1763,1792,1822,1851,1881,1910,1940,1969,1999,2028,2058,2087,2117,2146,2176,2205,2235,2264,2294,2323,2353,2383,2413,2442,2472,2501,2531,2560,2590,2619,2649,2678,2708,2737,2767,2796,2826,2855,2885,2914,2944,2973,3003,3032,3062,3091,3121,3150,3180,3209,3239,3268,3298,3327,3357,3386,3416,3446,3476,3505,3535,3564,3594,3623,3653,3682,3712,3741,3771,3800,3830,3859,3889,3918,3948,3977,4007,4036,4066,4095,4125,4155,4185,4214,4244,4273,4303,4332,4362,4391,4421,4450,4480,4509,4539,4568,4598,4627,4657,4686,4716,4745,4775,4804,4834,4863,4893,4922,4952,4981,5011,5040,5070,5099,5129,5158,5188,5218,5248,5277,5307,5336,5366,5395,5425,5454,5484,5513,5543,5572,5602,5631,5661,5690,5720,5749,5779,5808,5838,5867,5897,5926,5956,5985,6015,6044,6074,6103,6133,6162,6192,6221,6251,6281,6311,6340,6370,6399,6429,6458,6488,6517,6547,6576,6606,6635,6665,6694,6724,6753,6783,6812,6842,6871,6901,6930,6960,6989,7019,7048,7078,7107,7137,7166,7196,7225,7255,7284,7314,7344,7374,7403,7433,7462,7492,7521,7551,7580,7610,7639,7669,7698,7728,7757,7787,7816,7846,7875,7905,7934,7964,7993,8023,8053,8083,8112,8142,8171,8201,8230,8260,8289,8319,8348,8378,8407,8437,8466,8496,8525,8555,8584,8614,8643,8673,8702,8732,8761,8791,8821,8850,8880,8909,8938,8968,8997,9027,9056,9086,9115,9145,9175,9205,9234,9264,9293,9322,9352,9381,9410,9440,9470,9499,9529,9559,9589,9618,9648,9677,9706,9736,9765,9794,9824,9853,9883,9913,9943,9972,10002,10032,10061,10090,10120,10149,10178,10208,10237,10267,10297,10326,10356,10386,10415,10445,10474,10504,10533,10562,10592,10621,10651,10680,10710,10740,10770,10799,10829,10858,10888,10917,10947,10976,11005,11035,11064,11094,11124,11153,11183,11213,11242,11272,11301,11331,11360,11389,11419,11448,11478,11507,11537,11567,11596,11626,11655,11685,11715,11744,11774,11803,11832,11862,11891,11921,11950,11980,12010,12039,12069,12099,12128,12158,12187,12216,12246,12275,12304,12334,12364,12393,12423,12453,12483,12512,12542,12571,12600,12630,12659,12688,12718,12747,12777,12807,12837,12866,12896,12926,12955,12984,13014,13043,13072,13102,13131,13161,13191,13220,13250,13280,13310,13339,13368,13398,13427,13456,13486,13515,13545,13574,13604,13634,13664,13693,13723,13752,13782,13811,13840,13870,13899,13929,13958,13988,14018,14047,14077,14107,14136,14166,14195,14224,14254,14283,14313,14342,14372,14401,14431,14461,14490,14520,14550,14579,14609,14638,14667,14697,14726,14756,14785,14815,14844,14874,14904,14933,14963,14993,15021,15051,15081,15110,15140,15169,15199,15228,15258,15287,15317,15347,15377,15406,15436,15465,15494,15524,15553,15582,15612,15641,15671,15701,15731,15760,15790,15820,15849,15878,15908,15937,15966,15996,16025,16055,16085,16114,16144,16174,16204,16233,16262,16292,16321,16350,16380,16409,16439,16468,16498,16528,16558,16587,16617,16646,16676,16705,16734,16764,16793,16823,16852,16882,16912,16941,16971,17001,17030,17060,17089,17118,17148,17177,17207,17236,17266,17295,17325,17355,17384,17414,17444,17473,17502,17532,17561,17591,17620,17650,17679,17709,17738,17768,17798,17827,17857,17886,17916,17945,17975,18004,18034,18063,18093,18122,18152,18181,18211,18241,18270,18300,18330,18359,18388,18418,18447,18476,18506,18535,18565,18595,18625,18654,18684,18714,18743,18772,18802,18831,18860,18890,18919,18949,18979,19008,19038,19068,19098,19127,19156,19186,19215,19244,19274,19303,19333,19362,19392,19422,19452,19481,19511,19540,19570,19599,19628,19658,19687,19717,19746,19776,19806,19836,19865,19895,19924,19954,19983,20012,20042,20071,20101,20130,20160,20190,20219,20249,20279,20308,20338,20367,20396,20426,20455,20485,20514,20544,20573,20603,20633,20662,20692,20721,20751,20780,20810,20839,20869,20898,20928,20957,20987,21016,21046,21076,21105,21135,21164,21194,21223,21253,21282,21312,21341,21371,21400,21430,21459,21489,21519,21548,21578,21607,21637,21666,21696,21725,21754,21784,21813,21843,21873,21902,21932,21962,21991,22021,22050,22080,22109,22138,22168,22197,22227,22256,22286,22316,22346,22375,22405,22434,22464,22493,22522,22552,22581,22611,22640,22670,22700,22730,22759,22789,22818,22848,22877,22906,22936,22965,22994,23024,23054,23083,23113,23143,23173,23202,23232,23261,23290,23320,23349,23379,23408,23438,23467,23497,23527,23556,23586,23616,23645,23674,23704,23733,23763,23792,23822,23851,23881,23910,23940,23970,23999,24029,24058,24088,24117,24147,24176,24206,24235,24265,24294,24324,24353,24383,24413,24442,24472,24501,24531,24560,24590,24619,24648,24678,24707,24737,24767,24796,24826,24856,24885,24915,24944,24974,25003,25032,25062,25091,25121,25150,25180,25210,25240,25269,25299,25328,25358,25387,25416,25446,25475,25505,25534,25564,25594,25624,25653,25683,25712,25742,25771,25800,25830,25859,25888,25918,25948,25977,26007,26037,26067,26096,26126,26155,26184,26214,26243,26272,26302,26332,26361,26391,26421,26451,26480,26510,26539,26568,26598,26627,26656,26686,26715,26745,26775,26805,26834,26864,26893,26923,26952,26982,27011,27041,27070,27099,27129,27159,27188,27218,27248,27277,27307,27336,27366,27395,27425,27454,27484,27513,27542,27572,27602,27631,27661,27691,27720,27750,27779,27809,27838,27868,27897,27926,27956,27985,28015,28045,28074,28104,28134,28163,28193,28222,28252,28281,28310,28340,28369,28399,28428,28458,28488,28517,28547,28577,28607,28636,28665,28695,28724,28754,28783,28813,28843,28872,28901,28931,28960,28990,29019,29049,29078,29108,29137,29167,29196,29226,29255,29285,29315,29345,29375,29404,29434,29463,29492,29522,29551,29580,29610,29640,29669,29699,29729,29759,29788,29818,29847,29876,29906,29935,29964,29994,30023,30053,30082,30112,30141,30171,30200,30230,30259,30289,30318,30348,30378,30408,30437,30467,30496,30526,30555,30585,30614,30644,30673,30703,30732,30762,30791,30821,30850,30880,30909,30939,30968,30998,31027,31057,31086,31116,31145,31175,31204,31234,31263,31293,31322,31352,31381,31411,31441,31471,31500,31530,31559,31589,31618,31648,31676,31706,31736,31766,31795,31825,31854,31884,31913,31943,31972,32002,32031,32061,32090,32120,32150,32180,32209,32239,32268,32298,32327,32357,32386,32416,32445,32475,32504,32534,32563,32593,32622,32652,32681,32711,32740,32770,32799,32829,32858,32888,32917,32947,32976,33006,33035,33065,33094,33124,33153,33183,33213,33243,33272,33302,33331,33361,33390,33420,33450,33479,33509,33539,33568,33598,33627,33657,33686,33716,33745,33775,33804,33834,33863,33893,33922,33952,33981,34011,34040,34069,34099,34128,34158,34187,34217,34247,34277,34306,34336,34365,34395,34424,34454,34483,34512,34542,34571,34601,34631,34660,34690,34719,34749,34778,34808,34837,34867,34896,34926,34955,34985,35015,35044,35074,35103,35133,35162,35192,35222,35251,35280,35310,35340,35370,35399,35429,35458,35488,35517,35547,35576,35605,35635,35665,35694,35723,35753,35782,35811,35841,35871,35901,35930,35960,35989,36019,36048,36078,36107,36136,36166,36195,36225,36254,36284,36314,36343,36373,36403,36433,36462,36492,36521,36551,36580,36610,36639,36669,36698,36728,36757,36786,36816,36845,36875,36904,36934,36963,36993,37022,37052,37081,37111,37141,37170,37200,37229,37259,37288,37318,37347,37377,37406,37436,37465,37495,37524,37554,37584,37613,37643,37672,37701,37731,37760,37790,37819,37849,37878,37908,37938,37967,37997,38027,38056,38085,38115,38144,38174,38203,38233,38262,38292,38322,38351,38381,38410,38440,38469,38499,38528,38558,38587,38617,38646,38676,38705,38735,38764,38794,38823,38853,38882,38912,38941,38971,39001,39030,39059,39089,39118,39148,39178,39208,39237,39267,39297,39326,39355,39385,39414,39444,39473,39503,39532,39562,39592,39621,39650,39680,39709,39739,39768,39798,39827,39857,39886,39916,39946,39975,40005,40035,40064,40094,40123,40153,40182,40212,40241,40271,40300,40330,40359,40389,40418,40448,40477,40507,40536,40566,40595,40625,40655,40685,40714,40744,40773,40803,40832,40862,40892,40921,40951,40980,41009,41039,41068,41098,41127,41157,41186,41216,41245,41275,41304,41334,41364,41393,41422,41452,41481,41511,41540,41570,41599,41629,41658,41688,41718,41748,41777,41807,41836,41865,41894,41924,41953,41983,42012,42042,42072,42102,42131,42161,42190,42220,42249,42279,42308,42337,42367,42397,42426,42456,42485,42515,42545,42574,42604,42633,42662,42692,42721,42751,42780,42810,42839,42869,42899,42929,42958,42988,43017,43046,43076,43105,43135,43164,43194,43223,43253,43283,43312,43342,43371,43401,43430,43460,43489,43519,43548,43578,43607,43637,43666,43696,43726,43755,43785,43814,43844,43873,43903,43932,43962,43991,44021,44050,44080,44109,44139,44169,44198,44228,44258,44287,44317,44346,44375,44405,44434,44464,44493,44523,44553,44582,44612,44641,44671,44700,44730,44759,44788,44818,44847,44877,44906,44936,44966,44996,45025,45055,45084,45114,45143,45172,45202,45231,45261,45290,45320,45350,45380,45409,45439,45468,45498,45527,45556,45586,45615,45644,45674,45704,45733,45763,45793,45823,45852,45882,45911,45940,45970,45999,46028,46058,46088,46117,46147,46177,46206,46236,46265,46295,46324,46354,46383,46413,46442,46472,46501,46531,46560,46590,46620,46649,46679,46708,46738,46767,46797,46826,46856,46885,46915,46944,46974,47003,47033,47063,47092,47122,47151,47181,47210,47240,47269,47298,47328,47357,47387,47417,47446,47476,47506,47535,47565,47594,47624,47653,47682,47712,47741,47771,47800,47830,47860,47890,47919,47949,47978,48008,48037,48066,48096,48125,48155,48184,48214,48244,48273,48303,48333,48362,48392,48421,48450,48480,48509,48538,48568,48598,48627,48657,48687,48717,48746,48776,48805,48834,48864,48893,48922,48952,48982,49011,49041,49071,49100,49130,49160,49189,49218,49248,49277,49306,49336,49365,49395,49425,49455,49484,49514,49543,49573,49602,49632,49661,49690,49720,49749,49779,49809,49838,49868,49898,49927,49957,49986,50016,50045,50075,50104,50133,50163,50192,50222,50252,50281,50311,50340,50370,50400,50429,50459,50488,50518,50547,50576,50606,50635,50665,50694,50724,50754,50784,50813,50843,50872,50902,50931,50960,50990,51019,51049,51078,51108,51138,51167,51197,51227,51256,51286,51315,51345,51374,51403,51433,51462,51492,51522,51552,51582,51611,51641,51670,51699,51729,51758,51787,51816,51846,51876,51906,51936,51965,51995,52025,52054,52083,52113,52142,52171,52200,52230,52260,52290,52319,52349,52379,52408,52438,52467,52497,52526,52555,52585,52614,52644,52673,52703,52733,52762,52792,52822,52851,52881,52910,52939,52969,52998,53028,53057,53087,53116,53146,53176,53205,53235,53264,53294,53324,53353,53383,53412,53441,53471,53500,53530,53559,53589,53619,53648,53678,53708,53737,53767,53796,53825,53855,53884,53913,53943,53973,54003,54032,54062,54092,54121,54151,54180,54209,54239,54268,54297,54327,54357,54387,54416,54446,54476,54505,54535,54564,54593,54623,54652,54681,54711,54741,54770,54800,54830,54859,54889,54919,54948,54977,55007,55036,55066,55095,55125,55154,55184,55213,55243,55273,55302,55332,55361,55391,55420,55450,55479,55508,55538,55567,55597,55627,55657,55686,55716,55745,55775,55804,55834,55863,55892,55922,55951,55981,56011,56040,56070,56100,56129,56159,56188,56218,56247,56276,56306,56335,56365,56394,56424,56454,56483,56513,56543,56572,56601,56631,56660,56690,56719,56749,56778,56808,56837,56867,56897,56926,56956,56985,57015,57044,57074,57103,57133,57162,57192,57221,57251,57280,57310,57340,57369,57399,57429,57458,57487,57517,57546,57576,57605,57634,57664,57694,57723,57753,57783,57813,57842,57871,57901,57930,57959,57989,58018,58048,58077,58107,58137,58167,58196,58226,58255,58285,58314,58343,58373,58402,58432,58461,58491,58521,58551,58580,58610,58639,58669,58698,58727,58757,58786,58816,58845,58875,58905,58934,58964,58994,59023,59053,59082,59111,59141,59170,59200,59229,59259,59288,59318,59348,59377,59407,59436,59466,59495,59525,59554,59584,59613,59643,59672,59702,59731,59761,59791,59820,59850,59879,59909,59939,59968,59997,60027,60056,60086,60115,60145,60174,60204,60234,60264,60293,60323,60352,60381,60411,60440,60469,60499,60528,60558,60588,60618,60648,60677,60707,60736,60765,60795,60824,60853,60883,60912,60942,60972,61002,61031,61061,61090,61120,61149,61179,61208,61237,61267,61296,61326,61356,61385,61415,61445,61474,61504,61533,61563,61592,61621,61651,61680,61710,61739,61769,61799,61828,61858,61888,61917,61947,61976,62006,62035,62064,62094,62123,62153,62182,62212,62242,62271,62301,62331,62360,62390,62419,62448,62478,62507,62537,62566,62596,62625,62655,62685,62715,62744,62774,62803,62832,62862,62891,62921,62950,62980,63009,63039,63069,63099,63128,63157,63187,63216,63246,63275,63305,63334,63363,63393,63423,63453,63482,63512,63541,63571,63600,63630,63659,63689,63718,63747,63777,63807,63836,63866,63895,63925,63955,63984,64014,64043,64073,64102,64131,64161,64190,64220,64249,64279,64309,64339,64368,64398,64427,64457,64486,64515,64545,64574,64603,64633,64663,64692,64722,64752,64782,64811,64841,64870,64899,64929,64958,64987,65017,65047,65076,65106,65136,65166,65195,65225,65254,65283,65313,65342,65371,65401,65431,65460,65490,65520,65549,65579,65608,65638,65667,65697,65726,65755,65785,65815,65844,65874,65903,65933,65963,65992,66022,66051,66081,66110,66140,66169,66199,66228,66258,66287,66317,66346,66376,66405,66435,66465,66494,66524,66553,66583,66612,66641,66671,66700,66730,66760,66789,66819,66849,66878,66908,66937,66967,66996,67025,67055,67084,67114,67143,67173,67203,67233,67262,67292,67321,67351,67380,67409,67439,67468,67497,67527,67557,67587,67617,67646,67676,67705,67735,67764,67793,67823,67852,67882,67911,67941,67971,68e3,68030,68060,68089,68119,68148,68177,68207,68236,68266,68295,68325,68354,68384,68414,68443,68473,68502,68532,68561,68591,68620,68650,68679,68708,68738,68768,68797,68827,68857,68886,68916,68946,68975,69004,69034,69063,69092,69122,69152,69181,69211,69240,69270,69300,69330,69359,69388,69418,69447,69476,69506,69535,69565,69595,69624,69654,69684,69713,69743,69772,69802,69831,69861,69890,69919,69949,69978,70008,70038,70067,70097,70126,70156,70186,70215,70245,70274,70303,70333,70362,70392,70421,70451,70481,70510,70540,70570,70599,70629,70658,70687,70717,70746,70776,70805,70835,70864,70894,70924,70954,70983,71013,71042,71071,71101,71130,71159,71189,71218,71248,71278,71308,71337,71367,71397,71426,71455,71485,71514,71543,71573,71602,71632,71662,71691,71721,71751,71781,71810,71839,71869,71898,71927,71957,71986,72016,72046,72075,72105,72135,72164,72194,72223,72253,72282,72311,72341,72370,72400,72429,72459,72489,72518,72548,72577,72607,72637,72666,72695,72725,72754,72784,72813,72843,72872,72902,72931,72961,72991,73020,73050,73080,73109,73139,73168,73197,73227,73256,73286,73315,73345,73375,73404,73434,73464,73493,73523,73552,73581,73611,73640,73669,73699,73729,73758,73788,73818,73848,73877,73907,73936,73965,73995,74024,74053,74083,74113,74142,74172,74202,74231,74261,74291,74320,74349,74379,74408,74437,74467,74497,74526,74556,74586,74615,74645,74675,74704,74733,74763,74792,74822,74851,74881,74910,74940,74969,74999,75029,75058,75088,75117,75147,75176,75206,75235,75264,75294,75323,75353,75383,75412,75442,75472,75501,75531,75560,75590,75619,75648,75678,75707,75737,75766,75796,75826,75856,75885,75915,75944,75974,76003,76032,76062,76091,76121,76150,76180,76210,76239,76269,76299,76328,76358,76387,76416,76446,76475,76505,76534,76564,76593,76623,76653,76682,76712,76741,76771,76801,76830,76859,76889,76918,76948,76977,77007,77036,77066,77096,77125,77155,77185,77214,77243,77273,77302,77332,77361,77390,77420,77450,77479,77509,77539,77569,77598,77627,77657,77686,77715,77745,77774,77804,77833,77863,77893,77923,77952,77982,78011,78041,78070,78099,78129,78158,78188,78217,78247,78277,78307,78336,78366,78395,78425,78454,78483,78513,78542,78572,78601,78631,78661,78690,78720,78750,78779,78808,78838,78867,78897,78926,78956,78985,79015,79044,79074,79104,79133,79163,79192,79222,79251,79281,79310,79340,79369,79399,79428,79458,79487,79517,79546,79576,79606,79635,79665,79695,79724,79753,79783,79812,79841,79871,79900,79930,79960,79990]},{"../main":509,"object-assign":397}],509:[function(t,e,r){var n=t("object-assign");function i(){this.regionalOptions=[],this.regionalOptions[""]={invalidCalendar:"Calendar {0} not found",invalidDate:"Invalid {0} date",invalidMonth:"Invalid {0} month",invalidYear:"Invalid {0} year",differentCalendars:"Cannot mix {0} and {1} dates"},this.local=this.regionalOptions[""],this.calendars={},this._localCals={}}function a(t,e,r,n){if(this._calendar=t,this._year=e,this._month=r,this._day=n,0===this._calendar._validateLevel&&!this._calendar.isValid(this._year,this._month,this._day))throw(c.local.invalidDate||c.regionalOptions[""].invalidDate).replace(/\{0\}/,this._calendar.local.name)}function o(t,e){return"000000".substring(0,e-(t=""+t).length)+t}function s(){this.shortYearCutoff="+10"}function l(t){this.local=this.regionalOptions[t]||this.regionalOptions[""]}n(i.prototype,{instance:function(t,e){t=(t||"gregorian").toLowerCase(),e=e||"";var r=this._localCals[t+"-"+e];if(!r&&this.calendars[t]&&(r=new this.calendars[t](e),this._localCals[t+"-"+e]=r),!r)throw(this.local.invalidCalendar||this.regionalOptions[""].invalidCalendar).replace(/\{0\}/,t);return r},newDate:function(t,e,r,n,i){return(n=(null!=t&&t.year?t.calendar():"string"==typeof n?this.instance(n,i):n)||this.instance()).newDate(t,e,r)},substituteDigits:function(t){return function(e){return(e+"").replace(/[0-9]/g,function(e){return t[e]})}},substituteChineseDigits:function(t,e){return function(r){for(var n="",i=0;r>0;){var a=r%10;n=(0===a?"":t[a]+e[i])+n,i++,r=Math.floor(r/10)}return 0===n.indexOf(t[1]+e[1])&&(n=n.substr(1)),n||t[0]}}}),n(a.prototype,{newDate:function(t,e,r){return this._calendar.newDate(null==t?this:t,e,r)},year:function(t){return 0===arguments.length?this._year:this.set(t,"y")},month:function(t){return 0===arguments.length?this._month:this.set(t,"m")},day:function(t){return 0===arguments.length?this._day:this.set(t,"d")},date:function(t,e,r){if(!this._calendar.isValid(t,e,r))throw(c.local.invalidDate||c.regionalOptions[""].invalidDate).replace(/\{0\}/,this._calendar.local.name);return this._year=t,this._month=e,this._day=r,this},leapYear:function(){return this._calendar.leapYear(this)},epoch:function(){return this._calendar.epoch(this)},formatYear:function(){return this._calendar.formatYear(this)},monthOfYear:function(){return this._calendar.monthOfYear(this)},weekOfYear:function(){return this._calendar.weekOfYear(this)},daysInYear:function(){return this._calendar.daysInYear(this)},dayOfYear:function(){return this._calendar.dayOfYear(this)},daysInMonth:function(){return this._calendar.daysInMonth(this)},dayOfWeek:function(){return this._calendar.dayOfWeek(this)},weekDay:function(){return this._calendar.weekDay(this)},extraInfo:function(){return this._calendar.extraInfo(this)},add:function(t,e){return this._calendar.add(this,t,e)},set:function(t,e){return this._calendar.set(this,t,e)},compareTo:function(t){if(this._calendar.name!==t._calendar.name)throw(c.local.differentCalendars||c.regionalOptions[""].differentCalendars).replace(/\{0\}/,this._calendar.local.name).replace(/\{1\}/,t._calendar.local.name);var e=this._year!==t._year?this._year-t._year:this._month!==t._month?this.monthOfYear()-t.monthOfYear():this._day-t._day;return 0===e?0:e<0?-1:1},calendar:function(){return this._calendar},toJD:function(){return this._calendar.toJD(this)},fromJD:function(t){return this._calendar.fromJD(t)},toJSDate:function(){return this._calendar.toJSDate(this)},fromJSDate:function(t){return this._calendar.fromJSDate(t)},toString:function(){return(this.year()<0?"-":"")+o(Math.abs(this.year()),4)+"-"+o(this.month(),2)+"-"+o(this.day(),2)}}),n(s.prototype,{_validateLevel:0,newDate:function(t,e,r){return null==t?this.today():(t.year&&(this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),r=t.day(),e=t.month(),t=t.year()),new a(this,t,e,r))},today:function(){return this.fromJSDate(new Date)},epoch:function(t){return this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear).year()<0?this.local.epochs[0]:this.local.epochs[1]},formatYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear);return(e.year()<0?"-":"")+o(Math.abs(e.year()),4)},monthsInYear:function(t){return this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear),12},monthOfYear:function(t,e){var r=this._validate(t,e,this.minDay,c.local.invalidMonth||c.regionalOptions[""].invalidMonth);return(r.month()+this.monthsInYear(r)-this.firstMonth)%this.monthsInYear(r)+this.minMonth},fromMonthOfYear:function(t,e){var r=(e+this.firstMonth-2*this.minMonth)%this.monthsInYear(t)+this.minMonth;return this._validate(t,r,this.minDay,c.local.invalidMonth||c.regionalOptions[""].invalidMonth),r},daysInYear:function(t){var e=this._validate(t,this.minMonth,this.minDay,c.local.invalidYear||c.regionalOptions[""].invalidYear);return this.leapYear(e)?366:365},dayOfYear:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate);return n.toJD()-this.newDate(n.year(),this.fromMonthOfYear(n.year(),this.minMonth),this.minDay).toJD()+1},daysInWeek:function(){return 7},dayOfWeek:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate);return(Math.floor(this.toJD(n))+2)%this.daysInWeek()},extraInfo:function(t,e,r){return this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),{}},add:function(t,e,r){return this._validate(t,this.minMonth,this.minDay,c.local.invalidDate||c.regionalOptions[""].invalidDate),this._correctAdd(t,this._add(t,e,r),e,r)},_add:function(t,e,r){if(this._validateLevel++,"d"===r||"w"===r){var n=t.toJD()+e*("w"===r?this.daysInWeek():1),i=t.calendar().fromJD(n);return this._validateLevel--,[i.year(),i.month(),i.day()]}try{var a=t.year()+("y"===r?e:0),o=t.monthOfYear()+("m"===r?e:0);i=t.day();"y"===r?(t.month()!==this.fromMonthOfYear(a,o)&&(o=this.newDate(a,t.month(),this.minDay).monthOfYear()),o=Math.min(o,this.monthsInYear(a)),i=Math.min(i,this.daysInMonth(a,this.fromMonthOfYear(a,o)))):"m"===r&&(!function(t){for(;oe-1+t.minMonth;)a++,o-=e,e=t.monthsInYear(a)}(this),i=Math.min(i,this.daysInMonth(a,this.fromMonthOfYear(a,o))));var s=[a,this.fromMonthOfYear(a,o),i];return this._validateLevel--,s}catch(t){throw this._validateLevel--,t}},_correctAdd:function(t,e,r,n){if(!(this.hasYearZero||"y"!==n&&"m"!==n||0!==e[0]&&t.year()>0==e[0]>0)){var i={y:[1,1,"y"],m:[1,this.monthsInYear(-1),"m"],w:[this.daysInWeek(),this.daysInYear(-1),"d"],d:[1,this.daysInYear(-1),"d"]}[n],a=r<0?-1:1;e=this._add(t,r*i[0]+a*i[1],i[2])}return t.date(e[0],e[1],e[2])},set:function(t,e,r){this._validate(t,this.minMonth,this.minDay,c.local.invalidDate||c.regionalOptions[""].invalidDate);var n="y"===r?e:t.year(),i="m"===r?e:t.month(),a="d"===r?e:t.day();return"y"!==r&&"m"!==r||(a=Math.min(a,this.daysInMonth(n,i))),t.date(n,i,a)},isValid:function(t,e,r){this._validateLevel++;var n=this.hasYearZero||0!==t;if(n){var i=this.newDate(t,e,this.minDay);n=e>=this.minMonth&&e-this.minMonth=this.minDay&&r-this.minDay13.5?13:1),c=i-(l>2.5?4716:4715);return c<=0&&c--,this.newDate(c,l,s)},toJSDate:function(t,e,r){var n=this._validate(t,e,r,c.local.invalidDate||c.regionalOptions[""].invalidDate),i=new Date(n.year(),n.month()-1,n.day());return i.setHours(0),i.setMinutes(0),i.setSeconds(0),i.setMilliseconds(0),i.setHours(i.getHours()>12?i.getHours()+2:0),i},fromJSDate:function(t){return this.newDate(t.getFullYear(),t.getMonth()+1,t.getDate())}});var c=e.exports=new i;c.cdate=a,c.baseCalendar=s,c.calendars.gregorian=l},{"object-assign":397}],510:[function(t,e,r){var n=t("object-assign"),i=t("./main");n(i.regionalOptions[""],{invalidArguments:"Invalid arguments",invalidFormat:"Cannot format a date from another calendar",missingNumberAt:"Missing number at position {0}",unknownNameAt:"Unknown name at position {0}",unexpectedLiteralAt:"Unexpected literal at position {0}",unexpectedText:"Additional text found at end"}),i.local=i.regionalOptions[""],n(i.cdate.prototype,{formatDate:function(t,e){return"string"!=typeof t&&(e=t,t=""),this._calendar.formatDate(t||"",this,e)}}),n(i.baseCalendar.prototype,{UNIX_EPOCH:i.instance().newDate(1970,1,1).toJD(),SECS_PER_DAY:86400,TICKS_EPOCH:i.instance().jdEpoch,TICKS_PER_DAY:864e9,ATOM:"yyyy-mm-dd",COOKIE:"D, dd M yyyy",FULL:"DD, MM d, yyyy",ISO_8601:"yyyy-mm-dd",JULIAN:"J",RFC_822:"D, d M yy",RFC_850:"DD, dd-M-yy",RFC_1036:"D, d M yy",RFC_1123:"D, d M yyyy",RFC_2822:"D, d M yyyy",RSS:"D, d M yy",TICKS:"!",TIMESTAMP:"@",W3C:"yyyy-mm-dd",formatDate:function(t,e,r){if("string"!=typeof t&&(r=e,e=t,t=""),!e)return"";if(e.calendar()!==this)throw i.local.invalidFormat||i.regionalOptions[""].invalidFormat;t=t||this.local.dateFormat;for(var n,a,o,s,l=(r=r||{}).dayNamesShort||this.local.dayNamesShort,c=r.dayNames||this.local.dayNames,u=r.monthNumbers||this.local.monthNumbers,f=r.monthNamesShort||this.local.monthNamesShort,h=r.monthNames||this.local.monthNames,p=(r.calculateWeek||this.local.calculateWeek,function(e,r){for(var n=1;w+n1}),d=function(t,e,r,n){var i=""+e;if(p(t,n))for(;i.length1},x=function(t,r){var n=y(t,r),a=[2,3,n?4:2,n?4:2,10,11,20]["oyYJ@!".indexOf(t)+1],o=new RegExp("^-?\\d{1,"+a+"}"),s=e.substring(A).match(o);if(!s)throw(i.local.missingNumberAt||i.regionalOptions[""].missingNumberAt).replace(/\{0\}/,A);return A+=s[0].length,parseInt(s[0],10)},b=this,_=function(){if("function"==typeof l){y("m");var t=l.call(b,e.substring(A));return A+=t.length,t}return x("m")},w=function(t,r,n,a){for(var o=y(t,a)?n:r,s=0;s-1){p=1,d=g;for(var C=this.daysInMonth(h,p);d>C;C=this.daysInMonth(h,p))p++,d-=C}return f>-1?this.fromJD(f):this.newDate(h,p,d)},determineDate:function(t,e,r,n,i){r&&"object"!=typeof r&&(i=n,n=r,r=null),"string"!=typeof n&&(i=n,n="");var a=this;return e=e?e.newDate():null,t=null==t?e:"string"==typeof t?function(t){try{return a.parseDate(n,t,i)}catch(t){}for(var e=((t=t.toLowerCase()).match(/^c/)&&r?r.newDate():null)||a.today(),o=/([+-]?[0-9]+)\s*(d|w|m|y)?/g,s=o.exec(t);s;)e.add(parseInt(s[1],10),s[2]||"d"),s=o.exec(t);return e}(t):"number"==typeof t?isNaN(t)||t===1/0||t===-1/0?e:a.today().add(t,"d"):a.newDate(t)}})},{"./main":509,"object-assign":397}],511:[function(t,e,r){e.exports=t("cwise-compiler")({args:["array",{offset:[1],array:0},"scalar","scalar","index"],pre:{body:"{}",args:[],thisVars:[],localVars:[]},post:{body:"{}",args:[],thisVars:[],localVars:[]},body:{body:"{\n var _inline_1_da = _inline_1_arg0_ - _inline_1_arg3_\n var _inline_1_db = _inline_1_arg1_ - _inline_1_arg3_\n if((_inline_1_da >= 0) !== (_inline_1_db >= 0)) {\n _inline_1_arg2_.push(_inline_1_arg4_[0] + 0.5 + 0.5 * (_inline_1_da + _inline_1_db) / (_inline_1_da - _inline_1_db))\n }\n }",args:[{name:"_inline_1_arg0_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg1_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg2_",lvalue:!1,rvalue:!0,count:1},{name:"_inline_1_arg3_",lvalue:!1,rvalue:!0,count:2},{name:"_inline_1_arg4_",lvalue:!1,rvalue:!0,count:1}],thisVars:[],localVars:["_inline_1_da","_inline_1_db"]},funcName:"zeroCrossings"})},{"cwise-compiler":117}],512:[function(t,e,r){"use strict";e.exports=function(t,e){var r=[];return e=+e||0,n(t.hi(t.shape[0]-1),r,e),r};var n=t("./lib/zc-core")},{"./lib/zc-core":511}],513:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/cartesian/axes"),a=t("./common_defaults"),o=t("./attributes");e.exports=function(t,e,r,s,l){function c(r,i){return n.coerce(t,e,o,r,i)}s=s||{};var u=c("visible",!(l=l||{}).itemIsNotPlainObject),f=c("clicktoshow");if(!u&&!f)return e;a(t,e,r,c);for(var h=e.showarrow,p=["x","y"],d=[-10,-30],g={_fullLayout:r},m=0;m<2;m++){var v=p[m],y=i.coerceRef(t,e,g,v,"","paper");if(i.coercePosition(e,g,c,y,v,.5),h){var x="a"+v,b=i.coerceRef(t,e,g,x,"pixel");"pixel"!==b&&b!==y&&(b=e[x]="pixel");var _="pixel"===b?d[m]:.4;i.coercePosition(e,g,c,b,x,_)}c(v+"anchor"),c(v+"shift")}if(n.noneOrAll(t,e,["x","y"]),h&&n.noneOrAll(t,e,["ax","ay"]),f){var w=c("xclick"),k=c("yclick");e._xclick=void 0===w?e.x:i.cleanPosition(w,g,e.xref),e._yclick=void 0===k?e.y:i.cleanPosition(k,g,e.yref)}return e}},{"../../lib":660,"../../plots/cartesian/axes":706,"./attributes":515,"./common_defaults":518}],514:[function(t,e,r){"use strict";e.exports=[{path:"",backoff:0},{path:"M-2.4,-3V3L0.6,0Z",backoff:.6},{path:"M-3.7,-2.5V2.5L1.3,0Z",backoff:1.3},{path:"M-4.45,-3L-1.65,-0.2V0.2L-4.45,3L1.55,0Z",backoff:1.55},{path:"M-2.2,-2.2L-0.2,-0.2V0.2L-2.2,2.2L-1.4,3L1.6,0L-1.4,-3Z",backoff:1.6},{path:"M-4.4,-2.1L-0.6,-0.2V0.2L-4.4,2.1L-4,3L2,0L-4,-3Z",backoff:2},{path:"M2,0A2,2 0 1,1 0,-2A2,2 0 0,1 2,0Z",backoff:0,noRotate:!0},{path:"M2,2V-2H-2V2Z",backoff:0,noRotate:!0}]},{}],515:[function(t,e,r){"use strict";var n=t("./arrow_paths"),i=t("../../plots/font_attributes"),a=t("../../plots/cartesian/constants");e.exports={_isLinkedToArray:"annotation",visible:{valType:"boolean",dflt:!0,editType:"calcIfAutorange+arraydraw"},text:{valType:"string",editType:"calcIfAutorange+arraydraw"},textangle:{valType:"angle",dflt:0,editType:"calcIfAutorange+arraydraw"},font:i({editType:"calcIfAutorange+arraydraw",colorEditType:"arraydraw"}),width:{valType:"number",min:1,dflt:null,editType:"calcIfAutorange+arraydraw"},height:{valType:"number",min:1,dflt:null,editType:"calcIfAutorange+arraydraw"},opacity:{valType:"number",min:0,max:1,dflt:1,editType:"arraydraw"},align:{valType:"enumerated",values:["left","center","right"],dflt:"center",editType:"arraydraw"},valign:{valType:"enumerated",values:["top","middle","bottom"],dflt:"middle",editType:"arraydraw"},bgcolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"arraydraw"},bordercolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"arraydraw"},borderpad:{valType:"number",min:0,dflt:1,editType:"calcIfAutorange+arraydraw"},borderwidth:{valType:"number",min:0,dflt:1,editType:"calcIfAutorange+arraydraw"},showarrow:{valType:"boolean",dflt:!0,editType:"calcIfAutorange+arraydraw"},arrowcolor:{valType:"color",editType:"arraydraw"},arrowhead:{valType:"integer",min:0,max:n.length,dflt:1,editType:"arraydraw"},startarrowhead:{valType:"integer",min:0,max:n.length,dflt:1,editType:"arraydraw"},arrowside:{valType:"flaglist",flags:["end","start"],extras:["none"],dflt:"end",editType:"arraydraw"},arrowsize:{valType:"number",min:.3,dflt:1,editType:"calcIfAutorange+arraydraw"},startarrowsize:{valType:"number",min:.3,dflt:1,editType:"calcIfAutorange+arraydraw"},arrowwidth:{valType:"number",min:.1,editType:"calcIfAutorange+arraydraw"},standoff:{valType:"number",min:0,dflt:0,editType:"calcIfAutorange+arraydraw"},startstandoff:{valType:"number",min:0,dflt:0,editType:"calcIfAutorange+arraydraw"},ax:{valType:"any",editType:"calcIfAutorange+arraydraw"},ay:{valType:"any",editType:"calcIfAutorange+arraydraw"},axref:{valType:"enumerated",dflt:"pixel",values:["pixel",a.idRegex.x.toString()],editType:"calc"},ayref:{valType:"enumerated",dflt:"pixel",values:["pixel",a.idRegex.y.toString()],editType:"calc"},xref:{valType:"enumerated",values:["paper",a.idRegex.x.toString()],editType:"calc"},x:{valType:"any",editType:"calcIfAutorange+arraydraw"},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"auto",editType:"calcIfAutorange+arraydraw"},xshift:{valType:"number",dflt:0,editType:"calcIfAutorange+arraydraw"},yref:{valType:"enumerated",values:["paper",a.idRegex.y.toString()],editType:"calc"},y:{valType:"any",editType:"calcIfAutorange+arraydraw"},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"auto",editType:"calcIfAutorange+arraydraw"},yshift:{valType:"number",dflt:0,editType:"calcIfAutorange+arraydraw"},clicktoshow:{valType:"enumerated",values:[!1,"onoff","onout"],dflt:!1,editType:"arraydraw"},xclick:{valType:"any",editType:"arraydraw"},yclick:{valType:"any",editType:"arraydraw"},hovertext:{valType:"string",editType:"arraydraw"},hoverlabel:{bgcolor:{valType:"color",editType:"arraydraw"},bordercolor:{valType:"color",editType:"arraydraw"},font:i({editType:"arraydraw"}),editType:"arraydraw"},captureevents:{valType:"boolean",editType:"arraydraw"},editType:"calc",_deprecated:{ref:{valType:"string",editType:"calc"}}}},{"../../plots/cartesian/constants":711,"../../plots/font_attributes":732,"./arrow_paths":514}],516:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/cartesian/axes"),a=t("./draw").draw;function o(t){var e=t._fullLayout;n.filterVisible(e.annotations).forEach(function(e){var r,n,a,o,s=i.getFromId(t,e.xref),l=i.getFromId(t,e.yref),c=3*e.arrowsize*e.arrowwidth||0,u=3*e.startarrowsize*e.arrowwidth||0;s&&s.autorange&&(r=c+e.xshift,n=c-e.xshift,a=u+e.xshift,o=u-e.xshift,e.axref===e.xref?(i.expand(s,[s.r2c(e.x)],{ppadplus:r,ppadminus:n}),i.expand(s,[s.r2c(e.ax)],{ppadplus:Math.max(e._xpadplus,a),ppadminus:Math.max(e._xpadminus,o)})):(a=e.ax?a+e.ax:a,o=e.ax?o-e.ax:o,i.expand(s,[s.r2c(e.x)],{ppadplus:Math.max(e._xpadplus,r,a),ppadminus:Math.max(e._xpadminus,n,o)}))),l&&l.autorange&&(r=c-e.yshift,n=c+e.yshift,a=u-e.yshift,o=u+e.yshift,e.ayref===e.yref?(i.expand(l,[l.r2c(e.y)],{ppadplus:r,ppadminus:n}),i.expand(l,[l.r2c(e.ay)],{ppadplus:Math.max(e._ypadplus,a),ppadminus:Math.max(e._ypadminus,o)})):(a=e.ay?a+e.ay:a,o=e.ay?o-e.ay:o,i.expand(l,[l.r2c(e.y)],{ppadplus:Math.max(e._ypadplus,r,a),ppadminus:Math.max(e._ypadminus,n,o)})))})}e.exports=function(t){var e=t._fullLayout,r=n.filterVisible(e.annotations);if(r.length&&t._fullData.length){var s={};for(var l in r.forEach(function(t){s[t.xref]=1,s[t.yref]=1}),s){var c=i.getFromId(t,l);if(c&&c.autorange)return n.syncOrAsync([a,o],t)}}}},{"../../lib":660,"../../plots/cartesian/axes":706,"./draw":521}],517:[function(t,e,r){"use strict";var n=t("../../registry");function i(t,e){var r,n,i,o,s,l,c,u=t._fullLayout.annotations,f=[],h=[],p=[],d=(e||[]).length;for(r=0;r0||r.explicitOff.length>0},onClick:function(t,e){var r,a=i(t,e),o=a.on,s=a.off.concat(a.explicitOff),l={};if(!o.length&&!s.length)return;for(r=0;r2/3?"right":"center"),{center:0,middle:0,left:.5,bottom:-.5,right:-.5,top:.5}[e]}e._w=I,e._h=B;for(var V=!1,U=["x","y"],q=0;q1)&&(K===J?((ot=Q.r2fraction(e["a"+Z]))<0||ot>1)&&(V=!0):V=!0,V))continue;H=Q._offset+Q.r2p(e[Z]),Y=.5}else"x"===Z?(W=e[Z],H=x.l+x.w*W):(W=1-e[Z],H=x.t+x.h*W),Y=e.showarrow?.5:W;if(e.showarrow){at.head=H;var st=e["a"+Z];X=tt*j(.5,e.xanchor)-et*j(.5,e.yanchor),K===J?(at.tail=Q._offset+Q.r2p(st),G=X):(at.tail=H+st,G=X+st),at.text=at.tail+X;var lt=y["x"===Z?"width":"height"];if("paper"===J&&(at.head=o.constrain(at.head,1,lt-1)),"pixel"===K){var ct=-Math.max(at.tail-3,at.text),ut=Math.min(at.tail+3,at.text)-lt;ct>0?(at.tail+=ct,at.text+=ct):ut>0&&(at.tail-=ut,at.text-=ut)}at.tail+=it,at.head+=it}else G=X=rt*j(Y,nt),at.text=H+X;at.text+=it,X+=it,G+=it,e["_"+Z+"padplus"]=rt/2+G,e["_"+Z+"padminus"]=rt/2-G,e["_"+Z+"size"]=rt,e["_"+Z+"shift"]=X}if(V)C.remove();else{var ft=0,ht=0;if("left"!==e.align&&(ft=(I-S)*("center"===e.align?.5:1)),"top"!==e.valign&&(ht=(B-L)*("middle"===e.valign?.5:1)),u)n.select("svg").attr({x:z+ft-1,y:z+ht}).call(c.setClipUrl,D?_:null);else{var pt=z+ht-m.top,dt=z+ft-m.left;R.call(f.positionText,dt,pt).call(c.setClipUrl,D?_:null)}O.select("rect").call(c.setRect,z,z,I,B),P.call(c.setRect,E/2,E/2,F-E,N-E),C.call(c.setTranslate,Math.round(w.x.text-F/2),Math.round(w.y.text-N/2)),A.attr({transform:"rotate("+k+","+w.x.text+","+w.y.text+")"});var gt,mt,vt=function(r,n){M.selectAll(".annotation-arrow-g").remove();var u=w.x.head,f=w.y.head,h=w.x.tail+r,m=w.y.tail+n,y=w.x.text+r,_=w.y.text+n,T=o.rotationXYMatrix(k,y,_),S=o.apply2DTransform(T),E=o.apply2DTransform2(T),L=+P.attr("width"),z=+P.attr("height"),D=y-.5*L,O=D+L,I=_-.5*z,R=I+z,B=[[D,I,D,R],[D,R,O,R],[O,R,O,I],[O,I,D,I]].map(E);if(!B.reduce(function(t,e){return t^!!o.segmentsIntersect(u,f,u+1e6,f+1e6,e[0],e[1],e[2],e[3])},!1)){B.forEach(function(t){var e=o.segmentsIntersect(h,m,u,f,t[0],t[1],t[2],t[3]);e&&(h=e.x,m=e.y)});var F=e.arrowwidth,N=e.arrowcolor,j=e.arrowside,V=M.append("g").style({opacity:l.opacity(N)}).classed("annotation-arrow-g",!0),U=V.append("path").attr("d","M"+h+","+m+"L"+u+","+f).style("stroke-width",F+"px").call(l.stroke,l.rgb(N));if(d(U,j,e),b.annotationPosition&&U.node().parentNode&&!a){var q=u,H=f;if(e.standoff){var G=Math.sqrt(Math.pow(u-h,2)+Math.pow(f-m,2));q+=e.standoff*(h-u)/G,H+=e.standoff*(m-f)/G}var W,Y,X,Z=V.append("path").classed("annotation-arrow",!0).classed("anndrag",!0).classed("cursor-move",!0).attr({d:"M3,3H-3V-3H3ZM0,0L"+(h-q)+","+(m-H),transform:"translate("+q+","+H+")"}).style("stroke-width",F+6+"px").call(l.stroke,"rgba(0,0,0,0)").call(l.fill,"rgba(0,0,0,0)");p.init({element:Z.node(),gd:t,prepFn:function(){var t=c.getTranslate(C);Y=t.x,X=t.y,W={},s&&s.autorange&&(W[s._name+".autorange"]=!0),g&&g.autorange&&(W[g._name+".autorange"]=!0)},moveFn:function(t,r){var n=S(Y,X),i=n[0]+t,a=n[1]+r;C.call(c.setTranslate,i,a),W[v+".x"]=s?s.p2r(s.r2p(e.x)+t):e.x+t/x.w,W[v+".y"]=g?g.p2r(g.r2p(e.y)+r):e.y-r/x.h,e.axref===e.xref&&(W[v+".ax"]=s.p2r(s.r2p(e.ax)+t)),e.ayref===e.yref&&(W[v+".ay"]=g.p2r(g.r2p(e.ay)+r)),V.attr("transform","translate("+t+","+r+")"),A.attr({transform:"rotate("+k+","+i+","+a+")"})},doneFn:function(){i.call("relayout",t,W);var e=document.querySelector(".js-notes-box-panel");e&&e.redraw(e.selectedObj)}})}}};if(e.showarrow&&vt(0,0),T)p.init({element:C.node(),gd:t,prepFn:function(){mt=A.attr("transform"),gt={}},moveFn:function(t,r){var n="pointer";if(e.showarrow)e.axref===e.xref?gt[v+".ax"]=s.p2r(s.r2p(e.ax)+t):gt[v+".ax"]=e.ax+t,e.ayref===e.yref?gt[v+".ay"]=g.p2r(g.r2p(e.ay)+r):gt[v+".ay"]=e.ay+r,vt(t,r);else{if(a)return;if(s)gt[v+".x"]=s.p2r(s.r2p(e.x)+t);else{var i=e._xsize/x.w,o=e.x+(e._xshift-e.xshift)/x.w-i/2;gt[v+".x"]=p.align(o+t/x.w,i,0,1,e.xanchor)}if(g)gt[v+".y"]=g.p2r(g.r2p(e.y)+r);else{var l=e._ysize/x.h,c=e.y-(e._yshift+e.yshift)/x.h-l/2;gt[v+".y"]=p.align(c-r/x.h,l,0,1,e.yanchor)}s&&g||(n=p.getCursor(s?.5:gt[v+".x"],g?.5:gt[v+".y"],e.xanchor,e.yanchor))}A.attr({transform:"translate("+t+","+r+")"+mt}),h(C,n)},doneFn:function(){h(C),i.call("relayout",t,gt);var e=document.querySelector(".js-notes-box-panel");e&&e.redraw(e.selectedObj)}})}}}e.exports={draw:function(t){var e=t._fullLayout;e._infolayer.selectAll(".annotation").remove();for(var r=0;r=0,m=e.indexOf("end")>=0,v=f.backoff*p+r.standoff,y=h.backoff*d+r.startstandoff;if("line"===u.nodeName){o={x:+t.attr("x1"),y:+t.attr("y1")},s={x:+t.attr("x2"),y:+t.attr("y2")};var x=o.x-s.x,b=o.y-s.y;if(c=(l=Math.atan2(b,x))+Math.PI,v&&y&&v+y>Math.sqrt(x*x+b*b))return void z();if(v){if(v*v>x*x+b*b)return void z();var _=v*Math.cos(l),w=v*Math.sin(l);s.x+=_,s.y+=w,t.attr({x2:s.x,y2:s.y})}if(y){if(y*y>x*x+b*b)return void z();var k=y*Math.cos(l),M=y*Math.sin(l);o.x-=k,o.y-=M,t.attr({x1:o.x,y1:o.y})}}else if("path"===u.nodeName){var A=u.getTotalLength(),T="";if(A1){c=!0;break}}c?t.fullLayout._infolayer.select(".annotation-"+t.id+'[data-index="'+s+'"]').remove():(l._pdata=i(t.glplot.cameraParams,[e.xaxis.r2l(l.x)*r[0],e.yaxis.r2l(l.y)*r[1],e.zaxis.r2l(l.z)*r[2]]),n(t.graphDiv,l,s,t.id,l._xa,l._ya))}}},{"../../plots/gl3d/project":757,"../annotations/draw":521}],528:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib");e.exports={moduleType:"component",name:"annotations3d",schema:{subplots:{scene:{annotations:t("./attributes")}}},layoutAttributes:t("./attributes"),handleDefaults:t("./defaults"),includeBasePlot:function(t,e){var r=n.subplotsRegistry.gl3d;if(!r)return;for(var a=r.attrRegex,o=Object.keys(t),s=0;s=0))return t;if(3===o)n[o]>1&&(n[o]=1);else if(n[o]>=1)return t}var s=Math.round(255*n[0])+", "+Math.round(255*n[1])+", "+Math.round(255*n[2]);return a?"rgba("+s+", "+n[3]+")":"rgb("+s+")"}a.tinyRGB=function(t){var e=t.toRgb();return"rgb("+Math.round(e.r)+", "+Math.round(e.g)+", "+Math.round(e.b)+")"},a.rgb=function(t){return a.tinyRGB(n(t))},a.opacity=function(t){return t?n(t).getAlpha():0},a.addOpacity=function(t,e){var r=n(t).toRgb();return"rgba("+Math.round(r.r)+", "+Math.round(r.g)+", "+Math.round(r.b)+", "+e+")"},a.combine=function(t,e){var r=n(t).toRgb();if(1===r.a)return n(t).toRgbString();var i=n(e||l).toRgb(),a=1===i.a?i:{r:255*(1-i.a)+i.r*i.a,g:255*(1-i.a)+i.g*i.a,b:255*(1-i.a)+i.b*i.a},o={r:a.r*(1-r.a)+r.r*r.a,g:a.g*(1-r.a)+r.g*r.a,b:a.b*(1-r.a)+r.b*r.a};return n(o).toRgbString()},a.contrast=function(t,e,r){var i=n(t);return 1!==i.getAlpha()&&(i=n(a.combine(t,l))),(i.isDark()?e?i.lighten(e):l:r?i.darken(r):s).toString()},a.stroke=function(t,e){var r=n(e);t.style({stroke:a.tinyRGB(r),"stroke-opacity":r.getAlpha()})},a.fill=function(t,e){var r=n(e);t.style({fill:a.tinyRGB(r),"fill-opacity":r.getAlpha()})},a.clean=function(t){if(t&&"object"==typeof t){var e,r,n,i,o=Object.keys(t);for(e=0;e0?A>=P:A<=P));T++)A>O&&A0?A>=P:A<=P));T++)A>S[0]&&A1){var nt=Math.pow(10,Math.floor(Math.log(rt)/Math.LN10));tt*=nt*c.roundUp(rt/nt,[2,5,10]),(Math.abs(r.levels.start)/r.levels.size+1e-6)%1<2e-6&&(Q.tick0=0)}Q.dtick=tt}Q.domain=[X+G,X+U-G],Q.setScale();var it=c.ensureSingle(b._infolayer,"g",e,function(t){t.classed(_.colorbar,!0).each(function(){var t=n.select(this);t.append("rect").classed(_.cbbg,!0),t.append("g").classed(_.cbfills,!0),t.append("g").classed(_.cblines,!0),t.append("g").classed(_.cbaxis,!0).classed(_.crisp,!0),t.append("g").classed(_.cbtitleunshift,!0).append("g").classed(_.cbtitle,!0),t.append("rect").classed(_.cboutline,!0),t.select(".cbtitle").datum(0)})});it.attr("transform","translate("+Math.round(M.l)+","+Math.round(M.t)+")");var at=it.select(".cbtitleunshift").attr("transform","translate(-"+Math.round(M.l)+",-"+Math.round(M.t)+")");Q._axislayer=it.select(".cbaxis");var ot=0;if(-1!==["top","bottom"].indexOf(r.titleside)){var st,lt=M.l+(r.x+q)*M.w,ct=Q.titlefont.size;st="top"===r.titleside?(1-(X+U-G))*M.h+M.t+3+.75*ct:(1-(X+G))*M.h+M.t-3-.25*ct,gt(Q._id+"title",{attributes:{x:lt,y:st,"text-anchor":"start"}})}var ut,ft,ht,pt=c.syncOrAsync([a.previousPromises,function(){if(-1!==["top","bottom"].indexOf(r.titleside)){var e=it.select(".cbtitle"),a=e.select("text"),o=[-r.outlinewidth/2,r.outlinewidth/2],l=e.select(".h"+Q._id+"title-math-group").node(),u=15.6;if(a.node()&&(u=parseInt(a.node().style.fontSize,10)*m),l?(ot=h.bBox(l).height)>u&&(o[1]-=(ot-u)/2):a.node()&&!a.classed(_.jsPlaceholder)&&(ot=h.bBox(a.node()).height),ot){if(ot+=5,"top"===r.titleside)Q.domain[1]-=ot/M.h,o[1]*=-1;else{Q.domain[0]+=ot/M.h;var f=g.lineCount(a);o[1]+=(1-f)*u}e.attr("transform","translate("+o+")"),Q.setScale()}}it.selectAll(".cbfills,.cblines").attr("transform","translate(0,"+Math.round(M.h*(1-Q.domain[1]))+")"),Q._axislayer.attr("transform","translate(0,"+Math.round(-M.t)+")");var p=it.select(".cbfills").selectAll("rect.cbfill").data(E);p.enter().append("rect").classed(_.cbfill,!0).style("stroke","none"),p.exit().remove(),p.each(function(t,e){var r=[0===e?S[0]:(E[e]+E[e-1])/2,e===E.length-1?S[1]:(E[e]+E[e+1])/2].map(Q.c2p).map(Math.round);e!==E.length-1&&(r[1]+=r[1]>r[0]?1:-1);var a=z(t).replace("e-",""),o=i(a).toHexString();n.select(this).attr({x:W,width:Math.max(N,2),y:n.min(r),height:Math.max(n.max(r)-n.min(r),2),fill:o})});var d=it.select(".cblines").selectAll("path.cbline").data(r.line.color&&r.line.width?C:[]);return d.enter().append("path").classed(_.cbline,!0),d.exit().remove(),d.each(function(t){n.select(this).attr("d","M"+W+","+(Math.round(Q.c2p(t))+r.line.width/2%1)+"h"+N).call(h.lineGroupStyle,r.line.width,L(t),r.line.dash)}),Q._axislayer.selectAll("g."+Q._id+"tick,path").remove(),Q._pos=W+N+(r.outlinewidth||0)/2-("outside"===r.ticks?1:0),Q.side="right",c.syncOrAsync([function(){return s.doTicksSingle(t,Q,!0)},function(){if(-1===["top","bottom"].indexOf(r.titleside)){var e=Q.titlefont.size,i=Q._offset+Q._length/2,a=M.l+(Q.position||0)*M.w+("right"===Q.side?10+e*(Q.showticklabels?1:.5):-10-e*(Q.showticklabels?.5:0));gt("h"+Q._id+"title",{avoid:{selection:n.select(t).selectAll("g."+Q._id+"tick"),side:r.titleside,offsetLeft:M.l,offsetTop:0,maxShift:b.width},attributes:{x:a,y:i,"text-anchor":"middle"},transform:{rotate:"-90",offset:0}})}}])},a.previousPromises,function(){var n=N+r.outlinewidth/2+h.bBox(Q._axislayer.node()).width;if((R=at.select("text")).node()&&!R.classed(_.jsPlaceholder)){var i,o=at.select(".h"+Q._id+"title-math-group").node();i=o&&-1!==["top","bottom"].indexOf(r.titleside)?h.bBox(o).width:h.bBox(at.node()).right-W-M.l,n=Math.max(n,i)}var s=2*r.xpad+n+r.borderwidth+r.outlinewidth/2,l=Z-J;it.select(".cbbg").attr({x:W-r.xpad-(r.borderwidth+r.outlinewidth)/2,y:J-H,width:Math.max(s,2),height:Math.max(l+2*H,2)}).call(p.fill,r.bgcolor).call(p.stroke,r.bordercolor).style({"stroke-width":r.borderwidth}),it.selectAll(".cboutline").attr({x:W,y:J+r.ypad+("top"===r.titleside?ot:0),width:Math.max(N,2),height:Math.max(l-2*r.ypad-ot,2)}).call(p.stroke,r.outlinecolor).style({fill:"None","stroke-width":r.outlinewidth});var c=({center:.5,right:1}[r.xanchor]||0)*s;it.attr("transform","translate("+(M.l-c)+","+M.t+")"),a.autoMargin(t,e,{x:r.x,y:r.y,l:s*({right:1,center:.5}[r.xanchor]||0),r:s*({left:1,center:.5}[r.xanchor]||0),t:l*({bottom:1,middle:.5}[r.yanchor]||0),b:l*({top:1,middle:.5}[r.yanchor]||0)})}],t);if(pt&&pt.then&&(t._promises||[]).push(pt),t._context.edits.colorbarPosition)l.init({element:it.node(),gd:t,prepFn:function(){ut=it.attr("transform"),f(it)},moveFn:function(t,e){it.attr("transform",ut+" translate("+t+","+e+")"),ft=l.align(Y+t/M.w,j,0,1,r.xanchor),ht=l.align(X-e/M.h,U,0,1,r.yanchor);var n=l.getCursor(ft,ht,r.xanchor,r.yanchor);f(it,n)},doneFn:function(){f(it),void 0!==ft&&void 0!==ht&&o.call("restyle",t,{"colorbar.x":ft,"colorbar.y":ht},k().index)}});return pt}function dt(t,e){return c.coerce(K,Q,x,t,e)}function gt(e,r){var n,i=k();n=o.traceIs(i,"markerColorscale")?"marker.colorbar.title":"colorbar.title";var a={propContainer:Q,propName:n,traceIndex:i.index,placeholder:b._dfltTitle.colorbar,containerGroup:it.select(".cbtitle")},s="h"===e.charAt(0)?e.substr(1):"h"+e;it.selectAll("."+s+",."+s+"-math-group").remove(),d.draw(t,e,u(a,r||{}))}b._infolayer.selectAll("g."+e).remove()}function k(){var r,n,i=e.substr(2);for(r=0;r=0?i.Reds:i.Blues,s.reversescale?a(y):y),l.autocolorscale||f("autocolorscale",!1))}},{"../../lib":660,"./flip_scale":544,"./scales":551}],540:[function(t,e,r){"use strict";var n=t("./attributes"),i=t("../../lib/extend").extendFlat;t("./scales.js");e.exports=function(t,e,r){return{color:{valType:"color",arrayOk:!0,editType:e||"style"},colorscale:i({},n.colorscale,{}),cauto:i({},n.zauto,{impliedEdits:{cmin:void 0,cmax:void 0}}),cmax:i({},n.zmax,{editType:e||n.zmax.editType,impliedEdits:{cauto:!1}}),cmin:i({},n.zmin,{editType:e||n.zmin.editType,impliedEdits:{cauto:!1}}),autocolorscale:i({},n.autocolorscale,{dflt:!1===r?r:n.autocolorscale.dflt}),reversescale:i({},n.reversescale,{})}}},{"../../lib/extend":649,"./attributes":538,"./scales.js":551}],541:[function(t,e,r){"use strict";var n=t("./scales");e.exports=n.RdBu},{"./scales":551}],542:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("../colorbar/has_colorbar"),o=t("../colorbar/defaults"),s=t("./is_valid_scale"),l=t("./flip_scale");e.exports=function(t,e,r,c,u){var f,h=u.prefix,p=u.cLetter,d=h.slice(0,h.length-1),g=h?i.nestedProperty(t,d).get()||{}:t,m=h?i.nestedProperty(e,d).get()||{}:e,v=g[p+"min"],y=g[p+"max"],x=g.colorscale;c(h+p+"auto",!(n(v)&&n(y)&&v=0;i--,a++)e=t[i],n[a]=[1-e[0],e[1]];return n}},{}],545:[function(t,e,r){"use strict";var n=t("./scales"),i=t("./default_scale"),a=t("./is_valid_scale_array");e.exports=function(t,e){if(e||(e=i),!t)return e;function r(){try{t=n[t]||JSON.parse(t)}catch(r){t=e}}return"string"==typeof t&&(r(),"string"==typeof t&&r()),a(t)?t:e}},{"./default_scale":541,"./is_valid_scale_array":549,"./scales":551}],546:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("./is_valid_scale");e.exports=function(t,e){var r=e?i.nestedProperty(t,e).get()||{}:t,o=r.color,s=!1;if(i.isArrayOrTypedArray(o))for(var l=0;l4/3-s?o:s}},{}],553:[function(t,e,r){"use strict";var n=t("../../lib"),i=[["sw-resize","s-resize","se-resize"],["w-resize","move","e-resize"],["nw-resize","n-resize","ne-resize"]];e.exports=function(t,e,r,a){return t="left"===r?0:"center"===r?1:"right"===r?2:n.constrain(Math.floor(3*t),0,2),e="bottom"===a?0:"middle"===a?1:"top"===a?2:n.constrain(Math.floor(3*e),0,2),i[e][t]}},{"../../lib":660}],554:[function(t,e,r){"use strict";var n=t("mouse-event-offset"),i=t("has-hover"),a=t("has-passive-events"),o=t("../../registry"),s=t("../../lib"),l=t("../../plots/cartesian/constants"),c=t("../../constants/interactions"),u=e.exports={};u.align=t("./align"),u.getCursor=t("./cursor");var f=t("./unhover");function h(){var t=document.createElement("div");t.className="dragcover";var e=t.style;return e.position="fixed",e.left=0,e.right=0,e.top=0,e.bottom=0,e.zIndex=999999999,e.background="none",document.body.appendChild(t),t}function p(t){return n(t.changedTouches?t.changedTouches[0]:t,document.body)}u.unhover=f.wrapped,u.unhoverRaw=f.raw,u.init=function(t){var e,r,n,f,d,g,m,v,y=t.gd,x=1,b=c.DBLCLICKDELAY,_=t.element;y._mouseDownTime||(y._mouseDownTime=0),_.style.pointerEvents="all",_.onmousedown=k,a?(_._ontouchstart&&_.removeEventListener("touchstart",_._ontouchstart),_._ontouchstart=k,_.addEventListener("touchstart",k,{passive:!1})):_.ontouchstart=k;var w=t.clampFn||function(t,e,r){return Math.abs(t)b&&(x=Math.max(x-1,1)),y._dragged)t.doneFn&&t.doneFn();else if(t.clickFn&&t.clickFn(x,g),!v){var r;try{r=new MouseEvent("click",e)}catch(t){var n=p(e);(r=document.createEvent("MouseEvents")).initMouseEvent("click",e.bubbles,e.cancelable,e.view,e.detail,e.screenX,e.screenY,n[0],n[1],e.ctrlKey,e.altKey,e.shiftKey,e.metaKey,e.button,e.relatedTarget)}m.dispatchEvent(r)}!function(t){t._dragging=!1,t._replotPending&&o.call("plot",t)}(y),y._dragged=!1}else y._dragged=!1}},u.coverSlip=h},{"../../constants/interactions":636,"../../lib":660,"../../plots/cartesian/constants":711,"../../registry":790,"./align":552,"./cursor":553,"./unhover":555,"has-hover":354,"has-passive-events":355,"mouse-event-offset":379}],555:[function(t,e,r){"use strict";var n=t("../../lib/events"),i=t("../../lib/throttle"),a=t("../../lib/get_graph_div"),o=t("../fx/constants"),s=e.exports={};s.wrapped=function(t,e,r){(t=a(t))._fullLayout&&i.clear(t._fullLayout._uid+o.HOVERID),s.raw(t,e,r)},s.raw=function(t,e){var r=t._fullLayout,i=t._hoverdata;e||(e={}),e.target&&!1===n.triggerHandler(t,"plotly_beforehover",e)||(r._hoverlayer.selectAll("g").remove(),r._hoverlayer.selectAll("line").remove(),r._hoverlayer.selectAll("circle").remove(),t._hoverdata=void 0,e.target&&i&&t.emit("plotly_unhover",{event:e,points:i}))}},{"../../lib/events":648,"../../lib/get_graph_div":655,"../../lib/throttle":685,"../fx/constants":569}],556:[function(t,e,r){"use strict";r.dash={valType:"string",values:["solid","dot","dash","longdash","dashdot","longdashdot"],dflt:"solid",editType:"style"}},{}],557:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("tinycolor2"),o=t("../../registry"),s=t("../color"),l=t("../colorscale"),c=t("../../lib"),u=t("../../lib/svg_text_utils"),f=t("../../constants/xmlns_namespaces"),h=t("../../constants/alignment").LINE_SPACING,p=t("../../constants/interactions").DESELECTDIM,d=t("../../traces/scatter/subtypes"),g=t("../../traces/scatter/make_bubble_size_func"),m=e.exports={};m.font=function(t,e,r,n){c.isPlainObject(e)&&(n=e.color,r=e.size,e=e.family),e&&t.style("font-family",e),r+1&&t.style("font-size",r+"px"),n&&t.call(s.fill,n)},m.setPosition=function(t,e,r){t.attr("x",e).attr("y",r)},m.setSize=function(t,e,r){t.attr("width",e).attr("height",r)},m.setRect=function(t,e,r,n,i){t.call(m.setPosition,e,r).call(m.setSize,n,i)},m.translatePoint=function(t,e,r,n){var a=r.c2p(t.x),o=n.c2p(t.y);return!!(i(a)&&i(o)&&e.node())&&("text"===e.node().nodeName?e.attr("x",a).attr("y",o):e.attr("transform","translate("+a+","+o+")"),!0)},m.translatePoints=function(t,e,r){t.each(function(t){var i=n.select(this);m.translatePoint(t,i,e,r)})},m.hideOutsideRangePoint=function(t,e,r,n,i,a){e.attr("display",r.isPtWithinRange(t,i)&&n.isPtWithinRange(t,a)?null:"none")},m.hideOutsideRangePoints=function(t,e){if(e._hasClipOnAxisFalse){var r=e.xaxis,i=e.yaxis;t.each(function(e){var a=e[0].trace,o=a.xcalendar,s=a.ycalendar,l="bar"===a.type?".bartext":".point,.textpoint";t.selectAll(l).each(function(t){m.hideOutsideRangePoint(t,n.select(this),r,i,o,s)})})}},m.crispRound=function(t,e,r){return e&&i(e)?t._context.staticPlot?e:e<1?1:Math.round(e):r||0},m.singleLineStyle=function(t,e,r,n,i){e.style("fill","none");var a=(((t||[])[0]||{}).trace||{}).line||{},o=r||a.width||0,l=i||a.dash||"";s.stroke(e,n||a.color),m.dashLine(e,l,o)},m.lineGroupStyle=function(t,e,r,i){t.style("fill","none").each(function(t){var a=(((t||[])[0]||{}).trace||{}).line||{},o=e||a.width||0,l=i||a.dash||"";n.select(this).call(s.stroke,r||a.color).call(m.dashLine,l,o)})},m.dashLine=function(t,e,r){r=+r||0,e=m.dashStyle(e,r),t.style({"stroke-dasharray":e,"stroke-width":r+"px"})},m.dashStyle=function(t,e){e=+e||1;var r=Math.max(e,3);return"solid"===t?t="":"dot"===t?t=r+"px,"+r+"px":"dash"===t?t=3*r+"px,"+3*r+"px":"longdash"===t?t=5*r+"px,"+5*r+"px":"dashdot"===t?t=3*r+"px,"+r+"px,"+r+"px,"+r+"px":"longdashdot"===t&&(t=5*r+"px,"+2*r+"px,"+r+"px,"+2*r+"px"),t},m.singleFillStyle=function(t){var e=(((n.select(t.node()).data()[0]||[])[0]||{}).trace||{}).fillcolor;e&&t.call(s.fill,e)},m.fillGroupStyle=function(t){t.style("stroke-width",0).each(function(e){var r=n.select(this);try{r.call(s.fill,e[0].trace.fillcolor)}catch(e){c.error(e,t),r.remove()}})};var v=t("./symbol_defs");m.symbolNames=[],m.symbolFuncs=[],m.symbolNeedLines={},m.symbolNoDot={},m.symbolNoFill={},m.symbolList=[],Object.keys(v).forEach(function(t){var e=v[t];m.symbolList=m.symbolList.concat([e.n,t,e.n+100,t+"-open"]),m.symbolNames[e.n]=t,m.symbolFuncs[e.n]=e.f,e.needLine&&(m.symbolNeedLines[e.n]=!0),e.noDot?m.symbolNoDot[e.n]=!0:m.symbolList=m.symbolList.concat([e.n+200,t+"-dot",e.n+300,t+"-open-dot"]),e.noFill&&(m.symbolNoFill[e.n]=!0)});var y=m.symbolNames.length,x="M0,0.5L0.5,0L0,-0.5L-0.5,0Z";function b(t,e){var r=t%100;return m.symbolFuncs[r](e)+(t>=200?x:"")}m.symbolNumber=function(t){if("string"==typeof t){var e=0;t.indexOf("-open")>0&&(e=100,t=t.replace("-open","")),t.indexOf("-dot")>0&&(e+=200,t=t.replace("-dot","")),(t=m.symbolNames.indexOf(t))>=0&&(t+=e)}return t%100>=y||t>=400?0:Math.floor(Math.max(t,0))};var _={x1:1,x2:0,y1:0,y2:0},w={x1:0,x2:0,y1:1,y2:0};m.gradient=function(t,e,r,i,o,l){var u=e._fullLayout._defs.select(".gradients").selectAll("#"+r).data([i+o+l],c.identity);u.exit().remove(),u.enter().append("radial"===i?"radialGradient":"linearGradient").each(function(){var t=n.select(this);"horizontal"===i?t.attr(_):"vertical"===i&&t.attr(w),t.attr("id",r);var e=a(o),c=a(l);t.append("stop").attr({offset:"0%","stop-color":s.tinyRGB(c),"stop-opacity":c.getAlpha()}),t.append("stop").attr({offset:"100%","stop-color":s.tinyRGB(e),"stop-opacity":e.getAlpha()})}),t.style({fill:"url(#"+r+")","fill-opacity":null})},m.initGradients=function(t){c.ensureSingle(t._fullLayout._defs,"g","gradients").selectAll("linearGradient,radialGradient").remove()},m.pointStyle=function(t,e,r){if(t.size()){var i=m.makePointStyleFns(e);t.each(function(t){m.singlePointStyle(t,n.select(this),e,i,r)})}},m.singlePointStyle=function(t,e,r,n,i){var a=r.marker,o=a.line;if(e.style("opacity",n.selectedOpacityFn?n.selectedOpacityFn(t):void 0===t.mo?a.opacity:t.mo),n.ms2mrc){var l;l="various"===t.ms||"various"===a.size?3:n.ms2mrc(t.ms),t.mrc=l,n.selectedSizeFn&&(l=t.mrc=n.selectedSizeFn(t));var u=m.symbolNumber(t.mx||a.symbol)||0;t.om=u%200>=100,e.attr("d",b(u,l))}var f,h,p,d=!1;if(t.so?(p=o.outlierwidth,h=o.outliercolor,f=a.outliercolor):(p=(t.mlw+1||o.width+1||(t.trace?t.trace.marker.line.width:0)+1)-1,h="mlc"in t?t.mlcc=n.lineScale(t.mlc):c.isArrayOrTypedArray(o.color)?s.defaultLine:o.color,c.isArrayOrTypedArray(a.color)&&(f=s.defaultLine,d=!0),f="mc"in t?t.mcc=n.markerScale(t.mc):a.color||"rgba(0,0,0,0)",n.selectedColorFn&&(f=n.selectedColorFn(t))),t.om)e.call(s.stroke,f).style({"stroke-width":(p||1)+"px",fill:"none"});else{e.style("stroke-width",p+"px");var g=a.gradient,v=t.mgt;if(v?d=!0:v=g&&g.type,v&&"none"!==v){var y=t.mgc;y?d=!0:y=g.color;var x="g"+i._fullLayout._uid+"-"+r.uid;d&&(x+="-"+t.i),e.call(m.gradient,i,x,v,f,y)}else e.call(s.fill,f);p&&e.call(s.stroke,h)}},m.makePointStyleFns=function(t){var e={},r=t.marker;return e.markerScale=m.tryColorscale(r,""),e.lineScale=m.tryColorscale(r,"line"),o.traceIs(t,"symbols")&&(e.ms2mrc=d.isBubble(t)?g(t):function(){return(r.size||6)/2}),t.selectedpoints&&c.extendFlat(e,m.makeSelectedPointStyleFns(t)),e},m.makeSelectedPointStyleFns=function(t){var e={},r=t.selected||{},n=t.unselected||{},i=t.marker||{},a=r.marker||{},s=n.marker||{},l=i.opacity,u=a.opacity,f=s.opacity,h=void 0!==u,d=void 0!==f;(c.isArrayOrTypedArray(l)||h||d)&&(e.selectedOpacityFn=function(t){var e=void 0===t.mo?i.opacity:t.mo;return t.selected?h?u:e:d?f:p*e});var g=i.color,m=a.color,v=s.color;(m||v)&&(e.selectedColorFn=function(t){var e=t.mcc||g;return t.selected?m||e:v||e});var y=i.size,x=a.size,b=s.size,_=void 0!==x,w=void 0!==b;return o.traceIs(t,"symbols")&&(_||w)&&(e.selectedSizeFn=function(t){var e=t.mrc||y/2;return t.selected?_?x/2:e:w?b/2:e}),e},m.makeSelectedTextStyleFns=function(t){var e={},r=t.selected||{},n=t.unselected||{},i=t.textfont||{},a=r.textfont||{},o=n.textfont||{},l=i.color,c=a.color,u=o.color;return e.selectedTextColorFn=function(t){var e=t.tc||l;return t.selected?c||e:u||(c?e:s.addOpacity(e,p))},e},m.selectedPointStyle=function(t,e){if(t.size()&&e.selectedpoints){var r=m.makeSelectedPointStyleFns(e),i=e.marker||{},a=[];r.selectedOpacityFn&&a.push(function(t,e){t.style("opacity",r.selectedOpacityFn(e))}),r.selectedColorFn&&a.push(function(t,e){s.fill(t,r.selectedColorFn(e))}),r.selectedSizeFn&&a.push(function(t,e){var n=e.mx||i.symbol||0,a=r.selectedSizeFn(e);t.attr("d",b(m.symbolNumber(n),a)),e.mrc2=a}),a.length&&t.each(function(t){for(var e=n.select(this),r=0;r0?r:0}m.textPointStyle=function(t,e,r){if(t.size()){var i;if(e.selectedpoints){var a=m.makeSelectedTextStyleFns(e);i=a.selectedTextColorFn}t.each(function(t){var a=n.select(this),o=c.extractOption(t,e,"tx","text");if(o||0===o){var s=t.tp||e.textposition,l=A(t,e),f=i?i(t):t.tc||e.textfont.color;a.call(m.font,t.tf||e.textfont.family,l,f).text(o).call(u.convertToTspans,r).call(M,s,l,t.mrc)}else a.remove()})}},m.selectedTextStyle=function(t,e){if(t.size()&&e.selectedpoints){var r=m.makeSelectedTextStyleFns(e);t.each(function(t){var i=n.select(this),a=r.selectedTextColorFn(t),o=t.tp||e.textposition,l=A(t,e);s.fill(i,a),M(i,o,l,t.mrc2||t.mrc)})}};var T=.5;function S(t,e,r,i){var a=t[0]-e[0],o=t[1]-e[1],s=r[0]-e[0],l=r[1]-e[1],c=Math.pow(a*a+o*o,T/2),u=Math.pow(s*s+l*l,T/2),f=(u*u*a-c*c*s)*i,h=(u*u*o-c*c*l)*i,p=3*u*(c+u),d=3*c*(c+u);return[[n.round(e[0]+(p&&f/p),2),n.round(e[1]+(p&&h/p),2)],[n.round(e[0]-(d&&f/d),2),n.round(e[1]-(d&&h/d),2)]]}m.smoothopen=function(t,e){if(t.length<3)return"M"+t.join("L");var r,n="M"+t[0],i=[];for(r=1;r=1e4&&(m.savedBBoxes={},L=0),r&&(m.savedBBoxes[r]=v),L++,c.extendFlat({},v)},m.setClipUrl=function(t,e){if(e){if(void 0===m.baseUrl){var r=n.select("base");r.size()&&r.attr("href")?m.baseUrl=window.location.href.split("#")[0]:m.baseUrl=""}t.attr("clip-path","url("+m.baseUrl+"#"+e+")")}else t.attr("clip-path",null)},m.getTranslate=function(t){var e=(t[t.attr?"attr":"getAttribute"]("transform")||"").replace(/.*\btranslate\((-?\d*\.?\d*)[^-\d]*(-?\d*\.?\d*)[^\d].*/,function(t,e,r){return[e,r].join(" ")}).split(" ");return{x:+e[0]||0,y:+e[1]||0}},m.setTranslate=function(t,e,r){var n=t.attr?"attr":"getAttribute",i=t.attr?"attr":"setAttribute",a=t[n]("transform")||"";return e=e||0,r=r||0,a=a.replace(/(\btranslate\(.*?\);?)/,"").trim(),a=(a+=" translate("+e+", "+r+")").trim(),t[i]("transform",a),a},m.getScale=function(t){var e=(t[t.attr?"attr":"getAttribute"]("transform")||"").replace(/.*\bscale\((\d*\.?\d*)[^\d]*(\d*\.?\d*)[^\d].*/,function(t,e,r){return[e,r].join(" ")}).split(" ");return{x:+e[0]||1,y:+e[1]||1}},m.setScale=function(t,e,r){var n=t.attr?"attr":"getAttribute",i=t.attr?"attr":"setAttribute",a=t[n]("transform")||"";return e=e||1,r=r||1,a=a.replace(/(\bscale\(.*?\);?)/,"").trim(),a=(a+=" scale("+e+", "+r+")").trim(),t[i]("transform",a),a};var P=/\s*sc.*/;m.setPointGroupScale=function(t,e,r){if(e=e||1,r=r||1,t){var n=1===e&&1===r?"":" scale("+e+","+r+")";t.each(function(){var t=(this.getAttribute("transform")||"").replace(P,"");t=(t+=n).trim(),this.setAttribute("transform",t)})}};var D=/translate\([^)]*\)\s*$/;m.setTextPointsScale=function(t,e,r){t&&t.each(function(){var t,i=n.select(this),a=i.select("text");if(a.node()){var o=parseFloat(a.attr("x")||0),s=parseFloat(a.attr("y")||0),l=(i.attr("transform")||"").match(D);t=1===e&&1===r?[]:["translate("+o+","+s+")","scale("+e+","+r+")","translate("+-o+","+-s+")"],l&&t.push(l),i.attr("transform",t.join(" "))}})}},{"../../constants/alignment":632,"../../constants/interactions":636,"../../constants/xmlns_namespaces":639,"../../lib":660,"../../lib/svg_text_utils":684,"../../registry":790,"../../traces/scatter/make_bubble_size_func":1007,"../../traces/scatter/subtypes":1012,"../color":532,"../colorscale":547,"./symbol_defs":558,d3:131,"fast-isnumeric":197,tinycolor2:473}],558:[function(t,e,r){"use strict";var n=t("d3");e.exports={circle:{n:0,f:function(t){var e=n.round(t,2);return"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"}},square:{n:1,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"}},diamond:{n:2,f:function(t){var e=n.round(1.3*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"Z"}},cross:{n:3,f:function(t){var e=n.round(.4*t,2),r=n.round(1.2*t,2);return"M"+r+","+e+"H"+e+"V"+r+"H-"+e+"V"+e+"H-"+r+"V-"+e+"H-"+e+"V-"+r+"H"+e+"V-"+e+"H"+r+"Z"}},x:{n:4,f:function(t){var e=n.round(.8*t/Math.sqrt(2),2),r="l"+e+","+e,i="l"+e+",-"+e,a="l-"+e+",-"+e,o="l-"+e+","+e;return"M0,"+e+r+i+a+i+a+o+a+o+r+o+r+"Z"}},"triangle-up":{n:5,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+e+","+n.round(t/2,2)+"H"+e+"L0,-"+n.round(t,2)+"Z"}},"triangle-down":{n:6,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+e+",-"+n.round(t/2,2)+"H"+e+"L0,"+n.round(t,2)+"Z"}},"triangle-left":{n:7,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M"+n.round(t/2,2)+",-"+e+"V"+e+"L-"+n.round(t,2)+",0Z"}},"triangle-right":{n:8,f:function(t){var e=n.round(2*t/Math.sqrt(3),2);return"M-"+n.round(t/2,2)+",-"+e+"V"+e+"L"+n.round(t,2)+",0Z"}},"triangle-ne":{n:9,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M-"+r+",-"+e+"H"+e+"V"+r+"Z"}},"triangle-se":{n:10,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M"+e+",-"+r+"V"+e+"H-"+r+"Z"}},"triangle-sw":{n:11,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M"+r+","+e+"H-"+e+"V-"+r+"Z"}},"triangle-nw":{n:12,f:function(t){var e=n.round(.6*t,2),r=n.round(1.2*t,2);return"M-"+e+","+r+"V-"+e+"H"+r+"Z"}},pentagon:{n:13,f:function(t){var e=n.round(.951*t,2),r=n.round(.588*t,2),i=n.round(-t,2),a=n.round(-.309*t,2);return"M"+e+","+a+"L"+r+","+n.round(.809*t,2)+"H-"+r+"L-"+e+","+a+"L0,"+i+"Z"}},hexagon:{n:14,f:function(t){var e=n.round(t,2),r=n.round(t/2,2),i=n.round(t*Math.sqrt(3)/2,2);return"M"+i+",-"+r+"V"+r+"L0,"+e+"L-"+i+","+r+"V-"+r+"L0,-"+e+"Z"}},hexagon2:{n:15,f:function(t){var e=n.round(t,2),r=n.round(t/2,2),i=n.round(t*Math.sqrt(3)/2,2);return"M-"+r+","+i+"H"+r+"L"+e+",0L"+r+",-"+i+"H-"+r+"L-"+e+",0Z"}},octagon:{n:16,f:function(t){var e=n.round(.924*t,2),r=n.round(.383*t,2);return"M-"+r+",-"+e+"H"+r+"L"+e+",-"+r+"V"+r+"L"+r+","+e+"H-"+r+"L-"+e+","+r+"V-"+r+"Z"}},star:{n:17,f:function(t){var e=1.4*t,r=n.round(.225*e,2),i=n.round(.951*e,2),a=n.round(.363*e,2),o=n.round(.588*e,2),s=n.round(-e,2),l=n.round(-.309*e,2),c=n.round(.118*e,2),u=n.round(.809*e,2);return"M"+r+","+l+"H"+i+"L"+a+","+c+"L"+o+","+u+"L0,"+n.round(.382*e,2)+"L-"+o+","+u+"L-"+a+","+c+"L-"+i+","+l+"H-"+r+"L0,"+s+"Z"}},hexagram:{n:18,f:function(t){var e=n.round(.66*t,2),r=n.round(.38*t,2),i=n.round(.76*t,2);return"M-"+i+",0l-"+r+",-"+e+"h"+i+"l"+r+",-"+e+"l"+r+","+e+"h"+i+"l-"+r+","+e+"l"+r+","+e+"h-"+i+"l-"+r+","+e+"l-"+r+",-"+e+"h-"+i+"Z"}},"star-triangle-up":{n:19,f:function(t){var e=n.round(t*Math.sqrt(3)*.8,2),r=n.round(.8*t,2),i=n.round(1.6*t,2),a=n.round(4*t,2),o="A "+a+","+a+" 0 0 1 ";return"M-"+e+","+r+o+e+","+r+o+"0,-"+i+o+"-"+e+","+r+"Z"}},"star-triangle-down":{n:20,f:function(t){var e=n.round(t*Math.sqrt(3)*.8,2),r=n.round(.8*t,2),i=n.round(1.6*t,2),a=n.round(4*t,2),o="A "+a+","+a+" 0 0 1 ";return"M"+e+",-"+r+o+"-"+e+",-"+r+o+"0,"+i+o+e+",-"+r+"Z"}},"star-square":{n:21,f:function(t){var e=n.round(1.1*t,2),r=n.round(2*t,2),i="A "+r+","+r+" 0 0 1 ";return"M-"+e+",-"+e+i+"-"+e+","+e+i+e+","+e+i+e+",-"+e+i+"-"+e+",-"+e+"Z"}},"star-diamond":{n:22,f:function(t){var e=n.round(1.4*t,2),r=n.round(1.9*t,2),i="A "+r+","+r+" 0 0 1 ";return"M-"+e+",0"+i+"0,"+e+i+e+",0"+i+"0,-"+e+i+"-"+e+",0Z"}},"diamond-tall":{n:23,f:function(t){var e=n.round(.7*t,2),r=n.round(1.4*t,2);return"M0,"+r+"L"+e+",0L0,-"+r+"L-"+e+",0Z"}},"diamond-wide":{n:24,f:function(t){var e=n.round(1.4*t,2),r=n.round(.7*t,2);return"M0,"+r+"L"+e+",0L0,-"+r+"L-"+e+",0Z"}},hourglass:{n:25,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"H-"+e+"L"+e+",-"+e+"H-"+e+"Z"},noDot:!0},bowtie:{n:26,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"V-"+e+"L-"+e+","+e+"V-"+e+"Z"},noDot:!0},"circle-cross":{n:27,f:function(t){var e=n.round(t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"},needLine:!0,noDot:!0},"circle-x":{n:28,f:function(t){var e=n.round(t,2),r=n.round(t/Math.sqrt(2),2);return"M"+r+","+r+"L-"+r+",-"+r+"M"+r+",-"+r+"L-"+r+","+r+"M"+e+",0A"+e+","+e+" 0 1,1 0,-"+e+"A"+e+","+e+" 0 0,1 "+e+",0Z"},needLine:!0,noDot:!0},"square-cross":{n:29,f:function(t){var e=n.round(t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"},needLine:!0,noDot:!0},"square-x":{n:30,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e+"M"+e+",-"+e+"L-"+e+","+e+"M"+e+","+e+"H-"+e+"V-"+e+"H"+e+"Z"},needLine:!0,noDot:!0},"diamond-cross":{n:31,f:function(t){var e=n.round(1.3*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"ZM0,-"+e+"V"+e+"M-"+e+",0H"+e},needLine:!0,noDot:!0},"diamond-x":{n:32,f:function(t){var e=n.round(1.3*t,2),r=n.round(.65*t,2);return"M"+e+",0L0,"+e+"L-"+e+",0L0,-"+e+"ZM-"+r+",-"+r+"L"+r+","+r+"M-"+r+","+r+"L"+r+",-"+r},needLine:!0,noDot:!0},"cross-thin":{n:33,f:function(t){var e=n.round(1.4*t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e},needLine:!0,noDot:!0,noFill:!0},"x-thin":{n:34,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e+"M"+e+",-"+e+"L-"+e+","+e},needLine:!0,noDot:!0,noFill:!0},asterisk:{n:35,f:function(t){var e=n.round(1.2*t,2),r=n.round(.85*t,2);return"M0,"+e+"V-"+e+"M"+e+",0H-"+e+"M"+r+","+r+"L-"+r+",-"+r+"M"+r+",-"+r+"L-"+r+","+r},needLine:!0,noDot:!0,noFill:!0},hash:{n:36,f:function(t){var e=n.round(t/2,2),r=n.round(t,2);return"M"+e+","+r+"V-"+r+"m-"+r+",0V"+r+"M"+r+","+e+"H-"+r+"m0,-"+r+"H"+r},needLine:!0,noFill:!0},"y-up":{n:37,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+e+","+i+"L0,0M"+e+","+i+"L0,0M0,-"+r+"L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-down":{n:38,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+e+",-"+i+"L0,0M"+e+",-"+i+"L0,0M0,"+r+"L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-left":{n:39,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M"+i+","+e+"L0,0M"+i+",-"+e+"L0,0M-"+r+",0L0,0"},needLine:!0,noDot:!0,noFill:!0},"y-right":{n:40,f:function(t){var e=n.round(1.2*t,2),r=n.round(1.6*t,2),i=n.round(.8*t,2);return"M-"+i+","+e+"L0,0M-"+i+",-"+e+"L0,0M"+r+",0L0,0"},needLine:!0,noDot:!0,noFill:!0},"line-ew":{n:41,f:function(t){var e=n.round(1.4*t,2);return"M"+e+",0H-"+e},needLine:!0,noDot:!0,noFill:!0},"line-ns":{n:42,f:function(t){var e=n.round(1.4*t,2);return"M0,"+e+"V-"+e},needLine:!0,noDot:!0,noFill:!0},"line-ne":{n:43,f:function(t){var e=n.round(t,2);return"M"+e+",-"+e+"L-"+e+","+e},needLine:!0,noDot:!0,noFill:!0},"line-nw":{n:44,f:function(t){var e=n.round(t,2);return"M"+e+","+e+"L-"+e+",-"+e},needLine:!0,noDot:!0,noFill:!0}}},{d3:131}],559:[function(t,e,r){"use strict";e.exports={visible:{valType:"boolean",editType:"calc"},type:{valType:"enumerated",values:["percent","constant","sqrt","data"],editType:"calc"},symmetric:{valType:"boolean",editType:"calc"},array:{valType:"data_array",editType:"calc"},arrayminus:{valType:"data_array",editType:"calc"},value:{valType:"number",min:0,dflt:10,editType:"calc"},valueminus:{valType:"number",min:0,dflt:10,editType:"calc"},traceref:{valType:"integer",min:0,dflt:0,editType:"style"},tracerefminus:{valType:"integer",min:0,dflt:0,editType:"style"},copy_ystyle:{valType:"boolean",editType:"plot"},copy_zstyle:{valType:"boolean",editType:"style"},color:{valType:"color",editType:"style"},thickness:{valType:"number",min:0,dflt:2,editType:"style"},width:{valType:"number",min:0,editType:"plot"},editType:"calc",_deprecated:{opacity:{valType:"number",editType:"style"}}}},{}],560:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../registry"),a=t("../../plots/cartesian/axes"),o=t("./compute_error");function s(t,e,r,i){var s=e["error_"+i]||{},l=[];if(s.visible&&-1!==["linear","log"].indexOf(r.type)){for(var c=o(s),u=0;u0;t.each(function(t){var u,f=t[0].trace,h=f.error_x||{},p=f.error_y||{};f.ids&&(u=function(t){return t.id});var d=o.hasMarkers(f)&&f.marker.maxdisplayed>0;p.visible||h.visible||(t=[]);var g=n.select(this).selectAll("g.errorbar").data(t,u);if(g.exit().remove(),t.length){h.visible||g.selectAll("path.xerror").remove(),p.visible||g.selectAll("path.yerror").remove(),g.style("opacity",1);var m=g.enter().append("g").classed("errorbar",!0);c&&m.style("opacity",0).transition().duration(r.duration).style("opacity",1),a.setClipUrl(g,e.layerClipId),g.each(function(t){var e=n.select(this),a=function(t,e,r){var n={x:e.c2p(t.x),y:r.c2p(t.y)};void 0!==t.yh&&(n.yh=r.c2p(t.yh),n.ys=r.c2p(t.ys),i(n.ys)||(n.noYS=!0,n.ys=r.c2p(t.ys,!0)));void 0!==t.xh&&(n.xh=e.c2p(t.xh),n.xs=e.c2p(t.xs),i(n.xs)||(n.noXS=!0,n.xs=e.c2p(t.xs,!0)));return n}(t,s,l);if(!d||t.vis){var o,u=e.select("path.yerror");if(p.visible&&i(a.x)&&i(a.yh)&&i(a.ys)){var f=p.width;o="M"+(a.x-f)+","+a.yh+"h"+2*f+"m-"+f+",0V"+a.ys,a.noYS||(o+="m-"+f+",0h"+2*f),!u.size()?u=e.append("path").style("vector-effect","non-scaling-stroke").classed("yerror",!0):c&&(u=u.transition().duration(r.duration).ease(r.easing)),u.attr("d",o)}else u.remove();var g=e.select("path.xerror");if(h.visible&&i(a.y)&&i(a.xh)&&i(a.xs)){var m=(h.copy_ystyle?p:h).width;o="M"+a.xh+","+(a.y-m)+"v"+2*m+"m0,-"+m+"H"+a.xs,a.noXS||(o+="m0,-"+m+"v"+2*m),!g.size()?g=e.append("path").style("vector-effect","non-scaling-stroke").classed("xerror",!0):c&&(g=g.transition().duration(r.duration).ease(r.easing)),g.attr("d",o)}else g.remove()}})}})}},{"../../traces/scatter/subtypes":1012,"../drawing":557,d3:131,"fast-isnumeric":197}],565:[function(t,e,r){"use strict";var n=t("d3"),i=t("../color");e.exports=function(t){t.each(function(t){var e=t[0].trace,r=e.error_y||{},a=e.error_x||{},o=n.select(this);o.selectAll("path.yerror").style("stroke-width",r.thickness+"px").call(i.stroke,r.color),a.copy_ystyle&&(a=r),o.selectAll("path.xerror").style("stroke-width",a.thickness+"px").call(i.stroke,a.color)})}},{"../color":532,d3:131}],566:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes");e.exports={hoverlabel:{bgcolor:{valType:"color",arrayOk:!0,editType:"none"},bordercolor:{valType:"color",arrayOk:!0,editType:"none"},font:n({arrayOk:!0,editType:"none"}),namelength:{valType:"integer",min:-1,arrayOk:!0,editType:"none"},editType:"calc"}}},{"../../plots/font_attributes":732}],567:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry");function a(t,e,r,i){i=i||n.identity,Array.isArray(t)&&(e[0][r]=i(t))}e.exports=function(t){var e=t.calcdata,r=t._fullLayout;function o(t){return function(e){return n.coerceHoverinfo({hoverinfo:e},{_module:t._module},r)}}for(var s=0;s=0&&r.index-1&&o.length>y&&(o=y>3?o.substr(0,y-3)+"...":o.substr(0,y))}void 0!==t.zLabel?(void 0!==t.xLabel&&(c+="x: "+t.xLabel+"
"),void 0!==t.yLabel&&(c+="y: "+t.yLabel+"
"),c+=(c?"z: ":"")+t.zLabel):L&&t[i+"Label"]===M?c=t[("x"===i?"y":"x")+"Label"]||"":void 0===t.xLabel?void 0!==t.yLabel&&(c=t.yLabel):c=void 0===t.yLabel?t.xLabel:"("+t.xLabel+", "+t.yLabel+")",!t.text&&0!==t.text||Array.isArray(t.text)||(c+=(c?"
":"")+t.text),void 0!==t.extraText&&(c+=(c?"
":"")+t.extraText),""===c&&(""===o&&e.remove(),c=o);var x=e.select("text.nums").call(u.font,t.fontFamily||d,t.fontSize||g,t.fontColor||m).text(c).attr("data-notex",1).call(l.positionText,0,0).call(l.convertToTspans,r),b=e.select("text.name"),_=0;o&&o!==c?(b.call(u.font,t.fontFamily||d,t.fontSize||g,p).text(o).attr("data-notex",1).call(l.positionText,0,0).call(l.convertToTspans,r),_=b.node().getBoundingClientRect().width+2*k):(b.remove(),e.select("rect").remove()),e.select("path").style({fill:p,stroke:m});var A,T,z=x.node().getBoundingClientRect(),P=t.xa._offset+(t.x0+t.x1)/2,D=t.ya._offset+(t.y0+t.y1)/2,O=Math.abs(t.x1-t.x0),I=Math.abs(t.y1-t.y0),R=z.width+w+k+_;t.ty0=S-z.top,t.bx=z.width+2*k,t.by=z.height+2*k,t.anchor="start",t.txwidth=z.width,t.tx2width=_,t.offset=0,a?(t.pos=P,A=D+I/2+R<=E,T=D-I/2-R>=0,"top"!==t.idealAlign&&A||!T?A?(D+=I/2,t.anchor="start"):t.anchor="middle":(D-=I/2,t.anchor="end")):(t.pos=D,A=P+O/2+R<=C,T=P-O/2-R>=0,"left"!==t.idealAlign&&A||!T?A?(P+=O/2,t.anchor="start"):t.anchor="middle":(P-=O/2,t.anchor="end")),x.attr("text-anchor",t.anchor),_&&b.attr("text-anchor",t.anchor),e.attr("transform","translate("+P+","+D+")"+(a?"rotate("+v+")":""))}),R}function A(t,e){t.each(function(t){var r=n.select(this);if(t.del)r.remove();else{var i="end"===t.anchor?-1:1,a=r.select("text.nums"),o={start:1,end:-1,middle:0}[t.anchor],s=o*(w+k),c=s+o*(t.txwidth+k),f=0,h=t.offset;"middle"===t.anchor&&(s-=t.tx2width/2,c+=t.txwidth/2+k),e&&(h*=-_,f=t.offset*b),r.select("path").attr("d","middle"===t.anchor?"M-"+(t.bx/2+t.tx2width/2)+","+(h-t.by/2)+"h"+t.bx+"v"+t.by+"h-"+t.bx+"Z":"M0,0L"+(i*w+f)+","+(w+h)+"v"+(t.by/2-w)+"h"+i*t.bx+"v-"+t.by+"H"+(i*w+f)+"V"+(h-w)+"Z"),a.call(l.positionText,s+f,h+t.ty0-t.by/2+k),t.tx2width&&(r.select("text.name").call(l.positionText,c+o*k+f,h+t.ty0-t.by/2+k),r.select("rect").call(u.setRect,c+(o-1)*t.tx2width/2+f,h-t.by/2-1,t.tx2width,t.by+2))}})}function T(t,e){var r=t.index,n=t.trace||{},i=t.cd[0],a=t.cd[r]||{},s=Array.isArray(r)?function(t,e){return o.castOption(i,r,t)||o.extractOption({},n,"",e)}:function(t,e){return o.extractOption(a,n,t,e)};function l(e,r,n){var i=s(r,n);i&&(t[e]=i)}if(l("hoverinfo","hi","hoverinfo"),l("color","hbg","hoverlabel.bgcolor"),l("borderColor","hbc","hoverlabel.bordercolor"),l("fontFamily","htf","hoverlabel.font.family"),l("fontSize","hts","hoverlabel.font.size"),l("fontColor","htc","hoverlabel.font.color"),l("nameLength","hnl","hoverlabel.namelength"),t.posref="y"===e?t.xa._offset+(t.x0+t.x1)/2:t.ya._offset+(t.y0+t.y1)/2,t.x0=o.constrain(t.x0,0,t.xa._length),t.x1=o.constrain(t.x1,0,t.xa._length),t.y0=o.constrain(t.y0,0,t.ya._length),t.y1=o.constrain(t.y1,0,t.ya._length),void 0!==t.xLabelVal&&(t.xLabel="xLabel"in t?t.xLabel:p.hoverLabelText(t.xa,t.xLabelVal),t.xVal=t.xa.c2d(t.xLabelVal)),void 0!==t.yLabelVal&&(t.yLabel="yLabel"in t?t.yLabel:p.hoverLabelText(t.ya,t.yLabelVal),t.yVal=t.ya.c2d(t.yLabelVal)),void 0!==t.zLabelVal&&void 0===t.zLabel&&(t.zLabel=String(t.zLabelVal)),!(isNaN(t.xerr)||"log"===t.xa.type&&t.xerr<=0)){var c=p.tickText(t.xa,t.xa.c2l(t.xerr),"hover").text;void 0!==t.xerrneg?t.xLabel+=" +"+c+" / -"+p.tickText(t.xa,t.xa.c2l(t.xerrneg),"hover").text:t.xLabel+=" \xb1 "+c,"x"===e&&(t.distance+=1)}if(!(isNaN(t.yerr)||"log"===t.ya.type&&t.yerr<=0)){var u=p.tickText(t.ya,t.ya.c2l(t.yerr),"hover").text;void 0!==t.yerrneg?t.yLabel+=" +"+u+" / -"+p.tickText(t.ya,t.ya.c2l(t.yerrneg),"hover").text:t.yLabel+=" \xb1 "+u,"y"===e&&(t.distance+=1)}var f=t.hoverinfo||t.trace.hoverinfo;return"all"!==f&&(-1===(f=Array.isArray(f)?f:f.split("+")).indexOf("x")&&(t.xLabel=void 0),-1===f.indexOf("y")&&(t.yLabel=void 0),-1===f.indexOf("z")&&(t.zLabel=void 0),-1===f.indexOf("text")&&(t.text=void 0),-1===f.indexOf("name")&&(t.name=void 0)),t}function S(t,e){var r,n,i=e.container,o=e.fullLayout,s=e.event,l=!!t.hLinePoint,c=!!t.vLinePoint;if(i.selectAll(".spikeline").remove(),c||l){var h=f.combine(o.plot_bgcolor,o.paper_bgcolor);if(l){var p,d,g=t.hLinePoint;r=g&&g.xa,"cursor"===(n=g&&g.ya).spikesnap?(p=s.pointerX,d=s.pointerY):(p=r._offset+g.x,d=n._offset+g.y);var m,v,y=a.readability(g.color,h)<1.5?f.contrast(h):g.color,x=n.spikemode,b=n.spikethickness,_=n.spikecolor||y,w=n._boundingBox,k=(w.left+w.right)/2w[0]._length||tt<0||tt>k[0]._length)return h.unhoverRaw(t,e)}if(e.pointerX=$+w[0]._offset,e.pointerY=tt+k[0]._offset,I="xval"in e?g.flat(l,e.xval):g.p2c(w,$),R="yval"in e?g.flat(l,e.yval):g.p2c(k,tt),!i(I[0])||!i(R[0]))return o.warn("Fx.hover failed",e,t),h.unhoverRaw(t,e)}var nt=1/0;for(F=0;FY&&(J.splice(0,Y),nt=J[0].distance),y&&0!==Z&&0===J.length){W.distance=Z,W.index=!1;var lt=j._module.hoverPoints(W,H,G,"closest",u._hoverlayer);if(lt&&(lt=lt.filter(function(t){return t.spikeDistance<=Z})),lt&<.length){var ct,ut=lt.filter(function(t){return t.xa.showspikes});if(ut.length){var ft=ut[0];i(ft.x0)&&i(ft.y0)&&(ct=gt(ft),(!Q.vLinePoint||Q.vLinePoint.spikeDistance>ct.spikeDistance)&&(Q.vLinePoint=ct))}var ht=lt.filter(function(t){return t.ya.showspikes});if(ht.length){var pt=ht[0];i(pt.x0)&&i(pt.y0)&&(ct=gt(pt),(!Q.hLinePoint||Q.hLinePoint.spikeDistance>ct.spikeDistance)&&(Q.hLinePoint=ct))}}}}function dt(t,e){for(var r,n=null,i=1/0,a=0;a1,Ct=f.combine(u.plot_bgcolor||f.background,u.paper_bgcolor),Et={hovermode:O,rotateLabels:St,bgColor:Ct,container:u._hoverlayer,outerContainer:u._paperdiv,commonLabelOpts:u.hoverlabel,hoverdistance:u.hoverdistance},Lt=M(J,Et,t);if(function(t,e,r){var n,i,a,o,s,l,c,u=0,f=t.map(function(t,n){var i=t[e];return[{i:n,dp:0,pos:t.pos,posref:t.posref,size:t.by*("x"===i._id.charAt(0)?x:1)/2,pmin:0,pmax:"x"===i._id.charAt(0)?r.width:r.height}]}).sort(function(t,e){return t[0].posref-e[0].posref});function h(t){var e=t[0],r=t[t.length-1];if(i=e.pmin-e.pos-e.dp+e.size,a=r.pos+r.dp+r.size-e.pmax,i>.01){for(s=t.length-1;s>=0;s--)t[s].dp+=i;n=!1}if(!(a<.01)){if(i<-.01){for(s=t.length-1;s>=0;s--)t[s].dp-=a;n=!1}if(n){var c=0;for(o=0;oe.pmax&&c++;for(o=t.length-1;o>=0&&!(c<=0);o--)(l=t[o]).pos>e.pmax-1&&(l.del=!0,c--);for(o=0;o=0;s--)t[s].dp-=a;for(o=t.length-1;o>=0&&!(c<=0);o--)(l=t[o]).pos+l.dp+l.size>e.pmax&&(l.del=!0,c--)}}}for(;!n&&u<=t.length;){for(u++,n=!0,o=0;o.01&&g.pmin===m.pmin&&g.pmax===m.pmax){for(s=d.length-1;s>=0;s--)d[s].dp+=i;for(p.push.apply(p,d),f.splice(o+1,1),c=0,s=p.length-1;s>=0;s--)c+=p[s].dp;for(a=c/p.length,s=p.length-1;s>=0;s--)p[s].dp-=a;n=!1}else o++}f.forEach(h)}for(o=f.length-1;o>=0;o--){var v=f[o];for(s=v.length-1;s>=0;s--){var y=v[s],b=t[y.i];b.offset=y.dp,b.del=y.del}}}(J,St?"xa":"ya",u),A(Lt,St),e.target&&e.target.tagName){var zt=d.getComponentMethod("annotations","hasClickToShow")(t,At);c(n.select(e.target),zt?"pointer":"")}if(!e.target||a||!function(t,e,r){if(!r||r.length!==t._hoverdata.length)return!0;for(var n=r.length-1;n>=0;n--){var i=r[n],a=t._hoverdata[n];if(i.curveNumber!==a.curveNumber||String(i.pointNumber)!==String(a.pointNumber))return!0}return!1}(t,0,Mt))return;Mt&&t.emit("plotly_unhover",{event:e,points:Mt});t.emit("plotly_hover",{event:e,points:t._hoverdata,xaxes:w,yaxes:k,xvals:I,yvals:R})}(t,e,r,a)})},r.loneHover=function(t,e){var r={color:t.color||f.defaultLine,x0:t.x0||t.x||0,x1:t.x1||t.x||0,y0:t.y0||t.y||0,y1:t.y1||t.y||0,xLabel:t.xLabel,yLabel:t.yLabel,zLabel:t.zLabel,text:t.text,name:t.name,idealAlign:t.idealAlign,borderColor:t.borderColor,fontFamily:t.fontFamily,fontSize:t.fontSize,fontColor:t.fontColor,trace:{index:0,hoverinfo:""},xa:{_offset:0},ya:{_offset:0},index:0},i=n.select(e.container),a=e.outerContainer?n.select(e.outerContainer):i,o={hovermode:"closest",rotateLabels:!1,bgColor:e.bgColor||f.background,container:i,outerContainer:a},s=M([r],o,e.gd);return A(s,o.rotateLabels),s.node()}},{"../../lib":660,"../../lib/events":648,"../../lib/override_cursor":671,"../../lib/svg_text_utils":684,"../../plots/cartesian/axes":706,"../../registry":790,"../color":532,"../dragelement":554,"../drawing":557,"./constants":569,"./helpers":571,d3:131,"fast-isnumeric":197,tinycolor2:473}],573:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e,r,i){r("hoverlabel.bgcolor",(i=i||{}).bgcolor),r("hoverlabel.bordercolor",i.bordercolor),r("hoverlabel.namelength",i.namelength),n.coerceFont(r,"hoverlabel.font",i.font)}},{"../../lib":660}],574:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../dragelement"),o=t("./helpers"),s=t("./layout_attributes");e.exports={moduleType:"component",name:"fx",constants:t("./constants"),schema:{layout:s},attributes:t("./attributes"),layoutAttributes:s,supplyLayoutGlobalDefaults:t("./layout_global_defaults"),supplyDefaults:t("./defaults"),supplyLayoutDefaults:t("./layout_defaults"),calc:t("./calc"),getDistanceFunction:o.getDistanceFunction,getClosest:o.getClosest,inbox:o.inbox,quadrature:o.quadrature,appendArrayPointValue:o.appendArrayPointValue,castHoverOption:function(t,e,r){return i.castOption(t,e,"hoverlabel."+r)},castHoverinfo:function(t,e,r){return i.castOption(t,r,"hoverinfo",function(r){return i.coerceHoverinfo({hoverinfo:r},{_module:t._module},e)})},hover:t("./hover").hover,unhover:a.unhover,loneHover:t("./hover").loneHover,loneUnhover:function(t){var e=i.isD3Selection(t)?t:n.select(t);e.selectAll("g.hovertext").remove(),e.selectAll(".spikeline").remove()},click:t("./click")}},{"../../lib":660,"../dragelement":554,"./attributes":566,"./calc":567,"./click":568,"./constants":569,"./defaults":570,"./helpers":571,"./hover":572,"./layout_attributes":575,"./layout_defaults":576,"./layout_global_defaults":577,d3:131}],575:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../plots/font_attributes")({editType:"none"});i.family.dflt=n.HOVERFONT,i.size.dflt=n.HOVERFONTSIZE,e.exports={dragmode:{valType:"enumerated",values:["zoom","pan","select","lasso","orbit","turntable"],dflt:"zoom",editType:"modebar"},hovermode:{valType:"enumerated",values:["x","y","closest",!1],editType:"modebar"},hoverdistance:{valType:"integer",min:-1,dflt:20,editType:"none"},spikedistance:{valType:"integer",min:-1,dflt:20,editType:"none"},hoverlabel:{bgcolor:{valType:"color",editType:"none"},bordercolor:{valType:"color",editType:"none"},font:i,namelength:{valType:"integer",min:-1,dflt:15,editType:"none"},editType:"none"},selectdirection:{valType:"enumerated",values:["h","v","d","any"],dflt:"any",editType:"none"}}},{"../../plots/font_attributes":732,"./constants":569}],576:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./layout_attributes");e.exports=function(t,e,r){function a(r,a){return n.coerce(t,e,i,r,a)}var o;"select"===a("dragmode")&&a("selectdirection"),e._has("cartesian")?(e._isHoriz=function(t){for(var e=!0,r=0;r1){f||h||p||"independent"===k("pattern")&&(f=!0),g._hasSubplotGrid=f;var y,x,b="top to bottom"===k("roworder"),_=f?.2:.1,w=f?.3:.1;d&&e._splomGridDflt&&(y=e._splomGridDflt.xside,x=e._splomGridDflt.yside),g._domains={x:c("x",k,_,y,v),y:c("y",k,w,x,m,b)},e.grid=g}}function k(t,e){return n.coerce(r,g,s,t,e)}},contentDefaults:function(t,e){var r=e.grid;if(r&&r._domains){var n,i,a,o,s,c,f,h=t.grid||{},p=e._subplots,d=r._hasSubplotGrid,g=r.rows,m=r.columns,v="independent"===r.pattern,y=r._axisMap={};if(d){var x=h.subplots||[];c=r.subplots=new Array(g);var b=1;for(n=0;n=2/3},r.isCenterAnchor=function(t){return"center"===t.xanchor||"auto"===t.xanchor&&t.x>1/3&&t.x<2/3},r.isBottomAnchor=function(t){return"bottom"===t.yanchor||"auto"===t.yanchor&&t.y<=1/3},r.isMiddleAnchor=function(t){return"middle"===t.yanchor||"auto"===t.yanchor&&t.y>1/3&&t.y<2/3}},{}],585:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../color/attributes");e.exports={bgcolor:{valType:"color",editType:"legend"},bordercolor:{valType:"color",dflt:i.defaultLine,editType:"legend"},borderwidth:{valType:"number",min:0,dflt:0,editType:"legend"},font:n({editType:"legend"}),orientation:{valType:"enumerated",values:["v","h"],dflt:"v",editType:"legend"},traceorder:{valType:"flaglist",flags:["reversed","grouped"],extras:["normal"],editType:"legend"},tracegroupgap:{valType:"number",min:0,dflt:10,editType:"legend"},x:{valType:"number",min:-2,max:3,dflt:1.02,editType:"legend"},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"left",editType:"legend"},y:{valType:"number",min:-2,max:3,dflt:1,editType:"legend"},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"auto",editType:"legend"},editType:"legend"}},{"../../plots/font_attributes":732,"../color/attributes":531}],586:[function(t,e,r){"use strict";e.exports={scrollBarWidth:6,scrollBarMinHeight:20,scrollBarColor:"#808BA4",scrollBarMargin:4}},{}],587:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("./attributes"),o=t("../../plots/layout_attributes"),s=t("./helpers");e.exports=function(t,e,r){for(var l,c,u,f,h=t.legend||{},p={},d=0,g="normal",m=0;m1)){if(e.legend=p,y("bgcolor",e.paper_bgcolor),y("bordercolor"),y("borderwidth"),i.coerceFont(y,"font",e.font),y("orientation"),"h"===p.orientation){var x=t.xaxis;x&&x.rangeslider&&x.rangeslider.visible?(l=0,u="left",c=1.1,f="bottom"):(l=0,u="left",c=-.1,f="top")}y("traceorder",g),s.isGrouped(e.legend)&&y("tracegroupgap"),y("x",l),y("xanchor",u),y("y",c),y("yanchor",f),i.noneOrAll(h,p,["x","y"])}}},{"../../lib":660,"../../plots/layout_attributes":759,"../../registry":790,"./attributes":585,"./helpers":591}],588:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib/events"),l=t("../dragelement"),c=t("../drawing"),u=t("../color"),f=t("../../lib/svg_text_utils"),h=t("./handle_click"),p=t("./constants"),d=t("../../constants/interactions"),g=t("../../constants/alignment"),m=g.LINE_SPACING,v=g.FROM_TL,y=g.FROM_BR,x=t("./get_legend_data"),b=t("./style"),_=t("./helpers"),w=t("./anchor_utils"),k=d.DBLCLICKDELAY;function M(t,e,r,n,i){var a=r.data()[0][0].trace,o={event:i,node:r.node(),curveNumber:a.index,expandedIndex:a._expandedIndex,data:t.data,layout:t.layout,frames:t._transitionData._frames,config:t._context,fullData:t._fullData,fullLayout:t._fullLayout};if(a._group&&(o.group=a._group),"pie"===a.type&&(o.label=r.datum()[0].label),!1!==s.triggerHandler(t,"plotly_legendclick",o))if(1===n)e._clickTimeout=setTimeout(function(){h(r,t,n)},k);else if(2===n){e._clickTimeout&&clearTimeout(e._clickTimeout),t._legendMouseDownTime=0,!1!==s.triggerHandler(t,"plotly_legenddoubleclick",o)&&h(r,t,n)}}function A(t,e,r){var n=t.data()[0][0],a=e._fullLayout,s=n.trace,l=o.traceIs(s,"pie"),u=s.index,h=l?n.label:s.name,p=e._context.edits.legendText&&!l,d=i.ensureSingle(t,"text","legendtext");function g(r){f.convertToTspans(r,e,function(){!function(t,e){var r=t.data()[0][0];if(!r.trace.showlegend)return void t.remove();var n,i,a=t.select("g[class*=math-group]"),o=a.node(),s=e._fullLayout.legend.font.size*m;if(o){var l=c.bBox(o);n=l.height,i=l.width,c.setTranslate(a,0,n/4)}else{var u=t.select(".legendtext"),h=f.lineCount(u),p=u.node();n=s*h,i=p?c.bBox(p).width:0;var d=s*(.3+(1-h)/2);f.positionText(u,40,d)}n=Math.max(n,16)+3,r.height=n,r.width=i}(t,e)})}d.attr("text-anchor","start").classed("user-select-none",!0).call(c.font,a.legend.font).text(p?T(h,r):h),p?d.call(f.makeEditable,{gd:e,text:h}).call(g).on("edit",function(t){this.text(T(t,r)).call(g);var a=n.trace._fullInput||{},s={};if(o.hasTransform(a,"groupby")){var l=o.getTransformIndices(a,"groupby"),c=l[l.length-1],f=i.keyedContainer(a,"transforms["+c+"].styles","target","value.name");f.set(n.trace._group,t),s=f.constructUpdate()}else s.name=t;return o.call("restyle",e,s,u)}):g(d)}function T(t,e){var r=Math.max(4,e);if(t&&t.trim().length>=r/2)return t;for(var n=r-(t=t||"").length;n>0;n--)t+=" ";return t}function S(t,e){var r,a=1,o=i.ensureSingle(t,"rect","legendtoggle",function(t){t.style("cursor","pointer").attr("pointer-events","all").call(u.fill,"rgba(0,0,0,0)")});o.on("mousedown",function(){(r=(new Date).getTime())-e._legendMouseDownTimek&&(a=Math.max(a-1,1)),M(e,r,t,a,n.event)}})}function C(t,e,r){var i=t._fullLayout,a=i.legend,o=a.borderwidth,s=_.isGrouped(a),l=0;if(a._width=0,a._height=0,_.isVertical(a))s&&e.each(function(t,e){c.setTranslate(this,0,e*a.tracegroupgap)}),r.each(function(t){var e=t[0],r=e.height,n=e.width;c.setTranslate(this,o,5+o+a._height+r/2),a._height+=r,a._width=Math.max(a._width,n)}),a._width+=45+2*o,a._height+=10+2*o,s&&(a._height+=(a._lgroupsLength-1)*a.tracegroupgap),l=40;else if(s){for(var u=[a._width],f=e.data(),h=0,p=f.length;ho+w-k,r.each(function(t){var e=t[0],r=m?40+t[0].width:x;o+b+k+r>i.width-(i.margin.r+i.margin.l)&&(b=0,v+=y,a._height=a._height+y,y=0),c.setTranslate(this,o+b,5+o+e.height/2+v),a._width+=k+r,a._height=Math.max(a._height,e.height),b+=k+r,y=Math.max(e.height,y)}),a._width+=2*o,a._height+=10+2*o}a._width=Math.ceil(a._width),a._height=Math.ceil(a._height),r.each(function(e){var r=e[0],i=n.select(this).select(".legendtoggle");c.setRect(i,0,-r.height/2,(t._context.edits.legendText?0:a._width)+l,r.height)})}function E(t){var e=t._fullLayout.legend,r="left";w.isRightAnchor(e)?r="right":w.isCenterAnchor(e)&&(r="center");var n="top";w.isBottomAnchor(e)?n="bottom":w.isMiddleAnchor(e)&&(n="middle"),a.autoMargin(t,"legend",{x:e.x,y:e.y,l:e._width*v[r],r:e._width*y[r],b:e._height*y[n],t:e._height*v[n]})}e.exports=function(t){var e=t._fullLayout,r="legend"+e._uid;if(e._infolayer&&t.calcdata){t._legendMouseDownTime||(t._legendMouseDownTime=0);var s=e.legend,f=e.showlegend&&x(t.calcdata,s),h=e.hiddenlabels||[];if(!e.showlegend||!f.length)return e._infolayer.selectAll(".legend").remove(),e._topdefs.select("#"+r).remove(),void a.autoMargin(t,"legend");for(var d=0,g=0;gN?function(t){var e=t._fullLayout.legend,r="left";w.isRightAnchor(e)?r="right":w.isCenterAnchor(e)&&(r="center");a.autoMargin(t,"legend",{x:e.x,y:.5,l:e._width*v[r],r:e._width*y[r],b:0,t:0})}(t):E(t);var j=e._size,V=j.l+j.w*s.x,U=j.t+j.h*(1-s.y);w.isRightAnchor(s)?V-=s._width:w.isCenterAnchor(s)&&(V-=s._width/2),w.isBottomAnchor(s)?U-=s._height:w.isMiddleAnchor(s)&&(U-=s._height/2);var q=s._width,H=j.w;q>H?(V=j.l,q=H):(V+q>F&&(V=F-q),V<0&&(V=0),q=Math.min(F-V,s._width));var G,W,Y,X,Z=s._height,J=j.h;if(Z>J?(U=j.t,Z=J):(U+Z>N&&(U=N-Z),U<0&&(U=0),Z=Math.min(N-U,s._height)),c.setTranslate(z,V,U),I.on(".drag",null),z.on("wheel",null),s._height<=Z||t._context.staticPlot)D.attr({width:q-s.borderwidth,height:Z-s.borderwidth,x:s.borderwidth/2,y:s.borderwidth/2}),c.setTranslate(O,0,0),P.select("rect").attr({width:q-2*s.borderwidth,height:Z-2*s.borderwidth,x:s.borderwidth,y:s.borderwidth}),c.setClipUrl(O,r),c.setRect(I,0,0,0,0),delete s._scrollY;else{var K,Q,$=Math.max(p.scrollBarMinHeight,Z*Z/s._height),tt=Z-$-2*p.scrollBarMargin,et=s._height-Z,rt=tt/et,nt=Math.min(s._scrollY||0,et);D.attr({width:q-2*s.borderwidth+p.scrollBarWidth+p.scrollBarMargin,height:Z-s.borderwidth,x:s.borderwidth/2,y:s.borderwidth/2}),P.select("rect").attr({width:q-2*s.borderwidth+p.scrollBarWidth+p.scrollBarMargin,height:Z-2*s.borderwidth,x:s.borderwidth,y:s.borderwidth+nt}),c.setClipUrl(O,r),at(nt,$,rt),z.on("wheel",function(){at(nt=i.constrain(s._scrollY+n.event.deltaY/tt*et,0,et),$,rt),0!==nt&&nt!==et&&n.event.preventDefault()});var it=n.behavior.drag().on("dragstart",function(){K=n.event.sourceEvent.clientY,Q=nt}).on("drag",function(){var t=n.event.sourceEvent;2===t.buttons||t.ctrlKey||at(nt=i.constrain((t.clientY-K)/rt+Q,0,et),$,rt)});I.call(it)}if(t._context.edits.legendPosition)z.classed("cursor-move",!0),l.init({element:z.node(),gd:t,prepFn:function(){var t=c.getTranslate(z);Y=t.x,X=t.y},moveFn:function(t,e){var r=Y+t,n=X+e;c.setTranslate(z,r,n),G=l.align(r,0,j.l,j.l+j.w,s.xanchor),W=l.align(n,0,j.t+j.h,j.t,s.yanchor)},doneFn:function(){void 0!==G&&void 0!==W&&o.call("relayout",t,{"legend.x":G,"legend.y":W})},clickFn:function(r,n){var i=e._infolayer.selectAll("g.traces").filter(function(){var t=this.getBoundingClientRect();return n.clientX>=t.left&&n.clientX<=t.right&&n.clientY>=t.top&&n.clientY<=t.bottom});i.size()>0&&M(t,z,i,r,n)}})}function at(e,r,n){s._scrollY=t._fullLayout.legend._scrollY=e,c.setTranslate(O,0,-e),c.setRect(I,q,p.scrollBarMargin+e*n,p.scrollBarWidth,r),P.select("rect").attr({y:s.borderwidth+e})}}},{"../../constants/alignment":632,"../../constants/interactions":636,"../../lib":660,"../../lib/events":648,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../../registry":790,"../color":532,"../dragelement":554,"../drawing":557,"./anchor_utils":584,"./constants":586,"./get_legend_data":589,"./handle_click":590,"./helpers":591,"./style":593,d3:131}],589:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("./helpers");e.exports=function(t,e){var r,a,o={},s=[],l=!1,c={},u=0;function f(t,r){if(""!==t&&i.isGrouped(e))-1===s.indexOf(t)?(s.push(t),l=!0,o[t]=[[r]]):o[t].push([r]);else{var n="~~i"+u;s.push(n),o[n]=[[r]],u++}}for(r=0;rr[1])return r[1]}return i}function d(t){return t[0]}if(u||f||h){var g={},m={};u&&(g.mc=p("marker.color",d),g.mo=p("marker.opacity",a.mean,[.2,1]),g.ms=p("marker.size",a.mean,[2,16]),g.mlc=p("marker.line.color",d),g.mlw=p("marker.line.width",a.mean,[0,5]),m.marker={sizeref:1,sizemin:1,sizemode:"diameter"}),h&&(m.line={width:p("line.width",d,[0,10])}),f&&(g.tx="Aa",g.tp=p("textposition",d),g.ts=10,g.tc=p("textfont.color",d),g.tf=p("textfont.family",d)),r=[a.minExtend(s,g)],(i=a.minExtend(c,m)).selectedpoints=null}var v=n.select(this).select("g.legendpoints"),y=v.selectAll("path.scatterpts").data(u?r:[]);y.enter().append("path").classed("scatterpts",!0).attr("transform","translate(20,0)"),y.exit().remove(),y.call(o.pointStyle,i,e),u&&(r[0].mrc=3);var x=v.selectAll("g.pointtext").data(f?r:[]);x.enter().append("g").classed("pointtext",!0).append("text").attr("transform","translate(20,0)"),x.exit().remove(),x.selectAll("text").call(o.textPointStyle,i,e)}).each(function(t){var e=t[0].trace,r=n.select(this).select("g.legendpoints").selectAll("path.legendcandle").data("candlestick"===e.type&&e.visible?[t,t]:[]);r.enter().append("path").classed("legendcandle",!0).attr("d",function(t,e){return e?"M-15,0H-8M-8,6V-6H8Z":"M15,0H8M8,-6V6H-8Z"}).attr("transform","translate(20,0)").style("stroke-miterlimit",1),r.exit().remove(),r.each(function(t,r){var i=e[r?"increasing":"decreasing"],a=i.line.width,o=n.select(this);o.style("stroke-width",a+"px").call(s.fill,i.fillcolor),a&&s.stroke(o,i.line.color)})}).each(function(t){var e=t[0].trace,r=n.select(this).select("g.legendpoints").selectAll("path.legendohlc").data("ohlc"===e.type&&e.visible?[t,t]:[]);r.enter().append("path").classed("legendohlc",!0).attr("d",function(t,e){return e?"M-15,0H0M-8,-6V0":"M15,0H0M8,6V0"}).attr("transform","translate(20,0)").style("stroke-miterlimit",1),r.exit().remove(),r.each(function(t,r){var i=e[r?"increasing":"decreasing"],a=i.line.width,l=n.select(this);l.style("fill","none").call(o.dashLine,i.line.dash,a),a&&s.stroke(l,i.line.color)})})}},{"../../lib":660,"../../registry":790,"../../traces/pie/style_one":976,"../../traces/scatter/subtypes":1012,"../color":532,"../drawing":557,d3:131}],594:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../plots/plots"),a=t("../../plots/cartesian/axis_ids"),o=t("../../lib"),s=t("../../../build/ploticon"),l=o._,c=e.exports={};function u(t,e){var r,i,o=e.currentTarget,s=o.getAttribute("data-attr"),l=o.getAttribute("data-val")||!0,c=t._fullLayout,u={},f=a.list(t,null,!0),h="on";if("zoom"===s){var p,d="in"===l?.5:2,g=(1+d)/2,m=(1-d)/2;for(i=0;i1?(_=["toggleHover"],w=["resetViews"]):f?(b=["zoomInGeo","zoomOutGeo"],_=["hoverClosestGeo"],w=["resetGeo"]):u?(_=["hoverClosest3d"],w=["resetCameraDefault3d","resetCameraLastSave3d"]):g?(_=["toggleHover"],w=["resetViewMapbox"]):_=p?["hoverClosestGl2d"]:h?["hoverClosestPie"]:["toggleHover"];c&&(_=["toggleSpikelines","hoverClosestCartesian","hoverCompareCartesian"]);!c&&!p||v||(b=["zoomIn2d","zoomOut2d","autoScale2d"],"resetViews"!==w[0]&&(w=["resetScale2d"]));u?k=["zoom3d","pan3d","orbitRotation","tableRotation"]:(c||p)&&!v||d?k=["zoom2d","pan2d"]:g||f?k=["pan2d"]:m&&(k=["zoom2d"]);(function(t){for(var e=!1,r=0;r0)){var d=function(t,e,r){for(var n=r.filter(function(r){return e[r].anchor===t._id}),i=0,a=0;a0?h+c:c;return{ppad:c,ppadplus:u?d:g,ppadminus:u?g:d}}return{ppad:c}}function u(t,e,r,n,i){var s="category"===t.type?t.r2c:t.d2c;if(void 0!==e)return[s(e),s(r)];if(n){var l,c,u,f,h=1/0,p=-1/0,d=n.match(a.segmentRE);for("date"===t.type&&(s=o.decodeDate(s)),l=0;lp&&(p=f)));return p>=h?[h,p]:void 0}}e.exports=function(t){var e=t._fullLayout,r=n.filterVisible(e.shapes);if(r.length&&t._fullData.length)for(var o=0;o10?t/2:10;return n.append("circle").attr({"data-line-point":"start-point",cx:W?Q(r.xanchor)+r.x0:Q(r.x0),cy:Y?$(r.yanchor)-r.y0:$(r.y0),r:a}).style(i).classed("cursor-grab",!0),n.append("circle").attr({"data-line-point":"end-point",cx:W?Q(r.xanchor)+r.x1:Q(r.x1),cy:Y?$(r.yanchor)-r.y1:$(r.y1),r:a}).style(i).classed("cursor-grab",!0),n}():e,nt={element:rt.node(),gd:t,prepFn:function(n){var i="shapes["+o+"]";W&&(_=Q(r.xanchor),S=i+".xanchor");Y&&(w=$(r.yanchor),C=i+".yanchor");"path"===r.type?(V=r.path,U=i+".path"):(v=W?r.x0:Q(r.x0),y=Y?r.y0:$(r.y0),x=W?r.x1:Q(r.x1),b=Y?r.y1:$(r.y1),k=i+".x0",M=i+".y0",A=i+".x1",T=i+".y1");vb?(E=y,D=i+".y0",B="y0",L=b,O=i+".y1",F="y1"):(E=b,D=i+".y1",B="y1",L=y,O=i+".y0",F="y0");m={},it(n),st(h,r),function(t,e,r){var n=e.xref,i=e.yref,o=a.getFromId(r,n),l=a.getFromId(r,i),c="";"paper"===n||o.autorange||(c+=n);"paper"===i||l.autorange||(c+=i);t.call(s.setClipUrl,c?"clip"+r._fullLayout._uid+c:null)}(e,r,t),nt.moveFn="move"===q?at:ot},doneFn:function(){c(e),lt(h),p(e,t,r),n.call("relayout",t,m)},clickFn:function(){lt(h)}};function it(t){if(X)q="path"===t.target.tagName?"move":"start-point"===t.target.attributes["data-line-point"].value?"resize-over-start-point":"resize-over-end-point";else{var r=nt.element.getBoundingClientRect(),n=r.right-r.left,i=r.bottom-r.top,a=t.clientX-r.left,o=t.clientY-r.top,s=!Z&&n>H&&i>G&&!t.shiftKey?l.getCursor(a/n,1-o/i):"move";c(e,s),q=s.split("-")[0]}}function at(n,i){if("path"===r.type){var a=function(t){return t},o=a,s=a;W?m[S]=r.xanchor=tt(_+n):(o=function(t){return tt(Q(t)+n)},J&&"date"===J.type&&(o=f.encodeDate(o))),Y?m[C]=r.yanchor=et(w+i):(s=function(t){return et($(t)+i)},K&&"date"===K.type&&(s=f.encodeDate(s))),r.path=g(V,o,s),m[U]=r.path}else W?m[S]=r.xanchor=tt(_+n):(m[k]=r.x0=tt(v+n),m[A]=r.x1=tt(x+n)),Y?m[C]=r.yanchor=et(w+i):(m[M]=r.y0=et(y+i),m[T]=r.y1=et(b+i));e.attr("d",d(t,r)),st(h,r)}function ot(n,i){if(Z){var a=function(t){return t},o=a,s=a;W?m[S]=r.xanchor=tt(_+n):(o=function(t){return tt(Q(t)+n)},J&&"date"===J.type&&(o=f.encodeDate(o))),Y?m[C]=r.yanchor=et(w+i):(s=function(t){return et($(t)+i)},K&&"date"===K.type&&(s=f.encodeDate(s))),r.path=g(V,o,s),m[U]=r.path}else if(X){if("resize-over-start-point"===q){var l=v+n,c=Y?y-i:y+i;m[k]=r.x0=W?l:tt(l),m[M]=r.y0=Y?c:et(c)}else if("resize-over-end-point"===q){var u=x+n,p=Y?b-i:b+i;m[A]=r.x1=W?u:tt(u),m[T]=r.y1=Y?p:et(p)}}else{var rt=~q.indexOf("n")?E+i:E,nt=~q.indexOf("s")?L+i:L,it=~q.indexOf("w")?z+n:z,at=~q.indexOf("e")?P+n:P;~q.indexOf("n")&&Y&&(rt=E-i),~q.indexOf("s")&&Y&&(nt=L-i),(!Y&&nt-rt>G||Y&&rt-nt>G)&&(m[D]=r[B]=Y?rt:et(rt),m[O]=r[F]=Y?nt:et(nt)),at-it>H&&(m[I]=r[N]=W?it:tt(it),m[R]=r[j]=W?at:tt(at))}e.attr("d",d(t,r)),st(h,r)}function st(t,e){(W||Y)&&function(){var r="path"!==e.type,n=t.selectAll(".visual-cue").data([0]);n.enter().append("path").attr({fill:"#fff","fill-rule":"evenodd",stroke:"#000","stroke-width":1}).classed("visual-cue",!0);var a=Q(W?e.xanchor:i.midRange(r?[e.x0,e.x1]:f.extractPathCoords(e.path,u.paramIsX))),o=$(Y?e.yanchor:i.midRange(r?[e.y0,e.y1]:f.extractPathCoords(e.path,u.paramIsY)));if(a=f.roundPositionForSharpStrokeRendering(a,1),o=f.roundPositionForSharpStrokeRendering(o,1),W&&Y){var s="M"+(a-1-1)+","+(o-1-1)+"h-8v2h8 v8h2v-8 h8v-2h-8 v-8h-2 Z";n.attr("d",s)}else if(W){var l="M"+(a-1-1)+","+(o-9-1)+"v18 h2 v-18 Z";n.attr("d",l)}else{var c="M"+(a-9-1)+","+(o-1-1)+"h18 v2 h-18 Z";n.attr("d",c)}}()}function lt(t){t.selectAll(".visual-cue").remove()}l.init(nt),rt.node().onmousemove=it}(t,y,h,e,r)}}function p(t,e,r){var n=(r.xref+r.yref).replace(/paper/g,"");t.call(s.setClipUrl,n?"clip"+e._fullLayout._uid+n:null)}function d(t,e){var r,n,o,s,l,c,h,p,d=e.type,g=a.getFromId(t,e.xref),m=a.getFromId(t,e.yref),v=t._fullLayout._size;if(g?(r=f.shapePositionToRange(g),n=function(t){return g._offset+g.r2p(r(t,!0))}):n=function(t){return v.l+v.w*t},m?(o=f.shapePositionToRange(m),s=function(t){return m._offset+m.r2p(o(t,!0))}):s=function(t){return v.t+v.h*(1-t)},"path"===d)return g&&"date"===g.type&&(n=f.decodeDate(n)),m&&"date"===m.type&&(s=f.decodeDate(s)),function(t,e,r){var n=t.path,a=t.xsizemode,o=t.ysizemode,s=t.xanchor,l=t.yanchor;return n.replace(u.segmentRE,function(t){var n=0,c=t.charAt(0),f=u.paramIsX[c],h=u.paramIsY[c],p=u.numParams[c],d=t.substr(1).replace(u.paramRE,function(t){return f[n]?t="pixel"===a?e(s)+Number(t):e(t):h[n]&&(t="pixel"===o?r(l)-Number(t):r(t)),++n>p&&(t="X"),t});return n>p&&(d=d.replace(/[\s,]*X.*/,""),i.log("Ignoring extra params in segment "+t)),c+d})}(e,n,s);if("pixel"===e.xsizemode){var y=n(e.xanchor);l=y+e.x0,c=y+e.x1}else l=n(e.x0),c=n(e.x1);if("pixel"===e.ysizemode){var x=s(e.yanchor);h=x-e.y0,p=x-e.y1}else h=s(e.y0),p=s(e.y1);if("line"===d)return"M"+l+","+h+"L"+c+","+p;if("rect"===d)return"M"+l+","+h+"H"+c+"V"+p+"H"+l+"Z";var b=(l+c)/2,_=(h+p)/2,w=Math.abs(b-l),k=Math.abs(_-h),M="A"+w+","+k,A=b+w+","+_;return"M"+A+M+" 0 1,1 "+(b+","+(_-k))+M+" 0 0,1 "+A+"Z"}function g(t,e,r){return t.replace(u.segmentRE,function(t){var n=0,i=t.charAt(0),a=u.paramIsX[i],o=u.paramIsY[i],s=u.numParams[i];return i+t.substr(1).replace(u.paramRE,function(t){return n>=s?t:(a[n]?t=e(t):o[n]&&(t=r(t)),n++,t)})})}e.exports={draw:function(t){var e=t._fullLayout;for(var r in e._shapeUpperLayer.selectAll("path").remove(),e._shapeLowerLayer.selectAll("path").remove(),e._plots){var n=e._plots[r].shapelayer;n&&n.selectAll("path").remove()}for(var i=0;i0)&&(i("active"),i("x"),i("y"),n.noneOrAll(t,e,["x","y"]),i("xanchor"),i("yanchor"),i("len"),i("lenmode"),i("pad.t"),i("pad.r"),i("pad.b"),i("pad.l"),n.coerceFont(i,"font",r.font),i("currentvalue.visible")&&(i("currentvalue.xanchor"),i("currentvalue.prefix"),i("currentvalue.suffix"),i("currentvalue.offset"),n.coerceFont(i,"currentvalue.font",e.font)),i("transition.duration"),i("transition.easing"),i("bgcolor"),i("activebgcolor"),i("bordercolor"),i("borderwidth"),i("ticklen"),i("tickwidth"),i("tickcolor"),i("minorticklen"))}e.exports=function(t,e){i(t,e,{name:o,handleItemDefaults:l})}},{"../../lib":660,"../../plots/array_container_defaults":702,"./attributes":620,"./constants":621}],623:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/plots"),a=t("../color"),o=t("../drawing"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../legend/anchor_utils"),u=t("./constants"),f=t("../../constants/alignment"),h=f.LINE_SPACING,p=f.FROM_TL,d=f.FROM_BR;function g(t){return t._index}function m(t,e){var r=o.tester.selectAll("g."+u.labelGroupClass).data(e.steps);r.enter().append("g").classed(u.labelGroupClass,!0);var a=0,s=0;r.each(function(t){var r=x(n.select(this),{step:t},e).node();if(r){var i=o.bBox(r);s=Math.max(s,i.height),a=Math.max(a,i.width)}}),r.remove();var f=e._dims={};f.inputAreaWidth=Math.max(u.railWidth,u.gripHeight);var h=t._fullLayout._size;f.lx=h.l+h.w*e.x,f.ly=h.t+h.h*(1-e.y),"fraction"===e.lenmode?f.outerLength=Math.round(h.w*e.len):f.outerLength=e.len,f.inputAreaStart=0,f.inputAreaLength=Math.round(f.outerLength-e.pad.l-e.pad.r);var g=(f.inputAreaLength-2*u.stepInset)/(e.steps.length-1),m=a+u.labelPadding;if(f.labelStride=Math.max(1,Math.ceil(m/g)),f.labelHeight=s,f.currentValueMaxWidth=0,f.currentValueHeight=0,f.currentValueTotalHeight=0,f.currentValueMaxLines=1,e.currentvalue.visible){var y=o.tester.append("g");r.each(function(t){var r=v(y,e,t.label),n=r.node()&&o.bBox(r.node())||{width:0,height:0},i=l.lineCount(r);f.currentValueMaxWidth=Math.max(f.currentValueMaxWidth,Math.ceil(n.width)),f.currentValueHeight=Math.max(f.currentValueHeight,Math.ceil(n.height)),f.currentValueMaxLines=Math.max(f.currentValueMaxLines,i)}),f.currentValueTotalHeight=f.currentValueHeight+e.currentvalue.offset,y.remove()}f.height=f.currentValueTotalHeight+u.tickOffset+e.ticklen+u.labelOffset+f.labelHeight+e.pad.t+e.pad.b;var b="left";c.isRightAnchor(e)&&(f.lx-=f.outerLength,b="right"),c.isCenterAnchor(e)&&(f.lx-=f.outerLength/2,b="center");var _="top";c.isBottomAnchor(e)&&(f.ly-=f.height,_="bottom"),c.isMiddleAnchor(e)&&(f.ly-=f.height/2,_="middle"),f.outerLength=Math.ceil(f.outerLength),f.height=Math.ceil(f.height),f.lx=Math.round(f.lx),f.ly=Math.round(f.ly),i.autoMargin(t,u.autoMarginIdRoot+e._index,{x:e.x,y:e.y,l:f.outerLength*p[b],r:f.outerLength*d[b],b:f.height*d[_],t:f.height*p[_]})}function v(t,e,r){if(e.currentvalue.visible){var n,i,a=e._dims;switch(e.currentvalue.xanchor){case"right":n=a.inputAreaLength-u.currentValueInset-a.currentValueMaxWidth,i="left";break;case"center":n=.5*a.inputAreaLength,i="middle";break;default:n=u.currentValueInset,i="left"}var c=s.ensureSingle(t,"text",u.labelClass,function(t){t.classed("user-select-none",!0).attr({"text-anchor":i,"data-notex":1})}),f=e.currentvalue.prefix?e.currentvalue.prefix:"";if("string"==typeof r)f+=r;else f+=e.steps[e.active].label;e.currentvalue.suffix&&(f+=e.currentvalue.suffix),c.call(o.font,e.currentvalue.font).text(f).call(l.convertToTspans,e._gd);var p=l.lineCount(c),d=(a.currentValueMaxLines+1-p)*e.currentvalue.font.size*h;return l.positionText(c,n,d),c}}function y(t,e,r){s.ensureSingle(t,"rect",u.gripRectClass,function(n){n.call(k,e,t,r).style("pointer-events","all")}).attr({width:u.gripWidth,height:u.gripHeight,rx:u.gripRadius,ry:u.gripRadius}).call(a.stroke,r.bordercolor).call(a.fill,r.bgcolor).style("stroke-width",r.borderwidth+"px")}function x(t,e,r){var n=s.ensureSingle(t,"text",u.labelClass,function(t){t.classed("user-select-none",!0).attr({"text-anchor":"middle","data-notex":1})});return n.call(o.font,r.font).text(e.step.label).call(l.convertToTspans,r._gd),n}function b(t,e){var r=s.ensureSingle(t,"g",u.labelsClass),i=e._dims,a=r.selectAll("g."+u.labelGroupClass).data(i.labelSteps);a.enter().append("g").classed(u.labelGroupClass,!0),a.exit().remove(),a.each(function(t){var r=n.select(this);r.call(x,t,e),o.setTranslate(r,T(e,t.fraction),u.tickOffset+e.ticklen+e.font.size*h+u.labelOffset+i.currentValueTotalHeight)})}function _(t,e,r,n,i){var a=Math.round(n*(r.steps.length-1));a!==r.active&&w(t,e,r,a,!0,i)}function w(t,e,r,n,a,o){var s=r.active;r._input.active=r.active=n;var l=r.steps[r.active];e.call(A,r,r.active/(r.steps.length-1),o),e.call(v,r),t.emit("plotly_sliderchange",{slider:r,step:r.steps[r.active],interaction:a,previousActive:s}),l&&l.method&&a&&(e._nextMethod?(e._nextMethod.step=l,e._nextMethod.doCallback=a,e._nextMethod.doTransition=o):(e._nextMethod={step:l,doCallback:a,doTransition:o},e._nextMethodRaf=window.requestAnimationFrame(function(){var r=e._nextMethod.step;r.method&&(r.execute&&i.executeAPICommand(t,r.method,r.args),e._nextMethod=null,e._nextMethodRaf=null)})))}function k(t,e,r){var i=r.node(),o=n.select(e);function s(){return r.data()[0]}t.on("mousedown",function(){var t=s();e.emit("plotly_sliderstart",{slider:t});var l=r.select("."+u.gripRectClass);n.event.stopPropagation(),n.event.preventDefault(),l.call(a.fill,t.activebgcolor);var c=S(t,n.mouse(i)[0]);_(e,r,t,c,!0),t._dragging=!0,o.on("mousemove",function(){var t=s(),a=S(t,n.mouse(i)[0]);_(e,r,t,a,!1)}),o.on("mouseup",function(){var t=s();t._dragging=!1,l.call(a.fill,t.bgcolor),o.on("mouseup",null),o.on("mousemove",null),e.emit("plotly_sliderend",{slider:t,step:t.steps[t.active]})})})}function M(t,e){var r=t.selectAll("rect."+u.tickRectClass).data(e.steps),i=e._dims;r.enter().append("rect").classed(u.tickRectClass,!0),r.exit().remove(),r.attr({width:e.tickwidth+"px","shape-rendering":"crispEdges"}),r.each(function(t,r){var s=r%i.labelStride==0,l=n.select(this);l.attr({height:s?e.ticklen:e.minorticklen}).call(a.fill,e.tickcolor),o.setTranslate(l,T(e,r/(e.steps.length-1))-.5*e.tickwidth,(s?u.tickOffset:u.minorTickOffset)+i.currentValueTotalHeight)})}function A(t,e,r,n){var i=t.select("rect."+u.gripRectClass),a=T(e,r);if(!e._invokingCommand){var o=i;n&&e.transition.duration>0&&(o=o.transition().duration(e.transition.duration).ease(e.transition.easing)),o.attr("transform","translate("+(a-.5*u.gripWidth)+","+e._dims.currentValueTotalHeight+")")}}function T(t,e){var r=t._dims;return r.inputAreaStart+u.stepInset+(r.inputAreaLength-2*u.stepInset)*Math.min(1,Math.max(0,e))}function S(t,e){var r=t._dims;return Math.min(1,Math.max(0,(e-u.stepInset-r.inputAreaStart)/(r.inputAreaLength-2*u.stepInset-2*r.inputAreaStart)))}function C(t,e,r){var n=r._dims,i=s.ensureSingle(t,"rect",u.railTouchRectClass,function(n){n.call(k,e,t,r).style("pointer-events","all")});i.attr({width:n.inputAreaLength,height:Math.max(n.inputAreaWidth,u.tickOffset+r.ticklen+n.labelHeight)}).call(a.fill,r.bgcolor).attr("opacity",0),o.setTranslate(i,0,n.currentValueTotalHeight)}function E(t,e){var r=e._dims,n=r.inputAreaLength-2*u.railInset,i=s.ensureSingle(t,"rect",u.railRectClass);i.attr({width:n,height:u.railWidth,rx:u.railRadius,ry:u.railRadius,"shape-rendering":"crispEdges"}).call(a.stroke,e.bordercolor).call(a.fill,e.bgcolor).style("stroke-width",e.borderwidth+"px"),o.setTranslate(i,u.railInset,.5*(r.inputAreaWidth-u.railWidth)+r.currentValueTotalHeight)}e.exports=function(t){var e=t._fullLayout,r=function(t,e){for(var r=t[u.name],n=[],i=0;i0?[0]:[]);if(a.enter().append("g").classed(u.containerClassName,!0).style("cursor","ew-resize"),a.exit().remove(),a.exit().size()&&function(t){for(var e=t._fullLayout._pushmargin||{},r=Object.keys(e),n=0;n=r.steps.length&&(r.active=0);e.call(v,r).call(E,r).call(b,r).call(M,r).call(C,t,r).call(y,t,r);var n=r._dims;o.setTranslate(e,n.lx+r.pad.l,n.ly+r.pad.t),e.call(A,r,r.active/(r.steps.length-1),!1),e.call(v,r)}(t,n.select(this),e)}})}}},{"../../constants/alignment":632,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../color":532,"../drawing":557,"../legend/anchor_utils":584,"./constants":621,d3:131}],624:[function(t,e,r){"use strict";var n=t("./constants");e.exports={moduleType:"component",name:n.name,layoutAttributes:t("./attributes"),supplyLayoutDefaults:t("./defaults"),draw:t("./draw")}},{"./attributes":620,"./constants":621,"./defaults":622,"./draw":623}],625:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib"),l=t("../drawing"),c=t("../color"),u=t("../../lib/svg_text_utils"),f=t("../../constants/interactions");e.exports={draw:function(t,e,r){var p,d=r.propContainer,g=r.propName,m=r.placeholder,v=r.traceIndex,y=r.avoid||{},x=r.attributes,b=r.transform,_=r.containerGroup,w=t._fullLayout,k=d.titlefont||{},M=k.family,A=k.size,T=k.color,S=1,C=!1,E=(d.title||"").trim();"title"===g?p="titleText":-1!==g.indexOf("axis")?p="axisTitleText":g.indexOf(!0)&&(p="colorbarTitleText");var L=t._context.edits[p];""===E?S=0:E.replace(h," % ")===m.replace(h," % ")&&(S=.2,C=!0,L||(E=""));var z=E||L;_||(_=s.ensureSingle(w._infolayer,"g","g-"+e));var P=_.selectAll("text").data(z?[0]:[]);if(P.enter().append("text"),P.text(E).attr("class",e),P.exit().remove(),!z)return _;function D(t){s.syncOrAsync([O,I],t)}function O(e){var r;return b?(r="",b.rotate&&(r+="rotate("+[b.rotate,x.x,x.y]+")"),b.offset&&(r+="translate(0, "+b.offset+")")):r=null,e.attr("transform",r),e.style({"font-family":M,"font-size":n.round(A,2)+"px",fill:c.rgb(T),opacity:S*c.opacity(T),"font-weight":a.fontWeight}).attr(x).call(u.convertToTspans,t),a.previousPromises(t)}function I(t){var e=n.select(t.node().parentNode);if(y&&y.selection&&y.side&&E){e.attr("transform",null);var r=0,a={left:"right",right:"left",top:"bottom",bottom:"top"}[y.side],o=-1!==["left","top"].indexOf(y.side)?-1:1,c=i(y.pad)?y.pad:2,u=l.bBox(e.node()),f={left:0,top:0,right:w.width,bottom:w.height},h=y.maxShift||(f[y.side]-u[y.side])*("left"===y.side||"top"===y.side?-1:1);if(h<0)r=h;else{var p=y.offsetLeft||0,d=y.offsetTop||0;u.left-=p,u.right-=p,u.top-=d,u.bottom-=d,y.selection.each(function(){var t=l.bBox(this);s.bBoxIntersect(u,t,c)&&(r=Math.max(r,o*(t[y.side]-u[a])+c))}),r=Math.min(h,r)}if(r>0||h<0){var g={left:[-r,0],right:[r,0],top:[0,-r],bottom:[0,r]}[y.side];e.attr("transform","translate("+g+")")}}}P.call(D),L&&(E?P.on(".opacity",null):(S=0,C=!0,P.text(m).on("mouseover.opacity",function(){n.select(this).transition().duration(f.SHOW_PLACEHOLDER).style("opacity",1)}).on("mouseout.opacity",function(){n.select(this).transition().duration(f.HIDE_PLACEHOLDER).style("opacity",0)})),P.call(u.makeEditable,{gd:t}).on("edit",function(e){void 0!==v?o.call("restyle",t,g,e,v):o.call("relayout",t,g,e)}).on("cancel",function(){this.text(this.attr("data-unformatted")).call(D)}).on("input",function(t){this.text(t||" ").call(u.positionText,x.x,x.y)}));return P.classed("js-placeholder",C),_}};var h=/ [XY][0-9]* /},{"../../constants/interactions":636,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/plots":768,"../../registry":790,"../color":532,"../drawing":557,d3:131,"fast-isnumeric":197}],626:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../color/attributes"),a=t("../../lib/extend").extendFlat,o=t("../../plot_api/edit_types").overrideAll,s=t("../../plots/pad_attributes");e.exports=o({_isLinkedToArray:"updatemenu",_arrayAttrRegexps:[/^updatemenus\[(0|[1-9][0-9]+)\]\.buttons/],visible:{valType:"boolean"},type:{valType:"enumerated",values:["dropdown","buttons"],dflt:"dropdown"},direction:{valType:"enumerated",values:["left","right","up","down"],dflt:"down"},active:{valType:"integer",min:-1,dflt:0},showactive:{valType:"boolean",dflt:!0},buttons:{_isLinkedToArray:"button",method:{valType:"enumerated",values:["restyle","relayout","animate","update","skip"],dflt:"restyle"},args:{valType:"info_array",freeLength:!0,items:[{valType:"any"},{valType:"any"},{valType:"any"}]},label:{valType:"string",dflt:""},execute:{valType:"boolean",dflt:!0}},x:{valType:"number",min:-2,max:3,dflt:-.05},xanchor:{valType:"enumerated",values:["auto","left","center","right"],dflt:"right"},y:{valType:"number",min:-2,max:3,dflt:1},yanchor:{valType:"enumerated",values:["auto","top","middle","bottom"],dflt:"top"},pad:a({},s,{}),font:n({}),bgcolor:{valType:"color"},bordercolor:{valType:"color",dflt:i.borderLine},borderwidth:{valType:"number",min:0,dflt:1,editType:"arraydraw"}},"arraydraw","from-root")},{"../../lib/extend":649,"../../plot_api/edit_types":691,"../../plots/font_attributes":732,"../../plots/pad_attributes":767,"../color/attributes":531}],627:[function(t,e,r){"use strict";e.exports={name:"updatemenus",containerClassName:"updatemenu-container",headerGroupClassName:"updatemenu-header-group",headerClassName:"updatemenu-header",headerArrowClassName:"updatemenu-header-arrow",dropdownButtonGroupClassName:"updatemenu-dropdown-button-group",dropdownButtonClassName:"updatemenu-dropdown-button",buttonClassName:"updatemenu-button",itemRectClassName:"updatemenu-item-rect",itemTextClassName:"updatemenu-item-text",menuIndexAttrName:"updatemenu-active-index",autoMarginIdRoot:"updatemenu-",blankHeaderOpts:{label:" "},minWidth:30,minHeight:30,textPadX:24,arrowPadX:16,rx:2,ry:2,textOffsetX:12,textOffsetY:3,arrowOffsetX:4,gapButtonHeader:5,gapButton:2,activeColor:"#F4FAFF",hoverColor:"#F4FAFF",arrowSymbol:{left:"\u25c4",right:"\u25ba",up:"\u25b2",down:"\u25bc"}}},{}],628:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../plots/array_container_defaults"),a=t("./attributes"),o=t("./constants").name,s=a.buttons;function l(t,e,r){function i(r,i){return n.coerce(t,e,a,r,i)}var o=function(t,e){var r,i,a=t.buttons||[],o=e.buttons=[];function l(t,e){return n.coerce(r,i,s,t,e)}for(var c=0;c0)&&(i("active"),i("direction"),i("type"),i("showactive"),i("x"),i("y"),n.noneOrAll(t,e,["x","y"]),i("xanchor"),i("yanchor"),i("pad.t"),i("pad.r"),i("pad.b"),i("pad.l"),n.coerceFont(i,"font",r.font),i("bgcolor",r.paper_bgcolor),i("bordercolor"),i("borderwidth"))}e.exports=function(t,e){i(t,e,{name:o,handleItemDefaults:l})}},{"../../lib":660,"../../plots/array_container_defaults":702,"./attributes":626,"./constants":627}],629:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/plots"),a=t("../color"),o=t("../drawing"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../legend/anchor_utils"),u=t("../../constants/alignment").LINE_SPACING,f=t("./constants"),h=t("./scrollbox");function p(t){return t._index}function d(t,e){return+t.attr(f.menuIndexAttrName)===e._index}function g(t,e,r,n,i,a,o,s){e._input.active=e.active=o,"buttons"===e.type?v(t,n,null,null,e):"dropdown"===e.type&&(i.attr(f.menuIndexAttrName,"-1"),m(t,n,i,a,e),s||v(t,n,i,a,e))}function m(t,e,r,n,i){var a=s.ensureSingle(e,"g",f.headerClassName,function(t){t.style("pointer-events","all")}),l=i._dims,c=i.active,u=i.buttons[c]||f.blankHeaderOpts,h={y:i.pad.t,yPad:0,x:i.pad.l,xPad:0,index:0},p={width:l.headerWidth,height:l.headerHeight};a.call(y,i,u,t).call(A,i,h,p),s.ensureSingle(e,"text",f.headerArrowClassName,function(t){t.classed("user-select-none",!0).attr("text-anchor","end").call(o.font,i.font).text(f.arrowSymbol[i.direction])}).attr({x:l.headerWidth-f.arrowOffsetX+i.pad.l,y:l.headerHeight/2+f.textOffsetY+i.pad.t}),a.on("click",function(){r.call(T),r.attr(f.menuIndexAttrName,d(r,i)?-1:String(i._index)),v(t,e,r,n,i)}),a.on("mouseover",function(){a.call(w)}),a.on("mouseout",function(){a.call(k,i)}),o.setTranslate(e,l.lx,l.ly)}function v(t,e,r,a,o){r||(r=e).attr("pointer-events","all");var s=function(t){return-1==+t.attr(f.menuIndexAttrName)}(r)&&"buttons"!==o.type?[]:o.buttons,l="dropdown"===o.type?f.dropdownButtonClassName:f.buttonClassName,c=r.selectAll("g."+l).data(s),u=c.enter().append("g").classed(l,!0),h=c.exit();"dropdown"===o.type?(u.attr("opacity","0").transition().attr("opacity","1"),h.transition().attr("opacity","0").remove()):h.remove();var p=0,d=0,m=o._dims,v=-1!==["up","down"].indexOf(o.direction);"dropdown"===o.type&&(v?d=m.headerHeight+f.gapButtonHeader:p=m.headerWidth+f.gapButtonHeader),"dropdown"===o.type&&"up"===o.direction&&(d=-f.gapButtonHeader+f.gapButton-m.openHeight),"dropdown"===o.type&&"left"===o.direction&&(p=-f.gapButtonHeader+f.gapButton-m.openWidth);var x={x:m.lx+p+o.pad.l,y:m.ly+d+o.pad.t,yPad:f.gapButton,xPad:f.gapButton,index:0},b={l:x.x+o.borderwidth,t:x.y+o.borderwidth};c.each(function(s,l){var u=n.select(this);u.call(y,o,s,t).call(A,o,x),u.on("click",function(){n.event.defaultPrevented||(g(t,o,0,e,r,a,l),s.execute&&i.executeAPICommand(t,s.method,s.args),t.emit("plotly_buttonclicked",{menu:o,button:s,active:o.active}))}),u.on("mouseover",function(){u.call(w)}),u.on("mouseout",function(){u.call(k,o),c.call(_,o)})}),c.call(_,o),v?(b.w=Math.max(m.openWidth,m.headerWidth),b.h=x.y-b.t):(b.w=x.x-b.l,b.h=Math.max(m.openHeight,m.headerHeight)),b.direction=o.direction,a&&(c.size()?function(t,e,r,n,i,a){var o,s,l,c=i.direction,u="up"===c||"down"===c,h=i._dims,p=i.active;if(u)for(s=0,l=0;l0?[0]:[]);if(a.enter().append("g").classed(f.containerClassName,!0).style("cursor","pointer"),a.exit().remove(),a.exit().size()&&function(t){for(var e=t._fullLayout._pushmargin||{},r=Object.keys(e),n=0;nw,A=s.barLength+2*s.barPad,T=s.barWidth+2*s.barPad,S=d,C=m+v;C+T>c&&(C=c-T);var E=this.container.selectAll("rect.scrollbar-horizontal").data(M?[0]:[]);E.exit().on(".drag",null).remove(),E.enter().append("rect").classed("scrollbar-horizontal",!0).call(i.fill,s.barColor),M?(this.hbar=E.attr({rx:s.barRadius,ry:s.barRadius,x:S,y:C,width:A,height:T}),this._hbarXMin=S+A/2,this._hbarTranslateMax=w-A):(delete this.hbar,delete this._hbarXMin,delete this._hbarTranslateMax);var L=v>k,z=s.barWidth+2*s.barPad,P=s.barLength+2*s.barPad,D=d+g,O=m;D+z>l&&(D=l-z);var I=this.container.selectAll("rect.scrollbar-vertical").data(L?[0]:[]);I.exit().on(".drag",null).remove(),I.enter().append("rect").classed("scrollbar-vertical",!0).call(i.fill,s.barColor),L?(this.vbar=I.attr({rx:s.barRadius,ry:s.barRadius,x:D,y:O,width:z,height:P}),this._vbarYMin=O+P/2,this._vbarTranslateMax=k-P):(delete this.vbar,delete this._vbarYMin,delete this._vbarTranslateMax);var R=this.id,B=u-.5,F=L?f+z+.5:f+.5,N=h-.5,j=M?p+T+.5:p+.5,V=o._topdefs.selectAll("#"+R).data(M||L?[0]:[]);if(V.exit().remove(),V.enter().append("clipPath").attr("id",R).append("rect"),M||L?(this._clipRect=V.select("rect").attr({x:Math.floor(B),y:Math.floor(N),width:Math.ceil(F)-Math.floor(B),height:Math.ceil(j)-Math.floor(N)}),this.container.call(a.setClipUrl,R),this.bg.attr({x:d,y:m,width:g,height:v})):(this.bg.attr({width:0,height:0}),this.container.on("wheel",null).on(".drag",null).call(a.setClipUrl,null),delete this._clipRect),M||L){var U=n.behavior.drag().on("dragstart",function(){n.event.sourceEvent.preventDefault()}).on("drag",this._onBoxDrag.bind(this));this.container.on("wheel",null).on("wheel",this._onBoxWheel.bind(this)).on(".drag",null).call(U);var q=n.behavior.drag().on("dragstart",function(){n.event.sourceEvent.preventDefault(),n.event.sourceEvent.stopPropagation()}).on("drag",this._onBarDrag.bind(this));M&&this.hbar.on(".drag",null).call(q),L&&this.vbar.on(".drag",null).call(q)}this.setTranslate(e,r)},s.prototype.disable=function(){(this.hbar||this.vbar)&&(this.bg.attr({width:0,height:0}),this.container.on("wheel",null).on(".drag",null).call(a.setClipUrl,null),delete this._clipRect),this.hbar&&(this.hbar.on(".drag",null),this.hbar.remove(),delete this.hbar,delete this._hbarXMin,delete this._hbarTranslateMax),this.vbar&&(this.vbar.on(".drag",null),this.vbar.remove(),delete this.vbar,delete this._vbarYMin,delete this._vbarTranslateMax)},s.prototype._onBoxDrag=function(){var t=this.translateX,e=this.translateY;this.hbar&&(t-=n.event.dx),this.vbar&&(e-=n.event.dy),this.setTranslate(t,e)},s.prototype._onBoxWheel=function(){var t=this.translateX,e=this.translateY;this.hbar&&(t+=n.event.deltaY),this.vbar&&(e+=n.event.deltaY),this.setTranslate(t,e)},s.prototype._onBarDrag=function(){var t=this.translateX,e=this.translateY;if(this.hbar){var r=t+this._hbarXMin,i=r+this._hbarTranslateMax;t=(o.constrain(n.event.x,r,i)-r)/(i-r)*(this.position.w-this._box.w)}if(this.vbar){var a=e+this._vbarYMin,s=a+this._vbarTranslateMax;e=(o.constrain(n.event.y,a,s)-a)/(s-a)*(this.position.h-this._box.h)}this.setTranslate(t,e)},s.prototype.setTranslate=function(t,e){var r=this.position.w-this._box.w,n=this.position.h-this._box.h;if(t=o.constrain(t||0,0,r),e=o.constrain(e||0,0,n),this.translateX=t,this.translateY=e,this.container.call(a.setTranslate,this._box.l-this.position.l-t,this._box.t-this.position.t-e),this._clipRect&&this._clipRect.attr({x:Math.floor(this.position.l+t-.5),y:Math.floor(this.position.t+e-.5)}),this.hbar){var i=t/r;this.hbar.call(a.setTranslate,t+i*this._hbarTranslateMax,e)}if(this.vbar){var s=e/n;this.vbar.call(a.setTranslate,t,e+s*this._vbarTranslateMax)}}},{"../../lib":660,"../color":532,"../drawing":557,d3:131}],632:[function(t,e,r){"use strict";e.exports={FROM_BL:{left:0,center:.5,right:1,bottom:0,middle:.5,top:1},FROM_TL:{left:0,center:.5,right:1,bottom:1,middle:.5,top:0},FROM_BR:{left:1,center:.5,right:0,bottom:0,middle:.5,top:1},LINE_SPACING:1.3,MID_SHIFT:.35,OPPOSITE_SIDE:{left:"right",right:"left",top:"bottom",bottom:"top"}}},{}],633:[function(t,e,r){"use strict";e.exports={COMPARISON_OPS:["=","!=","<",">=",">","<="],COMPARISON_OPS2:["=","<",">=",">","<="],INTERVAL_OPS:["[]","()","[)","(]","][",")(","](",")["],SET_OPS:["{}","}{"],CONSTRAINT_REDUCTION:{"=":"=","<":"<","<=":"<",">":">",">=":">","[]":"[]","()":"[]","[)":"[]","(]":"[]","][":"][",")(":"][","](":"][",")[":"]["}}},{}],634:[function(t,e,r){"use strict";e.exports={solid:[[],0],dot:[[.5,1],200],dash:[[.5,1],50],longdash:[[.5,1],10],dashdot:[[.5,.625,.875,1],50],longdashdot:[[.5,.7,.8,1],10]}},{}],635:[function(t,e,r){"use strict";e.exports={circle:"\u25cf","circle-open":"\u25cb",square:"\u25a0","square-open":"\u25a1",diamond:"\u25c6","diamond-open":"\u25c7",cross:"+",x:"\u274c"}},{}],636:[function(t,e,r){"use strict";e.exports={SHOW_PLACEHOLDER:100,HIDE_PLACEHOLDER:1e3,DBLCLICKDELAY:300,DESELECTDIM:.2}},{}],637:[function(t,e,r){"use strict";e.exports={BADNUM:void 0,FP_SAFE:Number.MAX_VALUE/1e4,ONEAVGYEAR:315576e5,ONEAVGMONTH:26298e5,ONEDAY:864e5,ONEHOUR:36e5,ONEMIN:6e4,ONESEC:1e3,EPOCHJD:2440587.5,ALMOST_EQUAL:1-1e-6,MINUS_SIGN:"\u2212"}},{}],638:[function(t,e,r){"use strict";e.exports={entityToUnicode:{mu:"\u03bc","#956":"\u03bc",amp:"&","#28":"&",lt:"<","#60":"<",gt:">","#62":">",nbsp:"\xa0","#160":"\xa0",times:"\xd7","#215":"\xd7",plusmn:"\xb1","#177":"\xb1",deg:"\xb0","#176":"\xb0"}}},{}],639:[function(t,e,r){"use strict";r.xmlns="http://www.w3.org/2000/xmlns/",r.svg="http://www.w3.org/2000/svg",r.xlink="http://www.w3.org/1999/xlink",r.svgAttrs={xmlns:r.svg,"xmlns:xlink":r.xlink}},{}],640:[function(t,e,r){"use strict";r.version="1.38.3",t("es6-promise").polyfill(),t("../build/plotcss"),t("./fonts/mathjax_config");for(var n=t("./registry"),i=r.register=n.register,a=t("./plot_api"),o=Object.keys(a),s=0;s180&&(t-=360*Math.round(t/360)),t}},{}],643:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../constants/numerical").BADNUM,a=/^['"%,$#\s']+|[, ]|['"%,$#\s']+$/g;e.exports=function(t){return"string"==typeof t&&(t=t.replace(a,"")),n(t)?Number(t):i}},{"../constants/numerical":637,"fast-isnumeric":197}],644:[function(t,e,r){"use strict";e.exports=function(t){var e=t._fullLayout;e._glcanvas&&e._glcanvas.size()&&e._glcanvas.each(function(t){t.regl&&t.regl.clear({color:!0,depth:!0})})}},{}],645:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("tinycolor2"),a=t("../plots/attributes"),o=t("../components/colorscale/get_scale"),s=(Object.keys(t("../components/colorscale/scales")),t("./nested_property")),l=t("./regex").counter,c=t("../constants/interactions").DESELECTDIM,u=t("./angles").wrap180,f=t("./is_array").isArrayOrTypedArray;r.valObjectMeta={data_array:{coerceFunction:function(t,e,r){f(t)?e.set(t):void 0!==r&&e.set(r)}},enumerated:{coerceFunction:function(t,e,r,n){n.coerceNumber&&(t=+t),-1===n.values.indexOf(t)?e.set(r):e.set(t)},validateFunction:function(t,e){e.coerceNumber&&(t=+t);for(var r=e.values,n=0;ni.max?e.set(r):e.set(+t)}},integer:{coerceFunction:function(t,e,r,i){t%1||!n(t)||void 0!==i.min&&ti.max?e.set(r):e.set(+t)}},string:{coerceFunction:function(t,e,r,n){if("string"!=typeof t){var i="number"==typeof t;!0!==n.strict&&i?e.set(String(t)):e.set(r)}else n.noBlank&&!t?e.set(r):e.set(t)}},color:{coerceFunction:function(t,e,r){i(t).isValid()?e.set(t):e.set(r)}},colorlist:{coerceFunction:function(t,e,r){Array.isArray(t)&&t.length&&t.every(function(t){return i(t).isValid()})?e.set(t):e.set(r)}},colorscale:{coerceFunction:function(t,e,r){e.set(o(t,r))}},angle:{coerceFunction:function(t,e,r){"auto"===t?e.set("auto"):n(t)?e.set(u(+t)):e.set(r)}},subplotid:{coerceFunction:function(t,e,r,n){var i=n.regex||l(r);"string"==typeof t&&i.test(t)?e.set(t):e.set(r)},validateFunction:function(t,e){var r=e.dflt;return t===r||"string"==typeof t&&!!l(r).test(t)}},flaglist:{coerceFunction:function(t,e,r,n){if("string"==typeof t)if(-1===(n.extras||[]).indexOf(t)){for(var i=t.split("+"),a=0;a=n&&t<=i?t:u;if("string"!=typeof t&&"number"!=typeof t)return u;t=String(t);var a=_(e),o=t.charAt(0);!a||"G"!==o&&"g"!==o||(t=t.substr(1),e="");var s=a&&"chinese"===e.substr(0,7),l=t.match(s?x:y);if(!l)return u;var c=l[1],v=l[3]||"1",w=Number(l[5]||1),k=Number(l[7]||0),M=Number(l[9]||0),A=Number(l[11]||0);if(a){if(2===c.length)return u;var T;c=Number(c);try{var S=m.getComponentMethod("calendars","getCal")(e);if(s){var C="i"===v.charAt(v.length-1);v=parseInt(v,10),T=S.newDate(c,S.toMonthIndex(c,v,C),w)}else T=S.newDate(c,Number(v),w)}catch(t){return u}return T?(T.toJD()-g)*f+k*h+M*p+A*d:u}c=2===c.length?(Number(c)+2e3-b)%100+b:Number(c),v-=1;var E=new Date(Date.UTC(2e3,v,w,k,M));return E.setUTCFullYear(c),E.getUTCMonth()!==v?u:E.getUTCDate()!==w?u:E.getTime()+A*d},n=r.MIN_MS=r.dateTime2ms("-9999"),i=r.MAX_MS=r.dateTime2ms("9999-12-31 23:59:59.9999"),r.isDateTime=function(t,e){return r.dateTime2ms(t,e)!==u};var k=90*f,M=3*h,A=5*p;function T(t,e,r,n,i){if((e||r||n||i)&&(t+=" "+w(e,2)+":"+w(r,2),(n||i)&&(t+=":"+w(n,2),i))){for(var a=4;i%10==0;)a-=1,i/=10;t+="."+w(i,a)}return t}r.ms2DateTime=function(t,e,r){if("number"!=typeof t||!(t>=n&&t<=i))return u;e||(e=0);var a,o,s,c,y,x,b=Math.floor(10*l(t+.05,1)),w=Math.round(t-b/10);if(_(r)){var S=Math.floor(w/f)+g,C=Math.floor(l(t,f));try{a=m.getComponentMethod("calendars","getCal")(r).fromJD(S).formatDate("yyyy-mm-dd")}catch(t){a=v("G%Y-%m-%d")(new Date(w))}if("-"===a.charAt(0))for(;a.length<11;)a="-0"+a.substr(1);else for(;a.length<10;)a="0"+a;o=e=n+f&&t<=i-f))return u;var e=Math.floor(10*l(t+.05,1)),r=new Date(Math.round(t-e/10));return T(a.time.format("%Y-%m-%d")(r),r.getHours(),r.getMinutes(),r.getSeconds(),10*r.getUTCMilliseconds()+e)},r.cleanDate=function(t,e,n){if(r.isJSDate(t)||"number"==typeof t){if(_(n))return s.error("JS Dates and milliseconds are incompatible with world calendars",t),e;if(!(t=r.ms2DateTimeLocal(+t))&&void 0!==e)return e}else if(!r.isDateTime(t,n))return s.error("unrecognized date",t),e;return t};var S=/%\d?f/g;function C(t,e,r,n){t=t.replace(S,function(t){var r=Math.min(+t.charAt(1)||6,6);return(e/1e3%1+2).toFixed(r).substr(2).replace(/0+$/,"")||"0"});var i=new Date(Math.floor(e+.05));if(_(n))try{t=m.getComponentMethod("calendars","worldCalFmt")(t,e,n)}catch(t){return"Invalid"}return r(t)(i)}var E=[59,59.9,59.99,59.999,59.9999];r.formatDate=function(t,e,r,n,i,a){if(i=_(i)&&i,!e)if("y"===r)e=a.year;else if("m"===r)e=a.month;else{if("d"!==r)return function(t,e){var r=l(t+.05,f),n=w(Math.floor(r/h),2)+":"+w(l(Math.floor(r/p),60),2);if("M"!==e){o(e)||(e=0);var i=(100+Math.min(l(t/d,60),E[e])).toFixed(e).substr(1);e>0&&(i=i.replace(/0+$/,"").replace(/[\.]$/,"")),n+=":"+i}return n}(t,r)+"\n"+C(a.dayMonthYear,t,n,i);e=a.dayMonth+"\n"+a.year}return C(e,t,n,i)};var L=3*f;r.incrementMonth=function(t,e,r){r=_(r)&&r;var n=l(t,f);if(t=Math.round(t-n),r)try{var i=Math.round(t/f)+g,a=m.getComponentMethod("calendars","getCal")(r),o=a.fromJD(i);return e%12?a.add(o,e,"m"):a.add(o,e/12,"y"),(o.toJD()-g)*f+n}catch(e){s.error("invalid ms "+t+" in calendar "+r)}var c=new Date(t+L);return c.setUTCMonth(c.getUTCMonth()+e)+n-L},r.findExactDates=function(t,e){for(var r,n,i=0,a=0,s=0,l=0,c=_(e)&&m.getComponentMethod("calendars","getCal")(e),u=0;u0&&(r.push(i),i=[])}return i.length>0&&r.push(i),r},r.makeLine=function(t){return 1===t.length?{type:"LineString",coordinates:t[0]}:{type:"MultiLineString",coordinates:t}},r.makePolygon=function(t){if(1===t.length)return{type:"Polygon",coordinates:t};for(var e=new Array(t.length),r=0;r1||g<0||g>1?null:{x:t+l*g,y:e+f*g}}function l(t,e,r,n,i){var a=n*t+i*e;if(a<0)return n*n+i*i;if(a>r){var o=n-t,s=i-e;return o*o+s*s}var l=n*e-i*t;return l*l/r}r.segmentsIntersect=s,r.segmentDistance=function(t,e,r,n,i,a,o,c){if(s(t,e,r,n,i,a,o,c))return 0;var u=r-t,f=n-e,h=o-i,p=c-a,d=u*u+f*f,g=h*h+p*p,m=Math.min(l(u,f,d,i-t,a-e),l(u,f,d,o-t,c-e),l(h,p,g,t-i,e-a),l(h,p,g,r-i,n-a));return Math.sqrt(m)},r.getTextLocation=function(t,e,r,s){if(t===i&&s===a||(n={},i=t,a=s),n[r])return n[r];var l=t.getPointAtLength(o(r-s/2,e)),c=t.getPointAtLength(o(r+s/2,e)),u=Math.atan((c.y-l.y)/(c.x-l.x)),f=t.getPointAtLength(o(r,e)),h={x:(4*f.x+l.x+c.x)/6,y:(4*f.y+l.y+c.y)/6,theta:u};return n[r]=h,h},r.clearLocationCache=function(){i=null},r.getVisibleSegment=function(t,e,r){var n,i,a=e.left,o=e.right,s=e.top,l=e.bottom,c=0,u=t.getTotalLength(),f=u;function h(e){var r=t.getPointAtLength(e);0===e?n=r:e===u&&(i=r);var c=r.xo?r.x-o:0,f=r.yl?r.y-l:0;return Math.sqrt(c*c+f*f)}for(var p=h(c);p;){if((c+=p+r)>f)return;p=h(c)}for(p=h(f);p;){if(c>(f-=p+r))return;p=h(f)}return{min:c,max:f,len:f-c,total:u,isClosed:0===c&&f===u&&Math.abs(n.x-i.x)<.1&&Math.abs(n.y-i.y)<.1}},r.findPointOnPath=function(t,e,r,n){for(var i,a,o,s=(n=n||{}).pathLength||t.getTotalLength(),l=n.tolerance||.001,c=n.iterationLimit||30,u=t.getPointAtLength(0)[r]>t.getPointAtLength(s)[r]?-1:1,f=0,h=0,p=s;f0?p=i:h=i,f++}return a}},{"./mod":667}],655:[function(t,e,r){"use strict";e.exports=function(t){var e;if("string"==typeof t){if(null===(e=document.getElementById(t)))throw new Error("No DOM element with id '"+t+"' exists on the page.");return e}if(null==t)throw new Error("DOM element provided is null or undefined");return t}},{}],656:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("tinycolor2"),a=t("color-normalize"),o=t("../components/colorscale"),s=t("../components/color/attributes").defaultLine,l=t("./is_array").isArrayOrTypedArray,c=a(s),u=1;function f(t,e){var r=t;return r[3]*=e,r}function h(t){if(n(t))return c;var e=a(t);return e.length?e:c}function p(t){return n(t)?t:u}e.exports={formatColor:function(t,e,r){var n,i,s,d,g,m=t.color,v=l(m),y=l(e),x=[];if(n=void 0!==t.colorscale?o.makeColorScaleFunc(o.extractScale(t.colorscale,t.cmin,t.cmax)):h,i=v?function(t,e){return void 0===t[e]?c:a(n(t[e]))}:h,s=y?function(t,e){return void 0===t[e]?u:p(t[e])}:p,v||y)for(var b=0;b=0;){var n=t.indexOf(";",r);if(n/g,"")}(function(t){for(var e=0;(e=t.indexOf("",e))>=0;){var r=t.indexOf("",e);if(r/g,"\n"))))}},{"../constants/string_mappings":638,"superscript-text":466}],659:[function(t,e,r){"use strict";e.exports=function(t){return t}},{}],660:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../constants/numerical"),o=a.FP_SAFE,s=a.BADNUM,l=e.exports={};l.nestedProperty=t("./nested_property"),l.keyedContainer=t("./keyed_container"),l.relativeAttr=t("./relative_attr"),l.isPlainObject=t("./is_plain_object"),l.mod=t("./mod"),l.toLogRange=t("./to_log_range"),l.relinkPrivateKeys=t("./relink_private"),l.ensureArray=t("./ensure_array");var c=t("./is_array");l.isTypedArray=c.isTypedArray,l.isArrayOrTypedArray=c.isArrayOrTypedArray,l.isArray1D=c.isArray1D;var u=t("./coerce");l.valObjectMeta=u.valObjectMeta,l.coerce=u.coerce,l.coerce2=u.coerce2,l.coerceFont=u.coerceFont,l.coerceHoverinfo=u.coerceHoverinfo,l.coerceSelectionMarkerOpacity=u.coerceSelectionMarkerOpacity,l.validate=u.validate;var f=t("./dates");l.dateTime2ms=f.dateTime2ms,l.isDateTime=f.isDateTime,l.ms2DateTime=f.ms2DateTime,l.ms2DateTimeLocal=f.ms2DateTimeLocal,l.cleanDate=f.cleanDate,l.isJSDate=f.isJSDate,l.formatDate=f.formatDate,l.incrementMonth=f.incrementMonth,l.dateTick0=f.dateTick0,l.dfltRange=f.dfltRange,l.findExactDates=f.findExactDates,l.MIN_MS=f.MIN_MS,l.MAX_MS=f.MAX_MS;var h=t("./search");l.findBin=h.findBin,l.sorterAsc=h.sorterAsc,l.sorterDes=h.sorterDes,l.distinctVals=h.distinctVals,l.roundUp=h.roundUp;var p=t("./stats");l.aggNums=p.aggNums,l.len=p.len,l.mean=p.mean,l.midRange=p.midRange,l.variance=p.variance,l.stdev=p.stdev,l.interp=p.interp;var d=t("./matrix");l.init2dArray=d.init2dArray,l.transposeRagged=d.transposeRagged,l.dot=d.dot,l.translationMatrix=d.translationMatrix,l.rotationMatrix=d.rotationMatrix,l.rotationXYMatrix=d.rotationXYMatrix,l.apply2DTransform=d.apply2DTransform,l.apply2DTransform2=d.apply2DTransform2;var g=t("./angles");l.deg2rad=g.deg2rad,l.rad2deg=g.rad2deg,l.wrap360=g.wrap360,l.wrap180=g.wrap180;var m=t("./geometry2d");l.segmentsIntersect=m.segmentsIntersect,l.segmentDistance=m.segmentDistance,l.getTextLocation=m.getTextLocation,l.clearLocationCache=m.clearLocationCache,l.getVisibleSegment=m.getVisibleSegment,l.findPointOnPath=m.findPointOnPath;var v=t("./extend");l.extendFlat=v.extendFlat,l.extendDeep=v.extendDeep,l.extendDeepAll=v.extendDeepAll,l.extendDeepNoArrays=v.extendDeepNoArrays;var y=t("./loggers");l.log=y.log,l.warn=y.warn,l.error=y.error;var x=t("./regex");l.counterRegex=x.counter;var b=t("./throttle");function _(t){var e={};for(var r in t)for(var n=t[r],i=0;io?s:i(t)?Number(t):s:s},l.isIndex=function(t,e){return!(void 0!==e&&t>=e)&&(i(t)&&t>=0&&t%1==0)},l.noop=t("./noop"),l.identity=t("./identity"),l.swapAttrs=function(t,e,r,n){r||(r="x"),n||(n="y");for(var i=0;ir?Math.max(r,Math.min(e,t)):Math.max(e,Math.min(r,t))},l.bBoxIntersect=function(t,e,r){return r=r||0,t.left<=e.right+r&&e.left<=t.right+r&&t.top<=e.bottom+r&&e.top<=t.bottom+r},l.simpleMap=function(t,e,r,n){for(var i=t.length,a=new Array(i),o=0;o-1||c!==1/0&&c>=Math.pow(2,r)?t(e,r,n):s},l.OptionControl=function(t,e){t||(t={}),e||(e="opt");var r={optionList:[],_newoption:function(n){n[e]=t,r[n.name]=n,r.optionList.push(n)}};return r["_"+e]=t,r},l.smooth=function(t,e){if((e=Math.round(e)||0)<2)return t;var r,n,i,a,o=t.length,s=2*o,l=2*e-1,c=new Array(l),u=new Array(o);for(r=0;r=s&&(i-=s*Math.floor(i/s)),i<0?i=-1-i:i>=o&&(i=s-1-i),a+=t[i]*c[n];u[r]=a}return u},l.syncOrAsync=function(t,e,r){var n;function i(){return l.syncOrAsync(t,e,r)}for(;t.length;)if((n=(0,t.splice(0,1)[0])(e))&&n.then)return n.then(i).then(void 0,l.promiseError);return r&&r(e)},l.stripTrailingSlash=function(t){return"/"===t.substr(-1)?t.substr(0,t.length-1):t},l.noneOrAll=function(t,e,r){if(t){var n,i=!1,a=!0;for(n=0;n1?i+o[1]:"";if(a&&(o.length>1||s.length>4||r))for(;n.test(s);)s=s.replace(n,"$1"+a+"$2");return s+l};var M=/%{([^\s%{}]*)}/g,A=/^\w*$/;l.templateString=function(t,e){var r={};return t.replace(M,function(t,n){return A.test(n)?e[n]||"":(r[n]=r[n]||l.nestedProperty(e,n).get,r[n]()||"")})};l.subplotSort=function(t,e){for(var r=Math.min(t.length,e.length)+1,n=0,i=0,a=0;a=48&&o<=57,c=s>=48&&s<=57;if(l&&(n=10*n+o-48),c&&(i=10*i+s-48),!l||!c){if(n!==i)return n-i;if(o!==s)return o-s}}return i-n};var T=2e9;l.seedPseudoRandom=function(){T=2e9},l.pseudoRandom=function(){var t=T;return T=(69069*T+1)%4294967296,Math.abs(T-t)<429496729?l.pseudoRandom():T/4294967296}},{"../constants/numerical":637,"./angles":642,"./clean_number":643,"./coerce":645,"./dates":646,"./ensure_array":647,"./extend":649,"./filter_unique":650,"./filter_visible":651,"./geometry2d":654,"./get_graph_div":655,"./identity":659,"./is_array":661,"./is_plain_object":662,"./keyed_container":663,"./localize":664,"./loggers":665,"./matrix":666,"./mod":667,"./nested_property":668,"./noop":669,"./notifier":670,"./push_unique":674,"./regex":676,"./relative_attr":677,"./relink_private":678,"./search":679,"./stats":682,"./throttle":685,"./to_log_range":686,d3:131,"fast-isnumeric":197}],661:[function(t,e,r){"use strict";var n="undefined"!=typeof ArrayBuffer&&ArrayBuffer.isView?ArrayBuffer:{isView:function(){return!1}},i="undefined"==typeof DataView?function(){}:DataView;function a(t){return n.isView(t)&&!(t instanceof i)}function o(t){return Array.isArray(t)||a(t)}e.exports={isTypedArray:a,isArrayOrTypedArray:o,isArray1D:function(t){return!o(t[0])}}},{}],662:[function(t,e,r){"use strict";e.exports=function(t){return window&&window.process&&window.process.versions?"[object Object]"===Object.prototype.toString.call(t):"[object Object]"===Object.prototype.toString.call(t)&&Object.getPrototypeOf(t)===Object.prototype}},{}],663:[function(t,e,r){"use strict";var n=t("./nested_property"),i=/^\w*$/;e.exports=function(t,e,r,a){var o,s,l;r=r||"name",a=a||"value";var c={};e&&e.length?(l=n(t,e),s=l.get()):s=t,e=e||"";var u={};if(s)for(o=0;o2)return c[e]=2|c[e],h.set(t,null);if(f){for(o=e;o1){for(var t=["LOG:"],e=0;e0){for(var t=["WARN:"],e=0;e0){for(var t=["ERROR:"],e=0;e/g),o=0;oo||a===i||al||e&&c(t))}:function(t,e){var a=t[0],c=t[1];if(a===i||ao||c===i||cl)return!1;var u,f,h,p,d,g=r.length,m=r[0][0],v=r[0][1],y=0;for(u=1;uMath.max(f,m)||c>Math.max(h,v)))if(cu||Math.abs(n(o,h))>i)return!0;return!1};a.filter=function(t,e){var r=[t[0]],n=0,i=0;function a(a){t.push(a);var s=r.length,l=n;r.splice(i+1);for(var c=l+1;c1&&a(t.pop());return{addPt:a,raw:t,filtered:r}}},{"../constants/numerical":637,"./matrix":666}],673:[function(t,e,r){(function(r){"use strict";var n=t("regl");e.exports=function(t,e){var i=t._fullLayout;i._glcanvas.each(function(a){a.regl||a.pick&&!i._has("parcoords")||(a.regl=n({canvas:this,attributes:{antialias:!a.pick,preserveDrawingBuffer:!0},pixelRatio:t._context.plotGlPixelRatio||r.devicePixelRatio,extensions:e||[]}))})}}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{regl:438}],674:[function(t,e,r){"use strict";e.exports=function(t,e){if(e instanceof RegExp){var r,n=e.toString();for(r=0;ri.queueLength&&(t.undoQueue.queue.shift(),t.undoQueue.index--))},startSequence:function(t){t.undoQueue=t.undoQueue||{index:0,queue:[],sequence:!1},t.undoQueue.sequence=!0,t.undoQueue.beginSequence=!0},stopSequence:function(t){t.undoQueue=t.undoQueue||{index:0,queue:[],sequence:!1},t.undoQueue.sequence=!1,t.undoQueue.beginSequence=!1},undo:function(t){var e,r;if(t.framework&&t.framework.isPolar)t.framework.undo();else if(!(void 0===t.undoQueue||isNaN(t.undoQueue.index)||t.undoQueue.index<=0)){for(t.undoQueue.index--,e=t.undoQueue.queue[t.undoQueue.index],t.undoQueue.inSequence=!0,r=0;r=t.undoQueue.queue.length)){for(e=t.undoQueue.queue[t.undoQueue.index],t.undoQueue.inSequence=!0,r=0;re}function l(t,e){return t>=e}r.findBin=function(t,e,r){if(n(e.start))return r?Math.ceil((t-e.start)/e.size-1e-9)-1:Math.floor((t-e.start)/e.size+1e-9);var c,u,f=0,h=e.length,p=0,d=h>1?(e[h-1]-e[0])/(h-1):1;for(u=d>=0?r?a:o:r?l:s,t+=1e-9*d*(r?-1:1)*(d>=0?1:-1);f90&&i.log("Long binary search..."),f-1},r.sorterAsc=function(t,e){return t-e},r.sorterDes=function(t,e){return e-t},r.distinctVals=function(t){var e=t.slice();e.sort(r.sorterAsc);for(var n=e.length-1,i=e[n]-e[0]||1,a=i/(n||1)/1e4,o=[e[0]],s=0;se[s]+a&&(i=Math.min(i,e[s+1]-e[s]),o.push(e[s+1]));return{vals:o,minDiff:i}},r.roundUp=function(t,e,r){for(var n,i=0,a=e.length-1,o=0,s=r?0:1,l=r?1:0,c=r?Math.ceil:Math.floor;ia.length)&&(o=a.length),n(e)||(e=!1),i(a[0])){for(l=new Array(o),s=0;st.length-1)return t[t.length-1];var r=e%1;return r*t[Math.ceil(e)]+(1-r)*t[Math.floor(e)]}},{"./is_array":661,"fast-isnumeric":197}],683:[function(t,e,r){"use strict";var n=t("color-normalize");e.exports=function(t){return t?n(t):[0,0,0,1]}},{"color-normalize":101}],684:[function(t,e,r){"use strict";var n=t("d3"),i=t("../lib"),a=t("../constants/xmlns_namespaces"),o=t("../constants/string_mappings"),s=t("../constants/alignment").LINE_SPACING;function l(t,e){return t.node().getBoundingClientRect()[e]}var c=/([^$]*)([$]+[^$]*[$]+)([^$]*)/;r.convertToTspans=function(t,e,o){var v=t.text(),E=!t.attr("data-notex")&&"undefined"!=typeof MathJax&&v.match(c),L=n.select(t.node().parentNode);if(!L.empty()){var z=t.attr("class")?t.attr("class").split(" ")[0]:"text";return z+="-math",L.selectAll("svg."+z).remove(),L.selectAll("g."+z+"-group").remove(),t.style("display",null).attr({"data-unformatted":v,"data-math":"N"}),E?(e&&e._promises||[]).push(new Promise(function(e){t.style("display","none");var r=parseInt(t.node().style.fontSize,10),a={fontSize:r};!function(t,e,r){var a="math-output-"+i.randstr([],64),o=n.select("body").append("div").attr({id:a}).style({visibility:"hidden",position:"absolute"}).style({"font-size":e.fontSize+"px"}).text((s=t,s.replace(u,"\\lt ").replace(f,"\\gt ")));var s;MathJax.Hub.Queue(["Typeset",MathJax.Hub,o.node()],function(){var e=n.select("body").select("#MathJax_SVG_glyphs");if(o.select(".MathJax_SVG").empty()||!o.select("svg").node())i.log("There was an error in the tex syntax.",t),r();else{var a=o.select("svg").node().getBoundingClientRect();r(o.select(".MathJax_SVG"),e,a)}o.remove()})}(E[2],a,function(n,i,a){L.selectAll("svg."+z).remove(),L.selectAll("g."+z+"-group").remove();var s=n&&n.select("svg");if(!s||!s.node())return P(),void e();var c=L.append("g").classed(z+"-group",!0).attr({"pointer-events":"none","data-unformatted":v,"data-math":"Y"});c.node().appendChild(s.node()),i&&i.node()&&s.node().insertBefore(i.node().cloneNode(!0),s.node().firstChild),s.attr({class:z,height:a.height,preserveAspectRatio:"xMinYMin meet"}).style({overflow:"visible","pointer-events":"none"});var u=t.node().style.fill||"black";s.select("g").attr({fill:u,stroke:u});var f=l(s,"width"),h=l(s,"height"),p=+t.attr("x")-f*{start:0,middle:.5,end:1}[t.attr("text-anchor")||"start"],d=-(r||l(t,"height"))/4;"y"===z[0]?(c.attr({transform:"rotate("+[-90,+t.attr("x"),+t.attr("y")]+") translate("+[-f/2,d-h/2]+")"}),s.attr({x:+t.attr("x"),y:+t.attr("y")})):"l"===z[0]?s.attr({x:t.attr("x"),y:d-h/2}):"a"===z[0]?s.attr({x:0,y:d}):s.attr({x:p,y:+t.attr("y")+d-h/2}),o&&o.call(t,c),e(c)})})):P(),t}function P(){L.empty()||(z=t.attr("class")+"-math",L.select("svg."+z).remove()),t.text("").style("white-space","pre"),function(t,e){e=(r=e,function(t,e){if(!t)return"";for(var r=0;r1)for(var i=1;i doesnt match end tag <"+t+">. Pretending it did match.",e),o=c[c.length-1].node}else i.log("Ignoring unexpected end tag .",e)}w.test(e)?f():(o=t,c=[{node:t}]);for(var z=e.split(b),P=0;P|>|>)/g;var h={sup:"font-size:70%",sub:"font-size:70%",b:"font-weight:bold",i:"font-style:italic",a:"cursor:pointer",span:"",em:"font-style:italic;font-weight:bold"},p={sub:"0.3em",sup:"-0.6em"},d={sub:"-0.21em",sup:"0.42em"},g="\u200b",m=["http:","https:","mailto:","",void 0,":"],v=new RegExp("]*)?/?>","g"),y=Object.keys(o.entityToUnicode).map(function(t){return{regExp:new RegExp("&"+t+";","g"),sub:o.entityToUnicode[t]}}),x=/(\r\n?|\n)/g,b=/(<[^<>]*>)/,_=/<(\/?)([^ >]*)(\s+(.*))?>/i,w=//i,k=/(^|[\s"'])style\s*=\s*("([^"]*);?"|'([^']*);?')/i,M=/(^|[\s"'])href\s*=\s*("([^"]*)"|'([^']*)')/i,A=/(^|[\s"'])target\s*=\s*("([^"\s]*)"|'([^'\s]*)')/i,T=/(^|[\s"'])popup\s*=\s*("([\w=,]*)"|'([\w=,]*)')/i;function S(t,e){if(!t)return null;var r=t.match(e);return r&&(r[3]||r[4])}var C=/(^|;)\s*color:/;function E(t,e,r){var n,i,a,o=r.horizontalAlign,s=r.verticalAlign||"top",l=t.node().getBoundingClientRect(),c=e.node().getBoundingClientRect();return i="bottom"===s?function(){return l.bottom-n.height}:"middle"===s?function(){return l.top+(l.height-n.height)/2}:function(){return l.top},a="right"===o?function(){return l.right-n.width}:"center"===o?function(){return l.left+(l.width-n.width)/2}:function(){return l.left},function(){return n=this.node().getBoundingClientRect(),this.style({top:i()-c.top+"px",left:a()-c.left+"px","z-index":1e3}),this}}r.plainText=function(t){return(t||"").replace(v," ")},r.lineCount=function(t){return t.selectAll("tspan.line").size()||1},r.positionText=function(t,e,r){return t.each(function(){var t=n.select(this);function i(e,r){return void 0===r?null===(r=t.attr(e))&&(t.attr(e,0),r=0):t.attr(e,r),r}var a=i("x",e),o=i("y",r);"text"===this.nodeName&&t.selectAll("tspan.line").attr({x:a,y:o})})},r.makeEditable=function(t,e){var r=e.gd,i=e.delegate,a=n.dispatch("edit","input","cancel"),o=i||t;if(t.style({"pointer-events":i?"none":"all"}),1!==t.size())throw new Error("boo");function s(){!function(){var i=n.select(r).select(".svg-container"),o=i.append("div"),s=t.node().style,c=parseFloat(s.fontSize||12),u=e.text;void 0===u&&(u=t.attr("data-unformatted"));o.classed("plugin-editable editable",!0).style({position:"absolute","font-family":s.fontFamily||"Arial","font-size":c,color:e.fill||s.fill||"black",opacity:1,"background-color":e.background||"transparent",outline:"#ffffff33 1px solid",margin:[-c/8+1,0,0,-1].join("px ")+"px",padding:"0","box-sizing":"border-box"}).attr({contenteditable:!0}).text(u).call(E(t,i,e)).on("blur",function(){r._editing=!1,t.text(this.textContent).style({opacity:1});var e,i=n.select(this).attr("class");(e=i?"."+i.split(" ")[0]+"-math-group":"[class*=-math-group]")&&n.select(t.node().parentNode).select(e).style({opacity:0});var o=this.textContent;n.select(this).transition().duration(0).remove(),n.select(document).on("mouseup",null),a.edit.call(t,o)}).on("focus",function(){var t=this;r._editing=!0,n.select(document).on("mouseup",function(){if(n.event.target===t)return!1;document.activeElement===o.node()&&o.node().blur()})}).on("keyup",function(){27===n.event.which?(r._editing=!1,t.style({opacity:1}),n.select(this).style({opacity:0}).on("blur",function(){return!1}).transition().remove(),a.cancel.call(t,this.textContent)):(a.input.call(t,this.textContent),n.select(this).call(E(t,i,e)))}).on("keydown",function(){13===n.event.which&&this.blur()}).call(l)}(),t.style({opacity:0});var i,s=o.attr("class");(i=s?"."+s.split(" ")[0]+"-math-group":"[class*=-math-group]")&&n.select(t.node().parentNode).select(i).style({opacity:0})}function l(t){var e=t.node(),r=document.createRange();r.selectNodeContents(e);var n=window.getSelection();n.removeAllRanges(),n.addRange(r),e.focus()}return e.immediate?s():o.on("click",s),n.rebind(t,a,"on")}},{"../constants/alignment":632,"../constants/string_mappings":638,"../constants/xmlns_namespaces":639,"../lib":660,d3:131}],685:[function(t,e,r){"use strict";var n={};function i(t){t&&null!==t.timer&&(clearTimeout(t.timer),t.timer=null)}r.throttle=function(t,e,r){var a=n[t],o=Date.now();if(!a){for(var s in n)n[s].tsa.ts+e?l():a.timer=setTimeout(function(){l(),a.timer=null},e)},r.done=function(t){var e=n[t];return e&&e.timer?new Promise(function(t){var r=e.onDone;e.onDone=function(){r&&r(),t(),e.onDone=null}}):Promise.resolve()},r.clear=function(t){if(t)i(n[t]),delete n[t];else for(var e in n)r.clear(e)}},{}],686:[function(t,e,r){"use strict";var n=t("fast-isnumeric");e.exports=function(t,e){if(t>0)return Math.log(t)/Math.LN10;var r=Math.log(Math.min(e[0],e[1]))/Math.LN10;return n(r)||(r=Math.log(Math.max(e[0],e[1]))/Math.LN10-6),r}},{"fast-isnumeric":197}],687:[function(t,e,r){"use strict";var n=e.exports={},i=t("../plots/geo/constants").locationmodeToLayer,a=t("topojson-client").feature;n.getTopojsonName=function(t){return[t.scope.replace(/ /g,"-"),"_",t.resolution.toString(),"m"].join("")},n.getTopojsonPath=function(t,e){return t+e+".json"},n.getTopojsonFeatures=function(t,e){var r=i[t.locationmode],n=e.objects[r];return a(e,n).features}},{"../plots/geo/constants":734,"topojson-client":476}],688:[function(t,e,r){"use strict";e.exports={moduleType:"locale",name:"en-US",dictionary:{"Click to enter Colorscale title":"Click to enter Colorscale title"},format:{date:"%m/%d/%Y"}}},{}],689:[function(t,e,r){"use strict";e.exports={moduleType:"locale",name:"en",dictionary:{"Click to enter Colorscale title":"Click to enter Colourscale title"},format:{days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],periods:["AM","PM"],dateTime:"%a %b %e %X %Y",date:"%d/%m/%Y",time:"%H:%M:%S",decimal:".",thousands:",",grouping:[3],currency:["$",""],year:"%Y",month:"%b %Y",dayMonth:"%b %-d",dayMonthYear:"%b %-d, %Y"}}},{}],690:[function(t,e,r){"use strict";var n=t("../registry");e.exports=function(t){for(var e,r,i=n.layoutArrayContainers,a=n.layoutArrayRegexes,o=t.split("[")[0],s=0;s0&&o.log("Clearing previous rejected promises from queue."),t._promises=[]},r.cleanLayout=function(t){var e,r;t||(t={}),t.xaxis1&&(t.xaxis||(t.xaxis=t.xaxis1),delete t.xaxis1),t.yaxis1&&(t.yaxis||(t.yaxis=t.yaxis1),delete t.yaxis1),t.scene1&&(t.scene||(t.scene=t.scene1),delete t.scene1);var n=(s.subplotsRegistry.cartesian||{}).attrRegex,a=(s.subplotsRegistry.gl3d||{}).attrRegex,l=Object.keys(t);for(e=0;e3?(T.x=1.02,T.xanchor="left"):T.x<-2&&(T.x=-.02,T.xanchor="right"),T.y>3?(T.y=1.02,T.yanchor="bottom"):T.y<-2&&(T.y=-.02,T.yanchor="top")),"rotate"===t.dragmode&&(t.dragmode="orbit"),f.clean(t),t},r.cleanData=function(t,e){for(var n=[],i=t.concat(Array.isArray(e)?e:[]).filter(function(t){return"uid"in t}).map(function(t){return t.uid}),l=0;l0)return t.substr(0,e)}r.hasParent=function(t,e){for(var r=y(e);r;){if(r in t)return!0;r=y(r)}return!1};var x=["x","y","z"];r.clearAxisTypes=function(t,e,r){for(var n=0;n1&&o.warn("Full array edits are incompatible with other edits",f);var y=r[""][""];if(u(y))e.set(null);else{if(!Array.isArray(y))return o.warn("Unrecognized full array edit value",f,y),!0;e.set(y)}return!g&&(h(m,v),p(t),!0)}var x,b,_,w,k,M,A,T=Object.keys(r).map(Number).sort(s),S=e.get(),C=S||[],E=n(v,f).get(),L=[],z=-1,P=C.length;for(x=0;xC.length-(A?0:1))o.warn("index out of range",f,_);else if(void 0!==M)k.length>1&&o.warn("Insertion & removal are incompatible with edits to the same index.",f,_),u(M)?L.push(_):A?("add"===M&&(M={}),C.splice(_,0,M),E&&E.splice(_,0,{})):o.warn("Unrecognized full object edit value",f,_,M),-1===z&&(z=_);else for(b=0;b=0;x--)C.splice(L[x],1),E&&E.splice(L[x],1);if(C.length?S||e.set(C):e.set(null),g)return!1;if(h(m,v),d!==a){var D;if(-1===z)D=T;else{for(P=Math.max(C.length,P),D=[],x=0;x=z);x++)D.push(_);for(x=z;x=t.data.length||i<-t.data.length)throw new Error(r+" must be valid indices for gd.data.");if(e.indexOf(i,n+1)>-1||i>=0&&e.indexOf(-t.data.length+i)>-1||i<0&&e.indexOf(t.data.length+i)>-1)throw new Error("each index in "+r+" must be unique.")}}function z(t,e,r){if(!Array.isArray(t.data))throw new Error("gd.data must be an array.");if(void 0===e)throw new Error("currentIndices is a required argument.");if(Array.isArray(e)||(e=[e]),L(t,e,"currentIndices"),void 0===r||Array.isArray(r)||(r=[r]),void 0!==r&&L(t,r,"newIndices"),void 0!==r&&e.length!==r.length)throw new Error("current and new indices must be of equal length.")}function P(t,e,r,n,a){!function(t,e,r,n){var i=o.isPlainObject(n);if(!Array.isArray(t.data))throw new Error("gd.data must be an array");if(!o.isPlainObject(e))throw new Error("update must be a key:value object");if(void 0===r)throw new Error("indices must be an integer or array of integers");for(var a in L(t,r,"indices"),e){if(!Array.isArray(e[a])||e[a].length!==r.length)throw new Error("attribute "+a+" must be an array of length equal to indices array length");if(i&&(!(a in n)||!Array.isArray(n[a])||n[a].length!==e[a].length))throw new Error("when maxPoints is set as a key:value object it must contain a 1:1 corrispondence with the keys and number of traces in the update object")}}(t,e,r,n);for(var s=function(t,e,r,n){var a,s,l,c,u,f=o.isPlainObject(n),h=[];for(var p in Array.isArray(r)||(r=[r]),r=E(r,t.data.length-1),e)for(var d=0;d=0&&r=0&&r0&&"string"!=typeof E.parts[z];)z--;var P=E.parts[z],D=E.parts[z-1]+"."+P,I=E.parts.slice(0,z).join("."),N=o.nestedProperty(t.layout,I).get(),U=o.nestedProperty(s,I).get(),q=E.get();if(void 0!==L){y[C]=L,x[C]="reverse"===P?L:O(q);var H=u.getLayoutValObject(s,E.parts);if(H&&H.impliedEdits&&null!==L)for(var G in H.impliedEdits)w(o.relativeAttr(C,G),H.impliedEdits[G]);if(-1!==["width","height"].indexOf(C)&&null===L)s[C]=t._initialAutoSize[C];else if(D.match(R))S(D),o.nestedProperty(s,I+"._inputRange").set(null);else if(D.match(B)){S(D),o.nestedProperty(s,I+"._inputRange").set(null);var W=o.nestedProperty(s,I).get();W._inputDomain&&(W._input.domain=W._inputDomain.slice())}else D.match(F)&&o.nestedProperty(s,I+"._inputDomain").set(null);if("type"===P){var Y=N,X="linear"===U.type&&"log"===L,Z="log"===U.type&&"linear"===L;if(X||Z){if(Y&&Y.range)if(U.autorange)X&&(Y.range=Y.range[1]>Y.range[0]?[1,2]:[2,1]);else{var J=Y.range[0],K=Y.range[1];X?(J<=0&&K<=0&&w(I+".autorange",!0),J<=0?J=K/1e6:K<=0&&(K=J/1e6),w(I+".range[0]",Math.log(J)/Math.LN10),w(I+".range[1]",Math.log(K)/Math.LN10)):(w(I+".range[0]",Math.pow(10,J)),w(I+".range[1]",Math.pow(10,K)))}else w(I+".autorange",!0);Array.isArray(s._subplots.polar)&&s._subplots.polar.length&&s[E.parts[0]]&&"radialaxis"===E.parts[1]&&delete s[E.parts[0]]._subplot.viewInitial["radialaxis.range"],c.getComponentMethod("annotations","convertCoords")(t,U,L,w),c.getComponentMethod("images","convertCoords")(t,U,L,w)}else w(I+".autorange",!0),w(I+".range",null);o.nestedProperty(s,I+"._inputRange").set(null)}else if(P.match(M)){var Q=o.nestedProperty(s,C).get(),$=(L||{}).type;$&&"-"!==$||($="linear"),c.getComponentMethod("annotations","convertCoords")(t,Q,$,w),c.getComponentMethod("images","convertCoords")(t,Q,$,w)}var tt=b.containerArrayMatch(C);if(tt){r=tt.array,n=tt.index;var et=tt.property,rt=(o.nestedProperty(a,r)||[])[n]||{},nt=rt,it=H||{editType:"calc"},at=-1!==it.editType.indexOf("calcIfAutorange");""===n?(at?v.calc=!0:k.update(v,it),at=!1):""===et&&(nt=L,b.isAddVal(L)?x[C]=null:b.isRemoveVal(L)?(x[C]=rt,nt=rt):o.warn("unrecognized full object value",e)),at&&(V(t,nt,"x")||V(t,nt,"y"))?v.calc=!0:k.update(v,it),h[r]||(h[r]={});var ot=h[r][n];ot||(ot=h[r][n]={}),ot[et]=L,delete e[C]}else"reverse"===P?(N.range?N.range.reverse():(w(I+".autorange",!0),N.range=[1,0]),U.autorange?v.calc=!0:v.plot=!0):(s._has("scatter-like")&&s._has("regl")&&"dragmode"===C&&("lasso"===L||"select"===L)&&"lasso"!==q&&"select"!==q?v.plot=!0:H?k.update(v,H):v.calc=!0,E.set(L))}}for(r in h){b.applyContainerArrayChanges(t,o.nestedProperty(a,r),h[r],v)||(v.plot=!0)}var st=s._axisConstraintGroups||[];for(A in T)for(n=0;n=i.length?i[0]:i[t]:i}function l(t){return Array.isArray(a)?t>=a.length?a[0]:a[t]:a}function c(t,e){var r=0;return function(){if(t&&++r===e)return t()}}return void 0===n._frameWaitingCnt&&(n._frameWaitingCnt=0),new Promise(function(a,u){function h(){n._currentFrame&&n._currentFrame.onComplete&&n._currentFrame.onComplete();var e=n._currentFrame=n._frameQueue.shift();if(e){var r=e.name?e.name.toString():null;t._fullLayout._currentFrame=r,n._lastFrameAt=Date.now(),n._timeToNext=e.frameOpts.duration,f.transition(t,e.frame.data,e.frame.layout,_.coerceTraceIndices(t,e.frame.traces),e.frameOpts,e.transitionOpts).then(function(){e.onComplete&&e.onComplete()}),t.emit("plotly_animatingframe",{name:r,frame:e.frame,animation:{frame:e.frameOpts,transition:e.transitionOpts}})}else t.emit("plotly_animated"),window.cancelAnimationFrame(n._animationRaf),n._animationRaf=null}function p(){t.emit("plotly_animating"),n._lastFrameAt=-1/0,n._timeToNext=0,n._runningTransitions=0,n._currentFrame=null;var e=function(){n._animationRaf=window.requestAnimationFrame(e),Date.now()-n._lastFrameAt>n._timeToNext&&h()};e()}var d,g,m=0;function v(t){return Array.isArray(i)?m>=i.length?t.transitionOpts=i[m]:t.transitionOpts=i[0]:t.transitionOpts=i,m++,t}var y=[],x=null==e,b=Array.isArray(e);if(!x&&!b&&o.isPlainObject(e))y.push({type:"object",data:v(o.extendFlat({},e))});else if(x||-1!==["string","number"].indexOf(typeof e))for(d=0;d0&&MM)&&A.push(g);y=A}}y.length>0?function(e){if(0!==e.length){for(var i=0;i=0;n--)if(o.isPlainObject(e[n])){var g=e[n].name,m=(u[g]||d[g]||{}).name,v=e[n].name,y=u[m]||d[m];m&&v&&"number"==typeof v&&y&&A<5&&(A++,o.warn('addFrames: overwriting frame "'+(u[m]||d[m]).name+'" with a frame whose name of type "number" also equates to "'+m+'". This is valid but may potentially lead to unexpected behavior since all plotly.js frame names are stored internally as strings.'),5===A&&o.warn("addFrames: This API call has yielded too many of these warnings. For the rest of this call, further warnings about numeric frame names will be suppressed.")),d[g]={name:g},p.push({frame:f.supplyFrameDefaults(e[n]),index:r&&void 0!==r[n]&&null!==r[n]?r[n]:h+n})}p.sort(function(t,e){return t.index>e.index?-1:t.index=0;n--){if("number"==typeof(i=p[n].frame).name&&o.warn("Warning: addFrames accepts frames with numeric names, but the numbers areimplicitly cast to strings"),!i.name)for(;u[i.name="frame "+t._transitionData._counter++];);if(u[i.name]){for(a=0;a=0;r--)n=e[r],a.push({type:"delete",index:n}),s.unshift({type:"insert",index:n,value:i[n]});var c=f.modifyFrames,u=f.modifyFrames,h=[t,s],p=[t,a];return l&&l.add(t,c,h,u,p),f.modifyFrames(t,a)},r.purge=function(t){var e=(t=o.getGraphDiv(t))._fullLayout||{},r=t._fullData||[],n=t.calcdata||[];return f.cleanPlot([],{},r,e,n),f.purge(t),s.purge(t),e._container&&e._container.remove(),delete t._context,t}},{"../components/color":532,"../components/drawing":557,"../constants/xmlns_namespaces":639,"../lib":660,"../lib/events":648,"../lib/queue":675,"../lib/svg_text_utils":684,"../plots/cartesian/axes":706,"../plots/cartesian/constants":711,"../plots/cartesian/graph_interact":715,"../plots/plots":768,"../plots/polar/legacy":776,"../registry":790,"./edit_types":691,"./helpers":692,"./manage_arrays":694,"./plot_config":696,"./plot_schema":697,"./subroutines":698,d3:131,"fast-isnumeric":197,"has-hover":354}],696:[function(t,e,r){"use strict";e.exports={staticPlot:!1,editable:!1,edits:{annotationPosition:!1,annotationTail:!1,annotationText:!1,axisTitleText:!1,colorbarPosition:!1,colorbarTitleText:!1,legendPosition:!1,legendText:!1,shapePosition:!1,titleText:!1},autosizable:!1,queueLength:0,fillFrame:!1,frameMargins:0,scrollZoom:!1,doubleClick:"reset+autosize",showTips:!0,showAxisDragHandles:!0,showAxisRangeEntryBoxes:!0,showLink:!1,sendData:!0,linkText:"Edit chart",showSources:!1,displayModeBar:"hover",modeBarButtonsToRemove:[],modeBarButtonsToAdd:[],modeBarButtons:!1,toImageButtonOptions:{},displaylogo:!0,plotGlPixelRatio:2,setBackground:"transparent",topojsonURL:"https://cdn.plot.ly/",mapboxAccessToken:null,logging:1,globalTransforms:[],locale:"en-US",locales:{}}},{}],697:[function(t,e,r){"use strict";var n=t("../registry"),i=t("../lib"),a=t("../plots/attributes"),o=t("../plots/layout_attributes"),s=t("../plots/frame_attributes"),l=t("../plots/animation_attributes"),c=t("../plots/polar/legacy/area_attributes"),u=t("../plots/polar/legacy/axis_attributes"),f=t("./edit_types"),h=i.extendFlat,p=i.extendDeepAll,d=i.isPlainObject,g="_isSubplotObj",m="_isLinkedToArray",v=[g,m,"_arrayAttrRegexps","_deprecated"];function y(t,e,r){if(!t)return!1;if(t._isLinkedToArray)if(x(e[r]))r++;else if(r=a.length)return!1;if(2===t.dimensions){if(r++,e.length===r)return t;var o=e[r];if(!x(o))return!1;t=a[i][o]}else t=a[i]}else t=a}}return t}function x(t){return t===Math.round(t)&&t>=0}function b(t){return function(t){r.crawl(t,function(t,e,n){r.isValObject(t)?"data_array"===t.valType?(t.role="data",n[e+"src"]={valType:"string",editType:"none"}):!0===t.arrayOk&&(n[e+"src"]={valType:"string",editType:"none"}):d(t)&&(t.role="object")})}(t),function(t){r.crawl(t,function(t,e,r){if(!t)return;var n=t[m];if(!n)return;delete t[m],r[e]={items:{}},r[e].items[n]=t,r[e].role="object"})}(t),function(t){!function t(e){for(var r in e)if(d(e[r]))t(e[r]);else if(Array.isArray(e[r]))for(var n=0;n=l.length)return!1;i=(r=(n.transformsRegistry[l[u].type]||{}).attributes)&&r[e[2]],s=3}else if("area"===t.type)i=c[o];else{var f=t._module;if(f||(f=(n.modules[t.type||a.type.dflt]||{})._module),!f)return!1;if(!(i=(r=f.attributes)&&r[o])){var h=f.basePlotModule;h&&h.attributes&&(i=h.attributes[o])}i||(i=a[o])}return y(i,e,s)},r.getLayoutValObject=function(t,e){return y(function(t,e){var r,i,a,s,l=t._basePlotModules;if(l){var c;for(r=0;r=t[1]||i[1]<=t[0])&&a[0]e[0])return!0}return!1}(r,n,k)){var s=a.node(),l=e.bg=o.ensureSingle(a,"rect","bg");s.insertBefore(l.node(),s.childNodes[0])}else a.select("rect.bg").remove(),w.push(t),k.push([r,n])});var M=i._bgLayer.selectAll(".bg").data(w);return M.enter().append("rect").classed("bg",!0),M.exit().remove(),M.each(function(t){i._plots[t].bg=n.select(this)}),b.each(function(t){var e=i._plots[t],r=e.xaxis,n=e.yaxis;e.bg&&d&&e.bg.call(c.setRect,r._offset-s,n._offset-s,r._length+2*s,n._length+2*s).call(l.fill,i.plot_bgcolor).style("stroke-width",0);var a,f,h=e.clipId="clip"+i._uid+t+"plot",p=o.ensureSingleById(i._clips,"clipPath",h,function(t){t.classed("plotclip",!0).append("rect")});if(e.clipRect=p.select("rect").attr({width:r._length,height:n._length}),c.setTranslate(e.plot,r._offset,n._offset),e._hasClipOnAxisFalse?(a=null,f=h):(a=h,f=null),c.setClipUrl(e.plot,a),e.layerClipId=f,d){var m,v,y,b,w,k,M,A,T,S,C,E,L,z="M0,0";x(r,t)&&(w=_(r,"left",n,u),m=r._offset-(w?s+w:0),k=_(r,"right",n,u),v=r._offset+r._length+(k?s+k:0),y=g(r,n,"bottom"),b=g(r,n,"top"),(L=!r._anchorAxis||t!==r._mainSubplot)&&r.ticks&&"allticks"===r.mirror&&(r._linepositions[t]=[y,b]),z=I(r,D,function(t){return"M"+r._offset+","+t+"h"+r._length}),L&&r.showline&&("all"===r.mirror||"allticks"===r.mirror)&&(z+=D(y)+D(b)),e.xlines.style("stroke-width",r._lw+"px").call(l.stroke,r.showline?r.linecolor:"rgba(0,0,0,0)")),e.xlines.attr("d",z);var P="M0,0";x(n,t)&&(C=_(n,"bottom",r,u),M=n._offset+n._length+(C?s:0),E=_(n,"top",r,u),A=n._offset-(E?s:0),T=g(n,r,"left"),S=g(n,r,"right"),(L=!n._anchorAxis||t!==r._mainSubplot)&&n.ticks&&"allticks"===n.mirror&&(n._linepositions[t]=[T,S]),P=I(n,O,function(t){return"M"+t+","+n._offset+"v"+n._length}),L&&n.showline&&("all"===n.mirror||"allticks"===n.mirror)&&(P+=O(T)+O(S)),e.ylines.style("stroke-width",n._lw+"px").call(l.stroke,n.showline?n.linecolor:"rgba(0,0,0,0)")),e.ylines.attr("d",P)}function D(t){return"M"+m+","+t+"H"+v}function O(t){return"M"+t+","+A+"V"+M}function I(e,r,n){if(!e.showline||t!==e._mainSubplot)return"";if(!e._anchorAxis)return n(e._mainLinePosition);var i=r(e._mainLinePosition);return e.mirror&&(i+=r(e._mainMirrorPosition)),i}}),h.makeClipPaths(t),r.drawMainTitle(t),f.manage(t),t._promises.length&&Promise.all(t._promises)},r.drawMainTitle=function(t){var e=t._fullLayout;u.draw(t,"gtitle",{propContainer:e,propName:"title",placeholder:e._dfltTitle.plot,attributes:{x:e.width/2,y:e._size.t/2,"text-anchor":"middle"}})},r.doTraceStyle=function(t){for(var e=0;ex.length&&i.push(p("unused",a,v.concat(x.length)));var M,A,T,S,C,E=x.length,L=Array.isArray(k);if(L&&(E=Math.min(E,k.length)),2===b.dimensions)for(A=0;Ax[A].length&&i.push(p("unused",a,v.concat(A,x[A].length)));var z=x[A].length;for(M=0;M<(L?Math.min(z,k[A].length):z);M++)T=L?k[A][M]:k,S=y[A][M],C=x[A][M],n.validate(S,T)?C!==S&&C!==+S&&i.push(p("dynamic",a,v.concat(A,M),S,C)):i.push(p("value",a,v.concat(A,M),S))}else i.push(p("array",a,v.concat(A),y[A]));else for(A=0;A1&&h.push(p("object","layout"))),i.supplyDefaults(d);for(var g=d._fullData,m=r.length,v=0;v0&&c>0&&u/c>d&&(o=n,l=a,d=u/c);if(h===p){var y=h-1,x=h+1;f="tozero"===t.rangemode?h<0?[y,0]:[0,x]:"nonnegative"===t.rangemode?[Math.max(0,y),Math.max(0,x)]:[y,x]}else d&&("linear"!==t.type&&"-"!==t.type||("tozero"===t.rangemode?(o.val>=0&&(o={val:0,pad:0}),l.val<=0&&(l={val:0,pad:0})):"nonnegative"===t.rangemode&&(o.val-d*m(o)<0&&(o={val:0,pad:0}),l.val<0&&(l={val:1,pad:0})),d=(l.val-o.val)/(t._length-m(o)-m(l))),f=[o.val-d*m(o),l.val+d*m(l)]);return f[0]===f[1]&&("tozero"===t.rangemode?f=f[0]<0?[f[0],0]:f[0]>0?[0,f[0]]:[0,1]:(f=[f[0]-1,f[0]+1],"nonnegative"===t.rangemode&&(f[0]=Math.max(0,f[0])))),g&&f.reverse(),i.simpleMap(f,t.l2r||Number)}function s(t){var e=t._length/20;return"domain"===t.constrain&&t._inputDomain&&(e*=(t._inputDomain[1]-t._inputDomain[0])/(t.domain[1]-t.domain[0])),function(t){return t.pad+(t.extrapad?e:0)}}function l(t){return n(t)&&Math.abs(t)=e}e.exports={getAutoRange:o,makePadFn:s,doAutoRange:function(t){t._length||t.setScale();var e,r=t._min&&t._max&&t._min.length&&t._max.length;t.autorange&&r&&(t.range=o(t),t._r=t.range.slice(),t._rl=i.simpleMap(t._r,t.r2l),(e=t._input).range=t.range.slice(),e.autorange=t.autorange);if(t._anchorAxis&&t._anchorAxis.rangeslider){var n=t._anchorAxis.rangeslider[t._name];n&&"auto"===n.rangemode&&(n.range=r?o(t):t._rangeInitial?t._rangeInitial.slice():t.range.slice()),(e=t._anchorAxis._input).rangeslider[t._name]=i.extendFlat({},n)}},expand:function(t,e,r){if(!function(t){return t.autorange||t._rangesliderAutorange}(t)||!e)return;t._min||(t._min=[]);t._max||(t._max=[]);r||(r={});t._m||t.setScale();var i,o,s,f,h,p,d,g,m,v,y,x,b=e.length,_=r.padded||!1,w=r.tozero&&("linear"===t.type||"-"===t.type),k="log"===t.type,M=!1;function A(t){if(Array.isArray(t))return M=!0,function(e){return Math.max(Number(t[e]||0),0)};var e=Math.max(Number(t||0),0);return function(){return e}}var T=A((t._m>0?r.ppadplus:r.ppadminus)||r.ppad||0),S=A((t._m>0?r.ppadminus:r.ppadplus)||r.ppad||0),C=A(r.vpadplus||r.vpad),E=A(r.vpadminus||r.vpad);if(!M){if(y=1/0,x=-1/0,k)for(i=0;i0&&(y=f),f>x&&f-a&&(y=f),f>x&&f=b&&(f.extrapad||!_)){v=!1;break}M(i,f.val)&&f.pad<=b&&(_||!f.extrapad)&&(a.splice(o,1),o--)}if(v){var A=w&&0===i;a.push({val:i,pad:A?0:b,extrapad:!A&&_})}}}}var z=Math.min(6,b);for(i=0;i=z;i--)L(i)}}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],706:[function(t,e,r){"use strict";var n=t("d3"),i=t("fast-isnumeric"),a=t("../../plots/plots"),o=t("../../registry"),s=t("../../lib"),l=t("../../lib/svg_text_utils"),c=t("../../components/titles"),u=t("../../components/color"),f=t("../../components/drawing"),h=t("../../constants/numerical"),p=h.ONEAVGYEAR,d=h.ONEAVGMONTH,g=h.ONEDAY,m=h.ONEHOUR,v=h.ONEMIN,y=h.ONESEC,x=h.MINUS_SIGN,b=h.BADNUM,_=t("../../constants/alignment").MID_SHIFT,w=t("../../constants/alignment").LINE_SPACING,k=e.exports={};k.setConvert=t("./set_convert");var M=t("./axis_autotype"),A=t("./axis_ids");k.id2name=A.id2name,k.name2id=A.name2id,k.cleanId=A.cleanId,k.list=A.list,k.listIds=A.listIds,k.getFromId=A.getFromId,k.getFromTrace=A.getFromTrace;var T=t("./autorange");k.expand=T.expand,k.getAutoRange=T.getAutoRange,k.coerceRef=function(t,e,r,n,i,a){var o=n.charAt(n.length-1),l=r._fullLayout._subplots[o+"axis"],c=n+"ref",u={};return i||(i=l[0]||a),a||(a=i),u[c]={valType:"enumerated",values:l.concat(a?[a]:[]),dflt:i},s.coerce(t,e,u,c)},k.coercePosition=function(t,e,r,n,i,a){var o,l;if("paper"===n||"pixel"===n)o=s.ensureNumber,l=r(i,a);else{var c=k.getFromId(e,n);l=r(i,a=c.fraction2r(a)),o=c.cleanPos}t[i]=o(l)},k.cleanPosition=function(t,e,r){return("paper"===r||"pixel"===r?s.ensureNumber:k.getFromId(e,r).cleanPos)(t)};var S=k.getDataConversions=function(t,e,r,n){var i,a="x"===r||"y"===r||"z"===r?r:n;if(Array.isArray(a)){if(i={type:M(n),_categories:[]},k.setConvert(i),"category"===i.type)for(var o=0;o2e-6||((r-t._forceTick0)/t._minDtick%1+1.000001)%1>2e-6)&&(t._minDtick=0)):t._minDtick=0},k.saveRangeInitial=function(t,e){for(var r=k.list(t,"",!0),n=!1,i=0;i.3*h||u(n)||u(a))){var p=r.dtick/2;t+=t+p.8){var o=Number(r.substr(1));a.exactYears>.8&&o%12==0?t=k.tickIncrement(t,"M6","reverse")+1.5*g:a.exactMonths>.8?t=k.tickIncrement(t,"M1","reverse")+15.5*g:t-=g/2;var l=k.tickIncrement(t,r);if(l<=n)return l}return t}(m,t,l.dtick,c,a)),d=m,0;d<=u;)d=k.tickIncrement(d,l.dtick,!1,a),0;return{start:e.c2r(m,0,a),end:e.c2r(d,0,a),size:l.dtick,_dataSpan:u-c}},k.prepTicks=function(t){var e=s.simpleMap(t.range,t.r2l);if("auto"===t.tickmode||!t.dtick){var r,n=t.nticks;n||("category"===t.type?(r=t.tickfont?1.2*(t.tickfont.size||12):15,n=t._length/r):(r="y"===t._id.charAt(0)?40:80,n=s.constrain(t._length/r,4,9)+1),"radialaxis"===t._name&&(n*=2)),"array"===t.tickmode&&(n*=100),k.autoTicks(t,Math.abs(e[1]-e[0])/n),t._minDtick>0&&t.dtick<2*t._minDtick&&(t.dtick=t._minDtick,t.tick0=t.l2r(t._forceTick0))}t.tick0||(t.tick0="date"===t.type?"2000-01-01":0),F(t)},k.calcTicks=function(t){k.prepTicks(t);var e=s.simpleMap(t.range,t.r2l);if("array"===t.tickmode)return function(t){var e,r,n=t.tickvals,i=t.ticktext,a=new Array(n.length),o=s.simpleMap(t.range,t.r2l),l=1.0001*o[0]-1e-4*o[1],c=1.0001*o[1]-1e-4*o[0],u=Math.min(l,c),f=Math.max(l,c),h=0;Array.isArray(i)||(i=[]);var p="category"===t.type?t.d2l_noadd:t.d2l;"log"===t.type&&"L"!==String(t.dtick).charAt(0)&&(t.dtick="L"+Math.pow(10,Math.floor(Math.min(t.range[0],t.range[1]))-1));for(r=0;ru&&e=n:c<=n)&&!(a.length>l||c===o);c=k.tickIncrement(c,t.dtick,i,t.calendar))o=c,a.push(c);"angular"===t._id&&360===Math.abs(e[1]-e[0])&&a.pop(),t._tmax=a[a.length-1],t._prevDateHead="",t._inCalcTicks=!0;for(var u=new Array(a.length),f=0;f10||"01-01"!==n.substr(5)?t._tickround="d":t._tickround=+e.substr(1)%12==0?"y":"m";else if(e>=g&&a<=10||e>=15*g)t._tickround="d";else if(e>=v&&a<=16||e>=m)t._tickround="M";else if(e>=y&&a<=19||e>=v)t._tickround="S";else{var o=t.l2r(r+e).replace(/^-/,"").length;t._tickround=Math.max(a,o)-20}}else if(i(e)||"L"===e.charAt(0)){var s=t.range.map(t.r2d||Number);i(e)||(e=Number(e.substr(1))),t._tickround=2-Math.floor(Math.log(e)/Math.LN10+.01);var l=Math.max(Math.abs(s[0]),Math.abs(s[1])),c=Math.floor(Math.log(l)/Math.LN10+.01);Math.abs(c)>3&&(V(t.exponentformat)&&!U(c)?t._tickexponent=3*Math.round((c-1)/3):t._tickexponent=c)}else t._tickround=null}function N(t,e,r){var n=t.tickfont||{};return{x:e,dx:0,dy:0,text:r||"",fontSize:n.size,font:n.family,fontColor:n.color}}k.autoTicks=function(t,e){var r;function n(t){return Math.pow(t,Math.floor(Math.log(e)/Math.LN10))}if("date"===t.type){t.tick0=s.dateTick0(t.calendar);var a=2*e;a>p?(e/=p,r=n(10),t.dtick="M"+12*B(e,r,L)):a>d?(e/=d,t.dtick="M"+B(e,1,z)):a>g?(t.dtick=B(e,g,D),t.tick0=s.dateTick0(t.calendar,!0)):a>m?t.dtick=B(e,m,z):a>v?t.dtick=B(e,v,P):a>y?t.dtick=B(e,y,P):(r=n(10),t.dtick=B(e,r,L))}else if("log"===t.type){t.tick0=0;var o=s.simpleMap(t.range,t.r2l);if(e>.7)t.dtick=Math.ceil(e);else if(Math.abs(o[1]-o[0])<1){var l=1.5*Math.abs((o[1]-o[0])/e);e=Math.abs(Math.pow(10,o[1])-Math.pow(10,o[0]))/l,r=n(10),t.dtick="L"+B(e,r,L)}else t.dtick=e>.3?"D2":"D1"}else"category"===t.type?(t.tick0=0,t.dtick=Math.ceil(Math.max(e,1))):"angular"===t._id?(t.tick0=0,r=1,t.dtick=B(e,r,R)):(t.tick0=0,r=n(10),t.dtick=B(e,r,L));if(0===t.dtick&&(t.dtick=1),!i(t.dtick)&&"string"!=typeof t.dtick){var c=t.dtick;throw t.dtick=1,"ax.dtick error: "+String(c)}},k.tickIncrement=function(t,e,r,a){var o=r?-1:1;if(i(e))return t+o*e;var l=e.charAt(0),c=o*Number(e.substr(1));if("M"===l)return s.incrementMonth(t,c,a);if("L"===l)return Math.log(Math.pow(10,t)+c)/Math.LN10;if("D"===l){var u="D2"===e?I:O,f=t+.01*o,h=s.roundUp(s.mod(f,1),u,r);return Math.floor(f)+Math.log(n.round(Math.pow(10,h),1))/Math.LN10}throw"unrecognized dtick "+String(e)},k.tickFirst=function(t){var e=t.r2l||Number,r=s.simpleMap(t.range,e),a=r[1]"+l,t._prevDateHead=l));e.text=c}(t,o,r,c):"log"===t.type?function(t,e,r,n,a){var o=t.dtick,l=e.x,c=t.tickformat;"never"===a&&(a="");!n||"string"==typeof o&&"L"===o.charAt(0)||(o="L3");if(c||"string"==typeof o&&"L"===o.charAt(0))e.text=q(Math.pow(10,l),t,a,n);else if(i(o)||"D"===o.charAt(0)&&s.mod(l+.01,1)<.1){var u=Math.round(l);-1!==["e","E","power"].indexOf(t.exponentformat)||V(t.exponentformat)&&U(u)?(e.text=0===u?1:1===u?"10":u>1?"10"+u+"":"10"+x+-u+"",e.fontSize*=1.25):(e.text=q(Math.pow(10,l),t,"","fakehover"),"D1"===o&&"y"===t._id.charAt(0)&&(e.dy-=e.fontSize/6))}else{if("D"!==o.charAt(0))throw"unrecognized dtick "+String(o);e.text=String(Math.round(Math.pow(10,s.mod(l,1)))),e.fontSize*=.75}if("D1"===t.dtick){var f=String(e.text).charAt(0);"0"!==f&&"1"!==f||("y"===t._id.charAt(0)?e.dx-=e.fontSize/4:(e.dy+=e.fontSize/2,e.dx+=(t.range[1]>t.range[0]?1:-1)*e.fontSize*(l<0?.5:.25)))}}(t,o,0,c,n):"category"===t.type?function(t,e){var r=t._categories[Math.round(e.x)];void 0===r&&(r="");e.text=String(r)}(t,o):"angular"===t._id?function(t,e,r,n,i){if("radians"!==t.thetaunit||r)e.text=q(e.x,t,i,n);else{var a=e.x/180;if(0===a)e.text="0";else{var o=function(t){function e(t,e){return Math.abs(t-e)<=1e-6}var r=function(t){var r=1;for(;!e(Math.round(t*r)/r,t);)r*=10;return r}(t),n=t*r,i=Math.abs(function t(r,n){return e(n,0)?r:t(n,r%n)}(n,r));return[Math.round(n/i),Math.round(r/i)]}(a);if(o[1]>=100)e.text=q(s.deg2rad(e.x),t,i,n);else{var l=e.x<0;1===o[1]?1===o[0]?e.text="\u03c0":e.text=o[0]+"\u03c0":e.text=["",o[0],"","\u2044","",o[1],"","\u03c0"].join(""),l&&(e.text=x+e.text)}}}}(t,o,r,c,n):function(t,e,r,n,i){"never"===i?i="":"all"===t.showexponent&&Math.abs(e.x/t.dtick)<1e-6&&(i="hide");e.text=q(e.x,t,i,n)}(t,o,0,c,n),t.tickprefix&&!p(t.showtickprefix)&&(o.text=t.tickprefix+o.text),t.ticksuffix&&!p(t.showticksuffix)&&(o.text+=t.ticksuffix),o},k.hoverLabelText=function(t,e,r){if(r!==b&&r!==e)return k.hoverLabelText(t,e)+" - "+k.hoverLabelText(t,r);var n="log"===t.type&&e<=0,i=k.tickText(t,t.c2l(n?-e:e),"hover").text;return n?0===e?"0":x+i:i};var j=["f","p","n","\u03bc","m","","k","M","G","T"];function V(t){return"SI"===t||"B"===t}function U(t){return t>14||t<-15}function q(t,e,r,n){var a=t<0,o=e._tickround,l=r||e.exponentformat||"B",c=e._tickexponent,u=k.getTickFormat(e),f=e.separatethousands;if(n){var h={exponentformat:l,dtick:"none"===e.showexponent?e.dtick:i(t)&&Math.abs(t)||1,range:"none"===e.showexponent?e.range.map(e.r2d):[0,t||1]};F(h),o=(Number(h._tickround)||0)+4,c=h._tickexponent,e.hoverformat&&(u=e.hoverformat)}if(u)return e._numFormat(u)(t).replace(/-/g,x);var p,d=Math.pow(10,-o)/2;if("none"===l&&(c=0),(t=Math.abs(t))"+p+"":"B"===l&&9===c?t+="B":V(l)&&(t+=j[c/3+5]));return a?x+t:t}function H(t,e){for(var r=0;r=0,a=c(t,e[1])<=0;return(r||i)&&(n||a)}if(t.tickformatstops&&t.tickformatstops.length>0)switch(t.type){case"date":case"linear":for(e=0;e=a(n))){r=t.tickformatstops[e];break}break;case"log":for(e=0;e1&&e1)for(n=1;n2*o}(t,e)?"date":function(t){for(var e,r=Math.max(1,(t.length-1)/1e3),n=0,o=0,s=0;s2*n}(t)?"category":function(t){if(!t)return!1;for(var e=0;en?1:-1:+(t.substr(1)||1)-+(e.substr(1)||1)}},{"../../registry":790,"./constants":711}],710:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){if("category"===e.type){var i,a=t.categoryarray,o=Array.isArray(a)&&a.length>0;o&&(i="array");var s,l=r("categoryorder",i);"array"===l&&(s=r("categoryarray")),o||"array"!==l||(l=e.categoryorder="trace"),"trace"===l?e._initialCategories=[]:"array"===l?e._initialCategories=s.slice():(s=function(t,e){var r,n,i,a=e.dataAttr||t._id.charAt(0),o={};if(e.axData)r=e.axData;else for(r=[],n=0;no*y)||w)for(r=0;rP&&IL&&(L=I);h/=(L-E)/(2*z),E=c.l2r(E),L=c.l2r(L),c.range=c._input.range=T=0?Math.min(t,.9):1/(1/Math.max(t,-.3)+3.222))}function P(t,e,r,n,i){return t.append("path").attr("class","zoombox").style({fill:e>.2?"rgba(0,0,0,0)":"rgba(255,255,255,0)","stroke-width":0}).attr("transform","translate("+r+", "+n+")").attr("d",i+"Z")}function D(t,e,r){return t.append("path").attr("class","zoombox-corners").style({fill:u.background,stroke:u.defaultLine,"stroke-width":1,opacity:0}).attr("transform","translate("+e+", "+r+")").attr("d","M0,0Z")}function O(t,e,r,n,i,a){t.attr("d",n+"M"+r.l+","+r.t+"v"+r.h+"h"+r.w+"v-"+r.h+"h-"+r.w+"Z"),I(t,e,i,a)}function I(t,e,r,n){r||(t.transition().style("fill",n>.2?"rgba(0,0,0,0.4)":"rgba(255,255,255,0.3)").duration(200),e.transition().style("opacity",1).duration(200))}function R(t){n.select(t).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove()}function B(t){A&&t.data&&t._context.showTips&&(s.notifier(s._(t,"Double-click to zoom back out"),"long"),A=!1)}function F(t){return"lasso"===t||"select"===t}function N(t){var e=Math.floor(Math.min(t.b-t.t,t.r-t.l,M)/2);return"M"+(t.l-3.5)+","+(t.t-.5+e)+"h3v"+-e+"h"+e+"v-3h-"+(e+3)+"ZM"+(t.r+3.5)+","+(t.t-.5+e)+"h-3v"+-e+"h"+-e+"v-3h"+(e+3)+"ZM"+(t.r+3.5)+","+(t.b+.5-e)+"h-3v"+e+"h"+-e+"v3h"+(e+3)+"ZM"+(t.l-3.5)+","+(t.b+.5-e)+"h3v"+e+"h"+e+"v3h-"+(e+3)+"Z"}function j(t,e){if(a){var r=void 0!==t.onwheel?"wheel":"mousewheel";t._onwheel&&t.removeEventListener(r,t._onwheel),t._onwheel=e,t.addEventListener(r,e,{passive:!1})}else void 0!==t.onwheel?t.onwheel=e:void 0!==t.onmousewheel&&(t.onmousewheel=e)}function V(t){var e=[];for(var r in t)e.push(t[r]);return e}e.exports={makeDragBox:function(t,e,r,a,u,p,A,T){var I,U,q,H,G,W,Y,X,Z,J,K,Q,$,tt,et,rt,nt,it,at,ot,st,lt=t._fullLayout._zoomlayer,ct=A+T==="nsew",ut=1===(A+T).length;function ft(){if(I=e.xaxis,U=e.yaxis,Z=I._length,J=U._length,Y=I._offset,X=U._offset,(q={})[I._id]=I,(H={})[U._id]=U,A&&T)for(var r=e.overlays,n=0;nM||o>M?(bt="xy",a/Z>o/J?(o=a*J/Z,gt>i?mt.t=gt-o:mt.b=gt+o):(a=o*Z/J,dt>n?mt.l=dt-a:mt.r=dt+a),wt.attr("d",N(mt))):s():!$||o10||r.scrollWidth-r.clientWidth>10)){clearTimeout(Dt);var n=-e.deltaY;if(isFinite(n)||(n=e.wheelDelta/10),isFinite(n)){var i,a=Math.exp(-Math.min(Math.max(n,-20),20)/200),o=It.draglayer.select(".nsewdrag").node().getBoundingClientRect(),l=(e.clientX-o.left)/o.width,c=(o.bottom-e.clientY)/o.height;if(rt){for(T||(l=.5),i=0;ig[1]-.01&&(e.domain=s),i.noneOrAll(t.domain,e.domain,s)}return r("layer"),e}},{"../../lib":660,"fast-isnumeric":197}],722:[function(t,e,r){"use strict";var n=t("../../constants/alignment").FROM_BL;e.exports=function(t,e,r){void 0===r&&(r=n[t.constraintoward||"center"]);var i=[t.r2l(t.range[0]),t.r2l(t.range[1])],a=i[0]+(i[1]-i[0])*r;t.range=t._input.range=[t.l2r(a+(i[0]-a)*e),t.l2r(a+(i[1]-a)*e)]}},{"../../constants/alignment":632}],723:[function(t,e,r){"use strict";var n=t("polybooljs"),i=t("../../registry"),a=t("../../components/color"),o=t("../../components/fx"),s=t("../../lib/polygon"),l=t("../../lib/throttle"),c=t("../../components/fx/helpers").makeEventData,u=t("./axis_ids").getFromId,f=t("../sort_modules").sortModules,h=t("./constants"),p=h.MINSELECT,d=s.filter,g=s.tester,m=s.multitester;function v(t){return t._id}function y(t,e,r){var n,a,o,s;if(r){var l=r.points||[];for(n=0;n0)return Math.log(e)/Math.LN10;if(e<=0&&r&&t.range&&2===t.range.length){var n=t.range[0],i=t.range[1];return.5*(n+i-3*u*Math.abs(n-i))}return h}function v(e,r,n){var a=l(e,n||t.calendar);if(a===h){if(!i(e))return h;a=l(new Date(+e))}return a}function y(e,r,n){return s(e,r,n||t.calendar)}function x(e){return t._categories[Math.round(e)]}function b(e){if(t._categoriesMap){var r=t._categoriesMap[e];if(void 0!==r)return r}if(i(e))return+e}function _(e){return i(e)?n.round(t._b+t._m*e,2):h}function w(e){return(e-t._b)/t._m}t.c2l="log"===t.type?m:c,t.l2c="log"===t.type?g:c,t.l2p=_,t.p2l=w,t.c2p="log"===t.type?function(t,e){return _(m(t,e))}:_,t.p2c="log"===t.type?function(t){return g(w(t))}:w,-1!==["linear","-"].indexOf(t.type)?(t.d2r=t.r2d=t.d2c=t.r2c=t.d2l=t.r2l=o,t.c2d=t.c2r=t.l2d=t.l2r=c,t.d2p=t.r2p=function(e){return t.l2p(o(e))},t.p2d=t.p2r=w,t.cleanPos=c):"log"===t.type?(t.d2r=t.d2l=function(t,e){return m(o(t),e)},t.r2d=t.r2c=function(t){return g(o(t))},t.d2c=t.r2l=o,t.c2d=t.l2r=c,t.c2r=m,t.l2d=g,t.d2p=function(e,r){return t.l2p(t.d2r(e,r))},t.p2d=function(t){return g(w(t))},t.r2p=function(e){return t.l2p(o(e))},t.p2r=w,t.cleanPos=c):"date"===t.type?(t.d2r=t.r2d=a.identity,t.d2c=t.r2c=t.d2l=t.r2l=v,t.c2d=t.c2r=t.l2d=t.l2r=y,t.d2p=t.r2p=function(e,r,n){return t.l2p(v(e,0,n))},t.p2d=t.p2r=function(t,e,r){return y(w(t),e,r)},t.cleanPos=function(e){return a.cleanDate(e,h,t.calendar)}):"category"===t.type&&(t.d2c=t.d2l=function(e){if(null!=e){if(void 0===t._categoriesMap&&(t._categoriesMap={}),void 0!==t._categoriesMap[e])return t._categoriesMap[e];t._categories.push(e);var r=t._categories.length-1;return t._categoriesMap[e]=r,r}return h},t.r2d=t.c2d=t.l2d=x,t.d2r=t.d2l_noadd=b,t.r2c=function(e){var r=b(e);return void 0!==r?r:t.fraction2r(.5)},t.l2r=t.c2r=c,t.r2l=b,t.d2p=function(e){return t.l2p(t.r2c(e))},t.p2d=function(t){return x(w(t))},t.r2p=t.d2p,t.p2r=w,t.cleanPos=function(t){return"string"==typeof t&&""!==t?t:c(t)}),t.fraction2r=function(e){var r=t.r2l(t.range[0]),n=t.r2l(t.range[1]);return t.l2r(r+e*(n-r))},t.r2fraction=function(e){var r=t.r2l(t.range[0]),n=t.r2l(t.range[1]);return(t.r2l(e)-r)/(n-r)},t.cleanRange=function(e,n){n||(n={}),e||(e="range");var o,s,l=a.nestedProperty(t,e).get();if(s=(s="date"===t.type?a.dfltRange(t.calendar):"y"===r?p.DFLTRANGEY:n.dfltRange||p.DFLTRANGEX).slice(),l&&2===l.length)for("date"===t.type&&(l[0]=a.cleanDate(l[0],h,t.calendar),l[1]=a.cleanDate(l[1],h,t.calendar)),o=0;o<2;o++)if("date"===t.type){if(!a.isDateTime(l[o],t.calendar)){t[e]=s;break}if(t.r2l(l[0])===t.r2l(l[1])){var c=a.constrain(t.r2l(l[0]),a.MIN_MS+1e3,a.MAX_MS-1e3);l[0]=t.l2r(c-1e3),l[1]=t.l2r(c+1e3);break}}else{if(!i(l[o])){if(!i(l[1-o])){t[e]=s;break}l[o]=l[1-o]*(o?10:.1)}if(l[o]<-f?l[o]=-f:l[o]>f&&(l[o]=f),l[0]===l[1]){var u=Math.max(1,Math.abs(1e-6*l[0]));l[0]-=u,l[1]+=u}}else a.nestedProperty(t,e).set(s)},t.setScale=function(n){var i=e._size;if(t._categories||(t._categories=[]),t._categoriesMap||(t._categoriesMap={}),t.overlaying){var a=d.getFromId({_fullLayout:e},t.overlaying);t.domain=a.domain}var o=n&&t._r?"_r":"range",s=t.calendar;t.cleanRange(o);var l=t.r2l(t[o][0],s),c=t.r2l(t[o][1],s);if("y"===r?(t._offset=i.t+(1-t.domain[1])*i.h,t._length=i.h*(t.domain[1]-t.domain[0]),t._m=t._length/(l-c),t._b=-t._m*c):(t._offset=i.l+t.domain[0]*i.w,t._length=i.w*(t.domain[1]-t.domain[0]),t._m=t._length/(c-l),t._b=-t._m*l),!isFinite(t._m)||!isFinite(t._b))throw e._replotting=!1,new Error("Something went wrong with axis scaling")},t.makeCalcdata=function(e,r){var n,i,o,s,l=t.type,c="date"===l&&e[r+"calendar"];if(r in e){if(n=e[r],s=e._length||n.length,a.isTypedArray(n)&&("linear"===l||"log"===l)){if(s===n.length)return n;if(n.subarray)return n.subarray(0,s)}for(i=new Array(s),o=0;o0?Number(u):c;else if("string"!=typeof u)e.dtick=c;else{var f=u.charAt(0),h=u.substr(1);((h=n(h)?Number(h):0)<=0||!("date"===o&&"M"===f&&h===Math.round(h)||"log"===o&&"L"===f||"log"===o&&"D"===f&&(1===h||2===h)))&&(e.dtick=c)}var p="date"===o?i.dateTick0(e.calendar):0,d=r("tick0",p);"date"===o?e.tick0=i.cleanDate(d,p):n(d)&&"D1"!==u&&"D2"!==u?e.tick0=Number(d):e.tick0=p}else{void 0===r("tickvals")?e.tickmode="auto":r("ticktext")}}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],728:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../registry"),a=t("../../components/drawing"),o=t("./axes"),s=t("./constants").attrRegex;e.exports=function(t,e,r,l){var c=t._fullLayout,u=[];var f,h,p,d,g=function(t){var e,r,n,i,a={};for(e in t)if((r=e.split("."))[0].match(s)){var o=e.charAt(0),l=r[0];if(n=c[l],i={},Array.isArray(t[e])?i.to=t[e].slice(0):Array.isArray(t[e].range)&&(i.to=t[e].range.slice(0)),!i.to)continue;i.axisName=l,i.length=n._length,u.push(o),a[o]=i}return a}(e),m=Object.keys(g),v=function(t,e,r){var n,i,a,o=t._plots,s=[];for(n in o){var l=o[n];if(-1===s.indexOf(l)){var c=l.xaxis._id,u=l.yaxis._id,f=l.xaxis.range,h=l.yaxis.range;l.xaxis._r=l.xaxis.range.slice(),l.yaxis._r=l.yaxis.range.slice(),i=r[c]?r[c].to:f,a=r[u]?r[u].to:h,f[0]===i[0]&&f[1]===i[1]&&h[0]===a[0]&&h[1]===a[1]||-1===e.indexOf(c)&&-1===e.indexOf(u)||s.push(l)}}return s}(c,m,g);if(!v.length)return function(){function e(e,r,n){for(var i=0;i rect").call(a.setTranslate,0,0).call(a.setScale,1,1),t.plot.call(a.setTranslate,e._offset,r._offset).call(a.setScale,1,1);var n=t.plot.selectAll(".scatterlayer .trace");n.selectAll(".point").call(a.setPointGroupScale,1,1),n.selectAll(".textpoint").call(a.setTextPointsScale,1,1),n.call(a.hideOutsideRangePoints,t)}function x(e,r){var n,s,l,u=g[e.xaxis._id],f=g[e.yaxis._id],h=[];if(u){s=(n=t._fullLayout[u.axisName])._r,l=u.to,h[0]=(s[0]*(1-r)+r*l[0]-s[0])/(s[1]-s[0])*e.xaxis._length;var p=s[1]-s[0],d=l[1]-l[0];n.range[0]=s[0]*(1-r)+r*l[0],n.range[1]=s[1]*(1-r)+r*l[1],h[2]=e.xaxis._length*(1-r+r*d/p)}else h[0]=0,h[2]=e.xaxis._length;if(f){s=(n=t._fullLayout[f.axisName])._r,l=f.to,h[1]=(s[1]*(1-r)+r*l[1]-s[1])/(s[0]-s[1])*e.yaxis._length;var m=s[1]-s[0],v=l[1]-l[0];n.range[0]=s[0]*(1-r)+r*l[0],n.range[1]=s[1]*(1-r)+r*l[1],h[3]=e.yaxis._length*(1-r+r*v/m)}else h[1]=0,h[3]=e.yaxis._length;!function(e,r){var n,a=[];for(a=[e._id,r._id],n=0;nr.duration?(function(){for(var e={},r=0;r0&&i["_"+r+"axes"][e])return i;if((i[r+"axis"]||r)===e){if(s(i,r))return i;if((i[r]||[]).length||i[r+"0"])return i}}}(e,r,a);if(!l)return;if("histogram"===l.type&&a==={v:"y",h:"x"}[l.orientation||"v"])return void(t.type="linear");var c,u=a+"calendar",f=l[u];if(s(l,a)){var h=o(l),p=[];for(c=0;c0?".":"")+a;i.isPlainObject(o)?l(o,e,s,n+1):e(s,a,o)}})}r.manageCommandObserver=function(t,e,n,o){var s={},l=!0;e&&e._commandObserver&&(s=e._commandObserver),s.cache||(s.cache={}),s.lookupTable={};var c=r.hasSimpleAPICommandBindings(t,n,s.lookupTable);if(e&&e._commandObserver){if(c)return s;if(e._commandObserver.remove)return e._commandObserver.remove(),e._commandObserver=null,s}if(c){a(t,c,s.cache),s.check=function(){if(l){var e=a(t,c,s.cache);return e.changed&&o&&void 0!==s.lookupTable[e.value]&&(s.disable(),Promise.resolve(o({value:e.value,type:c.type,prop:c.prop,traces:c.traces,index:s.lookupTable[e.value]})).then(s.enable,s.enable)),e.changed}};for(var u=["plotly_relayout","plotly_redraw","plotly_restyle","plotly_update","plotly_animatingframe","plotly_afterplot"],f=0;fi*Math.PI/180}return!1},r.getPath=function(){return n.geo.path().projection(r)},r.getBounds=function(t){return r.getPath().bounds(t)},r.fitExtent=function(t,e){var n=t[1][0]-t[0][0],i=t[1][1]-t[0][1],a=r.clipExtent&&r.clipExtent();r.scale(150).translate([0,0]),a&&r.clipExtent(null);var o=r.getBounds(e),s=Math.min(n/(o[1][0]-o[0][0]),i/(o[1][1]-o[0][1])),l=+t[0][0]+(n-s*(o[1][0]+o[0][0]))/2,c=+t[0][1]+(i-s*(o[1][1]+o[0][1]))/2;return a&&r.clipExtent(a),r.scale(150*s).translate([l,c])},r.precision(d.precision),i&&r.clipAngle(i-d.clipPad);return r}(e);u.center([c.lon-l.lon,c.lat-l.lat]).rotate([-l.lon,-l.lat,l.roll]).parallels(s.parallels);var f=[[r.l+r.w*o.x[0],r.t+r.h*(1-o.y[1])],[r.l+r.w*o.x[1],r.t+r.h*(1-o.y[0])]],h=e.lonaxis,p=e.lataxis,g=function(t,e){var r=d.clipPad,n=t[0]+r,i=t[1]-r,a=e[0]+r,o=e[1]-r;n>0&&i<0&&(i+=360);var s=(i-n)/4;return{type:"Polygon",coordinates:[[[n,a],[n,o],[n+s,o],[n+2*s,o],[n+3*s,o],[i,o],[i,a],[i-s,a],[i-2*s,a],[i-3*s,a],[n,a]]]}}(h.range,p.range);u.fitExtent(f,g);var m=this.bounds=u.getBounds(g),v=this.fitScale=u.scale(),y=u.translate();if(!isFinite(m[0][0])||!isFinite(m[0][1])||!isFinite(m[1][0])||!isFinite(m[1][1])||isNaN(y[0])||isNaN(y[0])){for(var x=this.graphDiv,b=["projection.rotation","center","lonaxis.range","lataxis.range"],_="Invalid geo settings, relayout'ing to default view.",w={},k=0;k0&&k<0&&(k+=360);var M,A,T,S=(w+k)/2;if(!c){var C=u?s.projRotate:[S,0,0];M=r("projection.rotation.lon",C[0]),r("projection.rotation.lat",C[1]),r("projection.rotation.roll",C[2]),r("showcoastlines",!u)&&(r("coastlinecolor"),r("coastlinewidth")),r("showocean")&&r("oceancolor")}(c?(A=-96.6,T=38.7):(A=u?S:M,T=(_[0]+_[1])/2),r("center.lon",A),r("center.lat",T),f)&&r("projection.parallels",s.projParallels||[0,60]);r("projection.scale"),r("showland")&&r("landcolor"),r("showlakes")&&r("lakecolor"),r("showrivers")&&(r("rivercolor"),r("riverwidth")),r("showcountries",u&&"usa"!==a)&&(r("countrycolor"),r("countrywidth")),("usa"===a||"north america"===a&&50===n)&&(r("showsubunits",!0),r("subunitcolor"),r("subunitwidth")),u||r("showframe",!0)&&(r("framecolor"),r("framewidth")),r("bgcolor")}e.exports=function(t,e,r){n(t,e,r,{type:"geo",attributes:a,handleDefaults:s,partition:"y"})}},{"../../subplot_defaults":782,"../constants":734,"./layout_attributes":739}],739:[function(t,e,r){"use strict";var n=t("../../../components/color/attributes"),i=t("../../domain").attributes,a=t("../constants"),o=t("../../../plot_api/edit_types").overrideAll,s={range:{valType:"info_array",items:[{valType:"number"},{valType:"number"}]},showgrid:{valType:"boolean",dflt:!1},tick0:{valType:"number"},dtick:{valType:"number"},gridcolor:{valType:"color",dflt:n.lightLine},gridwidth:{valType:"number",min:0,dflt:1}};e.exports=o({domain:i({name:"geo"},{}),resolution:{valType:"enumerated",values:[110,50],dflt:110,coerceNumber:!0},scope:{valType:"enumerated",values:Object.keys(a.scopeDefaults),dflt:"world"},projection:{type:{valType:"enumerated",values:Object.keys(a.projNames)},rotation:{lon:{valType:"number"},lat:{valType:"number"},roll:{valType:"number"}},parallels:{valType:"info_array",items:[{valType:"number"},{valType:"number"}]},scale:{valType:"number",min:0,dflt:1}},center:{lon:{valType:"number"},lat:{valType:"number"}},showcoastlines:{valType:"boolean"},coastlinecolor:{valType:"color",dflt:n.defaultLine},coastlinewidth:{valType:"number",min:0,dflt:1},showland:{valType:"boolean",dflt:!1},landcolor:{valType:"color",dflt:a.landColor},showocean:{valType:"boolean",dflt:!1},oceancolor:{valType:"color",dflt:a.waterColor},showlakes:{valType:"boolean",dflt:!1},lakecolor:{valType:"color",dflt:a.waterColor},showrivers:{valType:"boolean",dflt:!1},rivercolor:{valType:"color",dflt:a.waterColor},riverwidth:{valType:"number",min:0,dflt:1},showcountries:{valType:"boolean"},countrycolor:{valType:"color",dflt:n.defaultLine},countrywidth:{valType:"number",min:0,dflt:1},showsubunits:{valType:"boolean"},subunitcolor:{valType:"color",dflt:n.defaultLine},subunitwidth:{valType:"number",min:0,dflt:1},showframe:{valType:"boolean"},framecolor:{valType:"color",dflt:n.defaultLine},framewidth:{valType:"number",min:0,dflt:1},bgcolor:{valType:"color",dflt:n.background},lonaxis:s,lataxis:s},"plot","from-root")},{"../../../components/color/attributes":531,"../../../plot_api/edit_types":691,"../../domain":731,"../constants":734}],740:[function(t,e,r){"use strict";e.exports=function(t){function e(t,e){return{type:"Feature",id:t.id,properties:t.properties,geometry:r(t.geometry,e)}}function r(e,n){if(!e)return null;if("GeometryCollection"===e.type)return{type:"GeometryCollection",geometries:object.geometries.map(function(t){return r(t,n)})};if(!c.hasOwnProperty(e.type))return null;var i=c[e.type];return t.geo.stream(e,n(i)),i.result()}t.geo.project=function(t,e){var i=e.stream;if(!i)throw new Error("not yet supported");return(t&&n.hasOwnProperty(t.type)?n[t.type]:r)(t,i)};var n={Feature:e,FeatureCollection:function(t,r){return{type:"FeatureCollection",features:t.features.map(function(t){return e(t,r)})}}},i=[],a=[],o={point:function(t,e){i.push([t,e])},result:function(){var t=i.length?i.length<2?{type:"Point",coordinates:i[0]}:{type:"MultiPoint",coordinates:i}:null;return i=[],t}},s={lineStart:u,point:function(t,e){i.push([t,e])},lineEnd:function(){i.length&&(a.push(i),i=[])},result:function(){var t=a.length?a.length<2?{type:"LineString",coordinates:a[0]}:{type:"MultiLineString",coordinates:a}:null;return a=[],t}},l={polygonStart:u,lineStart:u,point:function(t,e){i.push([t,e])},lineEnd:function(){var t=i.length;if(t){do{i.push(i[0].slice())}while(++t<4);a.push(i),i=[]}},polygonEnd:u,result:function(){if(!a.length)return null;var t=[],e=[];return a.forEach(function(r){!function(t){if((e=t.length)<4)return!1;for(var e,r=0,n=t[e-1][1]*t[0][0]-t[e-1][0]*t[0][1];++rn^p>n&&r<(h-c)*(n-u)/(p-u)+c&&(i=!i)}return i}(t[0],r))return t.push(e),!0})||t.push([e])}),a=[],t.length?t.length>1?{type:"MultiPolygon",coordinates:t}:{type:"Polygon",coordinates:t[0]}:null}},c={Point:o,MultiPoint:o,LineString:s,MultiLineString:s,Polygon:l,MultiPolygon:l,Sphere:l};function u(){}var f=1e-6,h=f*f,p=Math.PI,d=p/2,g=(Math.sqrt(p),p/180),m=180/p;function v(t){return t>1?d:t<-1?-d:Math.asin(t)}function y(t){return t>1?0:t<-1?p:Math.acos(t)}var x=t.geo.projection,b=t.geo.projectionMutator;function _(t,e){var r=(2+d)*Math.sin(e);e/=2;for(var n=0,i=1/0;n<10&&Math.abs(i)>f;n++){var a=Math.cos(e);e-=i=(e+Math.sin(e)*(a+2)-r)/(2*a*(1+a))}return[2/Math.sqrt(p*(4+p))*t*(1+Math.cos(e)),2*Math.sqrt(p/(4+p))*Math.sin(e)]}t.geo.interrupt=function(e){var r,n=[[[[-p,0],[0,d],[p,0]]],[[[-p,0],[0,-d],[p,0]]]];function i(t,r){for(var i=r<0?-1:1,a=n[+(r<0)],o=0,s=a.length-1;oa[o][2][0];++o);var l=e(t-a[o][1][0],r);return l[0]+=e(a[o][1][0],i*r>i*a[o][0][1]?a[o][0][1]:r)[0],l}e.invert&&(i.invert=function(t,a){for(var o=r[+(a<0)],s=n[+(a<0)],c=0,u=o.length;c=0;--i){var o=n[1][i],l=180*o[0][0]/p,c=180*o[0][1]/p,u=180*o[1][1]/p,f=180*o[2][0]/p,h=180*o[2][1]/p;r.push(s([[f-e,h-e],[f-e,u+e],[l+e,u+e],[l+e,c-e]],30))}return{type:"Polygon",coordinates:[t.merge(r)]}}(),l)},i},a.lobes=function(t){return arguments.length?(n=t.map(function(t){return t.map(function(t){return[[t[0][0]*p/180,t[0][1]*p/180],[t[1][0]*p/180,t[1][1]*p/180],[t[2][0]*p/180,t[2][1]*p/180]]})}),r=n.map(function(t){return t.map(function(t){var r,n=e(t[0][0],t[0][1])[0],i=e(t[2][0],t[2][1])[0],a=e(t[1][0],t[0][1])[1],o=e(t[1][0],t[1][1])[1];return a>o&&(r=a,a=o,o=r),[[n,a],[i,o]]})}),a):n.map(function(t){return t.map(function(t){return[[180*t[0][0]/p,180*t[0][1]/p],[180*t[1][0]/p,180*t[1][1]/p],[180*t[2][0]/p,180*t[2][1]/p]]})})},a},_.invert=function(t,e){var r=.5*e*Math.sqrt((4+p)/p),n=v(r),i=Math.cos(n);return[t/(2/Math.sqrt(p*(4+p))*(1+i)),v((n+r*(i+2))/(2+d))]},(t.geo.eckert4=function(){return x(_)}).raw=_;var w=t.geo.azimuthalEqualArea.raw;function k(t,e){if(arguments.length<2&&(e=t),1===e)return w;if(e===1/0)return M;function r(r,n){var i=w(r/e,n);return i[0]*=t,i}return r.invert=function(r,n){var i=w.invert(r/t,n);return i[0]*=e,i},r}function M(t,e){return[t*Math.cos(e)/Math.cos(e/=2),2*Math.sin(e)]}function A(t,e){return[3*t/(2*p)*Math.sqrt(p*p/3-e*e),e]}function T(t,e){return[t,1.25*Math.log(Math.tan(p/4+.4*e))]}function S(t){return function(e){var r,n=t*Math.sin(e),i=30;do{e-=r=(e+Math.sin(e)-n)/(1+Math.cos(e))}while(Math.abs(r)>f&&--i>0);return e/2}}M.invert=function(t,e){var r=2*v(e/2);return[t*Math.cos(r/2)/Math.cos(r),r]},(t.geo.hammer=function(){var t=2,e=b(k),r=e(t);return r.coefficient=function(r){return arguments.length?e(t=+r):t},r}).raw=k,A.invert=function(t,e){return[2/3*p*t/Math.sqrt(p*p/3-e*e),e]},(t.geo.kavrayskiy7=function(){return x(A)}).raw=A,T.invert=function(t,e){return[t,2.5*Math.atan(Math.exp(.8*e))-.625*p]},(t.geo.miller=function(){return x(T)}).raw=T,S(p);var C=function(t,e,r){var n=S(r);function i(r,i){return[t*r*Math.cos(i=n(i)),e*Math.sin(i)]}return i.invert=function(n,i){var a=v(i/e);return[n/(t*Math.cos(a)),v((2*a+Math.sin(2*a))/r)]},i}(Math.SQRT2/d,Math.SQRT2,p);function E(t,e){var r=e*e,n=r*r;return[t*(.8707-.131979*r+n*(n*(.003971*r-.001529*n)-.013791)),e*(1.007226+r*(.015085+n*(.028874*r-.044475-.005916*n)))]}(t.geo.mollweide=function(){return x(C)}).raw=C,E.invert=function(t,e){var r,n=e,i=25;do{var a=n*n,o=a*a;n-=r=(n*(1.007226+a*(.015085+o*(.028874*a-.044475-.005916*o)))-e)/(1.007226+a*(.045255+o*(.259866*a-.311325-.005916*11*o)))}while(Math.abs(r)>f&&--i>0);return[t/(.8707+(a=n*n)*(a*(a*a*a*(.003971-.001529*a)-.013791)-.131979)),n]},(t.geo.naturalEarth=function(){return x(E)}).raw=E;var L=[[.9986,-.062],[1,0],[.9986,.062],[.9954,.124],[.99,.186],[.9822,.248],[.973,.31],[.96,.372],[.9427,.434],[.9216,.4958],[.8962,.5571],[.8679,.6176],[.835,.6769],[.7986,.7346],[.7597,.7903],[.7186,.8435],[.6732,.8936],[.6213,.9394],[.5722,.9761],[.5322,1]];function z(t,e){var r,n=Math.min(18,36*Math.abs(e)/p),i=Math.floor(n),a=n-i,o=(r=L[i])[0],s=r[1],l=(r=L[++i])[0],c=r[1],u=(r=L[Math.min(19,++i)])[0],f=r[1];return[t*(l+a*(u-o)/2+a*a*(u-2*l+o)/2),(e>0?d:-d)*(c+a*(f-s)/2+a*a*(f-2*c+s)/2)]}function P(t,e){return[t*Math.cos(e),e]}function D(t,e){var r,n=Math.cos(e),i=(r=y(n*Math.cos(t/=2)))?r/Math.sin(r):1;return[2*n*Math.sin(t)*i,Math.sin(e)*i]}function O(t,e){var r=D(t,e);return[(r[0]+t/d)/2,(r[1]+e)/2]}L.forEach(function(t){t[1]*=1.0144}),z.invert=function(t,e){var r=e/d,n=90*r,i=Math.min(18,Math.abs(n/5)),a=Math.max(0,Math.floor(i));do{var o=L[a][1],s=L[a+1][1],l=L[Math.min(19,a+2)][1],c=l-o,u=l-2*s+o,f=2*(Math.abs(r)-s)/c,p=u/c,v=f*(1-p*f*(1-2*p*f));if(v>=0||1===a){n=(e>=0?5:-5)*(v+i);var y,x=50;do{v=(i=Math.min(18,Math.abs(n)/5))-(a=Math.floor(i)),o=L[a][1],s=L[a+1][1],l=L[Math.min(19,a+2)][1],n-=(y=(e>=0?d:-d)*(s+v*(l-o)/2+v*v*(l-2*s+o)/2)-e)*m}while(Math.abs(y)>h&&--x>0);break}}while(--a>=0);var b=L[a][0],_=L[a+1][0],w=L[Math.min(19,a+2)][0];return[t/(_+v*(w-b)/2+v*v*(w-2*_+b)/2),n*g]},(t.geo.robinson=function(){return x(z)}).raw=z,P.invert=function(t,e){return[t/Math.cos(e),e]},(t.geo.sinusoidal=function(){return x(P)}).raw=P,D.invert=function(t,e){if(!(t*t+4*e*e>p*p+f)){var r=t,n=e,i=25;do{var a,o=Math.sin(r),s=Math.sin(r/2),l=Math.cos(r/2),c=Math.sin(n),u=Math.cos(n),h=Math.sin(2*n),d=c*c,g=u*u,m=s*s,v=1-g*l*l,x=v?y(u*l)*Math.sqrt(a=1/v):a=0,b=2*x*u*s-t,_=x*c-e,w=a*(g*m+x*u*l*d),k=a*(.5*o*h-2*x*c*s),M=.25*a*(h*s-x*c*g*o),A=a*(d*l+x*m*u),T=k*M-A*w;if(!T)break;var S=(_*k-b*A)/T,C=(b*M-_*w)/T;r-=S,n-=C}while((Math.abs(S)>f||Math.abs(C)>f)&&--i>0);return[r,n]}},(t.geo.aitoff=function(){return x(D)}).raw=D,O.invert=function(t,e){var r=t,n=e,i=25;do{var a,o=Math.cos(n),s=Math.sin(n),l=Math.sin(2*n),c=s*s,u=o*o,h=Math.sin(r),p=Math.cos(r/2),g=Math.sin(r/2),m=g*g,v=1-u*p*p,x=v?y(o*p)*Math.sqrt(a=1/v):a=0,b=.5*(2*x*o*g+r/d)-t,_=.5*(x*s+n)-e,w=.5*a*(u*m+x*o*p*c)+.5/d,k=a*(h*l/4-x*s*g),M=.125*a*(l*g-x*s*u*h),A=.5*a*(c*p+x*m*o)+.5,T=k*M-A*w,S=(_*k-b*A)/T,C=(b*M-_*w)/T;r-=S,n-=C}while((Math.abs(S)>f||Math.abs(C)>f)&&--i>0);return[r,n]},(t.geo.winkel3=function(){return x(O)}).raw=O}},{}],741:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=Math.PI/180,o=180/Math.PI,s={cursor:"pointer"},l={cursor:"auto"};function c(t,e){return n.behavior.zoom().translate(e.translate()).scale(e.scale())}function u(t,e,r){var n=t.id,a=t.graphDiv,o=a.layout[n],s=a._fullLayout[n],l={};function c(t,e){var r=i.nestedProperty(s,t);r.get()!==e&&(r.set(e),i.nestedProperty(o,t).set(e),l[n+"."+t]=e)}r(c),c("projection.scale",e.scale()/t.fitScale),a.emit("plotly_relayout",l)}function f(t,e){var r=c(0,e);function i(r){var n=e.invert(t.midPt);r("center.lon",n[0]),r("center.lat",n[1])}return r.on("zoomstart",function(){n.select(this).style(s)}).on("zoom",function(){e.scale(n.event.scale).translate(n.event.translate),t.render()}).on("zoomend",function(){n.select(this).style(l),u(t,e,i)}),r}function h(t,e){var r,i,a,o,f,h,p,d,g=c(0,e),m=2;function v(t){return e.invert(t)}function y(r){var n=e.rotate(),i=e.invert(t.midPt);r("projection.rotation.lon",-n[0]),r("center.lon",i[0]),r("center.lat",i[1])}return g.on("zoomstart",function(){n.select(this).style(s),r=n.mouse(this),i=e.rotate(),a=e.translate(),o=i,f=v(r)}).on("zoom",function(){if(h=n.mouse(this),l=e(v(s=r)),Math.abs(l[0]-s[0])>m||Math.abs(l[1]-s[1])>m)return g.scale(e.scale()),void g.translate(e.translate());var s,l;e.scale(n.event.scale),e.translate([a[0],n.event.translate[1]]),f?v(h)&&(d=v(h),p=[o[0]+(d[0]-f[0]),i[1],i[2]],e.rotate(p),o=p):f=v(r=h),t.render()}).on("zoomend",function(){n.select(this).style(l),u(t,e,y)}),g}function p(t,e){var r,i={r:e.rotate(),k:e.scale()},f=c(0,e),h=function(t){var e=0,r=arguments.length,i=[];for(;++ed?(a=(f>0?90:-90)-p,i=0):(a=Math.asin(f/d)*o-p,i=Math.sqrt(d*d-f*f));var m=180-a-2*p,y=(Math.atan2(h,u)-Math.atan2(c,i))*o,x=(Math.atan2(h,u)-Math.atan2(c,-i))*o,b=g(r[0],r[1],a,y),_=g(r[0],r[1],m,x);return b<=_?[a,y,r[2]]:[m,x,r[2]]}(k,r,C);isFinite(M[0])&&isFinite(M[1])&&isFinite(M[2])||(M=C),e.rotate(M),C=M}}else r=d(e,T=b);h.of(this,arguments)({type:"zoom"})}),A=h.of(this,arguments),p++||A({type:"zoomstart"})}).on("zoomend",function(){var r;n.select(this).style(l),m.call(f,"zoom",null),r=h.of(this,arguments),--p||r({type:"zoomend"}),u(t,e,x)}).on("zoom.redraw",function(){t.render()}),n.rebind(f,h,"on")}function d(t,e){var r=t.invert(e);return r&&isFinite(r[0])&&isFinite(r[1])&&function(t){var e=t[0]*a,r=t[1]*a,n=Math.cos(r);return[n*Math.cos(e),n*Math.sin(e),Math.sin(r)]}(r)}function g(t,e,r,n){var i=m(r-t),a=m(n-e);return Math.sqrt(i*i+a*a)}function m(t){return(t%360+540)%360-180}function v(t,e,r){var n=r*a,i=t.slice(),o=0===e?1:0,s=2===e?1:2,l=Math.cos(n),c=Math.sin(n);return i[o]=t[o]*l-t[s]*c,i[s]=t[s]*l+t[o]*c,i}function y(t,e){for(var r=0,n=0,i=t.length;nMath.abs(s)?(c.boxEnd[1]=c.boxStart[1]+Math.abs(a)*_*(s>=0?1:-1),c.boxEnd[1]l[3]&&(c.boxEnd[1]=l[3],c.boxEnd[0]=c.boxStart[0]+(l[3]-c.boxStart[1])/Math.abs(_))):(c.boxEnd[0]=c.boxStart[0]+Math.abs(s)/_*(a>=0?1:-1),c.boxEnd[0]l[2]&&(c.boxEnd[0]=l[2],c.boxEnd[1]=c.boxStart[1]+(l[2]-c.boxStart[0])*Math.abs(_)))}}else c.boxEnabled?(a=c.boxStart[0]!==c.boxEnd[0],s=c.boxStart[1]!==c.boxEnd[1],a||s?(a&&(m(0,c.boxStart[0],c.boxEnd[0]),t.xaxis.autorange=!1),s&&(m(1,c.boxStart[1],c.boxEnd[1]),t.yaxis.autorange=!1),t.relayoutCallback()):t.glplot.setDirty(),c.boxEnabled=!1,c.boxInited=!1):c.boxInited&&(c.boxInited=!1);break;case"pan":c.boxEnabled=!1,c.boxInited=!1,e?(c.panning||(c.dragStart[0]=n,c.dragStart[1]=i),Math.abs(c.dragStart[0]-n)Math.abs(e))c.rotate(a,0,0,-t*r*Math.PI*d.rotateSpeed/window.innerWidth);else{var o=-d.zoomSpeed*i*e/window.innerHeight*(a-c.lastT())/20;c.pan(a,0,0,f*(Math.exp(o)-1))}}},!0),d};var n=t("right-now"),i=t("3d-view"),a=t("mouse-change"),o=t("mouse-wheel"),s=t("mouse-event-offset"),l=t("has-passive-events")},{"3d-view":42,"has-passive-events":355,"mouse-change":378,"mouse-event-offset":379,"mouse-wheel":381,"right-now":440}],748:[function(t,e,r){"use strict";var n=t("../../plot_api/edit_types").overrideAll,i=t("../../components/fx/layout_attributes"),a=t("./scene"),o=t("../get_data").getSubplotData,s=t("../../lib"),l=t("../../constants/xmlns_namespaces");r.name="gl3d",r.attr="scene",r.idRoot="scene",r.idRegex=r.attrRegex=s.counterRegex("scene"),r.attributes=t("./layout/attributes"),r.layoutAttributes=t("./layout/layout_attributes"),r.baseLayoutAttrOverrides=n({hoverlabel:i.hoverlabel},"plot","nested"),r.supplyLayoutDefaults=t("./layout/defaults"),r.plot=function(t){for(var e=t._fullLayout,r=t._fullData,n=e._subplots.gl3d,i=0;i1;o(t,e,r,{type:"gl3d",attributes:l,handleDefaults:c,fullLayout:e,font:e.font,fullData:r,getDfltFromLayout:function(e){if(!i)return n.validate(t[e],l[e])?t[e]:void 0},paper_bgcolor:e.paper_bgcolor,calendar:e.calendar})}},{"../../../components/color":532,"../../../lib":660,"../../../registry":790,"../../subplot_defaults":782,"./axis_defaults":751,"./layout_attributes":754}],754:[function(t,e,r){"use strict";var n=t("./axis_attributes"),i=t("../../domain").attributes,a=t("../../../lib/extend").extendFlat,o=t("../../../lib").counterRegex;function s(t,e,r){return{x:{valType:"number",dflt:t,editType:"camera"},y:{valType:"number",dflt:e,editType:"camera"},z:{valType:"number",dflt:r,editType:"camera"},editType:"camera"}}e.exports={_arrayAttrRegexps:[o("scene",".annotations",!0)],bgcolor:{valType:"color",dflt:"rgba(0,0,0,0)",editType:"plot"},camera:{up:a(s(0,0,1),{}),center:a(s(0,0,0),{}),eye:a(s(1.25,1.25,1.25),{}),editType:"camera"},domain:i({name:"scene",editType:"plot"}),aspectmode:{valType:"enumerated",values:["auto","cube","data","manual"],dflt:"auto",editType:"plot",impliedEdits:{"aspectratio.x":void 0,"aspectratio.y":void 0,"aspectratio.z":void 0}},aspectratio:{x:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},y:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},z:{valType:"number",min:0,editType:"plot",impliedEdits:{"^aspectmode":"manual"}},editType:"plot",impliedEdits:{aspectmode:"manual"}},xaxis:n,yaxis:n,zaxis:n,dragmode:{valType:"enumerated",values:["orbit","turntable","zoom","pan",!1],dflt:"turntable",editType:"plot"},hovermode:{valType:"enumerated",values:["closest",!1],dflt:"closest",editType:"modebar"},editType:"plot",_deprecated:{cameraposition:{valType:"info_array",editType:"camera"}}}},{"../../../lib":660,"../../../lib/extend":649,"../../domain":731,"./axis_attributes":750}],755:[function(t,e,r){"use strict";var n=t("../../../lib/str2rgbarray"),i=["xaxis","yaxis","zaxis"];function a(){this.enabled=[!0,!0,!0],this.colors=[[0,0,0,1],[0,0,0,1],[0,0,0,1]],this.drawSides=[!0,!0,!0],this.lineWidth=[1,1,1]}a.prototype.merge=function(t){for(var e=0;e<3;++e){var r=t[i[e]];r.visible?(this.enabled[e]=r.showspikes,this.colors[e]=n(r.spikecolor),this.drawSides[e]=r.spikesides,this.lineWidth[e]=r.spikethickness):(this.enabled[e]=!1,this.drawSides[e]=!1)}},e.exports=function(t){var e=new a;return e.merge(t),e}},{"../../../lib/str2rgbarray":683}],756:[function(t,e,r){"use strict";e.exports=function(t){for(var e=t.axesOptions,r=t.glplot.axesPixels,l=t.fullSceneLayout,c=[[],[],[]],u=0;u<3;++u){var f=l[o[u]];if(f._length=(r[u].hi-r[u].lo)*r[u].pixelsPerDataUnit/t.dataScale[u],Math.abs(f._length)===1/0)c[u]=[];else{f._input_range=f.range.slice(),f.range[0]=r[u].lo/t.dataScale[u],f.range[1]=r[u].hi/t.dataScale[u],f._m=1/(t.dataScale[u]*r[u].pixelsPerDataUnit),f.range[0]===f.range[1]&&(f.range[0]-=1,f.range[1]+=1);var h=f.tickmode;if("auto"===f.tickmode){f.tickmode="linear";var p=f.nticks||i.constrain(f._length/40,4,9);n.autoTicks(f,Math.abs(f.range[1]-f.range[0])/p)}for(var d=n.calcTicks(f),g=0;g")}else m=c.textLabel;t.fullSceneLayout.hovermode&&f.loneHover({x:(.5+.5*d[0]/d[3])*i,y:(.5-.5*d[1]/d[3])*a,xLabel:w,yLabel:k,zLabel:M,text:m,name:l.name,color:f.castHoverOption(e,v,"bgcolor")||l.color,borderColor:f.castHoverOption(e,v,"bordercolor"),fontFamily:f.castHoverOption(e,v,"font.family"),fontSize:f.castHoverOption(e,v,"font.size"),fontColor:f.castHoverOption(e,v,"font.color")},{container:r,gd:t.graphDiv});var T={x:c.traceCoordinate[0],y:c.traceCoordinate[1],z:c.traceCoordinate[2],data:e._input,fullData:e,curveNumber:e.index,pointNumber:v};f.appendArrayPointValue(T,e,v);var S={points:[T]};c.buttons&&c.distance<5?t.graphDiv.emit("plotly_click",S):t.graphDiv.emit("plotly_hover",S),o=S}else f.loneUnhover(r),t.graphDiv.emit("plotly_unhover",o);t.drawAnnotations(t)}.bind(null,t),t.traces={},!0}function b(t,e){var r=document.createElement("div"),n=t.container;this.graphDiv=t.graphDiv;var i=document.createElementNS("http://www.w3.org/2000/svg","svg");i.style.position="absolute",i.style.top=i.style.left="0px",i.style.width=i.style.height="100%",i.style["z-index"]=20,i.style["pointer-events"]="none",r.appendChild(i),this.svgContainer=i,r.id=t.id,r.style.position="absolute",r.style.top=r.style.left="0px",r.style.width=r.style.height="100%",n.appendChild(r),this.fullLayout=e,this.id=t.id||"scene",this.fullSceneLayout=e[this.id],this.plotArgs=[[],{},{}],this.axesOptions=m(e[this.id]),this.spikeOptions=v(e[this.id]),this.container=r,this.staticMode=!!t.staticPlot,this.pixelRatio=t.plotGlPixelRatio||2,this.dataScale=[1,1,1],this.contourLevels=[[],[],[]],this.convertAnnotations=l.getComponentMethod("annotations3d","convert"),this.drawAnnotations=l.getComponentMethod("annotations3d","draw"),x(this)}var _=b.prototype;_.recoverContext=function(){var t=this,e=this.glplot.gl,r=this.glplot.canvas;this.glplot.dispose(),requestAnimationFrame(function n(){e.isContextLost()?requestAnimationFrame(n):x(t,t.fullLayout,r,e)?t.plot.apply(t,t.plotArgs):c.error("Catastrophic and unrecoverable WebGL error. Context lost.")})};var w=["xaxis","yaxis","zaxis"];function k(t,e,r){for(var n=t.fullSceneLayout,i=0;i<3;i++){var a=w[i],o=a.charAt(0),s=n[a],l=e[o],u=e[o+"calendar"],f=e["_"+o+"length"];if(c.isArrayOrTypedArray(l))for(var h,p=0;p<(f||l.length);p++)if(c.isArrayOrTypedArray(l[p]))for(var d=0;df[1][o]?p[o]=1:f[1][o]===f[0][o]?p[o]=1:p[o]=1/(f[1][o]-f[0][o]);for(this.dataScale=p,this.convertAnnotations(this),a=0;ag[1][a])g[0][a]=-1,g[1][a]=1;else{var C=g[1][a]-g[0][a];g[0][a]-=C/32,g[1][a]+=C/32}}else{var E=s.range;g[0][a]=s.r2l(E[0]),g[1][a]=s.r2l(E[1])}g[0][a]===g[1][a]&&(g[0][a]-=1,g[1][a]+=1),m[a]=g[1][a]-g[0][a],this.glplot.bounds[0][a]=g[0][a]*p[a],this.glplot.bounds[1][a]=g[1][a]*p[a]}var L=[1,1,1];for(a=0;a<3;++a){var z=v[l=(s=c[w[a]]).type];L[a]=Math.pow(z.acc,1/z.count)/p[a]}var P;if("auto"===c.aspectmode)P=Math.max.apply(null,L)/Math.min.apply(null,L)<=4?L:[1,1,1];else if("cube"===c.aspectmode)P=[1,1,1];else if("data"===c.aspectmode)P=L;else{if("manual"!==c.aspectmode)throw new Error("scene.js aspectRatio was not one of the enumerated types");var D=c.aspectratio;P=[D.x,D.y,D.z]}c.aspectratio.x=u.aspectratio.x=P[0],c.aspectratio.y=u.aspectratio.y=P[1],c.aspectratio.z=u.aspectratio.z=P[2],this.glplot.aspect=P;var O=c.domain||null,I=e._size||null;if(O&&I){var R=this.container.style;R.position="absolute",R.left=I.l+O.x[0]*I.w+"px",R.top=I.t+(1-O.y[1])*I.h+"px",R.width=I.w*(O.x[1]-O.x[0])+"px",R.height=I.h*(O.y[1]-O.y[0])+"px"}this.glplot.redraw()}},_.destroy=function(){this.glplot&&(this.camera.mouseListener.enabled=!1,this.container.removeEventListener("wheel",this.camera.wheelListener),this.camera=this.glplot.camera=null,this.glplot.dispose(),this.container.parentNode.removeChild(this.container),this.glplot=null)},_.getCamera=function(){return this.glplot.camera.view.recalcMatrix(this.camera.view.lastT()),M(this.glplot.camera)},_.setCamera=function(t){var e;this.glplot.camera.lookAt.apply(this,[[(e=t).eye.x,e.eye.y,e.eye.z],[e.center.x,e.center.y,e.center.z],[e.up.x,e.up.y,e.up.z]])},_.saveCamera=function(t){var e=this.getCamera(),r=c.nestedProperty(t,this.id+".camera"),n=r.get(),i=!1;function a(t,e,r,n){var i=["up","center","eye"],a=["x","y","z"];return e[i[r]]&&t[i[r]][a[n]]===e[i[r]][a[n]]}if(void 0===n)i=!0;else for(var o=0;o<3;o++)for(var s=0;s<3;s++)if(!a(e,n,o,s)){i=!0;break}return i&&r.set(e),i},_.updateFx=function(t,e){var r=this.camera;r&&("orbit"===t?(r.mode="orbit",r.keyBindingMode="rotate"):"turntable"===t?(r.up=[0,0,1],r.mode="turntable",r.keyBindingMode="rotate"):r.keyBindingMode=t),this.fullSceneLayout.hovermode=e},_.toImage=function(t){t||(t="png"),this.staticMode&&this.container.appendChild(n),this.glplot.redraw();var e=this.glplot.gl,r=e.drawingBufferWidth,i=e.drawingBufferHeight;e.bindFramebuffer(e.FRAMEBUFFER,null);var a=new Uint8Array(r*i*4);e.readPixels(0,0,r,i,e.RGBA,e.UNSIGNED_BYTE,a);for(var o=0,s=i-1;o0}function l(t){var e={},r={};switch(t.type){case"circle":n.extendFlat(r,{"circle-radius":t.circle.radius,"circle-color":t.color,"circle-opacity":t.opacity});break;case"line":n.extendFlat(r,{"line-width":t.line.width,"line-color":t.color,"line-opacity":t.opacity});break;case"fill":n.extendFlat(r,{"fill-color":t.color,"fill-outline-color":t.fill.outlinecolor,"fill-opacity":t.opacity});break;case"symbol":var a=t.symbol,o=i(a.textposition,a.iconsize);n.extendFlat(e,{"icon-image":a.icon+"-15","icon-size":a.iconsize/10,"text-field":a.text,"text-size":a.textfont.size,"text-anchor":o.anchor,"text-offset":o.offset}),n.extendFlat(r,{"icon-color":t.color,"text-color":a.textfont.color,"text-opacity":t.opacity})}return{layout:e,paint:r}}o.update=function(t){this.visible?this.needsNewSource(t)?(this.updateLayer(t),this.updateSource(t)):this.needsNewLayer(t)?this.updateLayer(t):this.updateStyle(t):(this.updateSource(t),this.updateLayer(t)),this.visible=s(t)},o.needsNewSource=function(t){return this.sourceType!==t.sourcetype||this.source!==t.source||this.layerType!==t.type},o.needsNewLayer=function(t){return this.layerType!==t.type||this.below!==t.below},o.updateSource=function(t){var e=this.map;if(e.getSource(this.idSource)&&e.removeSource(this.idSource),this.sourceType=t.sourcetype,this.source=t.source,s(t)){var r=function(t){var e,r=t.sourcetype,n=t.source,i={type:r};"geojson"===r?e="data":"vector"===r&&(e="string"==typeof n?"url":"tiles");return i[e]=n,i}(t);e.addSource(this.idSource,r)}},o.updateLayer=function(t){var e=this.map,r=l(t);e.getLayer(this.idLayer)&&e.removeLayer(this.idLayer),this.layerType=t.type,s(t)&&e.addLayer({id:this.idLayer,source:this.idSource,"source-layer":t.sourcelayer||"",type:t.type,layout:r.layout,paint:r.paint},t.below)},o.updateStyle=function(t){if(s(t)){var e=l(t);this.mapbox.setOptions(this.idLayer,"setLayoutProperty",e.layout),this.mapbox.setOptions(this.idLayer,"setPaintProperty",e.paint)}},o.dispose=function(){var t=this.map;t.removeLayer(this.idLayer),t.removeSource(this.idSource)},e.exports=function(t,e,r){var n=new a(t,e);return n.update(r),n}},{"../../lib":660,"./convert_text_opts":761}],764:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../components/color").defaultLine,a=t("../domain").attributes,o=t("../font_attributes"),s=t("../../traces/scatter/attributes").textposition,l=t("../../plot_api/edit_types").overrideAll,c=o({});c.family.dflt="Open Sans Regular, Arial Unicode MS Regular",e.exports=l({_arrayAttrRegexps:[n.counterRegex("mapbox",".layers",!0)],domain:a({name:"mapbox"}),accesstoken:{valType:"string",noBlank:!0,strict:!0},style:{valType:"any",values:["basic","streets","outdoors","light","dark","satellite","satellite-streets"],dflt:"basic"},center:{lon:{valType:"number",dflt:0},lat:{valType:"number",dflt:0}},zoom:{valType:"number",dflt:1},bearing:{valType:"number",dflt:0},pitch:{valType:"number",dflt:0},layers:{_isLinkedToArray:"layer",sourcetype:{valType:"enumerated",values:["geojson","vector"],dflt:"geojson"},source:{valType:"any"},sourcelayer:{valType:"string",dflt:""},type:{valType:"enumerated",values:["circle","line","fill","symbol"],dflt:"circle"},below:{valType:"string",dflt:""},color:{valType:"color",dflt:i},opacity:{valType:"number",min:0,max:1,dflt:1},circle:{radius:{valType:"number",dflt:15}},line:{width:{valType:"number",dflt:2}},fill:{outlinecolor:{valType:"color",dflt:i}},symbol:{icon:{valType:"string",dflt:"marker"},iconsize:{valType:"number",dflt:10},text:{valType:"string",dflt:""},textfont:c,textposition:n.extendFlat({},s,{arrayOk:!1})}}},"plot","from-root")},{"../../components/color":532,"../../lib":660,"../../plot_api/edit_types":691,"../../traces/scatter/attributes":990,"../domain":731,"../font_attributes":732}],765:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../subplot_defaults"),a=t("./layout_attributes");function o(t,e,r,i){r("accesstoken",i.accessToken),r("style"),r("center.lon"),r("center.lat"),r("zoom"),r("bearing"),r("pitch"),function(t,e){var r,i,o=t.layers||[],s=e.layers=[];function l(t,e){return n.coerce(r,i,a.layers,t,e)}for(var c=0;c=e.width-20?(a["text-anchor"]="start",a.x=5):(a["text-anchor"]="end",a.x=e._paper.attr("width")-7),r.attr(a);var o=r.select(".js-link-to-tool"),c=r.select(".js-link-spacer"),u=r.select(".js-sourcelinks");t._context.showSources&&t._context.showSources(t),t._context.showLink&&function(t,e){e.text("");var r=e.append("a").attr({"xlink:xlink:href":"#",class:"link--impt link--embedview","font-weight":"bold"}).text(t._context.linkText+" "+String.fromCharCode(187));if(t._context.sendData)r.on("click",function(){m.sendDataToCloud(t)});else{var n=window.location.pathname.split("/"),i=window.location.search;r.attr({"xlink:xlink:show":"new","xlink:xlink:href":"/"+n[2].split(".")[0]+"/"+n[1]+i})}}(t,o),c.text(o.text()&&u.text()?" - ":"")}},m.sendDataToCloud=function(t){t.emit("plotly_beforeexport");var e=window.PLOTLYENV&&window.PLOTLYENV.BASE_URL||"https://plot.ly",r=n.select(t).append("div").attr("id","hiddenform").style("display","none"),i=r.append("form").attr({action:e+"/external",method:"post",target:"_blank"});return i.append("input").attr({type:"text",name:"data"}).node().value=m.graphJson(t,!1,"keepdata"),i.node().submit(),r.remove(),t.emit("plotly_afterexport"),!1};var x,b=["days","shortDays","months","shortMonths","periods","dateTime","date","time","decimal","thousands","grouping","currency"],_=["year","month","dayMonth","dayMonthYear"];function w(t,e){var r=t._context.locale,n=!1,i={};function o(t){for(var r=!0,a=0;a1&&O.length>1){for(a.getComponentMethod("grid","sizeDefaults")(c,l),o=0;o15&&O.length>15&&0===l.shapes.length&&0===l.images.length,l._hasCartesian=l._has("cartesian"),l._hasGeo=l._has("geo"),l._hasGL3D=l._has("gl3d"),l._hasGL2D=l._has("gl2d"),l._hasTernary=l._has("ternary"),l._hasPie=l._has("pie"),m.linkSubplots(p,l,h,i),m.cleanPlot(p,l,h,i,y),d(l,i),m.doAutoMargin(t);var F=u.list(t);for(o=0;o0){var u=function(t){var e,r={left:0,right:0,bottom:0,top:0};if(t)for(e in t)t.hasOwnProperty(e)&&(r.left+=t[e].left||0,r.right+=t[e].right||0,r.bottom+=t[e].bottom||0,r.top+=t[e].top||0);return r}(t._boundingBoxMargins),f=u.left+u.right,h=u.bottom+u.top,p=1-2*l,d=r._container&&r._container.node?r._container.node().getBoundingClientRect():{width:r.width,height:r.height};n=Math.round(p*(d.width-f)),a=Math.round(p*(d.height-h))}else{var g=c?window.getComputedStyle(t):{};n=parseFloat(g.width)||r.width,a=parseFloat(g.height)||r.height}var v=m.layoutAttributes.width.min,y=m.layoutAttributes.height.min;n1,b=!e.height&&Math.abs(r.height-a)>1;(b||x)&&(x&&(r.width=n),b&&(r.height=a)),t._initialAutoSize||(t._initialAutoSize={width:n,height:a}),m.sanitizeMargins(r)},m.supplyLayoutModuleDefaults=function(t,e,r,n){var i,o,l,c=a.componentsRegistry,u=e._basePlotModules,f=a.subplotsRegistry.cartesian;for(i in c)(l=c[i]).includeBasePlot&&l.includeBasePlot(t,e);for(var h in u.length||u.push(f),e._has("cartesian")&&(a.getComponentMethod("grid","contentDefaults")(t,e),f.finalizeSubplots(t,e)),e._subplots)e._subplots[h].sort(s.subplotSort);for(o=0;o.5*n.width&&(r.l=r.r=0),r.b+r.t>.5*n.height&&(r.b=r.t=0),n._pushmargin[e]={l:{val:r.x,size:r.l+i},r:{val:r.x,size:r.r+i},b:{val:r.y,size:r.b+i},t:{val:r.y,size:r.t+i}}}else delete n._pushmargin[e];n._replotting||m.doAutoMargin(t)}},m.doAutoMargin=function(t){var e=t._fullLayout;e._size||(e._size={}),e._pushmargin||(e._pushmargin={});var r=e._size,n=JSON.stringify(r),o=Math.max(e.margin.l||0,0),s=Math.max(e.margin.r||0,0),l=Math.max(e.margin.t||0,0),c=Math.max(e.margin.b||0,0),u=e._pushmargin;if(!1!==e.margin.autoexpand)for(var f in u.base={l:{val:0,size:o},r:{val:1,size:s},t:{val:1,size:l},b:{val:0,size:c}},u){var h=u[f].l||{},p=u[f].b||{},d=h.val,g=h.size,m=p.val,v=p.size;for(var y in u){if(i(g)&&u[y].r){var x=u[y].r.val,b=u[y].r.size;if(x>d){var _=(g*x+(b-e.width)*d)/(x-d),w=(b*(1-d)+(g-e.width)*(1-x))/(x-d);_>=0&&w>=0&&_+w>o+s&&(o=_,s=w)}}if(i(v)&&u[y].t){var k=u[y].t.val,M=u[y].t.size;if(k>m){var A=(v*k+(M-e.height)*m)/(k-m),T=(M*(1-m)+(v-e.height)*(1-k))/(k-m);A>=0&&T>=0&&A+T>c+l&&(c=A,l=T)}}}}if(r.l=Math.round(o),r.r=Math.round(s),r.t=Math.round(l),r.b=Math.round(c),r.p=Math.round(e.margin.pad),r.w=Math.round(e.width)-r.l-r.r,r.h=Math.round(e.height)-r.t-r.b,!e._replotting&&"{}"!==n&&n!==JSON.stringify(e._size))return a.call("plot",t)},m.graphJson=function(t,e,r,n,i){(i&&e&&!t._fullData||i&&!e&&!t._fullLayout)&&m.supplyDefaults(t);var a=i?t._fullData:t.data,o=i?t._fullLayout:t.layout,l=(t._transitionData||{})._frames;function c(t){if("function"==typeof t)return null;if(s.isPlainObject(t)){var e,n,i={};for(e in t)if("function"!=typeof t[e]&&-1===["_","["].indexOf(e.charAt(0))){if("keepdata"===r){if("src"===e.substr(e.length-3))continue}else if("keepstream"===r){if("string"==typeof(n=t[e+"src"])&&n.indexOf(":")>0&&!s.isPlainObject(t.stream))continue}else if("keepall"!==r&&"string"==typeof(n=t[e+"src"])&&n.indexOf(":")>0)continue;i[e]=c(t[e])}return i}return Array.isArray(t)?t.map(c):s.isJSDate(t)?s.ms2DateTimeLocal(+t):t}var u={data:(a||[]).map(function(t){var r=c(t);return e&&delete r.fit,r})};return e||(u.layout=c(o)),t.framework&&t.framework.isPolar&&(u=t.framework.getConfig()),l&&(u.frames=c(l)),"object"===n?u:JSON.stringify(u)},m.modifyFrames=function(t,e){var r,n,i,a=t._transitionData._frames,o=t._transitionData._frameHash;for(r=0;r0&&(t._transitioningWithDuration=!0),t._transitionData._interruptCallbacks.push(function(){p=!0}),i.redraw&&t._transitionData._interruptCallbacks.push(function(){return a.call("redraw",t)}),t._transitionData._interruptCallbacks.push(function(){t.emit("plotly_transitioninterrupted",[])});var n,l,c=0,u=0;function f(){return c++,function(){var r;u++,p||u!==c||(r=e,t._transitionData&&(function(t){if(t)for(;t.length;)t.shift()}(t._transitionData._interruptCallbacks),Promise.resolve().then(function(){if(i.redraw)return a.call("redraw",t)}).then(function(){t._transitioning=!1,t._transitioningWithDuration=!1,t.emit("plotly_transitioned",[])}).then(r)))}}var d=t._fullLayout._basePlotModules,g=!1;if(r)for(l=0;l=0;s--)if(o[s].enabled){r._indexToPoints=o[s]._indexToPoints;break}n&&n.calc&&(a=n.calc(t,r))}Array.isArray(a)&&a[0]||(a=[{x:c,y:c}]),a[0].t||(a[0].t={}),a[0].trace=r,p[e]=a}}for(m&&M(l),i=0;i=0?h.angularAxis.domain:n.extent(k),C=Math.abs(k[1]-k[0]);A&&!M&&(C=0);var E=S.slice();T&&M&&(E[1]+=C);var L=h.angularAxis.ticksCount||4;L>8&&(L=L/(L/8)+L%8),h.angularAxis.ticksStep&&(L=(E[1]-E[0])/L);var z=h.angularAxis.ticksStep||(E[1]-E[0])/(L*(h.minorTicks+1));w&&(z=Math.max(Math.round(z),1)),E[2]||(E[2]=z);var P=n.range.apply(this,E);if(P=P.map(function(t,e){return parseFloat(t.toPrecision(12))}),s=n.scale.linear().domain(E.slice(0,2)).range("clockwise"===h.direction?[0,360]:[360,0]),u.layout.angularAxis.domain=s.domain(),u.layout.angularAxis.endPadding=T?C:0,void 0===(t=n.select(this).select("svg.chart-root"))||t.empty()){var D=(new DOMParser).parseFromString("' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '' + '","application/xml"),O=this.appendChild(this.ownerDocument.importNode(D.documentElement,!0));t=n.select(O)}t.select(".guides-group").style({"pointer-events":"none"}),t.select(".angular.axis-group").style({"pointer-events":"none"}),t.select(".radial.axis-group").style({"pointer-events":"none"});var I,R=t.select(".chart-group"),B={fill:"none",stroke:h.tickColor},F={"font-size":h.font.size,"font-family":h.font.family,fill:h.font.color,"text-shadow":["-1px 0px","1px -1px","-1px 1px","1px 1px"].map(function(t,e){return" "+t+" 0 "+h.font.outlineColor}).join(",")};if(h.showLegend){I=t.select(".legend-group").attr({transform:"translate("+[x,h.margin.top]+")"}).style({display:"block"});var N=p.map(function(t,e){var r=o.util.cloneJson(t);return r.symbol="DotPlot"===t.geometry?t.dotType||"circle":"LinePlot"!=t.geometry?"square":"line",r.visibleInLegend=void 0===t.visibleInLegend||t.visibleInLegend,r.color="LinePlot"===t.geometry?t.strokeColor:t.color,r});o.Legend().config({data:p.map(function(t,e){return t.name||"Element"+e}),legendConfig:i({},o.Legend.defaultConfig().legendConfig,{container:I,elements:N,reverseOrder:h.legend.reverseOrder})})();var j=I.node().getBBox();x=Math.min(h.width-j.width-h.margin.left-h.margin.right,h.height-h.margin.top-h.margin.bottom)/2,x=Math.max(10,x),_=[h.margin.left+x,h.margin.top+x],r.range([0,x]),u.layout.radialAxis.domain=r.domain(),I.attr("transform","translate("+[_[0]+x,_[1]-x]+")")}else I=t.select(".legend-group").style({display:"none"});t.attr({width:h.width,height:h.height}).style({opacity:h.opacity}),R.attr("transform","translate("+_+")").style({cursor:"crosshair"});var V=[(h.width-(h.margin.left+h.margin.right+2*x+(j?j.width:0)))/2,(h.height-(h.margin.top+h.margin.bottom+2*x))/2];if(V[0]=Math.max(0,V[0]),V[1]=Math.max(0,V[1]),t.select(".outer-group").attr("transform","translate("+V+")"),h.title){var U=t.select("g.title-group text").style(F).text(h.title),q=U.node().getBBox();U.attr({x:_[0]-q.width/2,y:_[1]-x-20})}var H=t.select(".radial.axis-group");if(h.radialAxis.gridLinesVisible){var G=H.selectAll("circle.grid-circle").data(r.ticks(5));G.enter().append("circle").attr({class:"grid-circle"}).style(B),G.attr("r",r),G.exit().remove()}H.select("circle.outside-circle").attr({r:x}).style(B);var W=t.select("circle.background-circle").attr({r:x}).style({fill:h.backgroundColor,stroke:h.stroke});function Y(t,e){return s(t)%360+h.orientation}if(h.radialAxis.visible){var X=n.svg.axis().scale(r).ticks(5).tickSize(5);H.call(X).attr({transform:"rotate("+h.radialAxis.orientation+")"}),H.selectAll(".domain").style(B),H.selectAll("g>text").text(function(t,e){return this.textContent+h.radialAxis.ticksSuffix}).style(F).style({"text-anchor":"start"}).attr({x:0,y:0,dx:0,dy:0,transform:function(t,e){return"horizontal"===h.radialAxis.tickOrientation?"rotate("+-h.radialAxis.orientation+") translate("+[0,F["font-size"]]+")":"translate("+[0,F["font-size"]]+")"}}),H.selectAll("g>line").style({stroke:"black"})}var Z=t.select(".angular.axis-group").selectAll("g.angular-tick").data(P),J=Z.enter().append("g").classed("angular-tick",!0);Z.attr({transform:function(t,e){return"rotate("+Y(t)+")"}}).style({display:h.angularAxis.visible?"block":"none"}),Z.exit().remove(),J.append("line").classed("grid-line",!0).classed("major",function(t,e){return e%(h.minorTicks+1)==0}).classed("minor",function(t,e){return!(e%(h.minorTicks+1)==0)}).style(B),J.selectAll(".minor").style({stroke:h.minorTickColor}),Z.select("line.grid-line").attr({x1:h.tickLength?x-h.tickLength:0,x2:x}).style({display:h.angularAxis.gridLinesVisible?"block":"none"}),J.append("text").classed("axis-text",!0).style(F);var K=Z.select("text.axis-text").attr({x:x+h.labelOffset,dy:a+"em",transform:function(t,e){var r=Y(t),n=x+h.labelOffset,i=h.angularAxis.tickOrientation;return"horizontal"==i?"rotate("+-r+" "+n+" 0)":"radial"==i?r<270&&r>90?"rotate(180 "+n+" 0)":null:"rotate("+(r<=180&&r>0?-90:90)+" "+n+" 0)"}}).style({"text-anchor":"middle",display:h.angularAxis.labelsVisible?"block":"none"}).text(function(t,e){return e%(h.minorTicks+1)!=0?"":w?w[t]+h.angularAxis.ticksSuffix:t+h.angularAxis.ticksSuffix}).style(F);h.angularAxis.rewriteTicks&&K.text(function(t,e){return e%(h.minorTicks+1)!=0?"":h.angularAxis.rewriteTicks(this.textContent,e)});var Q=n.max(R.selectAll(".angular-tick text")[0].map(function(t,e){return t.getCTM().e+t.getBBox().width}));I.attr({transform:"translate("+[x+Q,h.margin.top]+")"});var $=t.select("g.geometry-group").selectAll("g").size()>0,tt=t.select("g.geometry-group").selectAll("g.geometry").data(p);if(tt.enter().append("g").attr({class:function(t,e){return"geometry geometry"+e}}),tt.exit().remove(),p[0]||$){var et=[];p.forEach(function(t,e){var n={};n.radialScale=r,n.angularScale=s,n.container=tt.filter(function(t,r){return r==e}),n.geometry=t.geometry,n.orientation=h.orientation,n.direction=h.direction,n.index=e,et.push({data:t,geometryConfig:n})});var rt=n.nest().key(function(t,e){return void 0!==t.data.groupId||"unstacked"}).entries(et),nt=[];rt.forEach(function(t,e){"unstacked"===t.key?nt=nt.concat(t.values.map(function(t,e){return[t]})):nt.push(t.values)}),nt.forEach(function(t,e){var r;r=Array.isArray(t)?t[0].geometryConfig.geometry:t.geometryConfig.geometry;var n=t.map(function(t,e){return i(o[r].defaultConfig(),t)});o[r]().config(n)()})}var it,at,ot=t.select(".guides-group"),st=t.select(".tooltips-group"),lt=o.tooltipPanel().config({container:st,fontSize:8})(),ct=o.tooltipPanel().config({container:st,fontSize:8})(),ut=o.tooltipPanel().config({container:st,hasTick:!0})();if(!M){var ft=ot.select("line").attr({x1:0,y1:0,y2:0}).style({stroke:"grey","pointer-events":"none"});R.on("mousemove.angular-guide",function(t,e){var r=o.util.getMousePos(W).angle;ft.attr({x2:-x,transform:"rotate("+r+")"}).style({opacity:.5});var n=(r+180+360-h.orientation)%360;it=s.invert(n);var i=o.util.convertToCartesian(x+12,r+180);lt.text(o.util.round(it)).move([i[0]+_[0],i[1]+_[1]])}).on("mouseout.angular-guide",function(t,e){ot.select("line").style({opacity:0})})}var ht=ot.select("circle").style({stroke:"grey",fill:"none"});R.on("mousemove.radial-guide",function(t,e){var n=o.util.getMousePos(W).radius;ht.attr({r:n}).style({opacity:.5}),at=r.invert(o.util.getMousePos(W).radius);var i=o.util.convertToCartesian(n,h.radialAxis.orientation);ct.text(o.util.round(at)).move([i[0]+_[0],i[1]+_[1]])}).on("mouseout.radial-guide",function(t,e){ht.style({opacity:0}),ut.hide(),lt.hide(),ct.hide()}),t.selectAll(".geometry-group .mark").on("mouseover.tooltip",function(e,r){var i=n.select(this),a=this.style.fill,s="black",l=this.style.opacity||1;if(i.attr({"data-opacity":l}),a&&"none"!==a){i.attr({"data-fill":a}),s=n.hsl(a).darker().toString(),i.style({fill:s,opacity:1});var c={t:o.util.round(e[0]),r:o.util.round(e[1])};M&&(c.t=w[e[0]]);var u="t: "+c.t+", r: "+c.r,f=this.getBoundingClientRect(),h=t.node().getBoundingClientRect(),p=[f.left+f.width/2-V[0]-h.left,f.top+f.height/2-V[1]-h.top];ut.config({color:s}).text(u),ut.move(p)}else a=this.style.stroke||"black",i.attr({"data-stroke":a}),s=n.hsl(a).darker().toString(),i.style({stroke:s,opacity:1})}).on("mousemove.tooltip",function(t,e){if(0!=n.event.which)return!1;n.select(this).attr("data-fill")&&ut.show()}).on("mouseout.tooltip",function(t,e){ut.hide();var r=n.select(this),i=r.attr("data-fill");i?r.style({fill:i,opacity:r.attr("data-opacity")}):r.style({stroke:r.attr("data-stroke"),opacity:r.attr("data-opacity")})})})}(c),this},h.config=function(t){if(!arguments.length)return l;var e=o.util.cloneJson(t);return e.data.forEach(function(t,e){l.data[e]||(l.data[e]={}),i(l.data[e],o.Axis.defaultConfig().data[0]),i(l.data[e],t)}),i(l.layout,o.Axis.defaultConfig().layout),i(l.layout,e.layout),this},h.getLiveConfig=function(){return u},h.getinputConfig=function(){return c},h.radialScale=function(t){return r},h.angularScale=function(t){return s},h.svg=function(){return t},n.rebind(h,f,"on"),h},o.Axis.defaultConfig=function(t,e){return{data:[{t:[1,2,3,4],r:[10,11,12,13],name:"Line1",geometry:"LinePlot",color:null,strokeDash:"solid",strokeColor:null,strokeSize:"1",visibleInLegend:!0,opacity:1}],layout:{defaultColorRange:n.scale.category10().range(),title:null,height:450,width:500,margin:{top:40,right:40,bottom:40,left:40},font:{size:12,color:"gray",outlineColor:"white",family:"Tahoma, sans-serif"},direction:"clockwise",orientation:0,labelOffset:10,radialAxis:{domain:null,orientation:-45,ticksSuffix:"",visible:!0,gridLinesVisible:!0,tickOrientation:"horizontal",rewriteTicks:null},angularAxis:{domain:[0,360],ticksSuffix:"",visible:!0,gridLinesVisible:!0,labelsVisible:!0,tickOrientation:"horizontal",rewriteTicks:null,ticksCount:null,ticksStep:null},minorTicks:0,tickLength:null,tickColor:"silver",minorTickColor:"#eee",backgroundColor:"none",needsEndSpacing:null,showLegend:!0,legend:{reverseOrder:!1},opacity:1}}},o.util={},o.DATAEXTENT="dataExtent",o.AREA="AreaChart",o.LINE="LinePlot",o.DOT="DotPlot",o.BAR="BarChart",o.util._override=function(t,e){for(var r in t)r in e&&(e[r]=t[r])},o.util._extend=function(t,e){for(var r in t)e[r]=t[r]},o.util._rndSnd=function(){return 2*Math.random()-1+(2*Math.random()-1)+(2*Math.random()-1)},o.util.dataFromEquation2=function(t,e){var r=e||6;return n.range(0,360+r,r).map(function(e,r){var n=e*Math.PI/180;return[e,t(n)]})},o.util.dataFromEquation=function(t,e,r){var i=e||6,a=[],o=[];n.range(0,360+i,i).forEach(function(e,r){var n=e*Math.PI/180,i=t(n);a.push(e),o.push(i)});var s={t:a,r:o};return r&&(s.name=r),s},o.util.ensureArray=function(t,e){if(void 0===t)return null;var r=[].concat(t);return n.range(e).map(function(t,e){return r[e]||r[0]})},o.util.fillArrays=function(t,e,r){return e.forEach(function(e,n){t[e]=o.util.ensureArray(t[e],r)}),t},o.util.cloneJson=function(t){return JSON.parse(JSON.stringify(t))},o.util.validateKeys=function(t,e){"string"==typeof e&&(e=e.split("."));var r=e.shift();return t[r]&&(!e.length||objHasKeys(t[r],e))},o.util.sumArrays=function(t,e){return n.zip(t,e).map(function(t,e){return n.sum(t)})},o.util.arrayLast=function(t){return t[t.length-1]},o.util.arrayEqual=function(t,e){for(var r=Math.max(t.length,e.length,1);r-- >=0&&t[r]===e[r];);return-2===r},o.util.flattenArray=function(t){for(var e=[];!o.util.arrayEqual(e,t);)e=t,t=[].concat.apply([],t);return t},o.util.deduplicate=function(t){return t.filter(function(t,e,r){return r.indexOf(t)==e})},o.util.convertToCartesian=function(t,e){var r=e*Math.PI/180;return[t*Math.cos(r),t*Math.sin(r)]},o.util.round=function(t,e){var r=e||2,n=Math.pow(10,r);return Math.round(t*n)/n},o.util.getMousePos=function(t){var e=n.mouse(t.node()),r=e[0],i=e[1],a={};return a.x=r,a.y=i,a.pos=e,a.angle=180*(Math.atan2(i,r)+Math.PI)/Math.PI,a.radius=Math.sqrt(r*r+i*i),a},o.util.duplicatesCount=function(t){for(var e,r={},n={},i=0,a=t.length;i0)){var l=n.select(this.parentNode).selectAll("path.line").data([0]);l.enter().insert("path"),l.attr({class:"line",d:u(s),transform:function(t,r){return"rotate("+(e.orientation+90)+")"},"pointer-events":"none"}).style({fill:function(t,e){return d.fill(r,i,a)},"fill-opacity":0,stroke:function(t,e){return d.stroke(r,i,a)},"stroke-width":function(t,e){return d["stroke-width"](r,i,a)},"stroke-dasharray":function(t,e){return d["stroke-dasharray"](r,i,a)},opacity:function(t,e){return d.opacity(r,i,a)},display:function(t,e){return d.display(r,i,a)}})}};var f=e.angularScale.range(),h=Math.abs(f[1]-f[0])/o[0].length*Math.PI/180,p=n.svg.arc().startAngle(function(t){return-h/2}).endAngle(function(t){return h/2}).innerRadius(function(t){return e.radialScale(l+(t[2]||0))}).outerRadius(function(t){return e.radialScale(l+(t[2]||0))+e.radialScale(t[1])});c.arc=function(t,r,i){n.select(this).attr({class:"mark arc",d:p,transform:function(t,r){return"rotate("+(e.orientation+s(t[0])+90)+")"}})};var d={fill:function(e,r,n){return t[n].data.color},stroke:function(e,r,n){return t[n].data.strokeColor},"stroke-width":function(e,r,n){return t[n].data.strokeSize+"px"},"stroke-dasharray":function(e,n,i){return r[t[i].data.strokeDash]},opacity:function(e,r,n){return t[n].data.opacity},display:function(e,r,n){return void 0===t[n].data.visible||t[n].data.visible?"block":"none"}},g=n.select(this).selectAll("g.layer").data(o);g.enter().append("g").attr({class:"layer"});var m=g.selectAll("path.mark").data(function(t,e){return t});m.enter().append("path").attr({class:"mark"}),m.style(d).each(c[e.geometryType]),m.exit().remove(),g.exit().remove()})}return a.config=function(e){return arguments.length?(e.forEach(function(e,r){t[r]||(t[r]={}),i(t[r],o.PolyChart.defaultConfig()),i(t[r],e)}),this):t},a.getColorScale=function(){},n.rebind(a,e,"on"),a},o.PolyChart.defaultConfig=function(){return{data:{name:"geom1",t:[[1,2,3,4]],r:[[1,2,3,4]],dotType:"circle",dotSize:64,dotVisible:!1,barWidth:20,color:"#ffa500",strokeSize:1,strokeColor:"silver",strokeDash:"solid",opacity:1,index:0,visible:!0,visibleInLegend:!0},geometryConfig:{geometry:"LinePlot",geometryType:"arc",direction:"clockwise",orientation:0,container:"body",radialScale:null,angularScale:null,colorScale:n.scale.category20()}}},o.BarChart=function(){return o.PolyChart()},o.BarChart.defaultConfig=function(){return{geometryConfig:{geometryType:"bar"}}},o.AreaChart=function(){return o.PolyChart()},o.AreaChart.defaultConfig=function(){return{geometryConfig:{geometryType:"arc"}}},o.DotPlot=function(){return o.PolyChart()},o.DotPlot.defaultConfig=function(){return{geometryConfig:{geometryType:"dot",dotType:"circle"}}},o.LinePlot=function(){return o.PolyChart()},o.LinePlot.defaultConfig=function(){return{geometryConfig:{geometryType:"line"}}},o.Legend=function(){var t=o.Legend.defaultConfig(),e=n.dispatch("hover");function r(){var e=t.legendConfig,a=t.data.map(function(t,r){return[].concat(t).map(function(t,n){var a=i({},e.elements[r]);return a.name=t,a.color=[].concat(e.elements[r].color)[n],a})}),o=n.merge(a);o=o.filter(function(t,r){return e.elements[r]&&(e.elements[r].visibleInLegend||void 0===e.elements[r].visibleInLegend)}),e.reverseOrder&&(o=o.reverse());var s=e.container;("string"==typeof s||s.nodeName)&&(s=n.select(s));var l=o.map(function(t,e){return t.color}),c=e.fontSize,u=null==e.isContinuous?"number"==typeof o[0]:e.isContinuous,f=u?e.height:c*o.length,h=s.classed("legend-group",!0).selectAll("svg").data([0]),p=h.enter().append("svg").attr({width:300,height:f+c,xmlns:"http://www.w3.org/2000/svg","xmlns:xlink":"http://www.w3.org/1999/xlink",version:"1.1"});p.append("g").classed("legend-axis",!0),p.append("g").classed("legend-marks",!0);var d=n.range(o.length),g=n.scale[u?"linear":"ordinal"]().domain(d).range(l),m=n.scale[u?"linear":"ordinal"]().domain(d)[u?"range":"rangePoints"]([0,f]);if(u){var v=h.select(".legend-marks").append("defs").append("linearGradient").attr({id:"grad1",x1:"0%",y1:"0%",x2:"0%",y2:"100%"}).selectAll("stop").data(l);v.enter().append("stop"),v.attr({offset:function(t,e){return e/(l.length-1)*100+"%"}}).style({"stop-color":function(t,e){return t}}),h.append("rect").classed("legend-mark",!0).attr({height:e.height,width:e.colorBandWidth,fill:"url(#grad1)"})}else{var y=h.select(".legend-marks").selectAll("path.legend-mark").data(o);y.enter().append("path").classed("legend-mark",!0),y.attr({transform:function(t,e){return"translate("+[c/2,m(e)+c/2]+")"},d:function(t,e){var r,i,a,o=t.symbol;return a=3*(i=c),"line"===(r=o)?"M"+[[-i/2,-i/12],[i/2,-i/12],[i/2,i/12],[-i/2,i/12]]+"Z":-1!=n.svg.symbolTypes.indexOf(r)?n.svg.symbol().type(r).size(a)():n.svg.symbol().type("square").size(a)()},fill:function(t,e){return g(e)}}),y.exit().remove()}var x=n.svg.axis().scale(m).orient("right"),b=h.select("g.legend-axis").attr({transform:"translate("+[u?e.colorBandWidth:c,c/2]+")"}).call(x);return b.selectAll(".domain").style({fill:"none",stroke:"none"}),b.selectAll("line").style({fill:"none",stroke:u?e.textColor:"none"}),b.selectAll("text").style({fill:e.textColor,"font-size":e.fontSize}).text(function(t,e){return o[e].name}),r}return r.config=function(e){return arguments.length?(i(t,e),this):t},n.rebind(r,e,"on"),r},o.Legend.defaultConfig=function(t,e){return{data:["a","b","c"],legendConfig:{elements:[{symbol:"line",color:"red"},{symbol:"square",color:"yellow"},{symbol:"diamond",color:"limegreen"}],height:150,colorBandWidth:30,fontSize:12,container:"body",isContinuous:null,textColor:"grey",reverseOrder:!1}}},o.tooltipPanel=function(){var t,e,r,a={container:null,hasTick:!1,fontSize:12,color:"white",padding:5},s="tooltip-"+o.tooltipPanel.uid++,l=10,c=function(){var n=(t=a.container.selectAll("g."+s).data([0])).enter().append("g").classed(s,!0).style({"pointer-events":"none",display:"none"});return r=n.append("path").style({fill:"white","fill-opacity":.9}).attr({d:"M0 0"}),e=n.append("text").attr({dx:a.padding+l,dy:.3*+a.fontSize}),c};return c.text=function(i){var o=n.hsl(a.color).l,s=o>=.5?"#aaa":"white",u=o>=.5?"black":"white",f=i||"";e.style({fill:u,"font-size":a.fontSize+"px"}).text(f);var h=a.padding,p=e.node().getBBox(),d={fill:a.color,stroke:s,"stroke-width":"2px"},g=p.width+2*h+l,m=p.height+2*h;return r.attr({d:"M"+[[l,-m/2],[l,-m/4],[a.hasTick?0:l,0],[l,m/4],[l,m/2],[g,m/2],[g,-m/2]].join("L")+"Z"}).style(d),t.attr({transform:"translate("+[l,-m/2+2*h]+")"}),t.style({display:"block"}),c},c.move=function(e){if(t)return t.attr({transform:"translate("+[e[0],e[1]]+")"}).style({display:"block"}),c},c.hide=function(){if(t)return t.style({display:"none"}),c},c.show=function(){if(t)return t.style({display:"block"}),c},c.config=function(t){return i(a,t),c},c},o.tooltipPanel.uid=1,o.adapter={},o.adapter.plotly=function(){var t={convert:function(t,e){var r={};if(t.data&&(r.data=t.data.map(function(t,r){var n=i({},t);return[[n,["marker","color"],["color"]],[n,["marker","opacity"],["opacity"]],[n,["marker","line","color"],["strokeColor"]],[n,["marker","line","dash"],["strokeDash"]],[n,["marker","line","width"],["strokeSize"]],[n,["marker","symbol"],["dotType"]],[n,["marker","size"],["dotSize"]],[n,["marker","barWidth"],["barWidth"]],[n,["line","interpolation"],["lineInterpolation"]],[n,["showlegend"],["visibleInLegend"]]].forEach(function(t,r){o.util.translator.apply(null,t.concat(e))}),e||delete n.marker,e&&delete n.groupId,e?("LinePlot"===n.geometry?(n.type="scatter",!0===n.dotVisible?(delete n.dotVisible,n.mode="lines+markers"):n.mode="lines"):"DotPlot"===n.geometry?(n.type="scatter",n.mode="markers"):"AreaChart"===n.geometry?n.type="area":"BarChart"===n.geometry&&(n.type="bar"),delete n.geometry):("scatter"===n.type?"lines"===n.mode?n.geometry="LinePlot":"markers"===n.mode?n.geometry="DotPlot":"lines+markers"===n.mode&&(n.geometry="LinePlot",n.dotVisible=!0):"area"===n.type?n.geometry="AreaChart":"bar"===n.type&&(n.geometry="BarChart"),delete n.mode,delete n.type),n}),!e&&t.layout&&"stack"===t.layout.barmode)){var a=o.util.duplicates(r.data.map(function(t,e){return t.geometry}));r.data.forEach(function(t,e){var n=a.indexOf(t.geometry);-1!=n&&(r.data[e].groupId=n)})}if(t.layout){var s=i({},t.layout);if([[s,["plot_bgcolor"],["backgroundColor"]],[s,["showlegend"],["showLegend"]],[s,["radialaxis"],["radialAxis"]],[s,["angularaxis"],["angularAxis"]],[s.angularaxis,["showline"],["gridLinesVisible"]],[s.angularaxis,["showticklabels"],["labelsVisible"]],[s.angularaxis,["nticks"],["ticksCount"]],[s.angularaxis,["tickorientation"],["tickOrientation"]],[s.angularaxis,["ticksuffix"],["ticksSuffix"]],[s.angularaxis,["range"],["domain"]],[s.angularaxis,["endpadding"],["endPadding"]],[s.radialaxis,["showline"],["gridLinesVisible"]],[s.radialaxis,["tickorientation"],["tickOrientation"]],[s.radialaxis,["ticksuffix"],["ticksSuffix"]],[s.radialaxis,["range"],["domain"]],[s.angularAxis,["showline"],["gridLinesVisible"]],[s.angularAxis,["showticklabels"],["labelsVisible"]],[s.angularAxis,["nticks"],["ticksCount"]],[s.angularAxis,["tickorientation"],["tickOrientation"]],[s.angularAxis,["ticksuffix"],["ticksSuffix"]],[s.angularAxis,["range"],["domain"]],[s.angularAxis,["endpadding"],["endPadding"]],[s.radialAxis,["showline"],["gridLinesVisible"]],[s.radialAxis,["tickorientation"],["tickOrientation"]],[s.radialAxis,["ticksuffix"],["ticksSuffix"]],[s.radialAxis,["range"],["domain"]],[s.font,["outlinecolor"],["outlineColor"]],[s.legend,["traceorder"],["reverseOrder"]],[s,["labeloffset"],["labelOffset"]],[s,["defaultcolorrange"],["defaultColorRange"]]].forEach(function(t,r){o.util.translator.apply(null,t.concat(e))}),e?(void 0!==s.tickLength&&(s.angularaxis.ticklen=s.tickLength,delete s.tickLength),s.tickColor&&(s.angularaxis.tickcolor=s.tickColor,delete s.tickColor)):(s.angularAxis&&void 0!==s.angularAxis.ticklen&&(s.tickLength=s.angularAxis.ticklen),s.angularAxis&&void 0!==s.angularAxis.tickcolor&&(s.tickColor=s.angularAxis.tickcolor)),s.legend&&"boolean"!=typeof s.legend.reverseOrder&&(s.legend.reverseOrder="normal"!=s.legend.reverseOrder),s.legend&&"boolean"==typeof s.legend.traceorder&&(s.legend.traceorder=s.legend.traceorder?"reversed":"normal",delete s.legend.reverseOrder),s.margin&&void 0!==s.margin.t){var l=["t","r","b","l","pad"],c=["top","right","bottom","left","pad"],u={};n.entries(s.margin).forEach(function(t,e){u[c[l.indexOf(t.key)]]=t.value}),s.margin=u}e&&(delete s.needsEndSpacing,delete s.minorTickColor,delete s.minorTicks,delete s.angularaxis.ticksCount,delete s.angularaxis.ticksCount,delete s.angularaxis.ticksStep,delete s.angularaxis.rewriteTicks,delete s.angularaxis.nticks,delete s.radialaxis.ticksCount,delete s.radialaxis.ticksCount,delete s.radialaxis.ticksStep,delete s.radialaxis.rewriteTicks,delete s.radialaxis.nticks),r.layout=s}return r}};return t}},{"../../../constants/alignment":632,"../../../lib":660,d3:131}],778:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../../lib"),a=t("../../../components/color"),o=t("./micropolar"),s=t("./undo_manager"),l=i.extendDeepAll,c=e.exports={};c.framework=function(t){var e,r,i,a,u,f=new s;function h(r,s){return s&&(u=s),n.select(n.select(u).node().parentNode).selectAll(".svg-container>*:not(.chart-root)").remove(),e=e?l(e,r):r,i||(i=o.Axis()),a=o.adapter.plotly().convert(e),i.config(a).render(u),t.data=e.data,t.layout=e.layout,c.fillLayout(t),e}return h.isPolar=!0,h.svg=function(){return i.svg()},h.getConfig=function(){return e},h.getLiveConfig=function(){return o.adapter.plotly().convert(i.getLiveConfig(),!0)},h.getLiveScales=function(){return{t:i.angularScale(),r:i.radialScale()}},h.setUndoPoint=function(){var t,n,i=this,a=o.util.cloneJson(e);t=a,n=r,f.add({undo:function(){n&&i(n)},redo:function(){i(t)}}),r=o.util.cloneJson(a)},h.undo=function(){f.undo()},h.redo=function(){f.redo()},h},c.fillLayout=function(t){var e=n.select(t).selectAll(".plot-container"),r=e.selectAll(".svg-container"),i=t.framework&&t.framework.svg&&t.framework.svg(),o={width:800,height:600,paper_bgcolor:a.background,_container:e,_paperdiv:r,_paper:i};t._fullLayout=l(o,t.layout)}},{"../../../components/color":532,"../../../lib":660,"./micropolar":777,"./undo_manager":779,d3:131}],779:[function(t,e,r){"use strict";e.exports=function(){var t,e=[],r=-1,n=!1;function i(t,e){return t?(n=!0,t[e](),n=!1,this):this}return{add:function(t){return n?this:(e.splice(r+1,e.length-r),e.push(t),r=e.length-1,this)},setCallback:function(e){t=e},undo:function(){var n=e[r];return n?(i(n,"undo"),r-=1,t&&t(n.undo),this):this},redo:function(){var n=e[r+1];return n?(i(n,"redo"),r+=1,t&&t(n.redo),this):this},clear:function(){e=[],r=-1},hasUndo:function(){return-1!==r},hasRedo:function(){return r0?1:-1}function F(t){return B(Math.cos(t))}function N(t){return B(Math.sin(t))}e.exports=function(t,e){return new S(t,e)},C.plot=function(t,e){var r=e[this.id];this._hasClipOnAxisFalse=!1;for(var n=0;n=90||s>90&&l>=450?1:u<=0&&h<=0?0:Math.max(u,h);e=s<=180&&l>=180||s>180&&l>=540?-1:c>=0&&f>=0?0:Math.min(c,f);r=s<=270&&l>=270||s>270&&l>=630?-1:u>=0&&h>=0?0:Math.min(u,h);n=l>=360?1:c<=0&&f<=0?0:Math.max(c,f);return[e,r,n,i]}(v),x=y[2]-y[0],b=y[3]-y[1],w=m/g,M=Math.abs(b/x);w>M?(c=g,d=(m-(f=g*M))/i.h/2,h=[a[0],a[1]],p=[o[0]+d,o[1]-d]):(f=m,d=(g-(c=m/M))/i.w/2,h=[a[0]+d,a[1]-d],p=[o[0],o[1]]),r.xLength2=c,r.yLength2=f,r.xDomain2=h,r.yDomain2=p;var A=r.xOffset2=i.l+i.w*h[0],T=r.yOffset2=i.t+i.h*(1-p[1]),S=r.radius=c/x,C=r.cx=A-S*y[0],E=r.cy=T+S*y[3],L=r.cxx=C-A,z=r.cyy=E-T;r.updateRadialAxis(t,e),r.updateRadialAxisTitle(t,e),r.updateAngularAxis(t,e);var D=r.radialAxis.range,O=D[1]-D[0],R=r.xaxis={type:"linear",_id:"x",range:[y[0]*O,y[2]*O],domain:h};u.setConvert(R,t),R.setScale();var B=r.yaxis={type:"linear",_id:"y",range:[y[1]*O,y[3]*O],domain:p};u.setConvert(B,t),B.setScale(),R.isPtWithinRange=function(t){return r.isPtWithinSector(t)},B.isPtWithinRange=function(){return!0},n.frontplot.attr("transform",I(A,T)).call(l.setClipUrl,r._hasClipOnAxisFalse?null:r.clipIds.circle),n.bgcircle.attr({d:P(S,v),transform:I(C,E)}).call(s.fill,e.bgcolor),r.clipPaths.circle.select("path").attr("d",P(S,v)).attr("transform",I(L,z)),r.framework.selectAll(".crisp").classed("crisp",0)},C.updateRadialAxis=function(t,e){var r=this.gd,n=this.layers,i=this.radius,a=this.cx,l=this.cy,c=t._size,h=e.radialaxis,p=e.sector,d=k(p[0]);this.fillViewInitialKey("radialaxis.angle",h.angle);var g=this.radialAxis=o.extendFlat({},h,{_axislayer:n["radial-axis"],_gridlayer:n["radial-grid"],_id:"x",_pos:0,side:{counterclockwise:"top",clockwise:"bottom"}[h.side],domain:[0,i/c.w],anchor:"free",position:0,_counteraxis:!0,automargin:!1});E(g,h,t),f(g),h.range=g.range.slice(),h._input.range=g.range.slice(),this.fillViewInitialKey("radialaxis.range",g.range.slice()),"auto"===g.tickangle&&d>90&&d<=270&&(g.tickangle=180),g._transfn=function(t){return"translate("+g.l2p(t.x)+",0)"},g._gridpath=function(t){return z(g.r2p(t.x),p)};var m=L(h);this.radialTickLayout!==m&&(n["radial-axis"].selectAll(".xtick").remove(),this.radialTickLayout=m),u.doTicksSingle(r,g,!0),O(n["radial-axis"],h.showticklabels||h.ticks,{transform:I(a,l)+R(-h.angle)}),O(n["radial-grid"],h.showgrid,{transform:I(a,l)}).selectAll("path").attr("transform",null),O(n["radial-line"].select("line"),h.showline,{x1:0,y1:0,x2:i,y2:0,transform:I(a,l)+R(-h.angle)}).attr("stroke-width",h.linewidth).call(s.stroke,h.linecolor)},C.updateRadialAxisTitle=function(t,e,r){var n=this.gd,i=this.radius,a=this.cx,o=this.cy,s=e.radialaxis,c=this.id+"title",u=void 0!==r?r:s.angle,f=_(u),h=Math.cos(f),p=Math.sin(f),d=0;if(s.title){var m=l.bBox(this.layers["radial-axis"].node()).height,v=s.titlefont.size;d="counterclockwise"===s.side?-m-.4*v:m+.8*v}this.layers["radial-axis-title"]=g.draw(n,c,{propContainer:s,propName:this.id+".radialaxis.title",placeholder:b(n,"Click to enter radial axis title"),attributes:{x:a+i/2*h+d*p,y:o-i/2*p+d*h,"text-anchor":"middle"},transform:{rotate:-u}})},C.updateAngularAxis=function(t,e){var r=this,i=r.gd,a=r.layers,l=r.radius,c=r.cx,f=r.cy,h=e.angularaxis,p=e.sector,d=p.map(_);r.fillViewInitialKey("angularaxis.rotation",h.rotation);var g=r.angularAxis=o.extendFlat({},h,{_axislayer:a["angular-axis"],_gridlayer:a["angular-grid"],_id:"angular",_pos:0,side:"right",domain:[0,Math.PI],anchor:"free",position:0,_counteraxis:!0,automargin:!1,autorange:!1});if("linear"===g.type)D(p)?g.range=p.slice():g.range=d.map(g.unTransformRad).map(w),"radians"===g.thetaunit&&(g.tick0=w(g.tick0),g.dtick=w(g.dtick));else if("category"===g.type){var m=h.period?Math.max(h.period,h._categories.length):h._categories.length;g.range=[0,m],g._tickFilter=function(t){return r.isPtWithinSector({r:r.radialAxis.range[1],rad:g.c2rad(t.x)})}}function v(t){return g.c2rad(t.x,"degrees")}function y(t){return[l*Math.cos(t),l*Math.sin(t)]}E(g,h,t),g._transfn=function(t){var e=v(t),r=y(e),i=I(c+r[0],f-r[1]),a=n.select(this);return a&&a.node()&&a.classed("ticks")&&(i+=R(-w(e))),i},g._gridpath=function(t){var e=y(v(t));return"M0,0L"+-e[0]+","+e[1]};var b="outside"!==h.ticks?.7:.5;g._labelx=function(t){var e=v(t),r=g._labelStandoff,n=g._pad;return(0===N(e)?0:Math.cos(e)*(r+n+b*t.fontSize))+F(e)*(t.dx+r+n)},g._labely=function(t){var e=v(t),r=g._labelStandoff,n=g._labelShift,i=g._pad;return t.dy+t.fontSize*x-n+-Math.sin(e)*(r+i+b*t.fontSize)},g._labelanchor=function(t,e){var r=v(e);return 0===N(r)?F(r)>0?"start":"end":"middle"};var k=L(h);r.angularTickLayout!==k&&(a["angular-axis"].selectAll(".angulartick").remove(),r.angularTickLayout=k),u.doTicksSingle(i,g,!0),O(a["angular-line"].select("path"),h.showline,{d:P(l,p),transform:I(c,f)}).attr("stroke-width",h.linewidth).call(s.stroke,h.linecolor)},C.updateFx=function(t,e){this.gd._context.staticPlot||(this.updateAngularDrag(t,e),this.updateRadialDrag(t,e),this.updateMainDrag(t,e))},C.updateMainDrag=function(t,e){var r=this,o=r.gd,s=r.layers,l=t._zoomlayer,c=T.MINZOOM,u=T.OFFEDGE,f=r.radius,g=r.cx,y=r.cy,x=r.cxx,b=r.cyy,_=e.sector,w=p.makeDragger(s,"path","maindrag","crosshair");n.select(w).attr("d",P(f,_)).attr("transform",I(g,y));var k,M,A,S,C,E,L,z,D,O={element:w,gd:o,subplot:r.id,plotinfo:{xaxis:r.xaxis,yaxis:r.yaxis},xaxes:[r.xaxis],yaxes:[r.yaxis]};function R(t,e){var r=t-x,n=e-b;return Math.sqrt(r*r+n*n)}function B(t,e){return Math.atan2(b-e,t-x)}function F(t,e){return[t*Math.cos(e),t*Math.sin(-e)]}function N(t,e){var r=T.cornerLen,n=T.cornerHalfWidth;if(0===t)return P(2*n,_);var i=r/t/2,a=e-i,o=e+i,s=Math.max(0,Math.min(t,f)),l=s-n,c=s+n;return"M"+F(l,a)+"A"+[l,l]+" 0,0,0 "+F(l,o)+"L"+F(c,o)+"A"+[c,c]+" 0,0,1 "+F(c,a)+"Z"}function j(t,e){var r,n,i=k+t,a=M+e,o=R(k,M),s=Math.min(R(i,a),f),l=B(k,M),h=B(i,a);oc?(o0==h>y[0]){S=d.range[1]=h,u.doTicksSingle(i,r.radialAxis,!0),s["radial-grid"].attr("transform",I(c,f)).selectAll("path").attr("transform",null);var p=S-y[0],g=r.sectorBBox;for(var v in r.xaxis.range=[g[0]*p,g[2]*p],r.yaxis.range=[g[1]*p,g[3]*p],r.xaxis.setScale(),r.yaxis.setScale(),r.traceHash){var b=r.traceHash[v],_=o.filterVisible(b),w=b[0][0].trace._module,k=i._fullLayout[r.id];if(w.plot(i,r,_,k),!a.traceIs(v,"gl"))for(var M=0;M<_.length;M++)w.style(i,_[M])}}}},C.updateAngularDrag=function(t,e){var r=this,i=r.gd,s=r.layers,c=r.radius,f=r.cx,d=r.cy,g=r.cxx,m=r.cyy,x=e.sector,b=T.angularDragBoxSize,k=p.makeDragger(s,"path","angulardrag","move"),S={element:k,gd:i};function C(t,e){return Math.atan2(m+b-e,t-g-b)}n.select(k).attr("d",function(t,e,r){var n,i,a,o=Math.abs(r[1]-r[0])<=180?0:1;function s(t,e){return[t*Math.cos(e),-t*Math.sin(e)]}function l(t,e,r){return"A"+[t,t]+" "+[0,o,r]+" "+s(t,e)}return D(r)?(n=0,a=2*Math.PI,i=Math.PI,"M"+s(t,n)+l(t,i,0)+l(t,a,0)+"ZM"+s(e,n)+l(e,i,1)+l(e,a,1)+"Z"):(n=_(r[0]),a=_(r[1]),"M"+s(t,n)+"L"+s(e,n)+l(e,a,0)+"L"+s(t,a)+l(t,n,1)+"Z")}(c,c+b,x)).attr("transform",I(f,d)).call(y,"move");var E,L,z,P,O,B,F=s.frontplot.select(".scatterlayer").selectAll(".trace"),N=F.selectAll(".point"),j=F.selectAll(".textpoint");function V(t,e){var c=C(E+t,L+e),f=w(c-B);P=z+f,s.frontplot.attr("transform",I(r.xOffset2,r.yOffset2)+R([-f,g,m])),r.clipPaths.circle.select("path").attr("transform",I(g,m)+R(f)),N.each(function(){var t=n.select(this),e=l.getTranslate(t);t.attr("transform",I(e.x,e.y)+R([f]))}),j.each(function(){var t=n.select(this),e=t.select("text"),r=l.getTranslate(t);t.attr("transform",R([f,e.attr("x"),e.attr("y")])+I(r.x,r.y))});var h=r.angularAxis;for(var p in h.rotation=M(P),"linear"!==h.type||D(x)||(h.range=O.map(_).map(h.unTransformRad).map(w)),A(h),u.doTicksSingle(i,h,!0),r._hasClipOnAxisFalse&&!D(x)&&(r.sector=[O[0]-f,O[1]-f],F.call(l.hideOutsideRangePoints,r)),r.traceHash)if(a.traceIs(p,"gl")){var d=r.traceHash[p],v=o.filterVisible(d),y=d[0][0].trace._module,b=i._fullLayout[r.id];y.plot(i,r,v,b)}}function U(){j.select("text").attr("transform",null);var t={};t[r.id+".angularaxis.rotation"]=P,a.call("relayout",i,t)}S.prepFn=function(e,n,i){var a=t[r.id];O=a.sector.slice(),z=a.angularaxis.rotation;var o=k.getBoundingClientRect();E=n-o.left,L=i-o.top,B=C(E,L),S.moveFn=V,S.doneFn=U,v(t._zoomlayer)},h.init(S)},C.isPtWithinSector=function(t){var e=this.sector,r=this.radialAxis,n=r.range,i=r.c2r(t.r),a=k(e[0]),o=k(e[1]);a>o&&(o+=360);var s,l,c=k(w(t.rad)),u=c+360;return n[1]>=n[0]?(s=n[0],l=n[1]):(s=n[1],l=n[0]),i>=s&&i<=l&&(D(e)||c>=a&&c<=o||u>=a&&u<=o)},C.fillViewInitialKey=function(t,e){t in this.viewInitial||(this.viewInitial[t]=e)}},{"../../components/color":532,"../../components/dragelement":554,"../../components/drawing":557,"../../components/fx":574,"../../components/titles":625,"../../constants/alignment":632,"../../lib":660,"../../lib/setcursor":680,"../../registry":790,"../cartesian/autorange":705,"../cartesian/axes":706,"../cartesian/dragbox":714,"../cartesian/select":723,"../plots":768,"./constants":769,"./helpers":770,d3:131,tinycolor2:473}],781:[function(t,e,r){"use strict";function n(t,e){return"splom"===t?-1:"splom"===e?1:0}e.exports={sortBasePlotModules:function(t,e){return n(t.name,e.name)},sortModules:n}},{}],782:[function(t,e,r){"use strict";var n=t("../lib"),i=t("./domain").defaults;e.exports=function(t,e,r,a){var o,s,l=a.type,c=a.attributes,u=a.handleDefaults,f=a.partition||"x",h=e._subplots[l],p=h.length;function d(t,e){return n.coerce(o,s,c,t,e)}for(var g=0;g=f&&(p.min=0,d.min=0,g.min=0,t.aaxis&&delete t.aaxis.min,t.baxis&&delete t.baxis.min,t.caxis&&delete t.caxis.min)}e.exports=function(t,e,r){i(t,e,r,{type:"ternary",attributes:a,handleDefaults:l,font:e.font,paper_bgcolor:e.paper_bgcolor})}},{"../../../components/color":532,"../../subplot_defaults":782,"./axis_defaults":786,"./layout_attributes":788}],788:[function(t,e,r){"use strict";var n=t("../../../components/color/attributes"),i=t("../../domain").attributes,a=t("./axis_attributes"),o=t("../../../plot_api/edit_types").overrideAll;e.exports=o({domain:i({name:"ternary"}),bgcolor:{valType:"color",dflt:n.background},sum:{valType:"number",dflt:1,min:0},aaxis:a,baxis:a,caxis:a},"plot","from-root")},{"../../../components/color/attributes":531,"../../../plot_api/edit_types":691,"../../domain":731,"./axis_attributes":785}],789:[function(t,e,r){"use strict";var n=t("d3"),i=t("tinycolor2"),a=t("../../registry"),o=t("../../lib"),s=o._,l=t("../../components/color"),c=t("../../components/drawing"),u=t("../cartesian/set_convert"),f=t("../../lib/extend").extendFlat,h=t("../plots"),p=t("../cartesian/axes"),d=t("../../components/dragelement"),g=t("../../components/fx"),m=t("../../components/titles"),v=t("../cartesian/select").prepSelect,y=t("../cartesian/select").clearSelect,x=t("../cartesian/constants");function b(t,e){this.id=t.id,this.graphDiv=t.graphDiv,this.init(e),this.makeFramework(e)}e.exports=b;var _=b.prototype;_.init=function(t){this.container=t._ternarylayer,this.defs=t._defs,this.layoutId=t._uid,this.traceHash={},this.layers={}},_.plot=function(t,e){var r=e[this.id],n=e._size;this._hasClipOnAxisFalse=!1;for(var i=0;iw*x?i=(a=x)*w:a=(i=y)/w,o=m*i/y,s=v*a/x,r=e.l+e.w*d-i/2,n=e.t+e.h*(1-g)-a/2,h.x0=r,h.y0=n,h.w=i,h.h=a,h.sum=b,h.xaxis={type:"linear",range:[_+2*M-b,b-_-2*k],domain:[d-o/2,d+o/2],_id:"x"},u(h.xaxis,h.graphDiv._fullLayout),h.xaxis.setScale(),h.xaxis.isPtWithinRange=function(t){return t.a>=h.aaxis.range[0]&&t.a<=h.aaxis.range[1]&&t.b>=h.baxis.range[1]&&t.b<=h.baxis.range[0]&&t.c>=h.caxis.range[1]&&t.c<=h.caxis.range[0]},h.yaxis={type:"linear",range:[_,b-k-M],domain:[g-s/2,g+s/2],_id:"y"},u(h.yaxis,h.graphDiv._fullLayout),h.yaxis.setScale(),h.yaxis.isPtWithinRange=function(){return!0};var A=h.yaxis.domain[0],T=h.aaxis=f({},t.aaxis,{visible:!0,range:[_,b-k-M],side:"left",_counterangle:30,tickangle:(+t.aaxis.tickangle||0)-30,domain:[A,A+s*w],_axislayer:h.layers.aaxis,_gridlayer:h.layers.agrid,_pos:0,_id:"y",_length:i,_gridpath:"M0,0l"+a+",-"+i/2,automargin:!1});u(T,h.graphDiv._fullLayout),T.setScale();var S=h.baxis=f({},t.baxis,{visible:!0,range:[b-_-M,k],side:"bottom",_counterangle:30,domain:h.xaxis.domain,_axislayer:h.layers.baxis,_gridlayer:h.layers.bgrid,_counteraxis:h.aaxis,_pos:0,_id:"x",_length:i,_gridpath:"M0,0l-"+i/2+",-"+a,automargin:!1});u(S,h.graphDiv._fullLayout),S.setScale(),T._counteraxis=S;var C=h.caxis=f({},t.caxis,{visible:!0,range:[b-_-k,M],side:"right",_counterangle:30,tickangle:(+t.caxis.tickangle||0)+30,domain:[A,A+s*w],_axislayer:h.layers.caxis,_gridlayer:h.layers.cgrid,_counteraxis:h.baxis,_pos:0,_id:"y",_length:i,_gridpath:"M0,0l-"+a+","+i/2,automargin:!1});u(C,h.graphDiv._fullLayout),C.setScale();var E="M"+r+","+(n+a)+"h"+i+"l-"+i/2+",-"+a+"Z";h.clipDef.select("path").attr("d",E),h.layers.plotbg.select("path").attr("d",E);var L="M0,"+a+"h"+i+"l-"+i/2+",-"+a+"Z";h.clipDefRelative.select("path").attr("d",L);var z="translate("+r+","+n+")";h.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform",z),h.clipDefRelative.select("path").attr("transform",null);var P="translate("+(r-S._offset)+","+(n+a)+")";h.layers.baxis.attr("transform",P),h.layers.bgrid.attr("transform",P);var D="translate("+(r+i/2)+","+n+")rotate(30)translate(0,"+-T._offset+")";h.layers.aaxis.attr("transform",D),h.layers.agrid.attr("transform",D);var O="translate("+(r+i/2)+","+n+")rotate(-30)translate(0,"+-C._offset+")";h.layers.caxis.attr("transform",O),h.layers.cgrid.attr("transform",O),h.drawAxes(!0),h.plotContainer.selectAll(".crisp").classed("crisp",!1),h.layers.aline.select("path").attr("d",T.showline?"M"+r+","+(n+a)+"l"+i/2+",-"+a:"M0,0").call(l.stroke,T.linecolor||"#000").style("stroke-width",(T.linewidth||0)+"px"),h.layers.bline.select("path").attr("d",S.showline?"M"+r+","+(n+a)+"h"+i:"M0,0").call(l.stroke,S.linecolor||"#000").style("stroke-width",(S.linewidth||0)+"px"),h.layers.cline.select("path").attr("d",C.showline?"M"+(r+i/2)+","+n+"l"+i/2+","+a:"M0,0").call(l.stroke,C.linecolor||"#000").style("stroke-width",(C.linewidth||0)+"px"),h.graphDiv._context.staticPlot||h.initInteractions(),c.setClipUrl(h.layers.frontplot,h._hasClipOnAxisFalse?null:h.clipId)},_.drawAxes=function(t){var e=this.graphDiv,r=this.id.substr(7)+"title",n=this.aaxis,i=this.baxis,a=this.caxis;if(p.doTicksSingle(e,n,!0),p.doTicksSingle(e,i,!0),p.doTicksSingle(e,a,!0),t){var o=Math.max(n.showticklabels?n.tickfont.size/2:0,(a.showticklabels?.75*a.tickfont.size:0)+("outside"===a.ticks?.87*a.ticklen:0));this.layers["a-title"]=m.draw(e,"a"+r,{propContainer:n,propName:this.id+".aaxis.title",placeholder:s(e,"Click to enter Component A title"),attributes:{x:this.x0+this.w/2,y:this.y0-n.titlefont.size/3-o,"text-anchor":"middle"}});var l=(i.showticklabels?i.tickfont.size:0)+("outside"===i.ticks?i.ticklen:0)+3;this.layers["b-title"]=m.draw(e,"b"+r,{propContainer:i,propName:this.id+".baxis.title",placeholder:s(e,"Click to enter Component B title"),attributes:{x:this.x0-l,y:this.y0+this.h+.83*i.titlefont.size+l,"text-anchor":"middle"}}),this.layers["c-title"]=m.draw(e,"c"+r,{propContainer:a,propName:this.id+".caxis.title",placeholder:s(e,"Click to enter Component C title"),attributes:{x:this.x0+this.w+l,y:this.y0+this.h+.83*a.titlefont.size+l,"text-anchor":"middle"}})}};var k=x.MINZOOM/2+.87,M="m-0.87,.5h"+k+"v3h-"+(k+5.2)+"l"+(k/2+2.6)+",-"+(.87*k+4.5)+"l2.6,1.5l-"+k/2+","+.87*k+"Z",A="m0.87,.5h-"+k+"v3h"+(k+5.2)+"l-"+(k/2+2.6)+",-"+(.87*k+4.5)+"l-2.6,1.5l"+k/2+","+.87*k+"Z",T="m0,1l"+k/2+","+.87*k+"l2.6,-1.5l-"+(k/2+2.6)+",-"+(.87*k+4.5)+"l-"+(k/2+2.6)+","+(.87*k+4.5)+"l2.6,1.5l"+k/2+",-"+.87*k+"Z",S="m0.5,0.5h5v-2h-5v-5h-2v5h-5v2h5v5h2Z",C=!0;function E(t){n.select(t).selectAll(".zoombox,.js-zoombox-backdrop,.js-zoombox-menu,.zoombox-corners").remove()}_.initInteractions=function(){var t,e,r,n,u,f,h,p,m,b,_=this,k=_.layers.plotbg.select("path").node(),L=_.graphDiv,z=L._fullLayout._zoomlayer,P={element:k,gd:L,plotinfo:{xaxis:_.xaxis,yaxis:_.yaxis},subplot:_.id,prepFn:function(a,o,s){P.xaxes=[_.xaxis],P.yaxes=[_.yaxis];var c=L._fullLayout.dragmode;a.shiftKey&&(c="pan"===c?"zoom":"pan"),P.minDrag="lasso"===c?1:void 0,"zoom"===c?(P.moveFn=R,P.doneFn=B,function(a,o,s){var c=k.getBoundingClientRect();t=o-c.left,e=s-c.top,r={a:_.aaxis.range[0],b:_.baxis.range[1],c:_.caxis.range[1]},u=r,n=_.aaxis.range[1]-r.a,f=i(_.graphDiv._fullLayout[_.id].bgcolor).getLuminance(),h="M0,"+_.h+"L"+_.w/2+", 0L"+_.w+","+_.h+"Z",p=!1,m=z.append("path").attr("class","zoombox").attr("transform","translate("+_.x0+", "+_.y0+")").style({fill:f>.2?"rgba(0,0,0,0)":"rgba(255,255,255,0)","stroke-width":0}).attr("d",h),b=z.append("path").attr("class","zoombox-corners").attr("transform","translate("+_.x0+", "+_.y0+")").style({fill:l.background,stroke:l.defaultLine,"stroke-width":1,opacity:0}).attr("d","M0,0Z"),y(z)}(0,o,s)):"pan"===c?(P.moveFn=F,P.doneFn=N,r={a:_.aaxis.range[0],b:_.baxis.range[1],c:_.caxis.range[1]},u=r,y(z)):"select"!==c&&"lasso"!==c||v(a,o,s,P,c)},clickFn:function(t,e){if(E(L),2===t){var r={};r[_.id+".aaxis.min"]=0,r[_.id+".baxis.min"]=0,r[_.id+".caxis.min"]=0,L.emit("plotly_doubleclick",null),a.call("relayout",L,r)}g.click(L,e,_.id)}};function D(t,e){return 1-e/_.h}function O(t,e){return 1-(t+(_.h-e)/Math.sqrt(3))/_.w}function I(t,e){return(t-(_.h-e)/Math.sqrt(3))/_.w}function R(i,a){var o=t+i,s=e+a,l=Math.max(0,Math.min(1,D(0,e),D(0,s))),c=Math.max(0,Math.min(1,O(t,e),O(o,s))),d=Math.max(0,Math.min(1,I(t,e),I(o,s))),g=(l/2+d)*_.w,v=(1-l/2-c)*_.w,y=(g+v)/2,k=v-g,C=(1-l)*_.h,E=C-k/w;k.2?"rgba(0,0,0,0.4)":"rgba(255,255,255,0.3)").duration(200),b.transition().style("opacity",1).duration(200),p=!0)}function B(){if(E(L),u!==r){var t={};t[_.id+".aaxis.min"]=u.a,t[_.id+".baxis.min"]=u.b,t[_.id+".caxis.min"]=u.c,a.call("relayout",L,t),C&&L.data&&L._context.showTips&&(o.notifier(s(L,"Double-click to zoom back out"),"long"),C=!1)}}function F(t,e){var n=t/_.xaxis._m,i=e/_.yaxis._m,a=[(u={a:r.a-i,b:r.b+(n+i)/2,c:r.c-(n-i)/2}).a,u.b,u.c].sort(),o=a.indexOf(u.a),s=a.indexOf(u.b),l=a.indexOf(u.c);a[0]<0&&(a[1]+a[0]/2<0?(a[2]+=a[0]+a[1],a[0]=a[1]=0):(a[2]+=a[0]/2,a[1]+=a[0]/2,a[0]=0),u={a:a[o],b:a[s],c:a[l]},e=(r.a-u.a)*_.yaxis._m,t=(r.c-u.c-r.b+u.b)*_.xaxis._m);var f="translate("+(_.x0+t)+","+(_.y0+e)+")";_.plotContainer.selectAll(".scatterlayer,.maplayer").attr("transform",f);var h="translate("+-t+","+-e+")";_.clipDefRelative.select("path").attr("transform",h),_.aaxis.range=[u.a,_.sum-u.b-u.c],_.baxis.range=[_.sum-u.a-u.c,u.b],_.caxis.range=[_.sum-u.a-u.b,u.c],_.drawAxes(!1),_.plotContainer.selectAll(".crisp").classed("crisp",!1),_._hasClipOnAxisFalse&&_.plotContainer.select(".scatterlayer").selectAll(".trace").call(c.hideOutsideRangePoints,_)}function N(){var t={};t[_.id+".aaxis.min"]=u.a,t[_.id+".baxis.min"]=u.b,t[_.id+".caxis.min"]=u.c,a.call("relayout",L,t)}k.onmousemove=function(t){g.hover(L,t,_.id),L._fullLayout._lasthover=k,L._fullLayout._hoversubplot=_.id},k.onmouseout=function(t){L._dragging||d.unhover(L,t)},d.init(P)}},{"../../components/color":532,"../../components/dragelement":554,"../../components/drawing":557,"../../components/fx":574,"../../components/titles":625,"../../lib":660,"../../lib/extend":649,"../../registry":790,"../cartesian/axes":706,"../cartesian/constants":711,"../cartesian/select":723,"../cartesian/set_convert":724,"../plots":768,d3:131,tinycolor2:473}],790:[function(t,e,r){"use strict";var n=t("./lib/loggers"),i=t("./lib/noop"),a=t("./lib/push_unique"),o=t("./lib/is_plain_object"),s=t("./lib/extend"),l=t("./plots/attributes"),c=t("./plots/layout_attributes"),u=s.extendFlat,f=s.extendDeepAll;function h(t){var e=t.name,i=t.categories,a=t.meta;if(r.modules[e])n.log("Type "+e+" already registered");else{r.subplotsRegistry[t.basePlotModule.name]||function(t){var e=t.name;if(r.subplotsRegistry[e])return void n.log("Plot type "+e+" already registered.");for(var i in m(t),r.subplotsRegistry[e]=t,r.componentsRegistry)x(i,t.name)}(t.basePlotModule);for(var o={},s=0;s-1&&(u[h[r]].title="");for(r=0;r")?"":e.html(t).text()});return e.remove(),r}(_),_=(_=_.replace(/&(?!\w+;|\#[0-9]+;| \#x[0-9A-F]+;)/g,"&")).replace(c,"'"),i.isIE()&&(_=(_=(_=_.replace(/"/gi,"'")).replace(/(\('#)([^']*)('\))/gi,'("#$2")')).replace(/(\\')/gi,'"')),_}},{"../components/color":532,"../components/drawing":557,"../constants/xmlns_namespaces":639,"../lib":660,d3:131}],799:[function(t,e,r){"use strict";var n=t("../../lib").mergeArray;e.exports=function(t,e){for(var r=0;ra;if(!o)return e}return void 0!==r?r:t.dflt}(t.size,s,n.size),color:function(t,e,r){return a(e).isValid()?e:void 0!==r?r:t.dflt}(t.color,l,n.color)}}function b(t,e){var r;return Array.isArray(t)?e.01?N:function(t,e){return Math.abs(t-e)>=2?N(t):t>e?Math.ceil(t):Math.floor(t)};A=F(A,C),C=F(C,A),E=F(E,L),L=F(L,E)}o.ensureSingle(z,"path").style("vector-effect","non-scaling-stroke").attr("d","M"+A+","+E+"V"+L+"H"+C+"V"+E+"Z").call(c.setClipUrl,e.layerClipId),function(t,e,r,n,i,a,l,u){var f;function w(e,r,n){var i=o.ensureSingle(e,"text").text(r).attr({class:"bartext bartext-"+f,transform:"","text-anchor":"middle","data-notex":1}).call(c.font,n).call(s.convertToTspans,t);return i}var k=r[0].trace,M=k.orientation,A=function(t,e){var r=b(t.text,e);return _(h,r)}(k,n);if(f=function(t,e){var r=b(t.textposition,e);return function(t,e,r){return t.coerceNumber&&(e=+e),-1!==t.values.indexOf(e)?e:void 0!==r?r:t.dflt}(p,r)}(k,n),!A||"none"===f)return void e.select("text").remove();var T,S,C,E,L,z,P=function(t,e,r){return x(d,t.textfont,e,r)}(k,n,t._fullLayout.font),D=function(t,e,r){return x(g,t.insidetextfont,e,r)}(k,n,P),O=function(t,e,r){return x(m,t.outsidetextfont,e,r)}(k,n,P),I=t._fullLayout.barmode,R="relative"===I,B="stack"===I||R,F=r[n],N=!B||F._outmost,j=Math.abs(a-i)-2*v,V=Math.abs(u-l)-2*v;"outside"===f&&(N||(f="inside"));if("auto"===f)if(N){f="inside",T=w(e,A,D),S=c.bBox(T.node()),C=S.width,E=S.height;var U=C>0&&E>0,q=C<=j&&E<=V,H=C<=V&&E<=j,G="h"===M?j>=C*(V/E):V>=E*(j/C);U&&(q||H||G)?f="inside":(f="outside",T.remove(),T=null)}else f="inside";if(!T&&(T=w(e,A,"outside"===f?O:D),S=c.bBox(T.node()),C=S.width,E=S.height,C<=0||E<=0))return void T.remove();"outside"===f?(z="both"===k.constraintext||"outside"===k.constraintext,L=function(t,e,r,n,i,a,o){var s,l="h"===a?Math.abs(n-r):Math.abs(e-t);l>2*v&&(s=v);var c=1;o&&(c="h"===a?Math.min(1,l/i.height):Math.min(1,l/i.width));var u,f,h,p,d=(i.left+i.right)/2,g=(i.top+i.bottom)/2;u=c*i.width,f=c*i.height,"h"===a?er?(h=(t+e)/2,p=n+s+f/2):(h=(t+e)/2,p=n-s-f/2);return y(d,g,h,p,c,!1)}(i,a,l,u,S,M,z)):(z="both"===k.constraintext||"inside"===k.constraintext,L=function(t,e,r,n,i,a,o){var s,l,c,u,f,h,p,d=i.width,g=i.height,m=(i.left+i.right)/2,x=(i.top+i.bottom)/2,b=Math.abs(e-t),_=Math.abs(n-r);b>2*v&&_>2*v?(b-=2*(f=v),_-=2*f):f=0;d<=b&&g<=_?(h=!1,p=1):d<=_&&g<=b?(h=!0,p=1):dr?(c=(t+e)/2,u=n-f-l/2):(c=(t+e)/2,u=n+f+l/2);return y(m,x,c,u,p,h)}(i,a,l,u,S,M,z));T.attr("transform",L)}(t,z,r,u,A,C,E,L),e.layerClipId&&c.hideOutsideRangePoint(r[u],z.select("text"),f,w,M.xcalendar,M.ycalendar)}else z.remove();function N(t){return 0===k.bargap&&0===k.bargroupgap?n.round(Math.round(t)-B,2):t}});var E=!1===r[0].trace.cliponaxis;c.setClipUrl(A,E?null:e.layerClipId)}),u.getComponentMethod("errorbars","plot")(M,e)}},{"../../components/color":532,"../../components/drawing":557,"../../lib":660,"../../lib/svg_text_utils":684,"../../registry":790,"./attributes":800,d3:131,"fast-isnumeric":197,tinycolor2:473}],808:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n=t.cd,i=t.xaxis,a=t.yaxis,o=[];if(!1===e)for(r=0;rf+c||!n(u))&&(p=!0,g(h,t))}for(var m=0;m1||0===s.bargap&&0===s.bargroupgap&&!t[0].trace.marker.line.width)&&n.select(this).attr("shape-rendering","crispEdges")}),r.selectAll("g.points").each(function(e){o(n.select(this),e[0].trace,t)}),a.getComponentMethod("errorbars","style")(r)},styleOnSelect:function(t,e){var r=e[0].node3,n=e[0].trace;n.selectedpoints?(i.selectedPointStyle(r.selectAll("path"),n),i.selectedTextStyle(r.selectAll("text"),n)):o(r,n,t)}}},{"../../components/drawing":557,"../../registry":790,d3:131}],812:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults");e.exports=function(t,e,r,o,s){r("marker.color",o),i(t,"marker")&&a(t,e,s,r,{prefix:"marker.",cLetter:"c"}),r("marker.line.color",n.defaultLine),i(t,"marker.line")&&a(t,e,s,r,{prefix:"marker.line.",cLetter:"c"}),r("marker.line.width"),r("marker.opacity"),r("selected.marker.color"),r("unselected.marker.color")}},{"../../components/color":532,"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546}],813:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../components/color/attributes"),a=t("../../lib/extend").extendFlat,o=n.marker,s=o.line;e.exports={y:{valType:"data_array",editType:"calc+clearAxisTypes"},x:{valType:"data_array",editType:"calc+clearAxisTypes"},x0:{valType:"any",editType:"calc+clearAxisTypes"},y0:{valType:"any",editType:"calc+clearAxisTypes"},name:{valType:"string",editType:"calc+clearAxisTypes"},text:a({},n.text,{}),whiskerwidth:{valType:"number",min:0,max:1,dflt:.5,editType:"calcIfAutorange"},notched:{valType:"boolean",editType:"calcIfAutorange"},notchwidth:{valType:"number",min:0,max:.5,dflt:.25,editType:"calcIfAutorange"},boxpoints:{valType:"enumerated",values:["all","outliers","suspectedoutliers",!1],dflt:"outliers",editType:"calcIfAutorange"},boxmean:{valType:"enumerated",values:[!0,"sd",!1],dflt:!1,editType:"calcIfAutorange"},jitter:{valType:"number",min:0,max:1,editType:"calcIfAutorange"},pointpos:{valType:"number",min:-2,max:2,editType:"calcIfAutorange"},orientation:{valType:"enumerated",values:["v","h"],editType:"calc+clearAxisTypes"},marker:{outliercolor:{valType:"color",dflt:"rgba(0, 0, 0, 0)",editType:"style"},symbol:a({},o.symbol,{arrayOk:!1,editType:"plot"}),opacity:a({},o.opacity,{arrayOk:!1,dflt:1,editType:"style"}),size:a({},o.size,{arrayOk:!1,editType:"calcIfAutorange"}),color:a({},o.color,{arrayOk:!1,editType:"style"}),line:{color:a({},s.color,{arrayOk:!1,dflt:i.defaultLine,editType:"style"}),width:a({},s.width,{arrayOk:!1,dflt:0,editType:"style"}),outliercolor:{valType:"color",editType:"style"},outlierwidth:{valType:"number",min:0,dflt:1,editType:"style"},editType:"style"},editType:"plot"},line:{color:{valType:"color",editType:"style"},width:{valType:"number",min:0,dflt:2,editType:"style"},editType:"plot"},fillcolor:n.fillcolor,selected:{marker:n.selected.marker,editType:"style"},unselected:{marker:n.unselected.marker,editType:"style"},hoveron:{valType:"flaglist",flags:["boxes","points"],dflt:"boxes+points",editType:"style"}}},{"../../components/color/attributes":531,"../../lib/extend":649,"../scatter/attributes":990}],814:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=i._,o=t("../../plots/cartesian/axes");function s(t,e,r){var n={text:"tx"};for(var i in n)Array.isArray(e[i])&&(t[n[i]]=e[i][r])}function l(t,e){return t.v-e.v}function c(t){return t.v}e.exports=function(t,e){var r,u,f,h,p,d=t._fullLayout,g=o.getFromId(t,e.xaxis||"x"),m=o.getFromId(t,e.yaxis||"y"),v=[],y="violin"===e.type?"_numViolins":"_numBoxes";"h"===e.orientation?(u=g,f="x",h=m,p="y"):(u=m,f="y",h=g,p="x");var x=u.makeCalcdata(e,f),b=function(t,e,r,a,o){if(e in t)return r.makeCalcdata(t,e);var s;s=e+"0"in t?t[e+"0"]:"name"in t&&("category"===r.type||n(t.name)&&-1!==["linear","log"].indexOf(r.type)||i.isDateTime(t.name)&&"date"===r.type)?t.name:o;var l=r.d2c(s,0,t[e+"calendar"]);return a.map(function(){return l})}(e,p,h,x,d[y]),_=i.distinctVals(b),w=_.vals,k=_.minDiff/2,M=function(t,e){for(var r=t.length,n=new Array(r+1),i=0;i=0&&C0){var L=T[r].sort(l),z=L.map(c),P=z.length,D={pos:w[r],pts:L};D.min=z[0],D.max=z[P-1],D.mean=i.mean(z,P),D.sd=i.stdev(z,P,D.mean),D.q1=i.interp(z,.25),D.med=i.interp(z,.5),D.q3=i.interp(z,.75),D.lf=Math.min(D.q1,z[Math.min(i.findBin(2.5*D.q1-1.5*D.q3,z,!0)+1,P-1)]),D.uf=Math.max(D.q3,z[Math.max(i.findBin(2.5*D.q3-1.5*D.q1,z),0)]),D.lo=4*D.q1-3*D.q3,D.uo=4*D.q3-3*D.q1;var O=1.57*(D.q3-D.q1)/Math.sqrt(P);D.ln=D.med-O,D.un=D.med+O,v.push(D)}return function(t,e){if(i.isArrayOrTypedArray(e.selectedpoints))for(var r=0;r0?(v[0].t={num:d[y],dPos:k,posLetter:p,valLetter:f,labels:{med:a(t,"median:"),min:a(t,"min:"),q1:a(t,"q1:"),q3:a(t,"q3:"),max:a(t,"max:"),mean:"sd"===e.boxmean?a(t,"mean \xb1 \u03c3:"):a(t,"mean:"),lf:a(t,"lower fence:"),uf:a(t,"upper fence:")}},d[y]++,v):[{t:{empty:!0}}]}},{"../../lib":660,"../../plots/cartesian/axes":706,"fast-isnumeric":197}],815:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry"),a=t("../../components/color"),o=t("./attributes");function s(t,e,r,n){var a,o,s=r("y"),l=r("x"),c=l&&l.length;if(s&&s.length)a="v",c?o=Math.min(l.length,s.length):(r("x0"),o=s.length);else{if(!c)return void(e.visible=!1);a="h",r("y0"),o=l.length}e._length=o,i.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x","y"],n),r("orientation",a)}function l(t,e,r,i){var a=i.prefix,s=n.coerce2(t,e,o,"marker.outliercolor"),l=r("marker.line.outliercolor"),c=r(a+"points",s||l?"suspectedoutliers":void 0);c?(r("jitter","all"===c?.3:0),r("pointpos","all"===c?-1.5:0),r("marker.symbol"),r("marker.opacity"),r("marker.size"),r("marker.color",e.line.color),r("marker.line.color"),r("marker.line.width"),"suspectedoutliers"===c&&(r("marker.line.outliercolor",e.marker.color),r("marker.line.outlierwidth")),r("selected.marker.color"),r("unselected.marker.color"),r("selected.marker.size"),r("unselected.marker.size"),r("text")):delete e.marker,r("hoveron"),n.coerceSelectionMarkerOpacity(e,r)}e.exports={supplyDefaults:function(t,e,r,i){function c(r,i){return n.coerce(t,e,o,r,i)}s(t,e,c,i),!1!==e.visible&&(c("line.color",(t.marker||{}).color||r),c("line.width"),c("fillcolor",a.addOpacity(e.line.color,.5)),c("whiskerwidth"),c("boxmean"),c("notched",void 0!==t.notchwidth)&&c("notchwidth"),l(t,e,c,{prefix:"box"}))},handleSampleDefaults:s,handlePointsDefaults:l}},{"../../components/color":532,"../../lib":660,"../../registry":790,"./attributes":813}],816:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib"),a=t("../../components/fx"),o=t("../../components/color"),s=t("../scatter/fill_hover_text");function l(t,e,r,s){var l,c,u,f,h,p,d,g,m,v,y,x,b=t.cd,_=t.xa,w=t.ya,k=b[0].trace,M=b[0].t,A="violin"===k.type,T=[],S=M.bdPos,C=M.wHover,E=function(t){return t.pos+M.bPos-p};A&&"both"!==k.side?("positive"===k.side&&(m=function(t){var e=E(t);return a.inbox(e,e+C,v)}),"negative"===k.side&&(m=function(t){var e=E(t);return a.inbox(e-C,e,v)})):m=function(t){var e=E(t);return a.inbox(e-C,e+C,v)},x=A?function(t){return a.inbox(t.span[0]-h,t.span[1]-h,v)}:function(t){return a.inbox(t.min-h,t.max-h,v)},"h"===k.orientation?(h=e,p=r,d=x,g=m,l="y",u=w,c="x",f=_):(h=r,p=e,d=m,g=x,l="x",u=_,c="y",f=w);var L=Math.min(1,S/Math.abs(u.r2c(u.range[1])-u.r2c(u.range[0])));function z(t){return(d(t)+g(t))/2}v=t.maxHoverDistance-L,y=t.maxSpikeDistance-L;var P=a.getDistanceFunction(s,d,g,z);if(a.getClosest(b,P,t),!1===t.index)return[];var D=b[t.index],O=k.line.color,I=(k.marker||{}).color;o.opacity(O)&&k.line.width?t.color=O:o.opacity(I)&&k.boxpoints?t.color=I:t.color=k.fillcolor,t[l+"0"]=u.c2p(D.pos+M.bPos-S,!0),t[l+"1"]=u.c2p(D.pos+M.bPos+S,!0),t[l+"LabelVal"]=D.pos;var R=l+"Spike";t.spikeDistance=z(D)*y/v,t[R]=u.c2p(D.pos,!0);var B={},F=["med","min","q1","q3","max"];(k.boxmean||(k.meanline||{}).visible)&&F.push("mean"),(k.boxpoints||k.points)&&F.push("lf","uf");for(var N=0;Nt.uf}),l=Math.max((t.max-t.min)/10,t.q3-t.q1),c=1e-9*l,p=l*s,d=[],g=0;if(r.jitter){if(0===l)for(g=1,d=new Array(a.length),e=0;et.lo&&(_.so=!0)}return a});d.enter().append("path").classed("point",!0),d.exit().remove(),d.call(a.translatePoints,l,c)}function u(t,e,r,a){var o,s,l=e.pos,c=e.val,u=a.bPos,f=a.bPosPxOffset||0;Array.isArray(a.bdPos)?(o=a.bdPos[0],s=a.bdPos[1]):(o=a.bdPos,s=a.bdPos);var h=t.selectAll("path.mean").data(i.identity);h.enter().append("path").attr("class","mean").style({fill:"none","vector-effect":"non-scaling-stroke"}),h.exit().remove(),h.each(function(t){var e=l.c2p(t.pos+u,!0)+f,i=l.c2p(t.pos+u-o,!0)+f,a=l.c2p(t.pos+u+s,!0)+f,h=c.c2p(t.mean,!0),p=c.c2p(t.mean-t.sd,!0),d=c.c2p(t.mean+t.sd,!0);"h"===r.orientation?n.select(this).attr("d","M"+h+","+i+"V"+a+("sd"===r.boxmean?"m0,0L"+p+","+e+"L"+h+","+i+"L"+d+","+e+"Z":"")):n.select(this).attr("d","M"+i+","+h+"H"+a+("sd"===r.boxmean?"m0,0L"+e+","+p+"L"+i+","+h+"L"+e+","+d+"Z":""))})}e.exports={plot:function(t,e,r,i){var a=t._fullLayout,o=e.xaxis,s=e.yaxis,f=i.selectAll("g.trace.boxes").data(r,function(t){return t[0].trace.uid});f.enter().append("g").attr("class","trace boxes"),f.exit().remove(),f.order(),f.each(function(t){var r=t[0],i=r.t,f=r.trace,h=n.select(this);e.isRangePlot||(r.node3=h);var p,d,g=a._numBoxes,m=1-a.boxgap,v="group"===a.boxmode&&g>1,y=i.dPos*m*(1-a.boxgroupgap)/(v?g:1),x=v?2*i.dPos*((i.num+.5)/g-.5)*m:0,b=y*f.whiskerwidth;!0!==f.visible||i.empty?h.remove():("h"===f.orientation?(p=s,d=o):(p=o,d=s),i.bPos=x,i.bdPos=y,i.wdPos=b,i.wHover=i.dPos*(v?m/g:1),l(h,{pos:p,val:d},f,i),f.boxpoints&&c(h,{x:o,y:s},f,i),f.boxmean&&u(h,{pos:p,val:d},f,i))})},plotBoxAndWhiskers:l,plotPoints:c,plotBoxMean:u}},{"../../components/drawing":557,"../../lib":660,d3:131}],821:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n,i=t.cd,a=t.xaxis,o=t.yaxis,s=[];if(!1===e)for(r=0;r=10)return null;var i=1/0;var a=-1/0;var o=e.length;for(var s=0;s0?Math.floor:Math.ceil,P=E>0?Math.ceil:Math.floor,D=E>0?Math.min:Math.max,O=E>0?Math.max:Math.min,I=z(S+L),R=P(C-L),B=[[f=T(S)]];for(a=I;a*E=0;i--)a[u-i]=t[f][i],o[u-i]=e[f][i];for(s.push({x:a,y:o,bicubic:l}),i=f,a=[],o=[];i>=0;i--)a[f-i]=t[i][0],o[f-i]=e[i][0];return s.push({x:a,y:o,bicubic:c}),s}},{}],836:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib/extend").extendFlat;e.exports=function(t,e,r){var a,o,s,l,c,u,f,h,p,d,g,m,v,y,x=t["_"+e],b=t[e+"axis"],_=b._gridlines=[],w=b._minorgridlines=[],k=b._boundarylines=[],M=t["_"+r],A=t[r+"axis"];"array"===b.tickmode&&(b.tickvals=x.slice());var T=t._xctrl,S=t._yctrl,C=T[0].length,E=T.length,L=t._a.length,z=t._b.length;n.prepTicks(b),"array"===b.tickmode&&delete b.tickvals;var P=b.smoothing?3:1;function D(n){var i,a,o,s,l,c,u,f,p,d,g,m,v=[],y=[],x={};if("b"===e)for(a=t.b2j(n),o=Math.floor(Math.max(0,Math.min(z-2,a))),s=a-o,x.length=z,x.crossLength=L,x.xy=function(e){return t.evalxy([],e,a)},x.dxy=function(e,r){return t.dxydi([],e,o,r,s)},i=0;i0&&(p=t.dxydi([],i-1,o,0,s),v.push(l[0]+p[0]/3),y.push(l[1]+p[1]/3),d=t.dxydi([],i-1,o,1,s),v.push(f[0]-d[0]/3),y.push(f[1]-d[1]/3)),v.push(f[0]),y.push(f[1]),l=f;else for(i=t.a2i(n),c=Math.floor(Math.max(0,Math.min(L-2,i))),u=i-c,x.length=L,x.crossLength=z,x.xy=function(e){return t.evalxy([],i,e)},x.dxy=function(e,r){return t.dxydj([],c,e,u,r)},a=0;a0&&(g=t.dxydj([],c,a-1,u,0),v.push(l[0]+g[0]/3),y.push(l[1]+g[1]/3),m=t.dxydj([],c,a-1,u,1),v.push(f[0]-m[0]/3),y.push(f[1]-m[1]/3)),v.push(f[0]),y.push(f[1]),l=f;return x.axisLetter=e,x.axis=b,x.crossAxis=A,x.value=n,x.constvar=r,x.index=h,x.x=v,x.y=y,x.smoothing=A.smoothing,x}function O(n){var i,a,o,s,l,c=[],u=[],f={};if(f.length=x.length,f.crossLength=M.length,"b"===e)for(o=Math.max(0,Math.min(z-2,n)),l=Math.min(1,Math.max(0,n-o)),f.xy=function(e){return t.evalxy([],e,n)},f.dxy=function(e,r){return t.dxydi([],e,o,r,l)},i=0;ix.length-1||_.push(i(O(o),{color:b.gridcolor,width:b.gridwidth}));for(h=u;hx.length-1||g<0||g>x.length-1))for(m=x[s],v=x[g],a=0;ax[x.length-1]||w.push(i(D(d),{color:b.minorgridcolor,width:b.minorgridwidth}));b.startline&&k.push(i(O(0),{color:b.startlinecolor,width:b.startlinewidth})),b.endline&&k.push(i(O(x.length-1),{color:b.endlinecolor,width:b.endlinewidth}))}else{for(l=5e-15,u=(c=[Math.floor((x[x.length-1]-b.tick0)/b.dtick*(1+l)),Math.ceil((x[0]-b.tick0)/b.dtick/(1+l))].sort(function(t,e){return t-e}))[0],f=c[1],h=u;h<=f;h++)p=b.tick0+b.dtick*h,_.push(i(D(p),{color:b.gridcolor,width:b.gridwidth}));for(h=u-1;hx[x.length-1]||w.push(i(D(d),{color:b.minorgridcolor,width:b.minorgridwidth}));b.startline&&k.push(i(D(x[0]),{color:b.startlinecolor,width:b.startlinewidth})),b.endline&&k.push(i(D(x[x.length-1]),{color:b.endlinecolor,width:b.endlinewidth}))}}},{"../../lib/extend":649,"../../plots/cartesian/axes":706}],837:[function(t,e,r){"use strict";var n=t("../../plots/cartesian/axes"),i=t("../../lib/extend").extendFlat;e.exports=function(t,e){var r,a,o,s=e._labels=[],l=e._gridlines;for(r=0;re.length&&(t=t.slice(0,e.length)):t=[],i=0;i90&&(p-=180,l=-l),{angle:p,flip:l,p:t.c2p(n,e,r),offsetMultplier:c}}},{}],851:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../components/drawing"),a=t("./map_1d_array"),o=t("./makepath"),s=t("./orient_text"),l=t("../../lib/svg_text_utils"),c=t("../../lib"),u=t("../../constants/alignment"),f=t("../../plots/get_data").getUidsFromCalcData;function h(t,e,r,n){var i=r[0],l=r[0].trace,u=e.xaxis,f=e.yaxis,h=l.aaxis,g=l.baxis,m=t._fullLayout._clips,y=c.ensureSingle(n,"g","carpet"+l.uid).classed("trace",!0),x=c.ensureSingle(y,"g","minorlayer"),b=c.ensureSingle(y,"g","majorlayer"),_=c.ensureSingle(y,"g","boundarylayer"),w=c.ensureSingle(y,"g","labellayer");y.style("opacity",l.opacity),p(u,f,b,h,"a",h._gridlines),p(u,f,b,g,"b",g._gridlines),p(u,f,x,h,"a",h._minorgridlines),p(u,f,x,g,"b",g._minorgridlines),p(u,f,_,h,"a-boundary",h._boundarylines),p(u,f,_,g,"b-boundary",g._boundarylines),function(t,e,r,n,i,a,o,l){var u,f,h,p;u=.5*(r.a[0]+r.a[r.a.length-1]),f=r.b[0],h=r.ab2xy(u,f,!0),p=r.dxyda_rough(u,f),void 0===o.angle&&c.extendFlat(o,s(r,i,a,h,r.dxydb_rough(u,f)));v(t,e,r,n,h,p,r.aaxis,i,a,o,"a-title"),u=r.a[0],f=.5*(r.b[0]+r.b[r.b.length-1]),h=r.ab2xy(u,f,!0),p=r.dxydb_rough(u,f),void 0===l.angle&&c.extendFlat(l,s(r,i,a,h,r.dxyda_rough(u,f)));v(t,e,r,n,h,p,r.baxis,i,a,l,"b-title")}(t,w,l,i,u,f,d(t,u,f,l,i,w,h._labels,"a-label"),d(t,u,f,l,i,w,g._labels,"b-label")),function(t,e,r,n,i){var s,l,u,f,h=r.select("#"+t._clipPathId);h.size()||(h=r.append("clipPath").classed("carpetclip",!0));var p=c.ensureSingle(h,"path","carpetboundary"),d=e.clipsegments,g=[];for(f=0;f0?"start":"end","data-notex":1}).call(i.font,o.font).text(o.text).call(l.convertToTspans,t),m=i.bBox(this);g.attr("transform","translate("+u.p[0]+","+u.p[1]+") rotate("+u.angle+")translate("+o.axis.labelpadding*h+","+.3*m.height+")"),p=Math.max(p,m.width+o.axis.labelpadding)}),h.exit().remove(),d.maxExtent=p,d}e.exports=function(t,e,r,i){var a=f(r);i.selectAll("g.trace").each(function(){var t=n.select(this).attr("class").split("carpet")[1].split(/\s/)[0];a[t]||n.select(this).remove()});for(var o=0;o90&&d<270,y=n.select(this);y.text(u.title||"").call(l.convertToTspans,t),v&&(x=(-l.lineCount(y)+m)*g*a-x),y.attr("transform","translate("+e.p[0]+","+e.p[1]+") rotate("+e.angle+") translate(0,"+x+")").classed("user-select-none",!0).attr("text-anchor","middle").call(i.font,u.titlefont)}),y.exit().remove()}},{"../../components/drawing":557,"../../constants/alignment":632,"../../lib":660,"../../lib/svg_text_utils":684,"../../plots/get_data":742,"./makepath":848,"./map_1d_array":849,"./orient_text":850,d3:131}],852:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../lib/search").findBin,a=t("./compute_control_points"),o=t("./create_spline_evaluator"),s=t("./create_i_derivative_evaluator"),l=t("./create_j_derivative_evaluator");e.exports=function(t){var e=t._a,r=t._b,c=e.length,u=r.length,f=t.aaxis,h=t.baxis,p=e[0],d=e[c-1],g=r[0],m=r[u-1],v=e[e.length-1]-e[0],y=r[r.length-1]-r[0],x=v*n.RELATIVE_CULL_TOLERANCE,b=y*n.RELATIVE_CULL_TOLERANCE;p-=x,d+=x,g-=b,m+=b,t.isVisible=function(t,e){return t>p&&tg&&ed||em},t.setScale=function(){var e=t._x,r=t._y,n=a(t._xctrl,t._yctrl,e,r,f.smoothing,h.smoothing);t._xctrl=n[0],t._yctrl=n[1],t.evalxy=o([t._xctrl,t._yctrl],c,u,f.smoothing,h.smoothing),t.dxydi=s([t._xctrl,t._yctrl],f.smoothing,h.smoothing),t.dxydj=l([t._xctrl,t._yctrl],f.smoothing,h.smoothing)},t.i2a=function(t){var r=Math.max(0,Math.floor(t[0]),c-2),n=t[0]-r;return(1-n)*e[r]+n*e[r+1]},t.j2b=function(t){var e=Math.max(0,Math.floor(t[1]),c-2),n=t[1]-e;return(1-n)*r[e]+n*r[e+1]},t.ij2ab=function(e){return[t.i2a(e[0]),t.j2b(e[1])]},t.a2i=function(t){var r=Math.max(0,Math.min(i(t,e),c-2)),n=e[r],a=e[r+1];return Math.max(0,Math.min(c-1,r+(t-n)/(a-n)))},t.b2j=function(t){var e=Math.max(0,Math.min(i(t,r),u-2)),n=r[e],a=r[e+1];return Math.max(0,Math.min(u-1,e+(t-n)/(a-n)))},t.ab2ij=function(e){return[t.a2i(e[0]),t.b2j(e[1])]},t.i2c=function(e,r){return t.evalxy([],e,r)},t.ab2xy=function(n,i,a){if(!a&&(ne[c-1]|ir[u-1]))return[!1,!1];var o=t.a2i(n),s=t.b2j(i),l=t.evalxy([],o,s);if(a){var f,h,p,d,g=0,m=0,v=[];ne[c-1]?(f=c-2,h=1,g=(n-e[c-1])/(e[c-1]-e[c-2])):h=o-(f=Math.max(0,Math.min(c-2,Math.floor(o)))),ir[u-1]?(p=u-2,d=1,m=(i-r[u-1])/(r[u-1]-r[u-2])):d=s-(p=Math.max(0,Math.min(u-2,Math.floor(s)))),g&&(t.dxydi(v,f,p,h,d),l[0]+=v[0]*g,l[1]+=v[1]*g),m&&(t.dxydj(v,f,p,h,d),l[0]+=v[0]*m,l[1]+=v[1]*m)}return l},t.c2p=function(t,e,r){return[e.c2p(t[0]),r.c2p(t[1])]},t.p2x=function(t,e,r){return[e.p2c(t[0]),r.p2c(t[1])]},t.dadi=function(t){var r=Math.max(0,Math.min(e.length-2,t));return e[r+1]-e[r]},t.dbdj=function(t){var e=Math.max(0,Math.min(r.length-2,t));return r[e+1]-r[e]},t.dxyda=function(e,r,n,i){var a=t.dxydi(null,e,r,n,i),o=t.dadi(e,n);return[a[0]/o,a[1]/o]},t.dxydb=function(e,r,n,i){var a=t.dxydj(null,e,r,n,i),o=t.dbdj(r,i);return[a[0]/o,a[1]/o]},t.dxyda_rough=function(e,r,n){var i=v*(n||.1),a=t.ab2xy(e+i,r,!0),o=t.ab2xy(e-i,r,!0);return[.5*(a[0]-o[0])/i,.5*(a[1]-o[1])/i]},t.dxydb_rough=function(e,r,n){var i=y*(n||.1),a=t.ab2xy(e,r+i,!0),o=t.ab2xy(e,r-i,!0);return[.5*(a[0]-o[0])/i,.5*(a[1]-o[1])/i]},t.dpdx=function(t){return t._m},t.dpdy=function(t){return t._m}}},{"../../lib/search":679,"./compute_control_points":840,"./constants":841,"./create_i_derivative_evaluator":842,"./create_j_derivative_evaluator":843,"./create_spline_evaluator":844}],853:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e,r){var i,a,o,s=[],l=[],c=t[0].length,u=t.length;function f(e,r){var n,i=0,a=0;return e>0&&void 0!==(n=t[r][e-1])&&(a++,i+=n),e0&&void 0!==(n=t[r-1][e])&&(a++,i+=n),r0&&a0&&i1e-5);return n.log("Smoother converged to",M,"after",A,"iterations"),t}},{"../../lib":660}],854:[function(t,e,r){"use strict";var n=t("../../lib").isArray1D;e.exports=function(t,e,r){var i=r("x"),a=i&&i.length,o=r("y"),s=o&&o.length;if(!a&&!s)return!1;if(e._cheater=!i,a&&!n(i)||s&&!n(o))e._length=null;else{var l=a?i.length:1/0;s&&(l=Math.min(l,o.length)),e.a&&e.a.length&&(l=Math.min(l,e.a.length)),e.b&&e.b.length&&(l=Math.min(l,e.b.length)),e._length=l}return!0}},{"../../lib":660}],855:[function(t,e,r){"use strict";var n=t("../scattergeo/attributes"),i=t("../../components/colorscale/attributes"),a=t("../../components/colorbar/attributes"),o=t("../../plots/attributes"),s=t("../../lib/extend"),l=s.extendFlat,c=s.extendDeepAll,u=n.marker.line;e.exports=l({locations:{valType:"data_array",editType:"calc"},locationmode:n.locationmode,z:{valType:"data_array",editType:"calc"},text:l({},n.text,{}),marker:{line:{color:u.color,width:l({},u.width,{dflt:1}),editType:"calc"},opacity:{valType:"number",arrayOk:!0,min:0,max:1,dflt:1,editType:"style"},editType:"calc"},selected:{marker:{opacity:n.selected.marker.opacity,editType:"plot"},editType:"plot"},unselected:{marker:{opacity:n.unselected.marker.opacity,editType:"plot"},editType:"plot"},hoverinfo:l({},o.hoverinfo,{editType:"calc",flags:["location","z","text","name"]})},c({},i,{zmax:{editType:"calc"},zmin:{editType:"calc"}}),{colorbar:a})},{"../../components/colorbar/attributes":533,"../../components/colorscale/attributes":538,"../../lib/extend":649,"../../plots/attributes":703,"../scattergeo/attributes":1028}],856:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../constants/numerical").BADNUM,a=t("../../components/colorscale/calc"),o=t("../scatter/arrays_to_calcdata"),s=t("../scatter/calc_selection");e.exports=function(t,e){for(var r=e._length,l=new Array(r),c=0;c")}(t,f,o,h.mockAxis),[t]}},{"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998,"./attributes":855}],860:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../heatmap/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("./style").style,n.styleOnSelect=t("./style").styleOnSelect,n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.moduleType="trace",n.name="choropleth",n.basePlotModule=t("../../plots/geo"),n.categories=["geo","noOpacity"],n.meta={},e.exports=n},{"../../plots/geo":736,"../heatmap/colorbar":902,"./attributes":855,"./calc":856,"./defaults":857,"./event_data":858,"./hover":859,"./plot":861,"./select":862,"./style":863}],861:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../lib/polygon"),o=t("../../lib/topojson_utils").getTopojsonFeatures,s=t("../../lib/geo_location_utils").locationToFeature,l=t("./style").style;function c(t,e){for(var r=t[0].trace,n=t.length,i=o(r,e),a=0;a0&&t[e+1][0]<0)return e;return null}switch(e="RUS"===l||"FJI"===l?function(t){var e;if(null===u(t))e=t;else for(e=new Array(t.length),i=0;ie?r[n++]=[t[i][0]+360,t[i][1]]:i===e?(r[n++]=t[i],r[n++]=[t[i][0],-90]):r[n++]=t[i];var o=a.tester(r);o.pts.pop(),c.push(o)}:function(t){c.push(a.tester(t))},o.type){case"MultiPolygon":for(r=0;r":f.value>h&&(s.prefixBoundary=!0);break;case"<":f.valueh)&&(s.prefixBoundary=!0);break;case"][":a=Math.min.apply(null,f.value),o=Math.max.apply(null,f.value),ah&&(s.prefixBoundary=!0)}}},{}],873:[function(t,e,r){"use strict";var n=t("../../plots/plots"),i=t("../../components/colorbar/draw"),a=t("./make_color_map"),o=t("./end_plus");e.exports=function(t,e){var r=e[0].trace,s="cb"+r.uid;if(t._fullLayout._infolayer.selectAll("."+s).remove(),r.showscale){var l=i(t,s);e[0].t.cb=l;var c=r.contours,u=r.line,f=c.size||1,h=c.coloring,p=a(r,{isColorbar:!0});"heatmap"===h&&l.filllevels({start:r.zmin,end:r.zmax,size:(r.zmax-r.zmin)/254}),l.fillcolor("fill"===h||"heatmap"===h?p:"").line({color:"lines"===h?p:u.color,width:!1!==c.showlines?u.width:0,dash:u.dash}).levels({start:c.start,end:o(c),size:f}).options(r.colorbar)()}else n.autoMargin(t,s)}},{"../../components/colorbar/draw":536,"../../plots/plots":768,"./end_plus":881,"./make_color_map":886}],874:[function(t,e,r){"use strict";e.exports={BOTTOMSTART:[1,9,13,104,713],TOPSTART:[4,6,7,104,713],LEFTSTART:[8,12,14,208,1114],RIGHTSTART:[2,3,11,208,1114],NEWDELTA:[null,[-1,0],[0,-1],[-1,0],[1,0],null,[0,-1],[-1,0],[0,1],[0,1],null,[0,1],[1,0],[1,0],[0,-1]],CHOOSESADDLE:{104:[4,1],208:[2,8],713:[7,13],1114:[11,14]},SADDLEREMAINDER:{1:4,2:8,4:1,7:13,8:2,11:14,13:7,14:11},LABELDISTANCE:2,LABELINCREASE:10,LABELMIN:3,LABELMAX:10,LABELOPTIMIZER:{EDGECOST:1,ANGLECOST:1,NEIGHBORCOST:5,SAMELEVELFACTOR:10,SAMELEVELDISTANCE:5,MAXCOST:100,INITIALSEARCHPOINTS:10,ITERATIONS:5}}},{}],875:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("./label_defaults"),a=t("../../components/color"),o=a.addOpacity,s=a.opacity,l=t("../../constants/filter_ops"),c=l.CONSTRAINT_REDUCTION,u=l.COMPARISON_OPS2;e.exports=function(t,e,r,a,l,f){var h,p,d,g=e.contours,m=r("contours.operation");(g._operation=c[m],function(t,e){var r;-1===u.indexOf(e.operation)?(t("contours.value",[0,1]),Array.isArray(e.value)?e.value.length>2?e.value=e.value.slice(2):0===e.length?e.value=[0,1]:e.length<2?(r=parseFloat(e.value[0]),e.value=[r,r+1]):e.value=[parseFloat(e.value[0]),parseFloat(e.value[1])]:n(e.value)&&(r=parseFloat(e.value),e.value=[r,r+1])):(t("contours.value",0),n(e.value)||(Array.isArray(e.value)?e.value=parseFloat(e.value[0]):e.value=0))}(r,g),"="===m?h=g.showlines=!0:(h=r("contours.showlines"),d=r("fillcolor",o((t.line||{}).color||l,.5))),h)&&(p=r("line.color",d&&s(d)?o(e.fillcolor,1):l),r("line.width",2),r("line.dash"));r("line.smoothing"),i(r,a,p,f)}},{"../../components/color":532,"../../constants/filter_ops":633,"./label_defaults":885,"fast-isnumeric":197}],876:[function(t,e,r){"use strict";var n=t("../../constants/filter_ops"),i=t("fast-isnumeric");function a(t,e){var r,a=Array.isArray(e);function o(t){return i(t)?+t:null}return-1!==n.COMPARISON_OPS2.indexOf(t)?r=o(a?e[0]:e):-1!==n.INTERVAL_OPS.indexOf(t)?r=a?[o(e[0]),o(e[1])]:[o(e),o(e)]:-1!==n.SET_OPS.indexOf(t)&&(r=a?e.map(o):[o(e)]),r}function o(t){return function(e){e=a(t,e);var r=Math.min(e[0],e[1]),n=Math.max(e[0],e[1]);return{start:r,end:n,size:n-r}}}function s(t){return function(e){return{start:e=a(t,e),end:1/0,size:1/0}}}e.exports={"[]":o("[]"),"][":o("]["),">":s(">"),"<":s("<"),"=":s("=")}},{"../../constants/filter_ops":633,"fast-isnumeric":197}],877:[function(t,e,r){"use strict";e.exports=function(t,e,r,n){var i=n("contours.start"),a=n("contours.end"),o=!1===i||!1===a,s=r("contours.size");!(o?e.autocontour=!0:r("autocontour",!1))&&s||r("ncontours")}},{}],878:[function(t,e,r){"use strict";var n=t("../../lib");function i(t){return n.extendFlat({},t,{edgepaths:n.extendDeep([],t.edgepaths),paths:n.extendDeep([],t.paths)})}e.exports=function(t,e){var r,a,o,s=function(t){return t.reverse()},l=function(t){return t};switch(e){case"=":case"<":return t;case">":for(1!==t.length&&n.warn("Contour data invalid for the specified inequality operation."),a=t[0],r=0;r1e3){n.warn("Too many contours, clipping at 1000",t);break}return l}},{"../../lib":660,"./constraint_mapping":876,"./end_plus":881}],881:[function(t,e,r){"use strict";e.exports=function(t){return t.end+t.size/1e6}},{}],882:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./constants");function a(t,e,r,n){return Math.abs(t[0]-e[0])20&&e?208===t||1114===t?n=0===r[0]?1:-1:a=0===r[1]?1:-1:-1!==i.BOTTOMSTART.indexOf(t)?a=1:-1!==i.LEFTSTART.indexOf(t)?n=1:-1!==i.TOPSTART.indexOf(t)?a=-1:n=-1;return[n,a]}(h,r,e),d=[s(t,e,[-p[0],-p[1]])],g=p.join(","),m=t.z.length,v=t.z[0].length;for(c=0;c<1e4;c++){if(h>20?(h=i.CHOOSESADDLE[h][(p[0]||p[1])<0?0:1],t.crossings[f]=i.SADDLEREMAINDER[h]):delete t.crossings[f],!(p=i.NEWDELTA[h])){n.log("Found bad marching index:",h,e,t.level);break}d.push(s(t,e,p)),e[0]+=p[0],e[1]+=p[1],a(d[d.length-1],d[d.length-2],o,l)&&d.pop(),f=e.join(",");var y=p[0]&&(e[0]<0||e[0]>v-2)||p[1]&&(e[1]<0||e[1]>m-2);if(f===u&&p.join(",")===g||r&&y)break;h=t.crossings[f]}1e4===c&&n.log("Infinite loop in contour?");var x,b,_,w,k,M,A,T,S,C,E,L,z,P,D,O=a(d[0],d[d.length-1],o,l),I=0,R=.2*t.smoothing,B=[],F=0;for(c=1;c=F;c--)if((x=B[c])=F&&x+B[b]T&&S--,t.edgepaths[S]=E.concat(d,C));break}U||(t.edgepaths[T]=d.concat(C))}for(T=0;Tt?0:1)+(e[0][1]>t?0:2)+(e[1][1]>t?0:4)+(e[1][0]>t?0:8);return 5===r||10===r?t>(e[0][0]+e[0][1]+e[1][0]+e[1][1])/4?5===r?713:1114:5===r?104:208:15===r?0:r}e.exports=function(t){var e,r,a,o,s,l,c,u,f,h=t[0].z,p=h.length,d=h[0].length,g=2===p||2===d;for(r=0;rt.level}return r?"M"+e.join("L")+"Z":""}(t,e),h=0,p=t.edgepaths.map(function(t,e){return e}),d=!0;function g(t){return Math.abs(t[1]-e[2][1])<.01}function m(t){return Math.abs(t[0]-e[0][0])<.01}function v(t){return Math.abs(t[0]-e[2][0])<.01}for(;p.length;){for(c=a.smoothopen(t.edgepaths[h],t.smoothing),f+=d?c:c.replace(/^M/,"L"),p.splice(p.indexOf(h),1),r=t.edgepaths[h][t.edgepaths[h].length-1],s=-1,o=0;o<4;o++){if(!r){i.log("Missing end?",h,t);break}for(u=r,Math.abs(u[1]-e[0][1])<.01&&!v(r)?n=e[1]:m(r)?n=e[0]:g(r)?n=e[3]:v(r)&&(n=e[2]),l=0;l=0&&(n=y,s=l):Math.abs(r[1]-n[1])<.01?Math.abs(r[1]-y[1])<.01&&(y[0]-r[0])*(n[0]-y[0])>=0&&(n=y,s=l):i.log("endpt to newendpt is not vert. or horz.",r,n,y)}if(r=n,s>=0)break;f+="L"+n}if(s===t.edgepaths.length){i.log("unclosed perimeter path");break}h=s,(d=-1===p.indexOf(h))&&(h=p[0],f+="Z")}for(h=0;hn.center?n.right-s:s-n.left)/(u+Math.abs(Math.sin(c)*o)),p=(l>n.middle?n.bottom-l:l-n.top)/(Math.abs(f)+Math.cos(c)*o);if(h<1||p<1)return 1/0;var d=v.EDGECOST*(1/(h-1)+1/(p-1));d+=v.ANGLECOST*c*c;for(var g=s-u,m=l-f,y=s+u,x=l+f,b=0;b2*v.MAXCOST)break;p&&(s/=2),l=(o=c-s/2)+1.5*s}if(h<=v.MAXCOST)return u},r.addLabelData=function(t,e,r,n){var i=e.width/2,a=e.height/2,o=t.x,s=t.y,l=t.theta,c=Math.sin(l),u=Math.cos(l),f=i*u,h=a*c,p=i*c,d=-a*u,g=[[o-f-h,s-p-d],[o+f-h,s+p-d],[o+f+h,s+p+d],[o-f+h,s-p+d]];r.push({text:e.text,x:o,y:s,dy:e.dy,theta:l,level:e.level,width:e.width,height:e.height}),n.push(g)},r.drawLabels=function(t,e,r,a,s){var l=t.selectAll("text").data(e,function(t){return t.text+","+t.x+","+t.y+","+t.theta});if(l.exit().remove(),l.enter().append("text").attr({"data-notex":1,"text-anchor":"middle"}).each(function(t){var e=t.x+Math.sin(t.theta)*t.dy,i=t.y-Math.cos(t.theta)*t.dy;n.select(this).text(t.text).attr({x:e,y:i,transform:"rotate("+180*t.theta/Math.PI+" "+e+" "+i+")"}).call(o.convertToTspans,r)}),s){for(var c="",u=0;ue.end&&(e.start=e.end=(e.start+e.end)/2),t._input.contours||(t._input.contours={}),i.extendFlat(t._input.contours,{start:e.start,end:e.end,size:e.size}),t._input.autocontour=!0}else if("constraint"!==e.type){var l,c=e.start,u=e.end,f=t._input.contours;if(c>u&&(e.start=f.start=u,u=e.end=f.end=c,c=e.start),!(e.size>0))l=c===u?1:a(c,u,t.ncontours).dtick,f.size=e.size=l}}},{"../../lib":660,"../../plots/cartesian/axes":706}],890:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../components/drawing"),a=t("../heatmap/style"),o=t("./make_color_map");e.exports=function(t){var e=n.select(t).selectAll("g.contour");e.style("opacity",function(t){return t.trace.opacity}),e.each(function(t){var e=n.select(this),r=t.trace,a=r.contours,s=r.line,l=a.size||1,c=a.start,u="constraint"===a.type,f=!u&&"lines"===a.coloring,h=!u&&"fill"===a.coloring,p=f||h?o(r):null;e.selectAll("g.contourlevel").each(function(t){n.select(this).selectAll("path").call(i.lineGroupStyle,s.width,f?p(t.level):s.color,s.dash)});var d=a.labelfont;if(e.selectAll("g.contourlabels text").each(function(t){i.font(n.select(this),{family:d.family,size:d.size,color:d.color||(f?p(t.level):s.color)})}),u)e.selectAll("g.contourfill path").style("fill",r.fillcolor);else if(h){var g;e.selectAll("g.contourfill path").style("fill",function(t){return void 0===g&&(g=t.level),p(t.level+.5*l)}),void 0===g&&(g=c),e.selectAll("g.contourbg path").style("fill",p(g-.5*l))}}),a(t)}},{"../../components/drawing":557,"../heatmap/style":912,"./make_color_map":886,d3:131}],891:[function(t,e,r){"use strict";var n=t("../../components/colorscale/defaults"),i=t("./label_defaults");e.exports=function(t,e,r,a,o){var s,l=r("contours.coloring"),c="";"fill"===l&&(s=r("contours.showlines")),!1!==s&&("lines"!==l&&(c=r("line.color","#000")),r("line.width",.5),r("line.dash")),"none"!==l&&n(t,e,a,r,{prefix:"",cLetter:"z"}),r("line.smoothing"),i(r,a,c,o)}},{"../../components/colorscale/defaults":542,"./label_defaults":885}],892:[function(t,e,r){"use strict";var n=t("../heatmap/attributes"),i=t("../contour/attributes"),a=i.contours,o=t("../scatter/attributes"),s=t("../../components/colorscale/attributes"),l=t("../../components/colorbar/attributes"),c=t("../../lib/extend").extendFlat,u=o.line;e.exports=c({},{carpet:{valType:"string",editType:"calc"},z:n.z,a:n.x,a0:n.x0,da:n.dx,b:n.y,b0:n.y0,db:n.dy,text:n.text,transpose:n.transpose,atype:n.xtype,btype:n.ytype,fillcolor:i.fillcolor,autocontour:i.autocontour,ncontours:i.ncontours,contours:{type:a.type,start:a.start,end:a.end,size:a.size,coloring:{valType:"enumerated",values:["fill","lines","none"],dflt:"fill",editType:"calc"},showlines:a.showlines,showlabels:a.showlabels,labelfont:a.labelfont,labelformat:a.labelformat,operation:a.operation,value:a.value,editType:"calc",impliedEdits:{autocontour:!1}},line:{color:c({},u.color,{}),width:u.width,dash:u.dash,smoothing:c({},u.smoothing,{}),editType:"plot"}},s,{autocolorscale:c({},s.autocolorscale,{dflt:!1})},{colorbar:l})},{"../../components/colorbar/attributes":533,"../../components/colorscale/attributes":538,"../../lib/extend":649,"../contour/attributes":870,"../heatmap/attributes":899,"../scatter/attributes":990}],893:[function(t,e,r){"use strict";var n=t("../../components/colorscale/calc"),i=t("../../lib").isArray1D,a=t("../heatmap/convert_column_xyz"),o=t("../heatmap/clean_2d_array"),s=t("../heatmap/max_row_length"),l=t("../heatmap/interp2d"),c=t("../heatmap/find_empties"),u=t("../heatmap/make_bound_array"),f=t("./defaults"),h=t("../carpet/lookup_carpetid"),p=t("../contour/set_contours");e.exports=function(t,e){var r=e._carpetTrace=h(t,e);if(r&&r.visible&&"legendonly"!==r.visible){if(!e.a||!e.b){var d=t.data[r.index],g=t.data[e.index];g.a||(g.a=d.a),g.b||(g.b=d.b),f(g,e,e._defaultColor,t._fullLayout)}var m=function(t,e){var r,f,h,p,d,g,m,v=e._carpetTrace,y=v.aaxis,x=v.baxis;y._minDtick=0,x._minDtick=0,i(e.z)&&a(e,y,x,"a","b",["z"]);r=e._a=e._a||e.a,p=e._b=e._b||e.b,r=r?y.makeCalcdata(e,"_a"):[],p=p?x.makeCalcdata(e,"_b"):[],f=e.a0||0,h=e.da||1,d=e.b0||0,g=e.db||1,m=e._z=o(e._z||e.z,e.transpose),e._emptypoints=c(m),l(m,e._emptypoints);var b=s(m),_="scaled"===e.xtype?"":r,w=u(e,_,f,h,b,y),k="scaled"===e.ytype?"":p,M=u(e,k,d,g,m.length,x),A={a:w,b:M,z:m};"levels"===e.contours.type&&"none"!==e.contours.coloring&&n(e,m,"","z");return[A]}(0,e);return p(e),m}}},{"../../components/colorscale/calc":539,"../../lib":660,"../carpet/lookup_carpetid":847,"../contour/set_contours":889,"../heatmap/clean_2d_array":901,"../heatmap/convert_column_xyz":903,"../heatmap/find_empties":905,"../heatmap/interp2d":908,"../heatmap/make_bound_array":909,"../heatmap/max_row_length":910,"./defaults":894}],894:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../heatmap/xyz_defaults"),a=t("./attributes"),o=t("../contour/constraint_defaults"),s=t("../contour/contours_defaults"),l=t("../contour/style_defaults");e.exports=function(t,e,r,c){function u(r,i){return n.coerce(t,e,a,r,i)}if(u("carpet"),t.a&&t.b){if(!i(t,e,u,c,"a","b"))return void(e.visible=!1);u("text");var f="constraint"===u("contours.type");f||delete e.showlegend,f?o(t,e,u,c,r,{hasHover:!1}):(s(t,e,u,function(r){return n.coerce2(t,e,a,r)}),l(t,e,u,c,{hasHover:!1}))}else e._defaultColor=r,e._length=null}},{"../../lib":660,"../contour/constraint_defaults":875,"../contour/contours_defaults":877,"../contour/style_defaults":891,"../heatmap/xyz_defaults":914,"./attributes":892}],895:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../contour/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../contour/style"),n.moduleType="trace",n.name="contourcarpet",n.basePlotModule=t("../../plots/cartesian"),n.categories=["cartesian","svg","carpet","contour","symbols","showLegend","hasLines","carpetDependent"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"../contour/colorbar":873,"../contour/style":890,"./attributes":892,"./calc":893,"./defaults":894,"./plot":898}],896:[function(t,e,r){"use strict";var n=t("../../components/drawing"),i=t("../carpet/axis_aligned_line"),a=t("../../lib");e.exports=function(t,e,r,o,s,l,c,u){var f,h,p,d,g,m,v,y="",x=e.edgepaths.map(function(t,e){return e}),b=!0,_=1e-4*Math.abs(r[0][0]-r[2][0]),w=1e-4*Math.abs(r[0][1]-r[2][1]);function k(t){return Math.abs(t[1]-r[0][1])=0&&(p=E,g=m):Math.abs(h[1]-p[1])=0&&(p=E,g=m):a.log("endpt to newendpt is not vert. or horz.",h,p,E)}if(g>=0)break;y+=S(h,p),h=p}if(g===e.edgepaths.length){a.log("unclosed perimeter path");break}f=g,(b=-1===x.indexOf(f))&&(f=x[0],y+=S(h,p)+"Z",h=null)}for(f=0;f=0;q--)j=M.clipsegments[q],V=i([],j.x,E.c2p),U=i([],j.y,L.c2p),V.reverse(),U.reverse(),G.push(a(V,U,j.bicubic));var W="M"+G.join("L")+"Z";!function(t,e,r,n,o,l){var c,u,f,h,p=s.ensureSingle(t,"g","contourbg").selectAll("path").data("fill"!==l||o?[]:[0]);p.enter().append("path"),p.exit().remove();var d=[];for(h=0;hm&&(n.max=m);n.len=n.max-n.min}(this,r,t,n,c,e.height),!(n.len<(e.width+e.height)*h.LABELMIN)))for(var i=Math.min(Math.ceil(n.len/P),h.LABELMAX),a=0;az){E("x scale is not linear");break}}if(m.length&&"fast"===S){var P=(m[m.length-1]-m[0])/(m.length-1),D=Math.abs(P/100);for(b=0;bD){E("y scale is not linear");break}}}var O=c(x),I="scaled"===e.xtype?"":r,R=p(e,I,d,g,O,w),B="scaled"===e.ytype?"":m,F=p(e,B,v,y,x.length,k);T||(a.expand(w,R),a.expand(k,F));var N={x:R,y:F,z:x,text:e._text||e.text};if(I&&I.length===R.length-1&&(N.xCenter=I),B&&B.length===F.length-1&&(N.yCenter=B),A&&(N.xRanges=_.xRanges,N.yRanges=_.yRanges,N.pts=_.pts),M&&"constraint"===e.contours.type||s(e,x,"","z"),M&&e.contours&&"heatmap"===e.contours.coloring){var j={type:"contour"===e.type?"heatmap":"histogram2d",xcalendar:e.xcalendar,ycalendar:e.ycalendar};N.xfill=p(j,I,d,g,O,w),N.yfill=p(j,B,v,y,x.length,k)}return[N]}},{"../../components/colorscale/calc":539,"../../lib":660,"../../plots/cartesian/axes":706,"../../registry":790,"../histogram2d/calc":931,"./clean_2d_array":901,"./convert_column_xyz":903,"./find_empties":905,"./interp2d":908,"./make_bound_array":909,"./max_row_length":910}],901:[function(t,e,r){"use strict";var n=t("fast-isnumeric");e.exports=function(t,e){var r,i,a,o,s,l;function c(t){if(n(t))return+t}if(e){for(r=0,s=0;s=0;o--)(s=((f[[(r=(a=h[o])[0])-1,i=a[1]]]||g)[2]+(f[[r+1,i]]||g)[2]+(f[[r,i-1]]||g)[2]+(f[[r,i+1]]||g)[2])/20)&&(l[a]=[r,i,s],h.splice(o,1),c=!0);if(!c)throw"findEmpties iterated with no new neighbors";for(a in l)f[a]=l[a],u.push(l[a])}return u.sort(function(t,e){return e[2]-t[2]})}},{"./max_row_length":910}],906:[function(t,e,r){"use strict";var n=t("../../components/fx"),i=t("../../lib"),a=t("../../plots/cartesian/axes");e.exports=function(t,e,r,o,s,l){var c,u,f,h,p=t.cd[0],d=p.trace,g=t.xa,m=t.ya,v=p.x,y=p.y,x=p.z,b=p.xCenter,_=p.yCenter,w=p.zmask,k=[d.zmin,d.zmax],M=d.zhoverformat,A=v,T=y;if(!1!==t.index){try{f=Math.round(t.index[1]),h=Math.round(t.index[0])}catch(e){return void i.error("Error hovering on heatmap, pointNumber must be [row,col], found:",t.index)}if(f<0||f>=x[0].length||h<0||h>x.length)return}else{if(n.inbox(e-v[0],e-v[v.length-1],0)>0||n.inbox(r-y[0],r-y[y.length-1],0)>0)return;if(l){var S;for(A=[2*v[0]-v[1]],S=1;Sg&&(v=Math.max(v,Math.abs(t[a][o]-d)/(m-g))))}return v}e.exports=function(t,e){var r,i=1;for(o(t,e),r=0;r.01;r++)i=o(t,e,a(i));return i>.01&&n.log("interp2d didn't converge quickly",i),t}},{"../../lib":660}],909:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib").isArrayOrTypedArray;e.exports=function(t,e,r,a,o,s){var l,c,u,f=[],h=n.traceIs(t,"contour"),p=n.traceIs(t,"histogram"),d=n.traceIs(t,"gl2d");if(i(e)&&e.length>1&&!p&&"category"!==s.type){var g=e.length;if(!(g<=o))return h?e.slice(0,o):e.slice(0,o+1);if(h||d)f=e.slice(0,o);else if(1===o)f=[e[0]-.5,e[0]+.5];else{for(f=[1.5*e[0]-.5*e[1]],u=1;u0;)f=_.c2p(A[y]),y--;for(f0;)v=w.c2p(T[y]),y--;if(v image").each(function(t){var e=t.trace||{};a[e.uid]||n.select(this.parentNode).remove()});for(var o=0;o0&&(a=!0);for(var l=0;la){var o=a-r[t];return r[t]=a,o}}return 0},max:function(t,e,r,i){var a=i[e];if(n(a)){if(a=Number(a),!n(r[t]))return r[t]=a,a;if(r[t]c?t>o?t>1.1*i?i:t>1.1*a?a:o:t>s?s:t>l?l:c:Math.pow(10,Math.floor(Math.log(t)/Math.LN10))}function p(t,e,r,n,a,s){if(n&&t>o){var l=d(e,a,s),c=d(r,a,s),u=t===i?0:1;return l[u]!==c[u]}return Math.floor(r/t)-Math.floor(e/t)>.1}function d(t,e,r){var n=e.c2d(t,i,r).split("-");return""===n[0]&&(n.unshift(),n[0]="-"+n[0]),n}e.exports=function(t,e,r,n,a){var s,l,c=-1.1*e,h=-.1*e,p=t-h,d=r[0],g=r[1],m=Math.min(f(d+h,d+p,n,a),f(g+h,g+p,n,a)),v=Math.min(f(d+c,d+h,n,a),f(g+c,g+h,n,a));if(m>v&&vo){var y=s===i?1:6,x=s===i?"M12":"M1";return function(e,r){var o=n.c2d(e,i,a),s=o.indexOf("-",y);s>0&&(o=o.substr(0,s));var c=n.d2c(o,0,a);if(cu.size/1.9?u.size:u.size/Math.ceil(u.size/x);var A=u.start+(u.size-x)/2;b=A-x*Math.ceil((A-b)/x)}for(s=0;s=0&&w=0;n--)s(n);else if("increasing"===e){for(n=1;n=0;n--)t[n]+=t[n+1];"exclude"===r&&(t.push(0),t.shift())}}(d,x.direction,x.currentbin);var Z=Math.min(f.length,d.length),J=[],K=0,Q=Z-1;for(r=0;r=K;r--)if(d[r]){Q=r;break}for(r=K;r<=Q;r++)if(n(f[r])&&n(d[r])){var $={p:f[r],s:d[r],b:0};x.enabled||($.pts=z[r],H?$.p0=$.p1=z[r].length?A[z[r][0]]:f[r]:($.p0=U(S[r]),$.p1=U(S[r+1],!0))),J.push($)}return 1===J.length&&(J[0].width1=a.tickIncrement(J[0].p,M.size,!1,y)-J[0].p),o(J,e),i.isArrayOrTypedArray(e.selectedpoints)&&i.tagSelected(J,e,Y),J}}},{"../../constants/numerical":637,"../../lib":660,"../../plots/cartesian/axes":706,"../bar/arrays_to_calcdata":799,"./average":919,"./bin_functions":921,"./bin_label_vals":922,"./clean_bins":924,"./norm_functions":929,"fast-isnumeric":197}],924:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib").cleanDate,a=t("../../constants/numerical"),o=a.ONEDAY,s=a.BADNUM;e.exports=function(t,e,r){var a=e.type,l=r+"bins",c=t[l];c||(c=t[l]={});var u="date"===a?function(t){return t||0===t?i(t,s,c.calendar):null}:function(t){return n(t)?Number(t):null};c.start=u(c.start),c.end=u(c.end);var f="date"===a?o:1,h=c.size;if(n(h))c.size=h>0?Number(h):f;else if("string"!=typeof h)c.size=f;else{var p=h.charAt(0),d=h.substr(1);((d=n(d)?Number(d):0)<=0||"date"!==a||"M"!==p||d!==Math.round(d))&&(c.size=f)}var g="autobin"+r;"boolean"!=typeof t[g]&&(t[g]=t._fullInput[g]=t._input[g]=!((c.start||0===c.start)&&(c.end||0===c.end))),t[g]||(delete t["nbins"+r],delete t._fullInput["nbins"+r])}},{"../../constants/numerical":637,"../../lib":660,"fast-isnumeric":197}],925:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("../../components/color"),o=t("./bin_defaults"),s=t("../bar/style_defaults"),l=t("./attributes");e.exports=function(t,e,r,c){function u(r,n){return i.coerce(t,e,l,r,n)}var f=u("x"),h=u("y");u("cumulative.enabled")&&(u("cumulative.direction"),u("cumulative.currentbin")),u("text");var p=u("orientation",h&&!f?"h":"v"),d="v"===p?"x":"y",g="v"===p?"y":"x",m=f&&h?Math.min(f.length&&h.length):(e[d]||[]).length;if(m){e._length=m,n.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x","y"],c),e[g]&&u("histfunc"),o(t,e,u,[d]),s(t,e,u,r,c);var v=n.getComponentMethod("errorbars","supplyDefaults");v(t,e,a.defaultLine,{axis:"y"}),v(t,e,a.defaultLine,{axis:"x",inherit:"y"}),i.coerceSelectionMarkerOpacity(e,u)}else e.visible=!1}},{"../../components/color":532,"../../lib":660,"../../registry":790,"../bar/style_defaults":812,"./attributes":918,"./bin_defaults":920}],926:[function(t,e,r){"use strict";e.exports=function(t,e,r,n,i){if(t.x="xVal"in e?e.xVal:e.x,t.y="yVal"in e?e.yVal:e.y,e.xa&&(t.xaxis=e.xa),e.ya&&(t.yaxis=e.ya),!(r.cumulative||{}).enabled){var a,o=Array.isArray(i)?n[0].pts[i[0]][i[1]]:n[i].pts;if(t.pointNumbers=o,t.binNumber=t.pointNumber,delete t.pointNumber,delete t.pointIndex,r._indexToPoints){a=[];for(var s=0;sA&&m.splice(A,m.length-A),y.length>A&&y.splice(A,y.length-A),u(e,"x",m,g,_,k,x),u(e,"y",y,v,w,M,b);var T=[],S=[],C=[],E="string"==typeof e.xbins.size,L="string"==typeof e.ybins.size,z=[],P=[],D=E?z:e.xbins,O=L?P:e.ybins,I=0,R=[],B=[],F=e.histnorm,N=e.histfunc,j=-1!==F.indexOf("density"),V="max"===N||"min"===N?null:0,U=a.count,q=o[F],H=!1,G=[],W=[],Y="z"in e?e.z:"marker"in e&&Array.isArray(e.marker.color)?e.marker.color:"";Y&&"count"!==N&&(H="avg"===N,U=a[N]);var X=e.xbins,Z=_(X.start),J=_(X.end)+(Z-i.tickIncrement(Z,X.size,!1,x))/1e6;for(r=Z;r=0&&c=0&&d0)c=a(t.alphahull,u);else{var p=["x","y","z"].indexOf(t.delaunayaxis);c=i(u.map(function(t){return[t[(p+1)%3],t[(p+2)%3]]}))}var d={positions:u,cells:c,lightPosition:[t.lightposition.x,t.lightposition.y,t.lightposition.z],ambient:t.lighting.ambient,diffuse:t.lighting.diffuse,specular:t.lighting.specular,roughness:t.lighting.roughness,fresnel:t.lighting.fresnel,vertexNormalsEpsilon:t.lighting.vertexnormalsepsilon,faceNormalsEpsilon:t.lighting.facenormalsepsilon,opacity:t.opacity,contourEnable:t.contour.show,contourColor:l(t.contour.color).slice(0,3),contourWidth:t.contour.width,useFacetNormals:t.flatshading};t.intensity?(this.color="#fff",d.vertexIntensity=t.intensity,d.vertexIntensityBounds=[t.cmin,t.cmax],d.colormap=s(t.colorscale)):t.vertexcolor?(this.color=t.vertexcolor[0],d.vertexColors=f(t.vertexcolor)):t.facecolor?(this.color=t.facecolor[0],d.cellColors=f(t.facecolor)):(this.color=t.color,d.meshColor=l(t.color)),this.mesh.update(d)},u.dispose=function(){this.scene.glplot.remove(this.mesh),this.mesh.dispose()},e.exports=function(t,e){var r=t.glplot.gl,i=n({gl:r}),a=new c(t,i,e.uid);return i._trace=a,a.update(e),t.glplot.add(i),a}},{"../../lib/gl_format_color":656,"../../lib/str2rgbarray":683,"alpha-shape":49,"convex-hull":111,"delaunay-triangulate":133,"gl-mesh3d":249}],943:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../lib"),a=t("../../components/colorscale/defaults"),o=t("./attributes");e.exports=function(t,e,r,s){function l(r,n){return i.coerce(t,e,o,r,n)}function c(t){var e=t.map(function(t){var e=l(t);return e&&i.isArrayOrTypedArray(e)?e:null});return e.every(function(t){return t&&t.length===e[0].length})&&e}var u=c(["x","y","z"]),f=c(["i","j","k"]);u?(f&&f.forEach(function(t){for(var e=0;ed):p=_>y,d=_;var w=s(y,x,b,_);w.pos=v,w.yc=(y+_)/2,w.i=m,w.dir=p?"increasing":"decreasing",h&&(w.tx=e.text[m]),g.push(w)}}return a.expand(n,u.concat(c),{padded:!0}),g.length&&(g[0].t={labels:{open:i(t,"open:")+" ",high:i(t,"high:")+" ",low:i(t,"low:")+" ",close:i(t,"close:")+" "}}),g}e.exports={calc:function(t,e){var r=a.getFromId(t,e.xaxis),i=a.getFromId(t,e.yaxis),o=function(t,e,r){var i=r._minDiff;if(!i){var a,o=t._fullData,s=[];for(i=1/0,a=0;a"),t.y0=t.y1=f.c2p(C.yc,!0),[t]}},{"../../components/color":532,"../../components/fx":574,"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998}],949:[function(t,e,r){"use strict";e.exports={moduleType:"trace",name:"ohlc",basePlotModule:t("../../plots/cartesian"),categories:["cartesian","svg","showLegend"],meta:{},attributes:t("./attributes"),supplyDefaults:t("./defaults"),calc:t("./calc").calc,plot:t("./plot"),style:t("./style"),hoverPoints:t("./hover"),selectPoints:t("./select")}},{"../../plots/cartesian":717,"./attributes":945,"./calc":946,"./defaults":947,"./hover":948,"./plot":951,"./select":952,"./style":953}],950:[function(t,e,r){"use strict";var n=t("../../registry");e.exports=function(t,e,r,i){var a=r("x"),o=r("open"),s=r("high"),l=r("low"),c=r("close");if(n.getComponentMethod("calendars","handleTraceDefaults")(t,e,["x"],i),o&&s&&l&&c){var u=Math.min(o.length,s.length,l.length,c.length);return a&&(u=Math.min(u,a.length)),e._length=u,u}}},{"../../registry":790}],951:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib");e.exports=function(t,e,r,a){var o=e.xaxis,s=e.yaxis,l=a.selectAll("g.trace").data(r,function(t){return t[0].trace.uid});l.enter().append("g").attr("class","trace ohlc"),l.exit().remove(),l.order(),l.each(function(t){var r=t[0],a=r.t,l=r.trace,c=n.select(this);if(e.isRangePlot||(r.node3=c),!0!==l.visible||a.empty)c.remove();else{var u=a.tickLen,f=c.selectAll("path").data(i.identity);f.enter().append("path"),f.exit().remove(),f.attr("d",function(t){var e=o.c2p(t.pos,!0),r=o.c2p(t.pos-u,!0),n=o.c2p(t.pos+u,!0);return"M"+r+","+s.c2p(t.o,!0)+"H"+e+"M"+e+","+s.c2p(t.h,!0)+"V"+s.c2p(t.l,!0)+"M"+n+","+s.c2p(t.c,!0)+"H"+e})}})}},{"../../lib":660,d3:131}],952:[function(t,e,r){"use strict";e.exports=function(t,e){var r,n=t.cd,i=t.xaxis,a=t.yaxis,o=[],s=n[0].t.bPos||0;if(!1===e)for(r=0;r=0;a--){var o=t[a];if(e>f(n,o))return c(n,i);if(e>o||a===t.length-1)return c(o,n);i=n,n=o}}function d(t,e){for(var r=0;r=e[r][0]&&t<=e[r][1])return!0;return!1}function g(t){t.attr("x",-n.bar.captureWidth/2).attr("width",n.bar.captureWidth)}function m(t){t.attr("visibility","visible").style("visibility","visible").attr("fill","yellow").attr("opacity",0)}function v(t){if(!t.brush.filterSpecified)return"0,"+t.height;for(var e,r,n,i=y(t.brush.filter.getConsolidated(),t.height),a=[0],o=i.length?i[0][0]:null,s=0;se){h=r;break}}if(a=u,isNaN(a)&&(a=isNaN(f)||isNaN(h)?isNaN(f)?h:f:e-c[f][1]t[1]+r||e=.9*t[1]+.1*t[0]?"n":e<=.9*t[0]+.1*t[1]?"s":"ns"}(d,e);g&&(o.interval=l[a],o.intervalPix=d,o.region=g)}}if(t.ordinal&&!o.region){var m=t.unitTickvals,v=t.unitToPaddedPx.invert(e);for(r=0;r=x[0]&&v<=x[1]){o.clickableOrdinalRange=x;break}}}return o}function k(t){t.on("mousemove",function(t){if(i.event.preventDefault(),!t.parent.inBrushDrag){var e=w(t,t.height-i.mouse(this)[1]-2*n.verticalPadding),r="crosshair";e.clickableOrdinalRange?r="pointer":e.region&&(r=e.region+"-resize"),i.select(document.body).style("cursor",r)}}).on("mouseleave",function(t){t.parent.inBrushDrag||x()}).call(i.behavior.drag().on("dragstart",function(t){i.event.sourceEvent.stopPropagation();var e=t.height-i.mouse(this)[1]-2*n.verticalPadding,r=t.unitToPaddedPx.invert(e),a=t.brush,o=w(t,e),s=o.interval,l=a.svgBrush;if(l.wasDragged=!1,l.grabbingBar="ns"===o.region,l.grabbingBar){var c=s.map(t.unitToPaddedPx);l.grabPoint=e-c[0]-n.verticalPadding,l.barLength=c[1]-c[0]}l.clickableOrdinalRange=o.clickableOrdinalRange,l.stayingIntervals=t.multiselect&&a.filterSpecified?a.filter.getConsolidated():[],s&&(l.stayingIntervals=l.stayingIntervals.filter(function(t){return t[0]!==s[0]&&t[1]!==s[1]})),l.startExtent=o.region?s["s"===o.region?1:0]:r,t.parent.inBrushDrag=!0,l.brushStartCallback()}).on("drag",function(t){i.event.sourceEvent.stopPropagation();var e=t.height-i.mouse(this)[1]-2*n.verticalPadding,r=t.brush.svgBrush;r.wasDragged=!0,r.grabbingBar?r.newExtent=[e-r.grabPoint,e+r.barLength-r.grabPoint].map(t.unitToPaddedPx.invert):r.newExtent=[r.startExtent,t.unitToPaddedPx.invert(e)].sort(s);var a=Math.max(0,-r.newExtent[0]),o=Math.max(0,r.newExtent[1]-1);r.newExtent[0]+=a,r.newExtent[1]-=o,r.grabbingBar&&(r.newExtent[1]+=a,r.newExtent[0]-=o),t.brush.filterSpecified=!0,r.extent=r.stayingIntervals.concat([r.newExtent]),r.brushCallback(t),_(this.parentNode)}).on("dragend",function(t){i.event.sourceEvent.stopPropagation();var e=t.brush,r=e.filter,n=e.svgBrush,a=n.grabbingBar;if(n.grabbingBar=!1,n.grabLocation=void 0,t.parent.inBrushDrag=!1,x(),!n.wasDragged)return n.wasDragged=void 0,n.clickableOrdinalRange?e.filterSpecified&&t.multiselect?n.extent.push(n.clickableOrdinalRange):(n.extent=[n.clickableOrdinalRange],e.filterSpecified=!0):a?(n.extent=n.stayingIntervals,0===n.extent.length&&A(e)):A(e),n.brushCallback(t),_(this.parentNode),void n.brushEndCallback(e.filterSpecified?r.getConsolidated():[]);var o=function(){r.set(r.getConsolidated())};if(t.ordinal){var s=t.unitTickvals;s[s.length-1]n.newExtent[0];n.extent=n.stayingIntervals.concat(l?[n.newExtent]:[]),n.extent.length||A(e),n.brushCallback(t),l?_(this.parentNode,o):(o(),_(this.parentNode))}else o();n.brushEndCallback(e.filterSpecified?r.getConsolidated():[])}))}function M(t,e){return t[0]-e[0]}function A(t){t.filterSpecified=!1,t.svgBrush.extent=[[0,1]]}function T(t){for(var e,r=t.slice(),n=[],i=r.shift();i;){for(e=i.slice();(i=r.shift())&&i[0]<=e[1];)e[1]=Math.max(e[1],i[1]);n.push(e)}return n}e.exports={makeBrush:function(t,e,r,n,i,a){var o,l=function(){var t,e,r=[];return{set:function(n){r=n.map(function(t){return t.slice().sort(s)}).sort(M),t=T(r),e=r.reduce(function(t,e){return[Math.min(t[0],e[0]),Math.max(t[1],e[1])]},[1/0,-1/0])},get:function(){return r.slice()},getConsolidated:function(){return t},getBounds:function(){return e}}}();return l.set(r),{filter:l,filterSpecified:e,svgBrush:{extent:[],brushStartCallback:n,brushCallback:(o=i,function(t){var e=t.brush,r=function(t){return t.svgBrush.extent.map(function(t){return t.slice()})}(e).slice();e.filter.set(r),o()}),brushEndCallback:a}}},ensureAxisBrush:function(t){var e=t.selectAll("."+n.cn.axisBrush).data(o,a);e.enter().append("g").classed(n.cn.axisBrush,!0),function(t){var e=t.selectAll(".background").data(o);e.enter().append("rect").classed("background",!0).call(g).call(m).style("pointer-events","auto").attr("transform","translate(0 "+n.verticalPadding+")"),e.call(k).attr("height",function(t){return t.height-n.verticalPadding});var r=t.selectAll(".highlight-shadow").data(o);r.enter().append("line").classed("highlight-shadow",!0).attr("x",-n.bar.width/2).attr("stroke-width",n.bar.width+n.bar.strokeWidth).attr("stroke",n.bar.strokeColor).attr("opacity",n.bar.strokeOpacity).attr("stroke-linecap","butt"),r.attr("y1",function(t){return t.height}).call(b);var i=t.selectAll(".highlight").data(o);i.enter().append("line").classed("highlight",!0).attr("x",-n.bar.width/2).attr("stroke-width",n.bar.width-n.bar.strokeWidth).attr("stroke",n.bar.fillColor).attr("opacity",n.bar.fillOpacity).attr("stroke-linecap","butt"),i.attr("y1",function(t){return t.height}).call(b)}(e)},cleanRanges:function(t,e){if(Array.isArray(t[0])?(t=t.map(function(t){return t.sort(s)}),t=e.multiselect?T(t.sort(M)):[t[0]]):t=[t.sort(s)],e.tickvals){var r=e.tickvals.slice().sort(s);if(!(t=t.map(function(t){var e=[h(r,t[0],[]),p(r,t[1],[])];if(e[1]>e[0])return e}).filter(function(t){return t})).length)return}return t.length>1?t:t[0]}}},{"../../lib":660,"../../lib/gup":657,"./constants":959,d3:131}],956:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../plots/get_data").getModuleCalcData,a=t("./plot"),o=t("../../constants/xmlns_namespaces");r.name="parcoords",r.plot=function(t){var e=i(t.calcdata,"parcoords")[0];e.length&&a(t,e)},r.clean=function(t,e,r,n){var i=n._has&&n._has("parcoords"),a=e._has&&e._has("parcoords");i&&!a&&(n._paperdiv.selectAll(".parcoords").remove(),n._glimages.selectAll("*").remove())},r.toSVG=function(t){var e=t._fullLayout._glimages,r=n.select(t).selectAll(".svg-container");r.filter(function(t,e){return e===r.size()-1}).selectAll(".gl-canvas-context, .gl-canvas-focus").each(function(){var t=this.toDataURL("image/png");e.append("svg:image").attr({xmlns:o.svg,"xlink:href":t,preserveAspectRatio:"none",x:0,y:0,width:this.width,height:this.height})}),window.setTimeout(function(){n.selectAll("#filterBarPattern").attr("id","filterBarPattern")},60)}},{"../../constants/xmlns_namespaces":639,"../../plots/get_data":742,"./plot":964,d3:131}],957:[function(t,e,r){"use strict";var n=t("../../components/colorscale/has_colorscale"),i=t("../../components/colorscale/calc"),a=t("../../lib"),o=t("../../lib/gup").wrap;e.exports=function(t,e){var r=!!e.line.colorscale&&a.isArrayOrTypedArray(e.line.color),s=r?e.line.color:function(t){for(var e=new Array(t),r=0;rs&&(n.log("parcoords traces support up to "+s+" dimensions at the moment"),l.splice(s)),o=0;o>>8*e)%256/255}function M(t,e,r){var n,i,a,o=[];for(i=0;i=h-4?k(o,h-2-s):.5);return a}(d,p,i);!function(t,e,r){for(var n=0;n<16;n++)t["p"+n.toString(16)](M(e,r,n))}(E,d,o),L=S.texture(l.extendFlat({data:function(t,e,r){for(var n=[],i=0;i<256;i++){var a=t(i/255);n.push((e?v:a).concat(r))}return n}(r.unitToColor,A,Math.round(255*(A?a:1)))},b))}var D=[0,1];var O=[];function I(t,e,n,i,a,o,s,c,u,f,h){var p,d,g,m,v=[t,e],y=[0,1].map(function(){return[0,1,2,3].map(function(){return new Float32Array(16)})});for(p=0;p<2;p++)for(m=v[p],d=0;d<4;d++)for(g=0;g<16;g++)y[p][d][g]=g+16*d===m?1:0;var x=r.lines.canvasOverdrag,b=r.domain,_=r.canvasWidth,w=r.canvasHeight;return l.extendFlat({key:s,resolution:[_,w],viewBoxPosition:[n+x,i],viewBoxSize:[a,o],i:t,ii:e,dim1A:y[0][0],dim1B:y[0][1],dim1C:y[0][2],dim1D:y[0][3],dim2A:y[1][0],dim2B:y[1][1],dim2C:y[1][2],dim2D:y[1][3],colorClamp:D,scissorX:(c===u?0:n+x)+(r.pad.l-x)+r.layoutWidth*b.x[0],scissorWidth:(c===f?_-n+x:a+.5)+(c===u?n+x:0),scissorY:i+r.pad.b+r.layoutHeight*b.y[0],scissorHeight:o,viewportX:r.pad.l-x+r.layoutWidth*b.x[0],viewportY:r.pad.b+r.layoutHeight*b.y[0],viewportWidth:_,viewportHeight:w},h)}return{setColorDomain:function(t){D[0]=t[0],D[1]=t[1]},render:function(t,e,n){var i,a,o,s=t.length,l=1/0,c=-1/0;for(i=0;ic&&(c=t[i].dim2.canvasX,o=i),t[i].dim1.canvasXn._length&&(M=M.slice(0,n._length));var A,T=n.tickvals;function S(t,e){return{val:t,text:A[e]}}function C(t,e){return t.val-e.val}if(Array.isArray(T)&&T.length){A=n.ticktext,Array.isArray(A)&&A.length?A.length>T.length?A=A.slice(0,T.length):T.length>A.length&&(T=T.slice(0,A.length)):A=T.map(o.format(n.tickformat));for(var E=1;E=r||s>=n)return;var l=t.lineLayer.readPixel(a,n-1-s),c=0!==l[3],u=c?l[2]+256*(l[1]+256*l[0]):null,f={x:a,y:s,clientX:e.clientX,clientY:e.clientY,dataIndex:t.model.key,curveNumber:u};u!==M&&(c?d.hover(f):d.unhover&&d.unhover(f),M=u)}}),k.style("opacity",function(t){return t.pick?.01:1}),e.style("background","rgba(255, 255, 255, 0)");var A=e.selectAll("."+i.cn.parcoords).data(w,c);A.exit().remove(),A.enter().append("g").classed(i.cn.parcoords,!0).style("shape-rendering","crispEdges").style("pointer-events","none"),A.attr("transform",function(t){return"translate("+t.model.translateX+","+t.model.translateY+")"});var T=A.selectAll("."+i.cn.parcoordsControlView).data(u,c);T.enter().append("g").classed(i.cn.parcoordsControlView,!0),T.attr("transform",function(t){return"translate("+t.model.pad.l+","+t.model.pad.t+")"});var S=T.selectAll("."+i.cn.yAxis).data(function(t){return t.dimensions},c);function C(t,e){for(var r=e.panels||(e.panels=[]),n=t.data(),i=n.length-1,a=0;aline").attr("fill","none").attr("stroke","black").attr("stroke-opacity",.25).attr("stroke-width","1px"),L.selectAll("text").style("text-shadow","1px 1px 1px #fff, -1px -1px 1px #fff, 1px -1px 1px #fff, -1px 1px 1px #fff").style("cursor","default").style("user-select","none");var z=E.selectAll("."+i.cn.axisHeading).data(u,c);z.enter().append("g").classed(i.cn.axisHeading,!0);var P=z.selectAll("."+i.cn.axisTitle).data(u,c);P.enter().append("text").classed(i.cn.axisTitle,!0).attr("text-anchor","middle").style("cursor","ew-resize").style("user-select","none").style("pointer-events","auto"),P.attr("transform","translate(0,"+-i.axisTitleOffset+")").text(function(t){return t.label}).each(function(t){s.font(o.select(this),t.model.labelFont)});var D=E.selectAll("."+i.cn.axisExtent).data(u,c);D.enter().append("g").classed(i.cn.axisExtent,!0);var O=D.selectAll("."+i.cn.axisExtentTop).data(u,c);O.enter().append("g").classed(i.cn.axisExtentTop,!0),O.attr("transform","translate(0,"+-i.axisExtentOffset+")");var I=O.selectAll("."+i.cn.axisExtentTopText).data(u,c);function R(t,e){if(t.ordinal)return"";var r=t.domainScale.domain();return o.format(t.tickFormat)(r[e?r.length-1:0])}I.enter().append("text").classed(i.cn.axisExtentTopText,!0).call(y),I.text(function(t){return R(t,!0)}).each(function(t){s.font(o.select(this),t.model.rangeFont)});var B=D.selectAll("."+i.cn.axisExtentBottom).data(u,c);B.enter().append("g").classed(i.cn.axisExtentBottom,!0),B.attr("transform",function(t){return"translate(0,"+(t.model.height+i.axisExtentOffset)+")"});var F=B.selectAll("."+i.cn.axisExtentBottomText).data(u,c);F.enter().append("text").classed(i.cn.axisExtentBottomText,!0).attr("dy","0.75em").call(y),F.text(function(t){return R(t)}).each(function(t){s.font(o.select(this),t.model.rangeFont)}),h.ensureAxisBrush(E)}},{"../../components/drawing":557,"../../lib":660,"../../lib/gup":657,"./axisbrush":955,"./constants":959,"./lines":962,d3:131}],964:[function(t,e,r){"use strict";var n=t("./parcoords"),i=t("../../lib/prepare_regl");e.exports=function(t,e){var r=t._fullLayout,a=r._toppaper,o=r._paperdiv,s=r._glcontainer;i(t);var l={},c={},u=r._size;e.forEach(function(e,r){l[r]=t.data[r].dimensions,c[r]=t.data[r].dimensions.slice()});n(o,a,s,e,{width:u.w,height:u.h,margin:{t:u.t,r:u.r,b:u.b,l:u.l}},{filterChanged:function(e,r,n){var i=c[e][r],a=n.map(function(t){return t.slice()});a.length?(1===a.length&&(a=a[0]),i.constraintrange=a,a=[a]):(delete i.constraintrange,a=null);var o={};o["dimensions["+r+"].constraintrange"]=a,t.emit("plotly_restyle",[o,[e]])},hover:function(e){t.emit("plotly_hover",e)},unhover:function(e){t.emit("plotly_unhover",e)},axesMoved:function(e,r){function n(t){return!("visible"in t)||t.visible}function i(t,e,r){var n=e.indexOf(r),i=t.indexOf(n);return-1===i&&(i+=e.length),i}var a=function(t){return function(e,n){return i(r,t,e)-i(r,t,n)}}(c[e].filter(n));l[e].sort(a),c[e].filter(function(t){return!n(t)}).sort(function(t){return c[e].indexOf(t)}).forEach(function(t){l[e].splice(l[e].indexOf(t),1),l[e].splice(c[e].indexOf(t),0,t)}),t.emit("plotly_restyle")}})}},{"../../lib/prepare_regl":673,"./parcoords":963}],965:[function(t,e,r){"use strict";var n=t("../../components/color/attributes"),i=t("../../plots/font_attributes"),a=t("../../plots/attributes"),o=t("../../plots/domain").attributes,s=t("../../lib/extend").extendFlat,l=i({editType:"calc",colorEditType:"style"});e.exports={labels:{valType:"data_array",editType:"calc"},label0:{valType:"number",dflt:0,editType:"calc"},dlabel:{valType:"number",dflt:1,editType:"calc"},values:{valType:"data_array",editType:"calc"},marker:{colors:{valType:"data_array",editType:"calc"},line:{color:{valType:"color",dflt:n.defaultLine,arrayOk:!0,editType:"style"},width:{valType:"number",min:0,dflt:0,arrayOk:!0,editType:"style"},editType:"calc"},editType:"calc"},text:{valType:"data_array",editType:"calc"},hovertext:{valType:"string",dflt:"",arrayOk:!0,editType:"style"},scalegroup:{valType:"string",dflt:"",editType:"calc"},textinfo:{valType:"flaglist",flags:["label","text","value","percent"],extras:["none"],editType:"calc"},hoverinfo:s({},a.hoverinfo,{flags:["label","text","value","percent","name"]}),textposition:{valType:"enumerated",values:["inside","outside","auto","none"],dflt:"auto",arrayOk:!0,editType:"calc"},textfont:s({},l,{}),insidetextfont:s({},l,{}),outsidetextfont:s({},l,{}),domain:o({name:"pie",trace:!0,editType:"calc"}),hole:{valType:"number",min:0,max:1,dflt:0,editType:"calc"},sort:{valType:"boolean",dflt:!0,editType:"calc"},direction:{valType:"enumerated",values:["clockwise","counterclockwise"],dflt:"counterclockwise",editType:"calc"},rotation:{valType:"number",min:-360,max:360,dflt:0,editType:"calc"},pull:{valType:"number",min:0,max:1,dflt:0,arrayOk:!0,editType:"calc"}}},{"../../components/color/attributes":531,"../../lib/extend":649,"../../plots/attributes":703,"../../plots/domain":731,"../../plots/font_attributes":732}],966:[function(t,e,r){"use strict";var n=t("../../registry"),i=t("../../plots/get_data").getModuleCalcData;r.name="pie",r.plot=function(t){var e=n.getModule("pie"),r=i(t.calcdata,e)[0];r.length&&e.plot(t,r)},r.clean=function(t,e,r,n){var i=n._has&&n._has("pie"),a=e._has&&e._has("pie");i&&!a&&n._pielayer.selectAll("g.trace").remove()}},{"../../plots/get_data":742,"../../registry":790}],967:[function(t,e,r){"use strict";var n,i=t("fast-isnumeric"),a=t("../../lib").isArrayOrTypedArray,o=t("tinycolor2"),s=t("../../components/color"),l=t("./helpers");function c(t,e){if(!n){var r=s.defaults;n=u(r)}var i=e||n;return i[t%i.length]}function u(t){var e,r=t.slice();for(e=0;e")}}return y}},{"../../components/color":532,"../../lib":660,"./helpers":970,"fast-isnumeric":197,tinycolor2:473}],968:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../plots/domain").defaults;e.exports=function(t,e,r,o){function s(r,a){return n.coerce(t,e,i,r,a)}var l,c=n.coerceFont,u=s("values"),f=n.isArrayOrTypedArray(u),h=s("labels");if(Array.isArray(h)&&(l=h.length,f&&(l=Math.min(l,u.length))),!Array.isArray(h)){if(!f)return void(e.visible=!1);l=u.length,s("label0"),s("dlabel")}if(l){e._length=l,s("marker.line.width")&&s("marker.line.color"),s("marker.colors"),s("scalegroup");var p=s("text"),d=s("textinfo",Array.isArray(p)?"text+percent":"percent");if(s("hovertext"),d&&"none"!==d){var g=s("textposition"),m=Array.isArray(g)||"auto"===g,v=m||"inside"===g,y=m||"outside"===g;if(v||y){var x=c(s,"textfont",o.font);v&&c(s,"insidetextfont",x),y&&c(s,"outsidetextfont",x)}}a(e,o,s),s("hole"),s("sort"),s("direction"),s("rotation"),s("pull")}else e.visible=!1}},{"../../lib":660,"../../plots/domain":731,"./attributes":965}],969:[function(t,e,r){"use strict";var n=t("../../components/fx/helpers").appendArrayMultiPointValues;e.exports=function(t,e){var r={curveNumber:e.index,pointNumbers:t.pts,data:e._input,fullData:e,label:t.label,color:t.color,value:t.v,v:t.v};return 1===t.pts.length&&(r.pointNumber=r.i=t.pts[0]),n(r,e,t.pts),r}},{"../../components/fx/helpers":571}],970:[function(t,e,r){"use strict";var n=t("../../lib");r.formatPiePercent=function(t,e){var r=(100*t).toPrecision(3);return-1!==r.lastIndexOf(".")&&(r=r.replace(/[.]?0+$/,"")),n.numSeparate(r,e)+"%"},r.formatPieValue=function(t,e){var r=t.toPrecision(10);return-1!==r.lastIndexOf(".")&&(r=r.replace(/[.]?0+$/,"")),n.numSeparate(r,e)},r.getFirstFilled=function(t,e){if(Array.isArray(t))for(var r=0;r0?1:-1)/2,y:a/(1+r*r/(n*n)),outside:!0}}e.exports=function(t,e){var r=t._fullLayout;!function(t,e){var r,n,i,a,o,s,l,c,u,f=[];for(i=0;il&&(l=s.pull[a]);o.r=Math.min(r,n)/(2+2*l),o.cx=e.l+e.w*(s.domain.x[1]+s.domain.x[0])/2,o.cy=e.t+e.h*(2-s.domain.y[1]-s.domain.y[0])/2,s.scalegroup&&-1===f.indexOf(s.scalegroup)&&f.push(s.scalegroup)}for(a=0;ai.vTotal/2?1:0)}(e),p.each(function(){var p=n.select(this).selectAll("g.slice").data(e);p.enter().append("g").classed("slice",!0),p.exit().remove();var m=[[[],[]],[[],[]]],v=!1;p.each(function(e){if(e.hidden)n.select(this).selectAll("path,g").remove();else{e.pointNumber=e.i,e.curveNumber=g.index,m[e.pxmid[1]<0?0:1][e.pxmid[0]<0?0:1].push(e);var a=d.cx,p=d.cy,y=n.select(this),x=y.selectAll("path.surface").data([e]),b=!1,_=!1;if(x.enter().append("path").classed("surface",!0).style({"pointer-events":"all"}),y.select("path.textline").remove(),y.on("mouseover",function(){var o=t._fullLayout,s=t._fullData[g.index];if(!t._dragging&&!1!==o.hovermode){var l=s.hoverinfo;if(Array.isArray(l)&&(l=i.castHoverinfo({hoverinfo:[c.castOption(l,e.pts)],_module:g._module},o,0)),"all"===l&&(l="label+text+value+percent+name"),"none"!==l&&"skip"!==l&&l){var h=f(e,d),m=a+e.pxmid[0]*(1-h),v=p+e.pxmid[1]*(1-h),y=r.separators,x=[];if(-1!==l.indexOf("label")&&x.push(e.label),-1!==l.indexOf("text")){var w=c.castOption(s.hovertext||s.text,e.pts);w&&x.push(w)}-1!==l.indexOf("value")&&x.push(c.formatPieValue(e.v,y)),-1!==l.indexOf("percent")&&x.push(c.formatPiePercent(e.v/d.vTotal,y));var k=g.hoverlabel,M=k.font;i.loneHover({x0:m-h*d.r,x1:m+h*d.r,y:v,text:x.join("
"),name:-1!==l.indexOf("name")?s.name:void 0,idealAlign:e.pxmid[0]<0?"left":"right",color:c.castOption(k.bgcolor,e.pts)||e.color,borderColor:c.castOption(k.bordercolor,e.pts),fontFamily:c.castOption(M.family,e.pts),fontSize:c.castOption(M.size,e.pts),fontColor:c.castOption(M.color,e.pts)},{container:o._hoverlayer.node(),outerContainer:o._paper.node(),gd:t}),b=!0}t.emit("plotly_hover",{points:[u(e,s)],event:n.event}),_=!0}}).on("mouseout",function(r){var a=t._fullLayout,o=t._fullData[g.index];_&&(r.originalEvent=n.event,t.emit("plotly_unhover",{points:[u(e,o)],event:n.event}),_=!1),b&&(i.loneUnhover(a._hoverlayer.node()),b=!1)}).on("click",function(){var r=t._fullLayout,a=t._fullData[g.index];t._dragging||!1===r.hovermode||(t._hoverdata=[u(e,a)],i.click(t,n.event))}),g.pull){var w=+c.castOption(g.pull,e.pts)||0;w>0&&(a+=w*e.pxmid[0],p+=w*e.pxmid[1])}e.cxFinal=a,e.cyFinal=p;var k=g.hole;if(e.v===d.vTotal){var M="M"+(a+e.px0[0])+","+(p+e.px0[1])+E(e.px0,e.pxmid,!0,1)+E(e.pxmid,e.px0,!0,1)+"Z";k?x.attr("d","M"+(a+k*e.px0[0])+","+(p+k*e.px0[1])+E(e.px0,e.pxmid,!1,k)+E(e.pxmid,e.px0,!1,k)+"Z"+M):x.attr("d",M)}else{var A=E(e.px0,e.px1,!0,1);if(k){var T=1-k;x.attr("d","M"+(a+k*e.px1[0])+","+(p+k*e.px1[1])+E(e.px1,e.px0,!1,k)+"l"+T*e.px0[0]+","+T*e.px0[1]+A+"Z")}else x.attr("d","M"+a+","+p+"l"+e.px0[0]+","+e.px0[1]+A+"Z")}var S=c.castOption(g.textposition,e.pts),C=y.selectAll("g.slicetext").data(e.text&&"none"!==S?[0]:[]);C.enter().append("g").classed("slicetext",!0),C.exit().remove(),C.each(function(){var r=s.ensureSingle(n.select(this),"text","",function(t){t.attr("data-notex",1)});r.text(e.text).attr({class:"slicetext",transform:"","text-anchor":"middle"}).call(o.font,"outside"===S?g.outsidetextfont:g.insidetextfont).call(l.convertToTspans,t);var i,c=o.bBox(r.node());"outside"===S?i=h(c,e):(i=function(t,e,r){var n=Math.sqrt(t.width*t.width+t.height*t.height),i=t.width/t.height,a=Math.PI*Math.min(e.v/r.vTotal,.5),o=1-r.trace.hole,s=f(e,r),l={scale:s*r.r*2/n,rCenter:1-s,rotate:0};if(l.scale>=1)return l;var c=i+1/(2*Math.tan(a)),u=r.r*Math.min(1/(Math.sqrt(c*c+.5)+c),o/(Math.sqrt(i*i+o/2)+i)),h={scale:2*u/t.height,rCenter:Math.cos(u/r.r)-u*i/r.r,rotate:(180/Math.PI*e.midangle+720)%180-90},p=1/i,d=p+1/(2*Math.tan(a)),g=r.r*Math.min(1/(Math.sqrt(d*d+.5)+d),o/(Math.sqrt(p*p+o/2)+p)),m={scale:2*g/t.width,rCenter:Math.cos(g/r.r)-g/i/r.r,rotate:(180/Math.PI*e.midangle+810)%180-90},v=m.scale>h.scale?m:h;return l.scale<1&&v.scale>l.scale?v:l}(c,e,d),"auto"===S&&i.scale<1&&(r.call(o.font,g.outsidetextfont),g.outsidetextfont.family===g.insidetextfont.family&&g.outsidetextfont.size===g.insidetextfont.size||(c=o.bBox(r.node())),i=h(c,e)));var u=a+e.pxmid[0]*i.rCenter+(i.x||0),m=p+e.pxmid[1]*i.rCenter+(i.y||0);i.outside&&(e.yLabelMin=m-c.height/2,e.yLabelMid=m,e.yLabelMax=m+c.height/2,e.labelExtraX=0,e.labelExtraY=0,v=!0),r.attr("transform","translate("+u+","+m+")"+(i.scale<1?"scale("+i.scale+")":"")+(i.rotate?"rotate("+i.rotate+")":"")+"translate("+-(c.left+c.right)/2+","+-(c.top+c.bottom)/2+")")})}function E(t,r,n,i){return"a"+i*d.r+","+i*d.r+" 0 "+e.largeArc+(n?" 1 ":" 0 ")+i*(r[0]-t[0])+","+i*(r[1]-t[1])}}),v&&function(t,e){var r,n,i,a,o,s,l,u,f,h,p,d,g;function m(t,e){return t.pxmid[1]-e.pxmid[1]}function v(t,e){return e.pxmid[1]-t.pxmid[1]}function y(t,r){r||(r={});var i,u,f,p,d,g,m=r.labelExtraY+(n?r.yLabelMax:r.yLabelMin),v=n?t.yLabelMin:t.yLabelMax,y=n?t.yLabelMax:t.yLabelMin,x=t.cyFinal+o(t.px0[1],t.px1[1]),b=m-v;if(b*l>0&&(t.labelExtraY=b),Array.isArray(e.pull))for(u=0;u=(c.castOption(e.pull,f.pts)||0)||((t.pxmid[1]-f.pxmid[1])*l>0?(p=f.cyFinal+o(f.px0[1],f.px1[1]),(b=p-v-t.labelExtraY)*l>0&&(t.labelExtraY+=b)):(y+t.labelExtraY-x)*l>0&&(i=3*s*Math.abs(u-h.indexOf(t)),d=f.cxFinal+a(f.px0[0],f.px1[0]),(g=d+i-(t.cxFinal+t.pxmid[0])-t.labelExtraX)*s>0&&(t.labelExtraX+=g)))}for(n=0;n<2;n++)for(i=n?m:v,o=n?Math.max:Math.min,l=n?1:-1,r=0;r<2;r++){for(a=r?Math.max:Math.min,s=r?1:-1,(u=t[n][r]).sort(i),f=t[1-n][r],h=f.concat(u),d=[],p=0;pMath.abs(c)?o+="l"+c*t.pxmid[0]/t.pxmid[1]+","+c+"H"+(i+t.labelExtraX+s):o+="l"+t.labelExtraX+","+l+"v"+(c-l)+"h"+s}else o+="V"+(t.yLabelMid+t.labelExtraY)+"h"+s;e.append("path").classed("textline",!0).call(a.stroke,g.outsidetextfont.color).attr({"stroke-width":Math.min(2,g.outsidetextfont.size/8),d:o,fill:"none"})}})})}),setTimeout(function(){p.selectAll("tspan").each(function(){var t=n.select(this);t.attr("dy")&&t.attr("dy",t.attr("dy"))})},0)}},{"../../components/color":532,"../../components/drawing":557,"../../components/fx":574,"../../lib":660,"../../lib/svg_text_utils":684,"./event_data":969,"./helpers":970,d3:131}],975:[function(t,e,r){"use strict";var n=t("d3"),i=t("./style_one");e.exports=function(t){t._fullLayout._pielayer.selectAll(".trace").each(function(t){var e=t[0].trace,r=n.select(this);r.style({opacity:e.opacity}),r.selectAll("path.surface").each(function(t){n.select(this).call(i,t,e)})})}},{"./style_one":976,d3:131}],976:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("./helpers").castOption;e.exports=function(t,e,r){var a=r.marker.line,o=i(a.color,e.pts)||n.defaultLine,s=i(a.width,e.pts)||0;t.style({"stroke-width":s}).call(n.fill,e.color).call(n.stroke,o)}},{"../../components/color":532,"./helpers":970}],977:[function(t,e,r){"use strict";var n=t("../scatter/attributes");e.exports={x:n.x,y:n.y,xy:{valType:"data_array",editType:"calc"},indices:{valType:"data_array",editType:"calc"},xbounds:{valType:"data_array",editType:"calc"},ybounds:{valType:"data_array",editType:"calc"},text:n.text,marker:{color:{valType:"color",arrayOk:!1,editType:"calc"},opacity:{valType:"number",min:0,max:1,dflt:1,arrayOk:!1,editType:"calc"},blend:{valType:"boolean",dflt:null,editType:"calc"},sizemin:{valType:"number",min:.1,max:2,dflt:.5,editType:"calc"},sizemax:{valType:"number",min:.1,dflt:20,editType:"calc"},border:{color:{valType:"color",arrayOk:!1,editType:"calc"},arearatio:{valType:"number",min:0,max:1,dflt:0,editType:"calc"},editType:"calc"},editType:"calc"}}},{"../scatter/attributes":990}],978:[function(t,e,r){"use strict";var n=t("gl-pointcloud2d"),i=t("../../lib/str2rgbarray"),a=t("../../plots/cartesian/autorange").expand,o=t("../scatter/get_trace_color");function s(t,e){this.scene=t,this.uid=e,this.type="pointcloud",this.pickXData=[],this.pickYData=[],this.xData=[],this.yData=[],this.textLabels=[],this.color="rgb(0, 0, 0)",this.name="",this.hoverinfo="all",this.idToIndex=new Int32Array(0),this.bounds=[0,0,0,0],this.pointcloudOptions={positions:new Float32Array(0),idToIndex:this.idToIndex,sizemin:.5,sizemax:12,color:[0,0,0,1],areaRatio:1,borderColor:[0,0,0,1]},this.pointcloud=n(t.glplot,this.pointcloudOptions),this.pointcloud._trace=this}var l=s.prototype;l.handlePick=function(t){var e=this.idToIndex[t.pointId];return{trace:this,dataCoord:t.dataCoord,traceCoord:this.pickXYData?[this.pickXYData[2*e],this.pickXYData[2*e+1]]:[this.pickXData[e],this.pickYData[e]],textLabel:Array.isArray(this.textLabels)?this.textLabels[e]:this.textLabels,color:this.color,name:this.name,pointIndex:e,hoverinfo:this.hoverinfo}},l.update=function(t){this.index=t.index,this.textLabels=t.text,this.name=t.name,this.hoverinfo=t.hoverinfo,this.bounds=[1/0,1/0,-1/0,-1/0],this.updateFast(t),this.color=o(t,{})},l.updateFast=function(t){var e,r,n,a,o,s,l=this.xData=this.pickXData=t.x,c=this.yData=this.pickYData=t.y,u=this.pickXYData=t.xy,f=t.xbounds&&t.ybounds,h=t.indices,p=this.bounds;if(u){if(n=u,e=u.length>>>1,f)p[0]=t.xbounds[0],p[2]=t.xbounds[1],p[1]=t.ybounds[0],p[3]=t.ybounds[1];else for(s=0;sp[2]&&(p[2]=a),op[3]&&(p[3]=o);if(h)r=h;else for(r=new Int32Array(e),s=0;sp[2]&&(p[2]=a),op[3]&&(p[3]=o);this.idToIndex=r,this.pointcloudOptions.idToIndex=r,this.pointcloudOptions.positions=n;var d=i(t.marker.color),g=i(t.marker.border.color),m=t.opacity*t.marker.opacity;d[3]*=m,this.pointcloudOptions.color=d;var v=t.marker.blend;if(null===v){v=l.length<100||c.length<100}this.pointcloudOptions.blend=v,g[3]*=m,this.pointcloudOptions.borderColor=g;var y=t.marker.sizemin,x=Math.max(t.marker.sizemax,t.marker.sizemin);this.pointcloudOptions.sizeMin=y,this.pointcloudOptions.sizeMax=x,this.pointcloudOptions.areaRatio=t.marker.border.arearatio,this.pointcloud.update(this.pointcloudOptions),this.expandAxesFast(p,x/2)},l.expandAxesFast=function(t,e){var r=e||.5;a(this.scene.xaxis,[t[0],t[2]],{ppad:r}),a(this.scene.yaxis,[t[1],t[3]],{ppad:r})},l.dispose=function(){this.pointcloud.dispose()},e.exports=function(t,e){var r=new s(t,e.uid);return r.update(e),r}},{"../../lib/str2rgbarray":683,"../../plots/cartesian/autorange":705,"../scatter/get_trace_color":1e3,"gl-pointcloud2d":260}],979:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes");e.exports=function(t,e,r){function a(r,a){return n.coerce(t,e,i,r,a)}a("x"),a("y"),a("xbounds"),a("ybounds"),t.xy&&t.xy instanceof Float32Array&&(e.xy=t.xy),t.indices&&t.indices instanceof Int32Array&&(e.indices=t.indices),a("text"),a("marker.color",r),a("marker.opacity"),a("marker.blend"),a("marker.sizemin"),a("marker.sizemax"),a("marker.border.color",r),a("marker.border.arearatio"),e._length=null}},{"../../lib":660,"./attributes":977}],980:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.calc=t("../scatter3d/calc"),n.plot=t("./convert"),n.moduleType="trace",n.name="pointcloud",n.basePlotModule=t("../../plots/gl2d"),n.categories=["gl","gl2d","showLegend"],n.meta={},e.exports=n},{"../../plots/gl2d":745,"../scatter3d/calc":1016,"./attributes":977,"./convert":978,"./defaults":979}],981:[function(t,e,r){"use strict";var n=t("../../plots/font_attributes"),i=t("../../plots/attributes"),a=t("../../components/color/attributes"),o=t("../../components/fx/attributes"),s=t("../../plots/domain").attributes,l=t("../../lib/extend").extendFlat,c=t("../../plot_api/edit_types").overrideAll;e.exports=c({hoverinfo:l({},i.hoverinfo,{flags:["label","text","value","percent","name"]}),hoverlabel:o.hoverlabel,domain:s({name:"sankey",trace:!0}),orientation:{valType:"enumerated",values:["v","h"],dflt:"h"},valueformat:{valType:"string",dflt:".3s"},valuesuffix:{valType:"string",dflt:""},arrangement:{valType:"enumerated",values:["snap","perpendicular","freeform","fixed"],dflt:"snap"},textfont:n({}),node:{label:{valType:"data_array",dflt:[]},color:{valType:"color",arrayOk:!0},line:{color:{valType:"color",dflt:a.defaultLine,arrayOk:!0},width:{valType:"number",min:0,dflt:.5,arrayOk:!0}},pad:{valType:"number",arrayOk:!1,min:0,dflt:20},thickness:{valType:"number",arrayOk:!1,min:1,dflt:20}},link:{label:{valType:"data_array",dflt:[]},color:{valType:"color",arrayOk:!0},line:{color:{valType:"color",dflt:a.defaultLine,arrayOk:!0},width:{valType:"number",min:0,dflt:0,arrayOk:!0}},source:{valType:"data_array",dflt:[]},target:{valType:"data_array",dflt:[]},value:{valType:"data_array",dflt:[]}}},"calc","nested")},{"../../components/color/attributes":531,"../../components/fx/attributes":566,"../../lib/extend":649,"../../plot_api/edit_types":691,"../../plots/attributes":703,"../../plots/domain":731,"../../plots/font_attributes":732}],982:[function(t,e,r){"use strict";var n=t("../../plot_api/edit_types").overrideAll,i=t("../../plots/get_data").getModuleCalcData,a=t("./plot"),o=t("../../components/fx/layout_attributes");r.name="sankey",r.baseLayoutAttrOverrides=n({hoverlabel:o.hoverlabel},"plot","nested"),r.plot=function(t){var e=i(t.calcdata,"sankey")[0];a(t,e)},r.clean=function(t,e,r,n){var i=n._has&&n._has("sankey"),a=e._has&&e._has("sankey");i&&!a&&n._paperdiv.selectAll(".sankey").remove()}},{"../../components/fx/layout_attributes":575,"../../plot_api/edit_types":691,"../../plots/get_data":742,"./plot":987}],983:[function(t,e,r){"use strict";var n=t("strongly-connected-components"),i=t("../../lib"),a=t("../../lib/gup").wrap;e.exports=function(t,e){return function(t,e,r){for(var a=t.length,o=i.init2dArray(a,0),s=0;s1})}(e.node.label,e.link.source,e.link.target)&&(i.error("Circularity is present in the Sankey data. Removing all nodes and links."),e.link.label=[],e.link.source=[],e.link.target=[],e.link.value=[],e.link.color=[],e.node.label=[],e.node.color=[]),a({link:e.link,node:e.node})}},{"../../lib":660,"../../lib/gup":657,"strongly-connected-components":465}],984:[function(t,e,r){"use strict";e.exports={nodeTextOffsetHorizontal:4,nodeTextOffsetVertical:3,nodePadAcross:10,sankeyIterations:50,forceIterations:5,forceTicksPerFrame:10,duration:500,ease:"cubic-in-out",cn:{sankey:"sankey",sankeyLinks:"sankey-links",sankeyLink:"sankey-link",sankeyNodeSet:"sankey-node-set",sankeyNode:"sankey-node",nodeRect:"node-rect",nodeCapture:"node-capture",nodeCentered:"node-entered",nodeLabelGuide:"node-label-guide",nodeLabel:"node-label",nodeLabelTextPath:"node-label-text-path"}}},{}],985:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../components/color"),o=t("tinycolor2"),s=t("../../plots/domain").defaults;e.exports=function(t,e,r,l){function c(r,a){return n.coerce(t,e,i,r,a)}c("node.label"),c("node.pad"),c("node.thickness"),c("node.line.color"),c("node.line.width");var u=l.colorway;c("node.color",e.node.label.map(function(t,e){return a.addOpacity(function(t){return u[t%u.length]}(e),.8)})),c("link.label"),c("link.source"),c("link.target"),c("link.value"),c("link.line.color"),c("link.line.width"),c("link.color",e.link.value.map(function(){return o(l.paper_bgcolor).getLuminance()<.333?"rgba(255, 255, 255, 0.6)":"rgba(0, 0, 0, 0.2)"})),s(e,l,c),c("orientation"),c("valueformat"),c("valuesuffix"),c("arrangement"),n.coerceFont(c,"textfont",n.extendFlat({},l.font)),e._length=null}},{"../../components/color":532,"../../lib":660,"../../plots/domain":731,"./attributes":981,tinycolor2:473}],986:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.calc=t("./calc"),n.plot=t("./plot"),n.moduleType="trace",n.name="sankey",n.basePlotModule=t("./base_plot"),n.categories=["noOpacity"],n.meta={},e.exports=n},{"./attributes":981,"./base_plot":982,"./calc":983,"./defaults":985,"./plot":987}],987:[function(t,e,r){"use strict";var n=t("d3"),i=t("./render"),a=t("../../components/fx"),o=t("../../components/color"),s=t("../../lib"),l=t("./constants").cn,c=s._;function u(t){return""!==t}function f(t,e){return t.filter(function(t){return t.key===e.traceId})}function h(t,e){n.select(t).select("path").style("fill-opacity",e),n.select(t).select("rect").style("fill-opacity",e)}function p(t){n.select(t).select("text.name").style("fill","black")}function d(t){return function(e){return-1!==t.node.sourceLinks.indexOf(e.link)||-1!==t.node.targetLinks.indexOf(e.link)}}function g(t){return function(e){return-1!==e.node.sourceLinks.indexOf(t.link)||-1!==e.node.targetLinks.indexOf(t.link)}}function m(t,e,r){e&&r&&f(r,e).selectAll("."+l.sankeyLink).filter(d(e)).call(y.bind(0,e,r,!1))}function v(t,e,r){e&&r&&f(r,e).selectAll("."+l.sankeyLink).filter(d(e)).call(x.bind(0,e,r,!1))}function y(t,e,r,n){var i=n.datum().link.label;n.style("fill-opacity",.4),i&&f(e,t).selectAll("."+l.sankeyLink).filter(function(t){return t.link.label===i}).style("fill-opacity",.4),r&&f(e,t).selectAll("."+l.sankeyNode).filter(g(t)).call(m)}function x(t,e,r,n){var i=n.datum().link.label;n.style("fill-opacity",function(t){return t.tinyColorAlpha}),i&&f(e,t).selectAll("."+l.sankeyLink).filter(function(t){return t.link.label===i}).style("fill-opacity",function(t){return t.tinyColorAlpha}),r&&f(e,t).selectAll(l.sankeyNode).filter(g(t)).call(v)}function b(t,e){var r=t.hoverlabel||{},n=s.nestedProperty(r,e).get();return!Array.isArray(n)&&n}e.exports=function(t,e){var r=t._fullLayout,s=r._paper,f=r._size,d=c(t,"source:")+" ",g=c(t,"target:")+" ",_=c(t,"incoming flow count:")+" ",w=c(t,"outgoing flow count:")+" ";i(s,e,{width:f.w,height:f.h,margin:{t:f.t,r:f.r,b:f.b,l:f.l}},{linkEvents:{hover:function(e,r,i){n.select(e).call(y.bind(0,r,i,!0)),t.emit("plotly_hover",{event:n.event,points:[r.link]})},follow:function(e,i){var s=i.link.trace,l=t._fullLayout._paperdiv.node().getBoundingClientRect(),c=e.getBoundingClientRect(),f=c.left+c.width/2,m=c.top+c.height/2,v=a.loneHover({x:f-l.left,y:m-l.top,name:n.format(i.valueFormat)(i.link.value)+i.valueSuffix,text:[i.link.label||"",d+i.link.source.label,g+i.link.target.label].filter(u).join("
"),color:b(s,"bgcolor")||o.addOpacity(i.tinyColorHue,1),borderColor:b(s,"bordercolor"),fontFamily:b(s,"font.family"),fontSize:b(s,"font.size"),fontColor:b(s,"font.color"),idealAlign:n.event.x"),color:b(o,"bgcolor")||i.tinyColorHue,borderColor:b(o,"bordercolor"),fontFamily:b(o,"font.family"),fontSize:b(o,"font.size"),fontColor:b(o,"font.color"),idealAlign:"left"},{container:r._hoverlayer.node(),outerContainer:r._paper.node(),gd:t});h(v,.85),p(v)},unhover:function(e,i,o){n.select(e).call(v,i,o),t.emit("plotly_unhover",{event:n.event,points:[i.node]}),a.loneUnhover(r._hoverlayer.node())},select:function(e,r,i){var o=r.node;o.originalEvent=n.event,t._hoverdata=[o],n.select(e).call(v,r,i),a.click(t,{target:!0})}}})}},{"../../components/color":532,"../../components/fx":574,"../../lib":660,"./constants":984,"./render":988,d3:131}],988:[function(t,e,r){"use strict";var n=t("./constants"),i=t("d3"),a=t("tinycolor2"),o=t("../../components/color"),s=t("../../components/drawing"),l=t("@plotly/d3-sankey").sankey,c=t("d3-force"),u=t("../../lib"),f=u.isArrayOrTypedArray,h=u.isIndex,p=t("../../lib/gup"),d=p.keyFun,g=p.repeat,m=p.unwrap;function v(t){t.lastDraggedX=t.x,t.lastDraggedY=t.y}function y(t){return function(e){return e.node.originalX===t.node.originalX}}function x(t){for(var e=0;e1||t.linkLineWidth>0}function T(t){return"translate("+t.translateX+","+t.translateY+")"+(t.horizontal?"matrix(1 0 0 1 0 0)":"matrix(0 1 1 0 0 0)")}function S(t){return"translate("+(t.horizontal?0:t.labelY)+" "+(t.horizontal?t.labelY:0)+")"}function C(t){return i.svg.line()([[t.horizontal?t.left?-t.sizeAcross:t.visibleWidth+n.nodeTextOffsetHorizontal:n.nodeTextOffsetHorizontal,0],[t.horizontal?t.left?-n.nodeTextOffsetHorizontal:t.sizeAcross:t.visibleHeight-n.nodeTextOffsetHorizontal,0]])}function E(t){return t.horizontal?"matrix(1 0 0 1 0 0)":"matrix(0 1 1 0 0 0)"}function L(t){return t.horizontal?"scale(1 1)":"scale(-1 1)"}function z(t){return t.darkBackground&&!t.horizontal?"rgb(255,255,255)":"rgb(0,0,0)"}function P(t){return t.horizontal&&t.left?"100%":"0%"}function D(t,e,r){t.on(".basic",null).on("mouseover.basic",function(t){t.interactionState.dragInProgress||(r.hover(this,t,e),t.interactionState.hovered=[this,t])}).on("mousemove.basic",function(t){t.interactionState.dragInProgress||(r.follow(this,t),t.interactionState.hovered=[this,t])}).on("mouseout.basic",function(t){t.interactionState.dragInProgress||(r.unhover(this,t,e),t.interactionState.hovered=!1)}).on("click.basic",function(t){t.interactionState.hovered&&(r.unhover(this,t,e),t.interactionState.hovered=!1),t.interactionState.dragInProgress||r.select(this,t,e)})}function O(t,e,r){var a=i.behavior.drag().origin(function(t){return t.node}).on("dragstart",function(i){if("fixed"!==i.arrangement&&(u.raiseToTop(this),i.interactionState.dragInProgress=i.node,v(i.node),i.interactionState.hovered&&(r.nodeEvents.unhover.apply(0,i.interactionState.hovered),i.interactionState.hovered=!1),"snap"===i.arrangement)){var a=i.traceId+"|"+Math.floor(i.node.originalX);i.forceLayouts[a]?i.forceLayouts[a].alpha(1):function(t,e,r){var i=r.sankey.nodes().filter(function(t){return t.originalX===r.node.originalX});r.forceLayouts[e]=c.forceSimulation(i).alphaDecay(0).force("collide",c.forceCollide().radius(function(t){return t.dy/2+r.nodePad/2}).strength(1).iterations(n.forceIterations)).force("constrain",function(t,e,r,i){return function(){for(var t=0,a=0;a0&&i.forceLayouts[e].alpha(0)}}(0,e,i,r)).stop()}(0,a,i),function(t,e,r,i){window.requestAnimationFrame(function a(){for(var o=0;o0&&window.requestAnimationFrame(a)})}(t,e,i,a)}}).on("drag",function(r){if("fixed"!==r.arrangement){var n=i.event.x,a=i.event.y;"snap"===r.arrangement?(r.node.x=n,r.node.y=a):("freeform"===r.arrangement&&(r.node.x=n),r.node.y=Math.max(r.node.dy/2,Math.min(r.size-r.node.dy/2,a))),v(r.node),"snap"!==r.arrangement&&(r.sankey.relayout(),k(t.filter(y(r)),e))}}).on("dragend",function(t){t.interactionState.dragInProgress=!1});t.on(".drag",null).call(a)}e.exports=function(t,e,r,i){var c=t.selectAll("."+n.cn.sankey).data(e.filter(function(t){return m(t).trace.visible}).map(function(t,e,r){var i,a=m(e).trace,o=a.domain,s=a.node,c=a.link,u=a.arrangement,p="h"===a.orientation,d=a.node.pad,g=a.node.thickness,v=a.node.line.color,y=a.node.line.width,b=a.link.line.color,_=a.link.line.width,w=a.valueformat,k=a.valuesuffix,M=a.textfont,A=t.width*(o.x[1]-o.x[0]),T=t.height*(o.y[1]-o.y[0]),S=[],C=f(c.color),E={},L=s.label.length;for(i=0;i0&&h(P,L)&&h(D,L)&&(D=+D,E[P=+P]=E[D]=!0,S.push({pointNumber:i,label:c.label[i],color:C?c.color[i]:c.color,source:P,target:D,value:+z}))}var O=f(s.color),I=[],R=!1,B={};for(i=0;i5?t.node.label:""}).attr("text-anchor",function(t){return t.horizontal&&t.left?"end":"start"}),F.transition().ease(n.ease).duration(n.duration).attr("startOffset",P).style("fill",z)}},{"../../components/color":532,"../../components/drawing":557,"../../lib":660,"../../lib/gup":657,"./constants":984,"@plotly/d3-sankey":43,d3:131,"d3-force":127,tinycolor2:473}],989:[function(t,e,r){"use strict";var n=t("../../lib");e.exports=function(t,e){for(var r=0;r=0;i--){var a=t[i];if("scatter"===a.type&&a.xaxis===r.xaxis&&a.yaxis===r.yaxis){a.opacity=void 0;break}}}}}},{}],994:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../../lib"),a=t("../../plots/plots"),o=t("../../components/colorscale"),s=t("../../components/colorbar/draw");e.exports=function(t,e){var r=e[0].trace,l=r.marker,c="cb"+r.uid;if(t._fullLayout._infolayer.selectAll("."+c).remove(),void 0!==l&&l.showscale){var u=l.color,f=l.cmin,h=l.cmax;n(f)||(f=i.aggNums(Math.min,null,u)),n(h)||(h=i.aggNums(Math.max,null,u));var p=e[0].t.cb=s(t,c),d=o.makeColorScaleFunc(o.extractScale(l.colorscale,f,h),{noNumericCheck:!0});p.fillcolor(d).filllevels({start:f,end:h,size:(h-f)/254}).options(l.colorbar)()}else a.autoMargin(t,c)}},{"../../components/colorbar/draw":536,"../../components/colorscale":547,"../../lib":660,"../../plots/plots":768,"fast-isnumeric":197}],995:[function(t,e,r){"use strict";var n=t("../../components/colorscale/has_colorscale"),i=t("../../components/colorscale/calc"),a=t("./subtypes");e.exports=function(t){a.hasLines(t)&&n(t,"line")&&i(t,t.line.color,"line","c"),a.hasMarkers(t)&&(n(t,"marker")&&i(t,t.marker.color,"marker","c"),n(t,"marker.line")&&i(t,t.marker.line.color,"marker.line","c"))}},{"../../components/colorscale/calc":539,"../../components/colorscale/has_colorscale":546,"./subtypes":1012}],996:[function(t,e,r){"use strict";e.exports={PTS_LINESONLY:20,minTolerance:.2,toleranceGrowth:10,maxScreensAway:20}},{}],997:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("../../registry"),a=t("./attributes"),o=t("./constants"),s=t("./subtypes"),l=t("./xy_defaults"),c=t("./marker_defaults"),u=t("./line_defaults"),f=t("./line_shape_defaults"),h=t("./text_defaults"),p=t("./fillcolor_defaults");e.exports=function(t,e,r,d){function g(r,i){return n.coerce(t,e,a,r,i)}var m=l(t,e,d,g),v=mV!=(D=C[T][1])>=V&&(L=C[T-1][0],z=C[T][0],D-P&&(E=L+(z-L)*(V-P)/(D-P),B=Math.min(B,E),F=Math.max(F,E)));B=Math.max(B,0),F=Math.min(F,h._length);var U=s.defaultLine;return s.opacity(f.fillcolor)?U=f.fillcolor:s.opacity((f.line||{}).color)&&(U=f.line.color),n.extendFlat(t,{distance:t.maxHoverDistance,x0:B,x1:F,y0:V,y1:V,color:U}),delete t.index,f.text&&!Array.isArray(f.text)?t.text=String(f.text):t.text=f.name,[t]}}}},{"../../components/color":532,"../../components/fx":574,"../../lib":660,"../../registry":790,"./fill_hover_text":998,"./get_trace_color":1e3}],1002:[function(t,e,r){"use strict";var n={},i=t("./subtypes");n.hasLines=i.hasLines,n.hasMarkers=i.hasMarkers,n.hasText=i.hasText,n.isBubble=i.isBubble,n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.cleanData=t("./clean_data"),n.calc=t("./calc").calc,n.arraysToCalcdata=t("./arrays_to_calcdata"),n.plot=t("./plot"),n.colorbar=t("./colorbar"),n.style=t("./style").style,n.styleOnSelect=t("./style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("./select"),n.animatable=!0,n.moduleType="trace",n.name="scatter",n.basePlotModule=t("../../plots/cartesian"),n.categories=["cartesian","svg","symbols","markerColorscale","errorBarsOK","showLegend","scatter-like","zoomScale"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"./arrays_to_calcdata":989,"./attributes":990,"./calc":991,"./clean_data":993,"./colorbar":994,"./defaults":997,"./hover":1001,"./plot":1009,"./select":1010,"./style":1011,"./subtypes":1012}],1003:[function(t,e,r){"use strict";var n=t("../../lib").isArrayOrTypedArray,i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults");e.exports=function(t,e,r,o,s,l){var c=(t.marker||{}).color;(s("line.color",r),i(t,"line"))?a(t,e,o,s,{prefix:"line.",cLetter:"c"}):s("line.color",!n(c)&&c||r);s("line.width"),(l||{}).noDash||s("line.dash")}},{"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546,"../../lib":660}],1004:[function(t,e,r){"use strict";var n=t("../../constants/numerical").BADNUM,i=t("../../lib"),a=i.segmentsIntersect,o=i.constrain,s=t("./constants");e.exports=function(t,e){var r,l,c,u,f,h,p,d,g,m,v,y,x,b,_,w,k=e.xaxis,M=e.yaxis,A=e.simplify,T=e.connectGaps,S=e.baseTolerance,C=e.shape,E="linear"===C,L=[],z=s.minTolerance,P=new Array(t.length),D=0;function O(e){var r=t[e],i=k.c2p(r.x),a=M.c2p(r.y);return i===n||a===n?r.intoCenter||!1:[i,a]}function I(t){var e=t[0]/k._length,r=t[1]/M._length;return(1+s.toleranceGrowth*Math.max(0,-e,e-1,-r,r-1))*S}function R(t,e){var r=t[0]-e[0],n=t[1]-e[1];return Math.sqrt(r*r+n*n)}A||(S=z=-1);var B,F,N,j,V,U,q,H=s.maxScreensAway,G=-k._length*H,W=k._length*(1+H),Y=-M._length*H,X=M._length*(1+H),Z=[[G,Y,W,Y],[W,Y,W,X],[W,X,G,X],[G,X,G,Y]];function J(t){if(t[0]W||t[1]X)return[o(t[0],G,W),o(t[1],Y,X)]}function K(t,e){return t[0]===e[0]&&(t[0]===G||t[0]===W)||(t[1]===e[1]&&(t[1]===Y||t[1]===X)||void 0)}function Q(t,e,r){return function(n,a){var o=J(n),s=J(a),l=[];if(o&&s&&K(o,s))return l;o&&l.push(o),s&&l.push(s);var c=2*i.constrain((n[t]+a[t])/2,e,r)-((o||n)[t]+(s||a)[t]);c&&((o&&s?c>0==o[t]>s[t]?o:s:o||s)[t]+=c);return l}}function $(t){var e=t[0],r=t[1],n=e===P[D-1][0],i=r===P[D-1][1];if(!n||!i)if(D>1){var a=e===P[D-2][0],o=r===P[D-2][1];n&&(e===G||e===W)&&a?o?D--:P[D-1]=t:i&&(r===Y||r===X)&&o?a?D--:P[D-1]=t:P[D++]=t}else P[D++]=t}function tt(t){P[D-1][0]!==t[0]&&P[D-1][1]!==t[1]&&$([N,j]),$(t),V=null,N=j=0}function et(t){if(B=t[0]W?W:0,F=t[1]X?X:0,B||F){if(D)if(V){var e=q(V,t);e.length>1&&(tt(e[0]),P[D++]=e[1])}else U=q(P[D-1],t)[0],P[D++]=U;else P[D++]=[B||t[0],F||t[1]];var r=P[D-1];B&&F&&(r[0]!==B||r[1]!==F)?(V&&(N!==B&&j!==F?$(N&&j?(n=V,a=(i=t)[0]-n[0],o=(i[1]-n[1])/a,(n[1]*i[0]-i[1]*n[0])/a>0?[o>0?G:W,X]:[o>0?W:G,Y]):[N||B,j||F]):N&&j&&$([N,j])),$([B,F])):N-B&&j-F&&$([B||N,F||j]),V=t,N=B,j=F}else V&&tt(q(V,t)[0]),P[D++]=t;var n,i,a,o}for("linear"===C||"spline"===C?q=function(t,e){for(var r=[],n=0,i=0;i<4;i++){var o=Z[i],s=a(t[0],t[1],e[0],e[1],o[0],o[1],o[2],o[3]);s&&(!n||Math.abs(s.x-r[0][0])>1||Math.abs(s.y-r[0][1])>1)&&(s=[s.x,s.y],n&&R(s,t)I(h))break;c=h,(x=g[0]*d[0]+g[1]*d[1])>v?(v=x,u=h,p=!1):x=t.length||!h)break;et(h),l=h}}else et(u)}V&&$([N||V[0],j||V[1]]),L.push(P.slice(0,D))}return L}},{"../../constants/numerical":637,"../../lib":660,"./constants":996}],1005:[function(t,e,r){"use strict";e.exports=function(t,e,r){"spline"===r("line.shape")&&r("line.smoothing")}},{}],1006:[function(t,e,r){"use strict";e.exports=function(t,e,r){var n,i,a=null;for(i=0;i0?Math.max(e,i):0}}},{"fast-isnumeric":197}],1008:[function(t,e,r){"use strict";var n=t("../../components/color"),i=t("../../components/colorscale/has_colorscale"),a=t("../../components/colorscale/defaults"),o=t("./subtypes");e.exports=function(t,e,r,s,l,c){var u=o.isBubble(t),f=(t.line||{}).color;(c=c||{},f&&(r=f),l("marker.symbol"),l("marker.opacity",u?.7:1),l("marker.size"),l("marker.color",r),i(t,"marker")&&a(t,e,s,l,{prefix:"marker.",cLetter:"c"}),c.noSelect||(l("selected.marker.color"),l("unselected.marker.color"),l("selected.marker.size"),l("unselected.marker.size")),c.noLine||(l("marker.line.color",f&&!Array.isArray(f)&&e.marker.color!==f?f:u?n.background:n.defaultLine),i(t,"marker.line")&&a(t,e,s,l,{prefix:"marker.line.",cLetter:"c"}),l("marker.line.width",u?1:0)),u&&(l("marker.sizeref"),l("marker.sizemin"),l("marker.sizemode")),c.gradient)&&("none"!==l("marker.gradient.type")&&l("marker.gradient.color"))}},{"../../components/color":532,"../../components/colorscale/defaults":542,"../../components/colorscale/has_colorscale":546,"./subtypes":1012}],1009:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../registry"),a=t("../../lib"),o=t("../../components/drawing"),s=t("./subtypes"),l=t("./line_points"),c=t("./link_traces"),u=t("../../lib/polygon").tester;function f(t,e,r,c,f,h,p){var d,g;!function(t,e,r,i,o){var l=r.xaxis,c=r.yaxis,u=n.extent(a.simpleMap(l.range,l.r2c)),f=n.extent(a.simpleMap(c.range,c.r2c)),h=i[0].trace;if(!s.hasMarkers(h))return;var p=h.marker.maxdisplayed;if(0===p)return;var d=i.filter(function(t){return t.x>=u[0]&&t.x<=u[1]&&t.y>=f[0]&&t.y<=f[1]}),g=Math.ceil(d.length/p),m=0;o.forEach(function(t,r){var n=t[0].trace;s.hasMarkers(n)&&n.marker.maxdisplayed>0&&r0;function v(t){return m?t.transition():t}var y=r.xaxis,x=r.yaxis,b=c[0].trace,_=b.line,w=n.select(h);if(i.getComponentMethod("errorbars","plot")(w,r,p),!0===b.visible){var k,M;v(w).style("opacity",b.opacity);var A=b.fill.charAt(b.fill.length-1);"x"!==A&&"y"!==A&&(A=""),r.isRangePlot||(c[0].node3=w);var T="",S=[],C=b._prevtrace;C&&(T=C._prevRevpath||"",M=C._nextFill,S=C._polygons);var E,L,z,P,D,O,I,R,B,F="",N="",j=[],V=a.noop;if(k=b._ownFill,s.hasLines(b)||"none"!==b.fill){for(M&&M.datum(c),-1!==["hv","vh","hvh","vhv"].indexOf(_.shape)?(z=o.steps(_.shape),P=o.steps(_.shape.split("").reverse().join(""))):z=P="spline"===_.shape?function(t){var e=t[t.length-1];return t.length>1&&t[0][0]===e[0]&&t[0][1]===e[1]?o.smoothclosed(t.slice(1),_.smoothing):o.smoothopen(t,_.smoothing)}:function(t){return"M"+t.join("L")},D=function(t){return P(t.reverse())},j=l(c,{xaxis:y,yaxis:x,connectGaps:b.connectgaps,baseTolerance:Math.max(_.width||1,3)/4,shape:_.shape,simplify:_.simplify}),B=b._polygons=new Array(j.length),g=0;g1){var r=n.select(this);if(r.datum(c),t)v(r.style("opacity",0).attr("d",E).call(o.lineGroupStyle)).style("opacity",1);else{var i=v(r);i.attr("d",E),o.singleLineStyle(c,i)}}}}}var U=w.selectAll(".js-line").data(j);v(U.exit()).style("opacity",0).remove(),U.each(V(!1)),U.enter().append("path").classed("js-line",!0).style("vector-effect","non-scaling-stroke").call(o.lineGroupStyle).each(V(!0)),o.setClipUrl(U,r.layerClipId),j.length?(k?O&&R&&(A?("y"===A?O[1]=R[1]=x.c2p(0,!0):"x"===A&&(O[0]=R[0]=y.c2p(0,!0)),v(k).attr("d","M"+R+"L"+O+"L"+F.substr(1)).call(o.singleFillStyle)):v(k).attr("d",F+"Z").call(o.singleFillStyle)):M&&("tonext"===b.fill.substr(0,6)&&F&&T?("tonext"===b.fill?v(M).attr("d",F+"Z"+T+"Z").call(o.singleFillStyle):v(M).attr("d",F+"L"+T.substr(1)+"Z").call(o.singleFillStyle),b._polygons=b._polygons.concat(S)):(H(M),b._polygons=null)),b._prevRevpath=N,b._prevPolygons=B):(k?H(k):M&&H(M),b._polygons=b._prevRevpath=b._prevPolygons=null);var q=w.selectAll(".points");d=q.data([c]),q.each(Z),d.enter().append("g").classed("points",!0).each(Z),d.exit().remove(),d.each(function(t){var e=!1===t[0].trace.cliponaxis;o.setClipUrl(n.select(this),e?null:r.layerClipId)})}function H(t){v(t).attr("d","M0,0Z")}function G(t){return t.filter(function(t){return t.vis})}function W(t){return t.id}function Y(t){if(t.ids)return W}function X(){return!1}function Z(e){var i,l=e[0].trace,c=n.select(this),u=s.hasMarkers(l),f=s.hasText(l),h=Y(l),p=X,d=X;u&&(p=l.marker.maxdisplayed||l._needsCull?G:a.identity),f&&(d=l.marker.maxdisplayed||l._needsCull?G:a.identity);var g,b=(i=c.selectAll("path.point").data(p,h)).enter().append("path").classed("point",!0);m&&b.call(o.pointStyle,l,t).call(o.translatePoints,y,x).style("opacity",0).transition().style("opacity",1),i.order(),u&&(g=o.makePointStyleFns(l)),i.each(function(e){var i=n.select(this),a=v(i);o.translatePoint(e,a,y,x)?(o.singlePointStyle(e,a,l,g,t),r.layerClipId&&o.hideOutsideRangePoint(e,a,y,x,l.xcalendar,l.ycalendar),l.customdata&&i.classed("plotly-customdata",null!==e.data&&void 0!==e.data)):a.remove()}),m?i.exit().transition().style("opacity",0).remove():i.exit().remove(),(i=c.selectAll("g").data(d,h)).enter().append("g").classed("textpoint",!0).append("text"),i.order(),i.each(function(t){var e=n.select(this),i=v(e.select("text"));o.translatePoint(t,i,y,x)?r.layerClipId&&o.hideOutsideRangePoint(t,e,y,x,l.xcalendar,l.ycalendar):e.remove()}),i.selectAll("text").call(o.textPointStyle,l,t).each(function(t){var e=y.c2p(t.x),r=x.c2p(t.y);n.select(this).selectAll("tspan.line").each(function(){v(n.select(this)).attr({x:e,y:r})})}),i.exit().remove()}}e.exports=function(t,e,r,i,a,s){var l,u,h,p,d=!a,g=!!a&&a.duration>0;for((h=i.selectAll("g.trace").data(r,function(t){return t[0].trace.uid})).enter().append("g").attr("class",function(t){return"trace scatter trace"+t[0].trace.uid}).style("stroke-miterlimit",2),c(t,e,r),function(t,e,r){var i;e.selectAll("g.trace").each(function(t){var e=n.select(this);if((i=t[0].trace)._nexttrace){if(i._nextFill=e.select(".js-fill.js-tonext"),!i._nextFill.size()){var a=":first-child";e.select(".js-fill.js-tozero").size()&&(a+=" + *"),i._nextFill=e.insert("path",a).attr("class","js-fill js-tonext")}}else e.selectAll(".js-fill.js-tonext").remove(),i._nextFill=null;i.fill&&("tozero"===i.fill.substr(0,6)||"toself"===i.fill||"to"===i.fill.substr(0,2)&&!i._prevtrace)?(i._ownFill=e.select(".js-fill.js-tozero"),i._ownFill.size()||(i._ownFill=e.insert("path",":first-child").attr("class","js-fill js-tozero"))):(e.selectAll(".js-fill.js-tozero").remove(),i._ownFill=null),e.selectAll(".js-fill").call(o.setClipUrl,r.layerClipId)})}(0,i,e),l=0,u={};lu[e[0].trace.uid]?1:-1}),g)?(s&&(p=s()),n.transition().duration(a.duration).ease(a.easing).each("end",function(){p&&p()}).each("interrupt",function(){p&&p()}).each(function(){i.selectAll("g.trace").each(function(n,i){f(t,i,e,n,r,this,a)})})):i.selectAll("g.trace").each(function(n,i){f(t,i,e,n,r,this,a)});d&&h.exit().remove(),i.selectAll("path:not([d])").remove()}},{"../../components/drawing":557,"../../lib":660,"../../lib/polygon":672,"../../registry":790,"./line_points":1004,"./link_traces":1006,"./subtypes":1012,d3:131}],1010:[function(t,e,r){"use strict";var n=t("./subtypes");e.exports=function(t,e){var r,i,a,o,s=t.cd,l=t.xaxis,c=t.yaxis,u=[],f=s[0].trace;if(!n.hasMarkers(f)&&!n.hasText(f))return[];if(!1===e)for(r=0;r=0&&(p[1]+=1),h.indexOf("top")>=0&&(p[1]-=1),h.indexOf("left")>=0&&(p[0]-=1),h.indexOf("right")>=0&&(p[0]+=1),p)),r.textColor=u(e.textfont,1,E),r.textSize=x(e.textfont.size,E,l.identity,12),r.textFont=e.textfont.family,r.textAngle=0);var O=["x","y","z"];for(r.project=[!1,!1,!1],r.projectScale=[1,1,1],r.projectOpacity=[1,1,1],n=0;n<3;++n){var I=e.projection[O[n]];(r.project[n]=I.show)&&(r.projectOpacity[n]=I.opacity,r.projectScale[n]=I.scale)}r.errorBounds=d(e,b);var R=function(t){for(var e=[0,0,0],r=[[0,0,0],[0,0,0],[0,0,0]],n=[0,0,0],i=0;i<3;i++){var a=t[i];a&&!1!==a.copy_zstyle&&(a=t[2]),a&&(e[i]=a.width/2,r[i]=c(a.color),n=a.thickness)}return{capSize:e,color:r,lineWidth:n}}([e.error_x,e.error_y,e.error_z]);return r.errorColor=R.color,r.errorLineWidth=R.lineWidth,r.errorCapSize=R.capSize,r.delaunayAxis=e.surfaceaxis,r.delaunayColor=c(e.surfacecolor),r}function _(t){if(Array.isArray(t)){var e=t[0];return Array.isArray(e)&&(t=e),"rgb("+t.slice(0,3).map(function(t){return Math.round(255*t)})+")"}return null}m.handlePick=function(t){if(t.object&&(t.object===this.linePlot||t.object===this.delaunayMesh||t.object===this.textMarkers||t.object===this.scatterPlot)){t.object.highlight&&t.object.highlight(null),this.scatterPlot&&(t.object=this.scatterPlot,this.scatterPlot.highlight(t.data)),this.textLabels?void 0!==this.textLabels[t.data.index]?t.textLabel=this.textLabels[t.data.index]:t.textLabel=this.textLabels:t.textLabel="";var e=t.index=t.data.index;return t.traceCoordinate=[this.data.x[e],this.data.y[e],this.data.z[e]],!0}},m.update=function(t){var e,r,l,c,u=this.scene.glplot.gl,f=h.solid;this.data=t;var p=b(this.scene,t);"mode"in p&&(this.mode=p.mode),"lineDashes"in p&&p.lineDashes in h&&(f=h[p.lineDashes]),this.color=_(p.scatterColor)||_(p.lineColor),this.dataPoints=p.position,e={gl:u,position:p.position,color:p.lineColor,lineWidth:p.lineWidth||1,dashes:f[0],dashScale:f[1],opacity:t.opacity,connectGaps:t.connectgaps},-1!==this.mode.indexOf("lines")?this.linePlot?this.linePlot.update(e):(this.linePlot=n(e),this.linePlot._trace=this,this.scene.glplot.add(this.linePlot)):this.linePlot&&(this.scene.glplot.remove(this.linePlot),this.linePlot.dispose(),this.linePlot=null);var d=t.opacity;if(t.marker&&t.marker.opacity&&(d*=t.marker.opacity),r={gl:u,position:p.position,color:p.scatterColor,size:p.scatterSize,glyph:p.scatterMarker,opacity:d,orthographic:!0,lineWidth:p.scatterLineWidth,lineColor:p.scatterLineColor,project:p.project,projectScale:p.projectScale,projectOpacity:p.projectOpacity},-1!==this.mode.indexOf("markers")?this.scatterPlot?this.scatterPlot.update(r):(this.scatterPlot=i(r),this.scatterPlot._trace=this,this.scatterPlot.highlightScale=1,this.scene.glplot.add(this.scatterPlot)):this.scatterPlot&&(this.scene.glplot.remove(this.scatterPlot),this.scatterPlot.dispose(),this.scatterPlot=null),c={gl:u,position:p.position,glyph:p.text,color:p.textColor,size:p.textSize,angle:p.textAngle,alignment:p.textOffset,font:p.textFont,orthographic:!0,lineWidth:0,project:!1,opacity:t.opacity},this.textLabels=t.hovertext||t.text,-1!==this.mode.indexOf("text")?this.textMarkers?this.textMarkers.update(c):(this.textMarkers=i(c),this.textMarkers._trace=this,this.textMarkers.highlightScale=1,this.scene.glplot.add(this.textMarkers)):this.textMarkers&&(this.scene.glplot.remove(this.textMarkers),this.textMarkers.dispose(),this.textMarkers=null),l={gl:u,position:p.position,color:p.errorColor,error:p.errorBounds,lineWidth:p.errorLineWidth,capSize:p.errorCapSize,opacity:t.opacity},this.errorBars?p.errorBounds?this.errorBars.update(l):(this.scene.glplot.remove(this.errorBars),this.errorBars.dispose(),this.errorBars=null):p.errorBounds&&(this.errorBars=a(l),this.errorBars._trace=this,this.scene.glplot.add(this.errorBars)),p.delaunayAxis>=0){var g=function(t,e,r){var n,i=(r+1)%3,a=(r+2)%3,o=[],l=[];for(n=0;n=0&&f("surfacecolor",h||p);for(var d=["x","y","z"],g=0;g<3;++g){var m="projection."+d[g];f(m+".show")&&(f(m+".opacity"),f(m+".scale"))}var v=n.getComponentMethod("errorbars","supplyDefaults");v(t,e,r,{axis:"z"}),v(t,e,r,{axis:"y",inherit:"z"}),v(t,e,r,{axis:"x",inherit:"z"})}else e.visible=!1}},{"../../lib":660,"../../registry":790,"../scatter/line_defaults":1003,"../scatter/marker_defaults":1008,"../scatter/subtypes":1012,"../scatter/text_defaults":1013,"./attributes":1015}],1020:[function(t,e,r){"use strict";var n={};n.plot=t("./convert"),n.attributes=t("./attributes"),n.markerSymbols=t("../../constants/gl3d_markers"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.moduleType="trace",n.name="scatter3d",n.basePlotModule=t("../../plots/gl3d"),n.categories=["gl3d","symbols","markerColorscale","showLegend"],n.meta={},e.exports=n},{"../../constants/gl3d_markers":635,"../../plots/gl3d":748,"../scatter/colorbar":994,"./attributes":1015,"./calc":1016,"./convert":1018,"./defaults":1019}],1021:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../plots/attributes"),a=t("../../components/colorscale/color_attributes"),o=t("../../components/colorbar/attributes"),s=t("../../lib/extend").extendFlat,l=n.marker,c=n.line,u=l.line;e.exports={carpet:{valType:"string",editType:"calc"},a:{valType:"data_array",editType:"calc"},b:{valType:"data_array",editType:"calc"},mode:s({},n.mode,{dflt:"markers"}),text:s({},n.text,{}),line:{color:c.color,width:c.width,dash:c.dash,shape:s({},c.shape,{values:["linear","spline"]}),smoothing:c.smoothing,editType:"calc"},connectgaps:n.connectgaps,fill:s({},n.fill,{values:["none","toself","tonext"]}),fillcolor:n.fillcolor,marker:s({symbol:l.symbol,opacity:l.opacity,maxdisplayed:l.maxdisplayed,size:l.size,sizeref:l.sizeref,sizemin:l.sizemin,sizemode:l.sizemode,line:s({width:u.width,editType:"calc"},a("marker".line)),gradient:l.gradient,editType:"calc"},a("marker"),{showscale:l.showscale,colorbar:o}),textfont:n.textfont,textposition:n.textposition,selected:n.selected,unselected:n.unselected,hoverinfo:s({},i.hoverinfo,{flags:["a","b","text","name"]}),hoveron:n.hoveron}},{"../../components/colorbar/attributes":533,"../../components/colorscale/color_attributes":540,"../../lib/extend":649,"../../plots/attributes":703,"../scatter/attributes":990}],1022:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../scatter/colorscale_calc"),a=t("../scatter/arrays_to_calcdata"),o=t("../scatter/calc_selection"),s=t("../scatter/calc").calcMarkerSize,l=t("../carpet/lookup_carpetid");e.exports=function(t,e){var r=e._carpetTrace=l(t,e);if(r&&r.visible&&"legendonly"!==r.visible){var c;e.xaxis=r.xaxis,e.yaxis=r.yaxis;var u,f,h=e._length,p=new Array(h),d=!1;for(c=0;c"),a}function w(t,e){var r;r=t.labelprefix&&t.labelprefix.length>0?t.labelprefix.replace(/ = $/,""):t._hovertitle,g.push(r+": "+e.toFixed(3)+t.labelsuffix)}}},{"../scatter/hover":1001}],1026:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../scatter/style").style,n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("../scatter/select"),n.eventData=t("./event_data"),n.moduleType="trace",n.name="scattercarpet",n.basePlotModule=t("../../plots/cartesian"),n.categories=["svg","carpet","symbols","markerColorscale","showLegend","carpetDependent","zoomScale"],n.meta={},e.exports=n},{"../../plots/cartesian":717,"../scatter/colorbar":994,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1021,"./calc":1022,"./defaults":1023,"./event_data":1024,"./hover":1025,"./plot":1027}],1027:[function(t,e,r){"use strict";var n=t("../scatter/plot"),i=t("../../plots/cartesian/axes"),a=t("../../components/drawing");e.exports=function(t,e,r,o){var s,l,c,u=r[0][0].carpet,f={xaxis:i.getFromId(t,u.xaxis||"x"),yaxis:i.getFromId(t,u.yaxis||"y"),plot:e.plot};for(n(t,f,r,o),s=0;s")}(u,m,p.mockAxis,c[0].t.labels),[t]}}},{"../../components/fx":574,"../../constants/numerical":637,"../../plots/cartesian/axes":706,"../scatter/fill_hover_text":998,"../scatter/get_trace_color":1e3,"./attributes":1028}],1033:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("./style"),n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.moduleType="trace",n.name="scattergeo",n.basePlotModule=t("../../plots/geo"),n.categories=["geo","symbols","markerColorscale","showLegend","scatter-like"],n.meta={},e.exports=n},{"../../plots/geo":736,"../scatter/colorbar":994,"../scatter/style":1011,"./attributes":1028,"./calc":1029,"./defaults":1030,"./event_data":1031,"./hover":1032,"./plot":1034,"./select":1035,"./style":1036}],1034:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../constants/numerical").BADNUM,o=t("../../lib/topojson_utils").getTopojsonFeatures,s=t("../../lib/geo_location_utils").locationToFeature,l=t("../../lib/geojson_utils"),c=t("../scatter/subtypes"),u=t("./style");function f(t,e){var r=t[0].trace;if(Array.isArray(r.locations))for(var n=o(r,e),i=r.locationmode,l=0;ld.TOO_MANY_POINTS?"rect":h.hasMarkers(e)?"rect":"round";if(o&&e.connectgaps){var l=n[0],c=n[1];for(i=0;i1&&c.extendFlat(o.line,b(t,r,n)),o.errorX||o.errorY){var s=_(t,r,n,i,a);o.errorX&&c.extendFlat(o.errorX,s.x),o.errorY&&c.extendFlat(o.errorY,s.y)}return o}function A(t,e){var r=e._scene,n=t._fullLayout,i={count:0,dirty:!0,lineOptions:[],fillOptions:[],markerOptions:[],selectedOptions:[],unselectedOptions:[],errorXOptions:[],errorYOptions:[]};return e._scene||((r=e._scene=c.extendFlat({},i,{selectBatch:null,unselectBatch:null,fill2d:!1,scatter2d:!1,error2d:!1,line2d:!1,select2d:null})).update=function(t){for(var e=new Array(r.count),n=0;n=k&&(T.marker.cluster=m.tree),S.lineOptions.push(T.line),S.errorXOptions.push(T.errorX),S.errorYOptions.push(T.errorY),S.fillOptions.push(T.fill),S.markerOptions.push(T.marker),S.selectedOptions.push(T.selected),S.unselectedOptions.push(T.unselected),S.count++,m._scene=S,m.index=S.count-1,m.x=v,m.y=y,m.positions=x,m.count=u,t.firstscatter=!1,[{x:!1,y:!1,t:m,trace:e}]},plot:function(t,e,r){if(r.length){var o=t._fullLayout,s=r[0][0].t._scene,l=o.dragmode;if(s){var h=o._size,p=o.width,d=o.height;u(t,["ANGLE_instanced_arrays","OES_element_index_uint"]);var g=o._glcanvas.data()[0].regl;if(m(t,e,r),s.dirty){if(!0===s.error2d&&(s.error2d=a(g)),!0===s.line2d&&(s.line2d=i(g)),!0===s.scatter2d&&(s.scatter2d=n(g)),!0===s.fill2d&&(s.fill2d=i(g)),s.line2d&&s.line2d.update(s.lineOptions),s.error2d){var v=(s.errorXOptions||[]).concat(s.errorYOptions||[]);s.error2d.update(v)}s.scatter2d&&s.scatter2d.update(s.markerOptions),s.fill2d&&(s.fillOptions=s.fillOptions.map(function(t,e){var n=r[e];if(!(t&&n&&n[0]&&n[0].trace))return null;var i,a,o=n[0],l=o.trace,c=o.t,u=s.lineOptions[e],f=[],h=u&&u.positions||c.positions;if("tozeroy"===l.fill)(f=(f=[h[0],0]).concat(h)).push(h[h.length-2]),f.push(0);else if("tozerox"===l.fill)(f=(f=[0,h[1]]).concat(h)).push(0),f.push(h[h.length-1]);else if("toself"===l.fill||"tonext"===l.fill){for(f=[],i=0,a=0;a=0?Math.floor((e+180)/360):Math.ceil((e-180)/360)),d=e-p;if(n.getClosest(l,function(t){var e=t.lonlat;if(e[0]===s)return 1/0;var n=i.wrap180(e[0]),a=e[1],o=h.project([n,a]),l=o.x-u.c2p([d,a]),c=o.y-f.c2p([n,r]),p=Math.max(3,t.mrc||0);return Math.max(Math.sqrt(l*l+c*c)-p,1-3/p)},t),!1!==t.index){var g=l[t.index],m=g.lonlat,v=[i.wrap180(m[0])+p,m[1]],y=u.c2p(v),x=f.c2p(v),b=g.mrc||1;return t.x0=y-b,t.x1=y+b,t.y0=x-b,t.y1=x+b,t.color=a(c,g),t.extraText=function(t,e,r){var n=(e.hi||t.hoverinfo).split("+"),i=-1!==n.indexOf("all"),a=-1!==n.indexOf("lon"),s=-1!==n.indexOf("lat"),l=e.lonlat,c=[];function u(t){return t+"\xb0"}i||a&&s?c.push("("+u(l[0])+", "+u(l[1])+")"):a?c.push(r.lon+u(l[0])):s&&c.push(r.lat+u(l[1]));(i||-1!==n.indexOf("text"))&&o(e,t,c);return c.join("
")}(c,g,l[0].t.labels),[t]}}},{"../../components/fx":574,"../../constants/numerical":637,"../../lib":660,"../scatter/fill_hover_text":998,"../scatter/get_trace_color":1e3}],1047:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("../scattergeo/calc"),n.plot=t("./plot"),n.hoverPoints=t("./hover"),n.eventData=t("./event_data"),n.selectPoints=t("./select"),n.style=function(t,e){e&&e[0].trace._glTrace.update(e)},n.moduleType="trace",n.name="scattermapbox",n.basePlotModule=t("../../plots/mapbox"),n.categories=["mapbox","gl","symbols","markerColorscale","showLegend","scatterlike"],n.meta={},e.exports=n},{"../../plots/mapbox":762,"../scatter/colorbar":994,"../scattergeo/calc":1029,"./attributes":1042,"./defaults":1044,"./event_data":1045,"./hover":1046,"./plot":1048,"./select":1049}],1048:[function(t,e,r){"use strict";var n=t("./convert");function i(t,e){this.subplot=t,this.uid=e,this.sourceIds={fill:e+"-source-fill",line:e+"-source-line",circle:e+"-source-circle",symbol:e+"-source-symbol"},this.layerIds={fill:e+"-layer-fill",line:e+"-layer-line",circle:e+"-layer-circle",symbol:e+"-layer-symbol"},this.order=["fill","line","circle","symbol"]}var a=i.prototype;a.addSource=function(t,e){this.subplot.map.addSource(this.sourceIds[t],{type:"geojson",data:e.geojson})},a.setSourceData=function(t,e){this.subplot.map.getSource(this.sourceIds[t]).setData(e.geojson)},a.addLayer=function(t,e){this.subplot.map.addLayer({type:t,id:this.layerIds[t],source:this.sourceIds[t],layout:e.layout,paint:e.paint})},a.update=function(t){for(var e=this.subplot,r=n(t),i=0;i")}e.exports={hoverPoints:function(t,e,r,i){var a=n(t,e,r,i);if(a&&!1!==a[0].index){var s=a[0];if(void 0===s.index)return a;var l=t.subplot,c=s.cd[s.index],u=s.trace;if(l.isPtWithinSector(c))return s.xLabelVal=void 0,s.yLabelVal=void 0,s.extraText=o(c,u,l),a}},makeHoverPointText:o}},{"../../lib":660,"../../plots/cartesian/axes":706,"../scatter/hover":1001}],1054:[function(t,e,r){"use strict";e.exports={moduleType:"trace",name:"scatterpolar",basePlotModule:t("../../plots/polar"),categories:["polar","symbols","markerColorscale","showLegend","scatter-like"],attributes:t("./attributes"),supplyDefaults:t("./defaults"),calc:t("./calc"),plot:t("./plot"),style:t("../scatter/style").style,hoverPoints:t("./hover").hoverPoints,selectPoints:t("../scatter/select"),meta:{}}},{"../../plots/polar":771,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1050,"./calc":1051,"./defaults":1052,"./hover":1053,"./plot":1055}],1055:[function(t,e,r){"use strict";var n=t("../scatter/plot"),i=t("../../constants/numerical").BADNUM;e.exports=function(t,e,r){var a,o,s,l={xaxis:e.xaxis,yaxis:e.yaxis,plot:e.framework,layerClipId:e._hasClipOnAxisFalse?e.clipIds.circle:null},c=e.radialAxis,u=c.range;for(s=u[0]>u[1]?function(t){return t<=0}:function(t){return t>=0},a=0;a=0?(m=o.c2r(g)-l[0],T=v,y=s.c2rad(T,b.thetaunit),E[d]=C[2*d]=m*Math.cos(y),L[d]=C[2*d+1]=m*Math.sin(y)):E[d]=L[d]=C[2*d]=C[2*d+1]=NaN;var z=a.sceneOptions(t,e,b,C);z.fill&&!f.fill2d&&(f.fill2d=!0),z.marker&&!f.scatter2d&&(f.scatter2d=!0),z.line&&!f.line2d&&(f.line2d=!0),!z.errorX&&!z.errorY||f.error2d||(f.error2d=!0),_.tree=n(C),z.marker&&S>=u&&(z.marker.cluster=_.tree),c.hasMarkers(b)&&(z.selected.positions=z.unselected.positions=z.marker.positions),f.lineOptions.push(z.line),f.errorXOptions.push(z.errorX),f.errorYOptions.push(z.errorY),f.fillOptions.push(z.fill),f.markerOptions.push(z.marker),f.selectedOptions.push(z.selected),f.unselectedOptions.push(z.unselected),f.count=r.length,_._scene=f,_.index=p,_.x=E,_.y=L,_.rawx=E,_.rawy=L,_.r=w,_.theta=k,_.positions=C,_.count=S}}),a.plot(t,e,r)},hoverPoints:function(t,e,r,n){var i=t.cd[0].t,o=i.r,s=i.theta,c=a.hoverPoints(t,e,r,n);if(c&&!1!==c[0].index){var u=c[0];if(void 0===u.index)return c;var f=t.subplot,h=f.angularAxis,p=u.cd[u.index],d=u.trace;if(p.r=o[u.index],p.theta=s[u.index],p.rad=h.c2rad(p.theta,d.thetaunit),f.isPtWithinSector(p))return u.xLabelVal=void 0,u.yLabelVal=void 0,u.extraText=l(p,d,f),c}},style:a.style,selectPoints:a.selectPoints,meta:{}}},{"../../plots/cartesian/axes":706,"../../plots/polar":771,"../scatter/colorscale_calc":995,"../scatter/subtypes":1012,"../scattergl":1041,"../scattergl/constants":1038,"../scatterpolar/hover":1053,"./attributes":1056,"./defaults":1057,"fast-isnumeric":197,"point-cluster":411}],1059:[function(t,e,r){"use strict";var n=t("../scatter/attributes"),i=t("../../plots/attributes"),a=t("../../components/colorscale/color_attributes"),o=t("../../components/colorbar/attributes"),s=t("../../components/drawing/attributes").dash,l=t("../../lib/extend").extendFlat,c=n.marker,u=n.line,f=c.line;e.exports={a:{valType:"data_array",editType:"calc"},b:{valType:"data_array",editType:"calc"},c:{valType:"data_array",editType:"calc"},sum:{valType:"number",dflt:0,min:0,editType:"calc"},mode:l({},n.mode,{dflt:"markers"}),text:l({},n.text,{}),hovertext:l({},n.hovertext,{}),line:{color:u.color,width:u.width,dash:s,shape:l({},u.shape,{values:["linear","spline"]}),smoothing:u.smoothing,editType:"calc"},connectgaps:n.connectgaps,cliponaxis:n.cliponaxis,fill:l({},n.fill,{values:["none","toself","tonext"]}),fillcolor:n.fillcolor,marker:l({symbol:c.symbol,opacity:c.opacity,maxdisplayed:c.maxdisplayed,size:c.size,sizeref:c.sizeref,sizemin:c.sizemin,sizemode:c.sizemode,line:l({width:f.width,editType:"calc"},a("marker.line")),gradient:c.gradient,editType:"calc"},a("marker"),{showscale:c.showscale,colorbar:o}),textfont:n.textfont,textposition:n.textposition,selected:n.selected,unselected:n.unselected,hoverinfo:l({},i.hoverinfo,{flags:["a","b","c","text","name"]}),hoveron:n.hoveron}},{"../../components/colorbar/attributes":533,"../../components/colorscale/color_attributes":540,"../../components/drawing/attributes":556,"../../lib/extend":649,"../../plots/attributes":703,"../scatter/attributes":990}],1060:[function(t,e,r){"use strict";var n=t("fast-isnumeric"),i=t("../scatter/colorscale_calc"),a=t("../scatter/arrays_to_calcdata"),o=t("../scatter/calc_selection"),s=t("../scatter/calc").calcMarkerSize,l=["a","b","c"],c={a:["b","c"],b:["a","c"],c:["a","b"]};e.exports=function(t,e){var r,u,f,h,p,d,g=t._fullLayout[e.subplot].sum,m=e.sum||g,v={a:e.a,b:e.b,c:e.c};for(r=0;r"),o}function v(t,e){m.push(t._hovertitle+": "+i.tickText(t,e,"hover").text)}}},{"../../plots/cartesian/axes":706,"../scatter/hover":1001}],1064:[function(t,e,r){"use strict";var n={};n.attributes=t("./attributes"),n.supplyDefaults=t("./defaults"),n.colorbar=t("../scatter/colorbar"),n.calc=t("./calc"),n.plot=t("./plot"),n.style=t("../scatter/style").style,n.styleOnSelect=t("../scatter/style").styleOnSelect,n.hoverPoints=t("./hover"),n.selectPoints=t("../scatter/select"),n.eventData=t("./event_data"),n.moduleType="trace",n.name="scatterternary",n.basePlotModule=t("../../plots/ternary"),n.categories=["ternary","symbols","markerColorscale","showLegend","scatter-like"],n.meta={},e.exports=n},{"../../plots/ternary":783,"../scatter/colorbar":994,"../scatter/select":1010,"../scatter/style":1011,"./attributes":1059,"./calc":1060,"./defaults":1061,"./event_data":1062,"./hover":1063,"./plot":1065}],1065:[function(t,e,r){"use strict";var n=t("../scatter/plot");e.exports=function(t,e,r){var i=e.plotContainer;i.select(".scatterlayer").selectAll("*").remove();var a={xaxis:e.xaxis,yaxis:e.yaxis,plot:i,layerClipId:e._hasClipOnAxisFalse?e.clipIdRelative:null},o=e.layers.frontplot.select("g.scatterlayer");n(t,a,r,o)}},{"../scatter/plot":1009}],1066:[function(t,e,r){"use strict";var n=t("../scattergl/attributes"),i=t("../../plots/cartesian/constants").idRegex;function a(t){return{valType:"info_array",freeLength:!0,editType:"calc",items:{valType:"subplotid",regex:i[t],editType:"plot"}}}e.exports={dimensions:{_isLinkedToArray:"dimension",visible:{valType:"boolean",dflt:!0,editType:"calc"},label:{valType:"string",editType:"calc"},values:{valType:"data_array",editType:"calc+clearAxisTypes"},editType:"calc+clearAxisTypes"},text:n.text,marker:n.marker,xaxes:a("x"),yaxes:a("y"),diagonal:{visible:{valType:"boolean",dflt:!0,editType:"calc"},editType:"calc"},showupperhalf:{valType:"boolean",dflt:!0,editType:"calc"},showlowerhalf:{valType:"boolean",dflt:!0,editType:"calc"},selected:{marker:n.selected.marker,editType:"calc"},unselected:{marker:n.unselected.marker,editType:"calc"},opacity:n.opacity}},{"../../plots/cartesian/constants":711,"../scattergl/attributes":1037}],1067:[function(t,e,r){"use strict";var n=t("regl-line2d"),i=t("../../registry"),a=t("../../lib"),o=t("../../lib/prepare_regl"),s=t("../../plots/get_data").getModuleCalcData,l=t("../../plots/cartesian"),c=t("../../plots/cartesian/axis_ids"),u="splom";function f(t,e,r){for(var n=e.dimensions,i=r.matrixOptions.data.length,a=new Array(i),o=0,s=0;o1&&ra&&f?r._splomSubplots[y]=1:iv;for(r=0,n=0;r",maxDimensionCount:60,overdrag:45,releaseTransitionDuration:120,releaseTransitionEase:"cubic-out",scrollbarCaptureWidth:18,scrollbarHideDelay:1e3,scrollbarHideDuration:1e3,scrollbarOffset:5,scrollbarWidth:8,transitionDuration:100,transitionEase:"cubic-out",uplift:5,wrapSpacer:" ",wrapSplitCharacter:" ",cn:{table:"table",tableControlView:"table-control-view",scrollBackground:"scroll-background",yColumn:"y-column",columnBlock:"column-block",scrollAreaClip:"scroll-area-clip",scrollAreaClipRect:"scroll-area-clip-rect",columnBoundary:"column-boundary",columnBoundaryClippath:"column-boundary-clippath",columnBoundaryRect:"column-boundary-rect",columnCells:"column-cells",columnCell:"column-cell",cellRect:"cell-rect",cellText:"cell-text",cellTextHolder:"cell-text-holder",scrollbarKit:"scrollbar-kit",scrollbar:"scrollbar",scrollbarSlider:"scrollbar-slider",scrollbarGlyph:"scrollbar-glyph",scrollbarCaptureZone:"scrollbar-capture-zone"}}},{}],1080:[function(t,e,r){"use strict";var n=t("./constants"),i=t("../../lib/extend").extendFlat,a=t("fast-isnumeric");function o(t){if(Array.isArray(t)){for(var e=0,r=0;r=e||c===t.length-1)&&(n[i]=o,o.key=l++,o.firstRowIndex=s,o.lastRowIndex=c,o={firstRowIndex:null,lastRowIndex:null,rows:[]},i+=a,s=c+1,a=0);return n}e.exports=function(t,e){var r=l(e.cells.values),p=function(t){return t.slice(e.header.values.length,t.length)},d=l(e.header.values);d.length&&!d[0].length&&(d[0]=[""],d=l(d));var g=d.concat(p(r).map(function(){return c((d[0]||[""]).length)})),m=e.domain,v=Math.floor(t._fullLayout._size.w*(m.x[1]-m.x[0])),y=Math.floor(t._fullLayout._size.h*(m.y[1]-m.y[0])),x=e.header.values.length?g[0].map(function(){return e.header.height}):[n.emptyHeaderHeight],b=r.length?r[0].map(function(){return e.cells.height}):[],_=x.reduce(s,0),w=h(b,y-_+n.uplift),k=f(h(x,_),[]),M=f(w,k),A={},T=e._fullInput.columnorder.concat(p(r.map(function(t,e){return e}))),S=g.map(function(t,r){var n=Array.isArray(e.columnwidth)?e.columnwidth[Math.min(r,e.columnwidth.length-1)]:e.columnwidth;return a(n)?Number(n):1}),C=S.reduce(s,0);S=S.map(function(t){return t/C*v});var E=Math.max(o(e.header.line.width),o(e.cells.line.width)),L={key:e.index,translateX:m.x[0]*t._fullLayout._size.w,translateY:t._fullLayout._size.h*(1-m.y[1]),size:t._fullLayout._size,width:v,maxLineWidth:E,height:y,columnOrder:T,groupHeight:y,rowBlocks:M,headerRowBlocks:k,scrollY:0,cells:i({},e.cells,{values:r}),headerCells:i({},e.header,{values:g}),gdColumns:g.map(function(t){return t[0]}),gdColumnsOriginalOrder:g.map(function(t){return t[0]}),prevPages:[0,0],scrollbarState:{scrollbarScrollInProgress:!1},columns:g.map(function(t,e){var r=A[t];return A[t]=(r||0)+1,{key:t+"__"+A[t],label:t,specIndex:e,xIndex:T[e],xScale:u,x:void 0,calcdata:void 0,columnWidth:S[e]}})};return L.columns.forEach(function(t){t.calcdata=L,t.x=u(t)}),L}},{"../../lib/extend":649,"./constants":1079,"fast-isnumeric":197}],1081:[function(t,e,r){"use strict";var n=t("../../lib/extend").extendFlat;r.splitToPanels=function(t){var e=[0,0],r=n({},t,{key:"header",type:"header",page:0,prevPages:e,currentRepaint:[null,null],dragHandle:!0,values:t.calcdata.headerCells.values[t.specIndex],rowBlocks:t.calcdata.headerRowBlocks,calcdata:n({},t.calcdata,{cells:t.calcdata.headerCells})});return[n({},t,{key:"cells1",type:"cells",page:0,prevPages:e,currentRepaint:[null,null],dragHandle:!1,values:t.calcdata.cells.values[t.specIndex],rowBlocks:t.calcdata.rowBlocks}),n({},t,{key:"cells2",type:"cells",page:1,prevPages:e,currentRepaint:[null,null],dragHandle:!1,values:t.calcdata.cells.values[t.specIndex],rowBlocks:t.calcdata.rowBlocks}),r]},r.splitToCells=function(t){var e=function(t){var e=t.rowBlocks[t.page],r=e?e.rows[0].rowIndex:0,n=e?r+e.rows.length:0;return[r,n]}(t);return(t.values||[]).slice(e[0],e[1]).map(function(r,n){return{keyWithinBlock:n+("string"==typeof r&&r.match(/[<$&> ]/)?"_keybuster_"+Math.random():""),key:e[0]+n,column:t,calcdata:t.calcdata,page:t.page,rowBlocks:t.rowBlocks,value:r}})}},{"../../lib/extend":649}],1082:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./attributes"),a=t("../../plots/domain").defaults;e.exports=function(t,e,r,o){function s(r,a){return n.coerce(t,e,i,r,a)}a(e,o,s),s("columnwidth"),s("header.values"),s("header.format"),s("header.align"),s("header.prefix"),s("header.suffix"),s("header.height"),s("header.line.width"),s("header.line.color"),s("header.fill.color"),n.coerceFont(s,"header.font",n.extendFlat({},o.font)),function(t,e){for(var r=t.columnorder||[],n=t.header.values.length,i=r.slice(0,n),a=i.slice().sort(function(t,e){return t-e}),o=i.map(function(t){return a.indexOf(t)}),s=o.length;s/i),l=!o||s;t.mayHaveMarkup=o&&a.match(/[<&>]/);var c,u="string"==typeof(c=a)&&c.match(n.latexCheck);t.latex=u;var f,h,p=u?"":_(t.calcdata.cells.prefix,e,r)||"",d=u?"":_(t.calcdata.cells.suffix,e,r)||"",g=u?null:_(t.calcdata.cells.format,e,r)||null,m=p+(g?i.format(g)(t.value):t.value)+d;if(t.wrappingNeeded=!t.wrapped&&!l&&!u&&(f=b(m)),t.cellHeightMayIncrease=s||u||t.mayHaveMarkup||(void 0===f?b(m):f),t.needsConvertToTspans=t.mayHaveMarkup||t.wrappingNeeded||t.latex,t.wrappingNeeded){var v=(" "===n.wrapSplitCharacter?m.replace(/i&&n.push(a),i+=l}return n}(i,l,s);1===c.length&&(c[0]===i.length-1?c.unshift(c[0]-1):c.push(c[0]+1)),c[0]%2&&c.reverse(),e.each(function(t,e){t.page=c[e],t.scrollY=l}),e.attr("transform",function(t){return"translate(0 "+(D(t.rowBlocks,t.page)-t.scrollY)+")"}),t&&(C(t,r,e,c,n.prevPages,n,0),C(t,r,e,c,n.prevPages,n,1),v(r,t))}}function S(t,e,r,a){return function(o){var s=o.calcdata?o.calcdata:o,l=e.filter(function(t){return s.key===t.key}),c=r||s.scrollbarState.dragMultiplier;s.scrollY=void 0===a?s.scrollY+c*i.event.dy:a;var u=l.selectAll("."+n.cn.yColumn).selectAll("."+n.cn.columnBlock).filter(k);T(t,u,l)}}function C(t,e,r,n,i,a,o){n[o]!==i[o]&&(clearTimeout(a.currentRepaint[o]),a.currentRepaint[o]=setTimeout(function(){var a=r.filter(function(t,e){return e===o&&n[e]!==i[e]});y(t,e,a,r),i[o]=n[o]}))}function E(t,e,r){return function(){var a=i.select(e.parentNode);a.each(function(t){var e=t.fragments;a.selectAll("tspan.line").each(function(t,r){e[r].width=this.getComputedTextLength()});var r,i,o=e[e.length-1].width,s=e.slice(0,-1),l=[],c=0,u=t.column.columnWidth-2*n.cellPad;for(t.value="";s.length;)c+(i=(r=s.shift()).width+o)>u&&(t.value+=l.join(n.wrapSpacer)+n.lineBreaker,l=[],c=0),l.push(r.text),c+=i;c&&(t.value+=l.join(n.wrapSpacer)),t.wrapped=!0}),a.selectAll("tspan.line").remove(),x(a.select("."+n.cn.cellText),r,t),i.select(e.parentNode.parentNode).call(P)}}function L(t,e,r,a,o){return function(){if(!o.settledY){var s=i.select(e.parentNode),l=R(o),c=o.key-l.firstRowIndex,u=l.rows[c].rowHeight,f=o.cellHeightMayIncrease?e.parentNode.getBoundingClientRect().height+2*n.cellPad:u,h=Math.max(f,u);h-l.rows[c].rowHeight&&(l.rows[c].rowHeight=h,t.selectAll("."+n.cn.columnCell).call(P),T(null,t.filter(k),0),v(r,a,!0)),s.attr("transform",function(){var t=this.parentNode.getBoundingClientRect(),e=i.select(this.parentNode).select("."+n.cn.cellRect).node().getBoundingClientRect(),r=this.transform.baseVal.consolidate(),a=e.top-t.top+(r?r.matrix.f:n.cellPad);return"translate("+z(o,i.select(this.parentNode).select("."+n.cn.cellTextHolder).node().getBoundingClientRect().width)+" "+a+")"}),o.settledY=!0}}}function z(t,e){switch(t.align){case"left":return n.cellPad;case"right":return t.column.columnWidth-(e||0)-n.cellPad;case"center":return(t.column.columnWidth-(e||0))/2;default:return n.cellPad}}function P(t){t.attr("transform",function(t){var e=t.rowBlocks[0].auxiliaryBlocks.reduce(function(t,e){return t+O(e,1/0)},0);return"translate(0 "+(O(R(t),t.key)+e)+")"}).selectAll("."+n.cn.cellRect).attr("height",function(t){return(e=R(t),r=t.key,e.rows[r-e.firstRowIndex]).rowHeight;var e,r})}function D(t,e){for(var r=0,n=e-1;n>=0;n--)r+=I(t[n]);return r}function O(t,e){for(var r=0,n=0;n0){var y,x,b,_,w,k=t.xa,M=t.ya;"h"===h.orientation?(w=e,y="y",b=M,x="x",_=k):(w=r,y="x",b=k,x="y",_=M);var A=f[t.index];if(w>=A.span[0]&&w<=A.span[1]){var T=n.extendFlat({},t),S=_.c2p(w,!0),C=o.getKdeValue(A,h,w),E=o.getPositionOnKdePath(A,h,S),L=b._offset,z=b._length;T[y+"0"]=E[0],T[y+"1"]=E[1],T[x+"0"]=T[x+"1"]=S,T[x+"Label"]=x+": "+i.hoverLabelText(_,w)+", "+f[0].t.labels.kde+" "+C.toFixed(3),T.spikeDistance=v[0].spikeDistance;var P=y+"Spike";T[P]=v[0][P],v[0].spikeDistance=void 0,v[0][P]=void 0,m.push(T),(u={stroke:t.color})[y+"1"]=n.constrain(L+E[0],L,L+z),u[y+"2"]=n.constrain(L+E[1],L,L+z),u[x+"1"]=u[x+"2"]=_._offset+S}}}-1!==p.indexOf("points")&&(c=a.hoverOnPoints(t,e,r));var D=l.selectAll(".violinline-"+h.uid).data(u?[0]:[]);return D.enter().append("line").classed("violinline-"+h.uid,!0).attr("stroke-width",1.5),D.exit().remove(),D.attr(u),"closest"===s?c?[c]:m:c?(m.push(c),m):m}},{"../../lib":660,"../../plots/cartesian/axes":706,"../box/hover":816,"./helpers":1088}],1090:[function(t,e,r){"use strict";e.exports={attributes:t("./attributes"),layoutAttributes:t("./layout_attributes"),supplyDefaults:t("./defaults"),supplyLayoutDefaults:t("./layout_defaults"),calc:t("./calc"),setPositions:t("./set_positions"),plot:t("./plot"),style:t("./style"),styleOnSelect:t("../scatter/style").styleOnSelect,hoverPoints:t("./hover"),selectPoints:t("../box/select"),moduleType:"trace",name:"violin",basePlotModule:t("../../plots/cartesian"),categories:["cartesian","svg","symbols","oriented","box-violin","showLegend","violinLayout","zoomScale"],meta:{}}},{"../../plots/cartesian":717,"../box/select":821,"../scatter/style":1011,"./attributes":1085,"./calc":1086,"./defaults":1087,"./hover":1089,"./layout_attributes":1091,"./layout_defaults":1092,"./plot":1093,"./set_positions":1094,"./style":1095}],1091:[function(t,e,r){"use strict";var n=t("../box/layout_attributes"),i=t("../../lib").extendFlat;e.exports={violinmode:i({},n.boxmode,{}),violingap:i({},n.boxgap,{}),violingroupgap:i({},n.boxgroupgap,{})}},{"../../lib":660,"../box/layout_attributes":818}],1092:[function(t,e,r){"use strict";var n=t("../../lib"),i=t("./layout_attributes"),a=t("../box/layout_defaults");e.exports=function(t,e,r){a._supply(t,e,r,function(r,a){return n.coerce(t,e,i,r,a)},"violin")}},{"../../lib":660,"../box/layout_defaults":819,"./layout_attributes":1091}],1093:[function(t,e,r){"use strict";var n=t("d3"),i=t("../../lib"),a=t("../../components/drawing"),o=t("../box/plot"),s=t("../scatter/line_points"),l=t("./helpers");e.exports=function(t,e,r,c){var u=t._fullLayout,f=e.xaxis,h=e.yaxis;function p(t){var e=s(t,{xaxis:f,yaxis:h,connectGaps:!0,baseTolerance:.75,shape:"spline",simplify:!0});return a.smoothopen(e[0],1)}var d=c.selectAll("g.trace.violins").data(r,function(t){return t[0].trace.uid});d.enter().append("g").attr("class","trace violins"),d.exit().remove(),d.order(),d.each(function(t){var r=t[0],a=r.t,s=r.trace,c=n.select(this);e.isRangePlot||(r.node3=c);var d=u._numViolins,g="group"===u.violinmode&&d>1,m=1-u.violingap,v=a.bdPos=a.dPos*m*(1-u.violingroupgap)/(g?d:1),y=a.bPos=g?2*a.dPos*((a.num+.5)/d-.5)*m:0;if(a.wHover=a.dPos*(g?m/d:1),!0!==s.visible||a.empty)n.select(this).remove();else{var x=e[a.valLetter+"axis"],b=e[a.posLetter+"axis"],_="both"===s.side,w=_||"positive"===s.side,k=_||"negative"===s.side,M=s.box&&s.box.visible,A=s.meanline&&s.meanline.visible,T=u._violinScaleGroupStats[s.scalegroup],S=c.selectAll("path.violin").data(i.identity);if(S.enter().append("path").style("vector-effect","non-scaling-stroke").attr("class","violin"),S.exit().remove(),S.each(function(t){var e,r,i,o,l,c,u,f,h=n.select(this),d=t.density,g=d.length,m=t.pos+y,M=b.c2p(m);switch(s.scalemode){case"width":e=T.maxWidth/v;break;case"count":e=T.maxWidth/v*(T.maxCount/t.pts.length)}if(w){for(u=new Array(g),l=0;la&&(a=u,o=c)}}return a?i(o):s};case"rms":return function(t,e){for(var r=0,a=0,o=0;o":return function(t){return h(t)>s};case">=":return function(t){return h(t)>=s};case"[]":return function(t){var e=h(t);return e>=s[0]&&e<=s[1]};case"()":return function(t){var e=h(t);return e>s[0]&&e=s[0]&&es[0]&&e<=s[1]};case"][":return function(t){var e=h(t);return e<=s[0]||e>=s[1]};case")(":return function(t){var e=h(t);return es[1]};case"](":return function(t){var e=h(t);return e<=s[0]||e>s[1]};case")[":return function(t){var e=h(t);return e=s[1]};case"{}":return function(t){return-1!==s.indexOf(h(t))};case"}{":return function(t){return-1===s.indexOf(h(t))}}}(r,a.getDataToCoordFunc(t,e,s,i),h),x={},b={},_=0;d?(m=function(t){x[t.astr]=n.extendDeep([],t.get()),t.set(new Array(f))},v=function(t,e){var r=x[t.astr][e];t.get()[e]=r}):(m=function(t){x[t.astr]=n.extendDeep([],t.get()),t.set([])},v=function(t,e){var r=x[t.astr][e];t.get().push(r)}),M(m);for(var w=o(e.transforms,r),k=0;k1?"%{group} (%{trace})":"%{group}");var l=t.styles,c=o.styles=[];if(l)for(a=0;a Javascript ipywidget serializer + + This function must repalce all objects that the ipywidget library + can't serialize natively (e.g. numpy arrays) with serializable + representations + + Parameters + ---------- + v + Object to be serialized + widget_manager + ipywidget widget_manager (unused) + + Returns + ------- + any + Value that the ipywidget library can serialize natively + """ + + # Handle dict recursively + # ----------------------- + if isinstance(v, dict): + return {k: _py_to_js(v, widget_manager) for k, v in v.items()} + + # Handle list/tuple recursively + # ----------------------------- + elif isinstance(v, (list, tuple)): + return [_py_to_js(v, widget_manager) for v in v] + + # Handle numpy array + # ------------------ + elif np is not None and isinstance(v, np.ndarray): + # Convert 1D numpy arrays with numeric types to memoryviews with + # datatype and shape metadata. + if v.ndim == 1 and v.dtype.kind in ['u', 'i', 'f']: + return {'buffer': memoryview(v), + 'dtype': str(v.dtype), + 'shape': v.shape} + else: + # Convert all other numpy to lists + return v.tolist() + + # Handle Undefined + # ---------------- + if v is Undefined: + return '_undefined_' + + # Handle simple value + # ------------------- + else: + return v + + +def _js_to_py(v, widget_manager): + """ + Javascript -> Python ipywidget deserializer + + Parameters + ---------- + v + Object to be deserialized + widget_manager + ipywidget widget_manager (unused) + + Returns + ------- + any + Deserialized object for use by the Python side of the library + """ + # Handle dict + # ----------- + if isinstance(v, dict): + return {k: _js_to_py(v, widget_manager) for k, v in v.items()} + + # Handle list/tuple + # ----------------- + elif isinstance(v, (list, tuple)): + return [_js_to_py(v, widget_manager) for v in v] + + # Handle Undefined + # ---------------- + elif isinstance(v, str) and v == '_undefined_': + return Undefined + + # Handle simple value + # ------------------- + else: + return v + + +# Custom serializer dict for use in ipywidget traitlet definitions +custom_serializers = { + 'from_json': _js_to_py, + 'to_json': _py_to_js +} diff --git a/plotly/tests/test_core/test_api/__init__.py b/plotly/tests/test_core/test_api/__init__.py index f8a93ee023..688eb8c8b8 100644 --- a/plotly/tests/test_core/test_api/__init__.py +++ b/plotly/tests/test_core/test_api/__init__.py @@ -1,11 +1,18 @@ from __future__ import absolute_import -from mock import patch from requests import Response from plotly.session import sign_in from plotly.tests.utils import PlotlyTestCase +import sys + +# import from mock +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import patch +else: + from mock import patch + class PlotlyApiTestCase(PlotlyTestCase): @@ -37,7 +44,7 @@ def setUp(self): api_key=self.api_key, proxy_username=self.proxy_username, proxy_password=self.proxy_password, - stream_ids = self.stream_ids, + stream_ids=self.stream_ids, plotly_domain=self.plotly_domain, plotly_api_domain=self.plotly_api_domain, plotly_streaming_domain=self.plotly_streaming_domain, diff --git a/plotly/tests/test_core/test_api/test_v1/test_clientresp.py b/plotly/tests/test_core/test_api/test_v1/test_clientresp.py index 784ca08764..18ee643549 100644 --- a/plotly/tests/test_core/test_api/test_v1/test_clientresp.py +++ b/plotly/tests/test_core/test_api/test_v1/test_clientresp.py @@ -25,7 +25,8 @@ def setUp(self): def test_data_only(self): data = [{'y': [3, 5], 'name': Duck()}] clientresp(data) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 + args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -33,7 +34,7 @@ def test_data_only(self): expected_data = ({ 'origin': 'plot', 'args': '[{"name": "what else floats?", "y": [3, 5]}]', - 'platform': 'python', 'version': version.__version__, 'key': 'bar', + 'platform': 'python', 'version': version.stable_semver(), 'key': 'bar', 'kwargs': '{}', 'un': 'foo' }) self.assertEqual(kwargs['data'], expected_data) @@ -44,7 +45,7 @@ def test_data_and_kwargs(self): data = [{'y': [3, 5], 'name': Duck()}] clientresp_kwargs = {'layout': {'title': 'mah plot'}, 'filename': 'ok'} clientresp(data, **clientresp_kwargs) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -52,7 +53,7 @@ def test_data_and_kwargs(self): expected_data = ({ 'origin': 'plot', 'args': '[{"name": "what else floats?", "y": [3, 5]}]', - 'platform': 'python', 'version': version.__version__, 'key': 'bar', + 'platform': 'python', 'version': version.stable_semver(), 'key': 'bar', 'kwargs': '{"filename": "ok", "layout": {"title": "mah plot"}}', 'un': 'foo' }) diff --git a/plotly/tests/test_core/test_api/test_v1/test_utils.py b/plotly/tests/test_core/test_api/test_v1/test_utils.py index dee352db78..42ffcc613d 100644 --- a/plotly/tests/test_core/test_api/test_v1/test_utils.py +++ b/plotly/tests/test_core/test_api/test_v1/test_utils.py @@ -2,7 +2,6 @@ from unittest import TestCase -from mock import MagicMock, patch from requests import Response from requests.compat import json as _json from requests.exceptions import ConnectionError @@ -14,6 +13,14 @@ from plotly.tests.test_core.test_api import PlotlyApiTestCase from plotly.tests.utils import PlotlyTestCase +import sys + +# import from mock, MagicMock +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock, patch +else: + from mock import patch, MagicMock + class ValidateResponseTest(PlotlyApiTestCase): @@ -172,4 +179,4 @@ def test_request_validate_response(self): # Finally, we check details elsewhere, but make sure we do validate. utils.request(self.method, self.url) - self.validate_response_mock.assert_called_once() + assert self.validate_response_mock.call_count == 1 diff --git a/plotly/tests/test_core/test_api/test_v2/test_files.py b/plotly/tests/test_core/test_api/test_v2/test_files.py index 32e4ec9934..033c7e4655 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_files.py +++ b/plotly/tests/test_core/test_api/test_v2/test_files.py @@ -18,7 +18,7 @@ def setUp(self): def test_retrieve(self): files.retrieve('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -29,7 +29,7 @@ def test_retrieve(self): def test_retrieve_share_key(self): files.retrieve('hodor:88', share_key='foobar') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -41,7 +41,7 @@ def test_retrieve_share_key(self): def test_update(self): new_filename = '..zzZ ..zzZ' files.update('hodor:88', body={'filename': new_filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'put') @@ -53,7 +53,7 @@ def test_update(self): def test_trash(self): files.trash('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -63,7 +63,7 @@ def test_trash(self): def test_restore(self): files.restore('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -73,7 +73,7 @@ def test_restore(self): def test_permanent_delete(self): files.permanent_delete('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'delete') @@ -92,7 +92,7 @@ def test_lookup(self): user = 'someone' exists = True files.lookup(path=path, parent=parent, user=user, exists=exists) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args expected_params = {'path': path, 'parent': parent, 'exists': 'true', diff --git a/plotly/tests/test_core/test_api/test_v2/test_folders.py b/plotly/tests/test_core/test_api/test_v2/test_folders.py index 0365ad7987..871a9d17c3 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_folders.py +++ b/plotly/tests/test_core/test_api/test_v2/test_folders.py @@ -19,7 +19,7 @@ def setUp(self): def test_create(self): path = '/foo/man/bar/' folders.create({'path': path}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -28,7 +28,7 @@ def test_create(self): def test_retrieve(self): folders.retrieve('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -39,7 +39,7 @@ def test_retrieve(self): def test_retrieve_share_key(self): folders.retrieve('hodor:88', share_key='foobar') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -51,7 +51,7 @@ def test_retrieve_share_key(self): def test_update(self): new_filename = '..zzZ ..zzZ' folders.update('hodor:88', body={'filename': new_filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'put') @@ -63,7 +63,7 @@ def test_update(self): def test_trash(self): folders.trash('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -73,7 +73,7 @@ def test_trash(self): def test_restore(self): folders.restore('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -83,7 +83,7 @@ def test_restore(self): def test_permanent_delete(self): folders.permanent_delete('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'delete') @@ -102,7 +102,7 @@ def test_lookup(self): user = 'someone' exists = True folders.lookup(path=path, parent=parent, user=user, exists=exists) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args expected_params = {'path': path, 'parent': parent, 'exists': 'true', diff --git a/plotly/tests/test_core/test_api/test_v2/test_grids.py b/plotly/tests/test_core/test_api/test_v2/test_grids.py index ff6fb3ec1b..47ebb059fd 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_grids.py +++ b/plotly/tests/test_core/test_api/test_v2/test_grids.py @@ -21,7 +21,7 @@ def setUp(self): def test_create(self): filename = 'a grid' grids.create({'filename': filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -32,7 +32,7 @@ def test_create(self): def test_retrieve(self): grids.retrieve('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -43,7 +43,7 @@ def test_retrieve(self): def test_retrieve_share_key(self): grids.retrieve('hodor:88', share_key='foobar') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -55,7 +55,7 @@ def test_retrieve_share_key(self): def test_update(self): new_filename = '..zzZ ..zzZ' grids.update('hodor:88', body={'filename': new_filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'put') @@ -67,7 +67,7 @@ def test_update(self): def test_trash(self): grids.trash('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -77,7 +77,7 @@ def test_trash(self): def test_restore(self): grids.restore('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -87,7 +87,7 @@ def test_restore(self): def test_permanent_delete(self): grids.permanent_delete('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'delete') @@ -106,7 +106,7 @@ def test_lookup(self): user = 'someone' exists = True grids.lookup(path=path, parent=parent, user=user, exists=exists) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args expected_params = {'path': path, 'parent': parent, 'exists': 'true', @@ -124,7 +124,7 @@ def test_col_create(self): ] body = {'cols': _json.dumps(cols, sort_keys=True)} grids.col_create('hodor:88', body) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -135,7 +135,7 @@ def test_col_create(self): def test_col_retrieve(self): grids.col_retrieve('hodor:88', 'aaaaaa,bbbbbb') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -151,7 +151,7 @@ def test_col_update(self): ] body = {'cols': _json.dumps(cols, sort_keys=True)} grids.col_update('hodor:88', 'aaaaaa,bbbbbb', body) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'put') @@ -163,7 +163,7 @@ def test_col_update(self): def test_col_delete(self): grids.col_delete('hodor:88', 'aaaaaa,bbbbbb') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'delete') @@ -175,7 +175,7 @@ def test_col_delete(self): def test_row(self): body = {'rows': [[1, 'A'], [2, 'B']]} grids.row('hodor:88', body) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') diff --git a/plotly/tests/test_core/test_api/test_v2/test_images.py b/plotly/tests/test_core/test_api/test_v2/test_images.py index 480cf0f05b..df330cc8d8 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_images.py +++ b/plotly/tests/test_core/test_api/test_v2/test_images.py @@ -33,7 +33,7 @@ def test_create(self): } images.create(body) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') diff --git a/plotly/tests/test_core/test_api/test_v2/test_plot_schema.py b/plotly/tests/test_core/test_api/test_v2/test_plot_schema.py index b52f1b3a00..edc7d2a511 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_plot_schema.py +++ b/plotly/tests/test_core/test_api/test_v2/test_plot_schema.py @@ -19,7 +19,7 @@ def setUp(self): def test_retrieve(self): plot_schema.retrieve('some-hash', timeout=400) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') diff --git a/plotly/tests/test_core/test_api/test_v2/test_plots.py b/plotly/tests/test_core/test_api/test_v2/test_plots.py index 31d50cb7aa..f43fbca223 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_plots.py +++ b/plotly/tests/test_core/test_api/test_v2/test_plots.py @@ -19,7 +19,7 @@ def setUp(self): def test_create(self): filename = 'a plot' plots.create({'filename': filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -30,7 +30,7 @@ def test_create(self): def test_retrieve(self): plots.retrieve('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -41,7 +41,7 @@ def test_retrieve(self): def test_retrieve_share_key(self): plots.retrieve('hodor:88', share_key='foobar') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') @@ -53,7 +53,7 @@ def test_retrieve_share_key(self): def test_update(self): new_filename = '..zzZ ..zzZ' plots.update('hodor:88', body={'filename': new_filename}) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'put') @@ -65,7 +65,7 @@ def test_update(self): def test_trash(self): plots.trash('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -75,7 +75,7 @@ def test_trash(self): def test_restore(self): plots.restore('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'post') @@ -85,7 +85,7 @@ def test_restore(self): def test_permanent_delete(self): plots.permanent_delete('hodor:88') - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'delete') @@ -104,7 +104,7 @@ def test_lookup(self): user = 'someone' exists = True plots.lookup(path=path, parent=parent, user=user, exists=exists) - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args expected_params = {'path': path, 'parent': parent, 'exists': 'true', diff --git a/plotly/tests/test_core/test_api/test_v2/test_users.py b/plotly/tests/test_core/test_api/test_v2/test_users.py index 59cf8731d5..2c192b6bc4 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_users.py +++ b/plotly/tests/test_core/test_api/test_v2/test_users.py @@ -18,7 +18,7 @@ def setUp(self): def test_current(self): users.current() - self.request_mock.assert_called_once() + assert self.request_mock.call_count == 1 args, kwargs = self.request_mock.call_args method, url = args self.assertEqual(method, 'get') diff --git a/plotly/tests/test_core/test_api/test_v2/test_utils.py b/plotly/tests/test_core/test_api/test_v2/test_utils.py index c370ef418e..0b1b83400e 100644 --- a/plotly/tests/test_core/test_api/test_v2/test_utils.py +++ b/plotly/tests/test_core/test_api/test_v2/test_utils.py @@ -167,7 +167,7 @@ class GetHeadersTest(PlotlyApiTestCase): def test_normal_auth(self): headers = utils.get_headers() expected_headers = { - 'plotly-client-platform': 'python {}'.format(version.__version__), + 'plotly-client-platform': 'python {}'.format(version.stable_semver()), 'authorization': 'Basic Zm9vOmJhcg==', 'content-type': 'application/json' } @@ -177,7 +177,7 @@ def test_proxy_auth(self): sign_in(self.username, self.api_key, plotly_proxy_authorization=True) headers = utils.get_headers() expected_headers = { - 'plotly-client-platform': 'python {}'.format(version.__version__), + 'plotly-client-platform': 'python {}'.format(version.stable_semver()), 'authorization': 'Basic Y25ldDpob29wbGE=', 'plotly-authorization': 'Basic Zm9vOmJhcg==', 'content-type': 'application/json' @@ -249,4 +249,4 @@ def test_request_validate_response(self): # Finally, we check details elsewhere, but make sure we do validate. utils.request(self.method, self.url) - self.validate_response_mock.assert_called_once() + assert self.request_mock.call_count == 1 diff --git a/plotly/tests/test_core/test_figure_messages/__init__.py b/plotly/tests/test_core/test_figure_messages/__init__.py new file mode 100644 index 0000000000..8b13789179 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/__init__.py @@ -0,0 +1 @@ + diff --git a/plotly/tests/test_core/test_figure_messages/test_add_traces.py b/plotly/tests/test_core/test_figure_messages/test_add_traces.py new file mode 100644 index 0000000000..839cc1ff2f --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_add_traces.py @@ -0,0 +1,62 @@ +import sys +from unittest import TestCase + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestAddTracesMessage(TestCase): + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[ + go.Scatter(y=[3, 2, 1], marker={'color': 'green'}), + go.Bar(y=[3, 2, 1, 0, -1], marker={'opacity': 0.5})], + layout={'xaxis': {'range': [-1, 4]}}, + frames=[go.Frame( + layout={'yaxis': + {'title': 'f1'}})]) + + # Mock out the message method + self.figure._send_addTraces_msg = MagicMock() + + def test_add_trace(self): + # Add a trace + self.figure.add_trace(go.Sankey(arrangement='snap')) + + # Check access properties + self.assertEqual(self.figure.data[-1].type, 'sankey') + self.assertEqual(self.figure.data[-1].arrangement, 'snap') + + # Check message + new_uid = self.figure.data[-1].uid + self.figure._send_addTraces_msg.assert_called_once_with( + [{'type': 'sankey', 'arrangement': 'snap', 'uid': new_uid}]) + + def test_add_traces(self): + + # Add two traces + self.figure.add_traces([go.Sankey(arrangement='snap'), + go.Histogram2dContour( + line={'color': 'cyan'})]) + + # Check access properties + self.assertEqual(self.figure.data[-2].type, 'sankey') + self.assertEqual(self.figure.data[-2].arrangement, 'snap') + + self.assertEqual(self.figure.data[-1].type, 'histogram2dcontour') + self.assertEqual(self.figure.data[-1].line.color, 'cyan') + + # Check message + new_uid1 = self.figure.data[-2].uid + new_uid2 = self.figure.data[-1].uid + self.figure._send_addTraces_msg.assert_called_once_with( + [{'type': 'sankey', + 'arrangement': 'snap', + 'uid': new_uid1}, + {'type': 'histogram2dcontour', + 'line': {'color': 'cyan'}, + 'uid': new_uid2}]) diff --git a/plotly/tests/test_core/test_figure_messages/test_batch_animate.py b/plotly/tests/test_core/test_figure_messages/test_batch_animate.py new file mode 100644 index 0000000000..58166f8f86 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_batch_animate.py @@ -0,0 +1,61 @@ +import sys +from unittest import TestCase + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestBatchAnimateMessage(TestCase): + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[ + go.Scatter(y=[3, 2, 1], marker={'color': 'green'}), + go.Bar(y=[3, 2, 1, 0, -1], marker={'opacity': 0.5})], + layout={'xaxis': {'range': [-1, 4]}}, + frames=[go.Frame( + layout={'yaxis': + {'title': 'f1'}})]) + + # Mock out the message method + self.figure._send_animate_msg = MagicMock() + + def test_batch_animate(self): + + with self.figure.batch_animate(easing='elastic', duration=1200): + + # Assign trace property + self.figure.data[0].marker.color = 'yellow' + self.figure.data[1].marker.opacity = 0.9 + + # Assign layout property + self.figure.layout.xaxis.range = [10, 20] + + # Assign frame property + self.figure.frames[0].layout.yaxis.title = 'f2' + + # Make sure that trace/layout assignments haven't been applied yet + self.assertEqual(self.figure.data[0].marker.color, 'green') + self.assertEqual(self.figure.data[1].marker.opacity, 0.5) + self.assertEqual(self.figure.layout.xaxis.range, (-1, 4)) + + # Expect the frame update to be applied immediately + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f2') + + # Make sure that trace/layout assignments have been applied after + # context exits + self.assertEqual(self.figure.data[0].marker.color, 'yellow') + self.assertEqual(self.figure.data[1].marker.opacity, 0.9) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + # Check that update message was sent + self.figure._send_animate_msg.assert_called_once_with( + styles_data=[{'marker.color': 'yellow'}, {'marker.opacity': 0.9}], + relayout_data={'xaxis.range': [10, 20]}, + trace_indexes=[0, 1], + animation_opts={'transition': {'easing': 'elastic', + 'duration': 1200}, + 'frame': {'duration': 1200}}) diff --git a/plotly/tests/test_core/test_figure_messages/test_move_delete_traces.py b/plotly/tests/test_core/test_figure_messages/test_move_delete_traces.py new file mode 100644 index 0000000000..b622c98819 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_move_delete_traces.py @@ -0,0 +1,96 @@ +import sys +from unittest import TestCase +from nose.tools import raises + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestMoveDeleteTracesMessages(TestCase): + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[ + go.Scatter(y=[3, 2, 1], marker={'color': 'green'}), + go.Bar(y=[3, 2, 1, 0, -1], marker={'opacity': 0.5}), + go.Sankey(arrangement='snap') + ]) + + # Mock out the message methods + self.figure._send_moveTraces_msg = MagicMock() + self.figure._send_deleteTraces_msg = MagicMock() + + def test_move_traces_swap(self): + + # Swap first and last trace + traces = self.figure.data + self.figure.data = [traces[2], traces[1], traces[0]] + + # Check messages + self.figure._send_moveTraces_msg.assert_called_once_with( + [0, 1, 2], [2, 1, 0]) + self.assertFalse(self.figure._send_deleteTraces_msg.called) + + def test_move_traces_cycle(self): + + # Cycle traces forward + traces = self.figure.data + self.figure.data = [traces[2], traces[0], traces[1]] + + # Check messages + self.figure._send_moveTraces_msg.assert_called_once_with( + [0, 1, 2], [1, 2, 0]) + self.assertFalse(self.figure._send_deleteTraces_msg.called) + + def test_delete_single_traces(self): + # Delete middle trace + traces = self.figure.data + self.figure.data = [traces[0], traces[2]] + + # Check messages + self.figure._send_deleteTraces_msg.assert_called_once_with([1]) + self.assertFalse(self.figure._send_moveTraces_msg.called) + + def test_delete_multiple_traces(self): + # Delete middle trace + traces = self.figure.data + self.figure.data = [traces[1]] + + # Check messages + self.figure._send_deleteTraces_msg.assert_called_once_with([0, 2]) + self.assertFalse(self.figure._send_moveTraces_msg.called) + + def test_delete_all_traces(self): + # Delete middle trace + self.figure.data = [] + + # Check messages + self.figure._send_deleteTraces_msg.assert_called_once_with([0, 1, 2]) + self.assertFalse(self.figure._send_moveTraces_msg.called) + + def test_move_and_delete_traces(self): + # Delete middle trace + traces = self.figure.data + self.figure.data = [traces[2], traces[0]] + + # Check messages + self.figure._send_deleteTraces_msg.assert_called_once_with([1]) + self.figure._send_moveTraces_msg.assert_called_once_with( + [0, 1], [1, 0]) + + @raises(ValueError) + def test_validate_assigned_traces_are_subset(self): + traces = self.figure.data + self.figure.data = [traces[2], + go.Scatter(y=[3, 2, 1]), + traces[1]] + + @raises(ValueError) + def test_validate_assigned_traces_are_not_duplicates(self): + traces = self.figure.data + self.figure.data = [traces[2], + traces[1], + traces[1]] \ No newline at end of file diff --git a/plotly/tests/test_core/test_figure_messages/test_on_change.py b/plotly/tests/test_core/test_figure_messages/test_on_change.py new file mode 100644 index 0000000000..d6b4c236fe --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_on_change.py @@ -0,0 +1,272 @@ +import sys +from unittest import TestCase +from nose.tools import raises + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestOnChangeCallbacks(TestCase): + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[ + go.Scatter(y=[3, 2, 1], marker={'color': 'green'}), + go.Bar(y=[3, 2, 1, 0, -1], marker={'opacity': 0.5})], + layout={ + 'xaxis': {'range': [-1, 4]}, + 'width': 1000}, + frames=[go.Frame( + layout={'yaxis': + {'title': 'f1'}})]) + + # on_change validation + # -------------------- + @raises(ValueError) + def test_raise_if_no_figure(self): + scatt = go.Scatter() + fn = MagicMock() + scatt.on_change(fn, 'x') + + @raises(ValueError) + def test_raise_on_frame_hierarchy(self): + fn = MagicMock() + self.figure.frames[0].layout.xaxis.on_change(fn, 'range') + + @raises(ValueError) + def test_validate_property_path_nested(self): + fn = MagicMock() + self.figure.layout.xaxis.on_change(fn, 'bogus') + + @raises(ValueError) + def test_validate_property_path_nested(self): + fn = MagicMock() + self.figure.layout.on_change(fn, 'xaxis.titlefont.bogus') + + # Python triggered changes + # ------------------------ + def test_single_prop_callback_on_assignment(self): + # Install callbacks on 'x', and 'y' property of first trace + fn_x = MagicMock() + fn_y = MagicMock() + self.figure.data[0].on_change(fn_x, 'x') + self.figure.data[0].on_change(fn_y, 'y') + + # Setting x and y on second trace does not trigger callback + self.figure.data[1].x = [1, 2, 3] + self.figure.data[1].y = [1, 2, 3] + + self.assertFalse(fn_x.called) + self.assertFalse(fn_y.called) + + # Set x on first trace + self.figure.data[0].x = [10, 20, 30] + fn_x.assert_called_once_with(self.figure.data[0], (10, 20, 30)) + self.assertFalse(fn_y.called) + + # Set y on first trace + self.figure.data[0].y = [11, 22, 33] + fn_y.assert_called_once_with(self.figure.data[0], (11, 22, 33)) + + def test_multi_prop_callback_on_assignment_trace(self): + # Register callback if either 'x' or 'y' changes on first trace + fn = MagicMock() + self.figure.data[0].on_change(fn, 'x', 'y') + + # Perform assignment on one of the properties + self.figure.data[0].x = [11, 22, 33] + + # Check function called once with new value of x and old value of y + fn.assert_called_once_with(self.figure.data[0], + (11, 22, 33), + (3, 2, 1)) + + def test_multi_prop_callback_on_assignment_layout(self): + fn_range = MagicMock() + + # Register callback if either axis range is changed. Both tuple and + # dot syntax are supported for nested properties + self.figure.layout.on_change(fn_range, + ('xaxis', 'range'), + 'yaxis.range') + + self.figure.layout.xaxis.range = [-10, 10] + fn_range.assert_called_once_with(self.figure.layout, (-10, 10), None) + + def test_multi_prop_callback_on_assignment_layout_nested(self): + fn_titlefont = MagicMock() + fn_xaxis = MagicMock() + fn_layout = MagicMock() + + # Register callback on change to family property under titlefont + self.figure.layout.xaxis.titlefont.on_change(fn_titlefont, + 'family') + + # Register callback on the range and titlefont.family properties + # under xaxis + self.figure.layout.xaxis.on_change(fn_xaxis, + 'range', + 'titlefont.family') + + # Register callback on xaxis object itself + self.figure.layout.on_change(fn_layout, 'xaxis') + + # Assign a new xaxis range and titlefont.family + self.figure.layout.xaxis.titlefont.family = 'courier' + + # Check that all callbacks were executed once + fn_titlefont.assert_called_once_with( + self.figure.layout.xaxis.titlefont, + 'courier') + + fn_xaxis.assert_called_once_with( + self.figure.layout.xaxis, + (-1, 4), + 'courier') + + fn_layout.assert_called_once_with( + self.figure.layout, + go.layout.XAxis(range=(-1, 4), titlefont={'family': 'courier'})) + + def test_prop_callback_nested_arrays(self): + + # Initialize updatemenus and buttons + self.figure.layout.updatemenus = [{}, {}, {}] + self.figure.layout.updatemenus[2].buttons = [{}, {}] + self.figure.layout.updatemenus[2].buttons[1].label = 'button 1' + self.figure.layout.updatemenus[2].buttons[1].method = 'relayout' + + # Register method callback + fn_button = MagicMock() + fn_layout = MagicMock() + + self.figure.layout.updatemenus[2].buttons[1].on_change( + fn_button, 'method') + + self.figure.layout.on_change( + fn_layout, 'updatemenus[2].buttons[1].method') + + # Update button method + self.figure.layout.updatemenus[2].buttons[1].method = 'restyle' + + # Check that both callbacks are called once + fn_button.assert_called_once_with( + self.figure.layout.updatemenus[2].buttons[1], 'restyle') + + fn_layout.assert_called_once_with(self.figure.layout, 'restyle') + + def test_callback_on_update(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range') + + self.figure.update({'layout': {'yaxis': {'range': [11, 22]}}}) + fn_range.assert_called_once_with(self.figure.layout, + (-1, 4), + (11, 22)) + + def test_callback_on_update_single_call(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range', + 'width') + + self.figure.update({'layout': { + 'xaxis': {'range': [-10, 10]}, + 'yaxis': {'range': [11, 22]}}}) + + # Even though both properties changed, callback should be called + # only once with the new value of both properties + fn_range.assert_called_once_with(self.figure.layout, + (-10, 10), + (11, 22), + 1000) + + def test_callback_on_batch_update(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range', + 'width') + + with self.figure.batch_update(): + self.figure.layout.xaxis.range = [-10, 10] + self.figure.layout.width = 500 + # Check fn not called before context exits + self.assertFalse(fn_range.called) + + fn_range.assert_called_once_with(self.figure.layout, + (-10, 10), + None, + 500) + + def test_callback_on_batch_animate(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range', + 'width') + + with self.figure.batch_animate(): + self.figure['layout.xaxis.range'] = [-10, 10] + self.figure[('layout', 'yaxis', 'range')] = (11, 22) + # Check fn not called before context exits + self.assertFalse(fn_range.called) + + fn_range.assert_called_once_with(self.figure.layout, + (-10, 10), + (11, 22), + 1000) + + def test_callback_on_plotly_relayout(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range', + 'width') + + self.figure.plotly_relayout( + relayout_data={'xaxis.range': [-10, 10], + 'yaxis.range': [11, 22]}) + + fn_range.assert_called_once_with(self.figure.layout, + (-10, 10), + (11, 22), + 1000) + + def test_callback_on_plotly_restyle(self): + # Register callback if either 'x' or 'y' changes on first trace + fn = MagicMock() + self.figure.data[0].on_change(fn, 'x', 'y') + + # Perform assignment on one of pthe properties + self.figure.plotly_restyle({'x': [[11, 22, 33], + [1, 11, 111]]}, + trace_indexes=[0, 1]) + + # Check function called once with new value of x and old value of y + fn.assert_called_once_with(self.figure.data[0], + (11, 22, 33), + (3, 2, 1)) + + def test_callback_on_plotly_update(self): + fn_range = MagicMock() + self.figure.layout.on_change(fn_range, + 'xaxis.range', + 'yaxis.range', + 'width') + + self.figure.plotly_update( + restyle_data={'marker.color': 'blue'}, + relayout_data={'xaxis.range': [-10, 10], + 'yaxis.range': [11, 22]}) + + fn_range.assert_called_once_with(self.figure.layout, + (-10, 10), + (11, 22), + 1000) diff --git a/plotly/tests/test_core/test_figure_messages/test_plotly_relayout.py b/plotly/tests/test_core/test_figure_messages/test_plotly_relayout.py new file mode 100644 index 0000000000..26cfde31c0 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_plotly_relayout.py @@ -0,0 +1,103 @@ +import sys +from unittest import TestCase + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestRelayoutMessage(TestCase): + + def setUp(self): + # Construct with mocked _send_relayout_msg method + self.figure = go.Figure(layout={'xaxis': {'range': [-1, 4]}}) + + # Mock out the message method + self.figure._send_relayout_msg = MagicMock() + + def test_property_assignment_toplevel(self): + self.figure.layout.title = 'hello' + self.figure._send_relayout_msg.assert_called_once_with( + {'title': 'hello'}) + + def test_property_assignment_nested(self): + self.figure.layout.xaxis.titlefont.family = 'courier' + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis.titlefont.family': 'courier'}) + + def test_property_assignment_nested_subplot2(self): + # Initialize xaxis2 + self.figure.layout.xaxis2 = {'range': [0, 1]} + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis2': {'range': [0, 1]}}) + + # Reset mock and perform property assignment + self.figure._send_relayout_msg = MagicMock() + self.figure.layout.xaxis2.titlefont.family = 'courier' + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis2.titlefont.family': 'courier'}) + + def test_property_assignment_nested_array(self): + + # Initialize images + self.figure.layout.updatemenus = [ + {}, + go.layout.Updatemenu(buttons=[ + {}, {}, go.layout.updatemenu.Button(method='relayout')]), + {}] + + self.figure._send_relayout_msg.assert_called_once_with( + {'updatemenus': [{}, {'buttons': [ + {}, {}, {'method': 'relayout'}]}, {}]}) + + # Reset mock and perform property assignment + self.figure._send_relayout_msg = MagicMock() + self.figure.layout.updatemenus[1].buttons[0].method = 'restyle' + self.figure._send_relayout_msg.assert_called_once_with( + {'updatemenus.1.buttons.0.method': 'restyle'}) + + def test_plotly_relayout_toplevel(self): + self.figure.plotly_relayout({'title': 'hello'}) + self.figure._send_relayout_msg.assert_called_once_with( + {'title': 'hello'}) + + def test_plotly_relayout_nested(self): + self.figure.plotly_relayout({'xaxis.titlefont.family': 'courier'}) + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis.titlefont.family': 'courier'}) + + def test_plotly_relayout_nested_subplot2(self): + # Initialize xaxis2 + self.figure.layout.xaxis2 = {'range': [0, 1]} + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis2': {'range': [0, 1]}}) + + # Reset mock and perform property assignment + self.figure._send_relayout_msg = MagicMock() + self.figure.plotly_relayout({'xaxis2.titlefont.family': 'courier'}) + self.figure._send_relayout_msg.assert_called_once_with( + {'xaxis2.titlefont.family': 'courier'}) + + def test_plotly_relayout_nested_array(self): + + # Initialize images + self.figure.layout.updatemenus = [ + {}, + go.layout.Updatemenu(buttons=[ + {}, {}, go.layout.updatemenu.Button(method='relayout')]), + {}] + + self.figure._send_relayout_msg.assert_called_once_with( + {'updatemenus': [{}, {'buttons': [ + {}, {}, {'method': 'relayout'}]}, {}]}) + + # Reset mock and perform property assignment + self.figure._send_relayout_msg = MagicMock() + + self.figure.plotly_relayout( + {'updatemenus[1].buttons.0.method': 'restyle'}) + self.figure._send_relayout_msg.assert_called_once_with( + {'updatemenus[1].buttons.0.method': 'restyle'}) diff --git a/plotly/tests/test_core/test_figure_messages/test_plotly_restyle.py b/plotly/tests/test_core/test_figure_messages/test_plotly_restyle.py new file mode 100644 index 0000000000..f3b46d8c08 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_plotly_restyle.py @@ -0,0 +1,84 @@ +import sys +from unittest import TestCase + +import plotly.graph_objs as go + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestRestyleMessage(TestCase): + + def setUp(self): + # Construct with mocked _send_restyle_msg method + self.figure = go.Figure(data=[ + go.Scatter(), + go.Bar(), + go.Parcoords(dimensions=[{}, {'label': 'dim 2'}, {}]) + ]) + + # Mock out the message method + self.figure._send_restyle_msg = MagicMock() + + def test_property_assignment_toplevel(self): + # Set bar marker + self.figure.data[1].marker = {'color': 'green'} + self.figure._send_restyle_msg.assert_called_once_with( + {'marker': [{'color': 'green'}]}, trace_indexes=1) + + def test_property_assignment_nested(self): + # Set scatter marker color + self.figure.data[0].marker.color = 'green' + self.figure._send_restyle_msg.assert_called_once_with( + {'marker.color': ['green']}, trace_indexes=0) + + def test_property_assignment_nested_array(self): + # Set parcoords dimension + self.figure.data[2].dimensions[0].label = 'dim 1' + self.figure._send_restyle_msg.assert_called_once_with( + {'dimensions.0.label': ['dim 1']}, trace_indexes=2) + + # plotly_restyle + def test_plotly_restyle_toplevel(self): + # Set bar marker + self.figure.plotly_restyle( + {'marker': {'color': 'green'}}, trace_indexes=1) + + self.figure._send_restyle_msg.assert_called_once_with( + {'marker': {'color': 'green'}}, trace_indexes=[1]) + + def test_plotly_restyle_nested(self): + # Set scatter marker color + self.figure.plotly_restyle( + {'marker.color': 'green'}, trace_indexes=0) + + self.figure._send_restyle_msg.assert_called_once_with( + {'marker.color': 'green'}, trace_indexes=[0]) + + def test_plotly_restyle_nested_array(self): + # Set parcoords dimension + self.figure.plotly_restyle( + {'dimensions[0].label': 'dim 1'}, trace_indexes=2) + + self.figure._send_restyle_msg.assert_called_once_with( + {'dimensions[0].label': 'dim 1'}, trace_indexes=[2]) + + def test_plotly_restyle_multi_prop(self): + self.figure.plotly_restyle( + {'marker': {'color': 'green'}, + 'name': 'MARKER 1'}, trace_indexes=1) + + self.figure._send_restyle_msg.assert_called_once_with( + {'marker': {'color': 'green'}, + 'name': 'MARKER 1'}, trace_indexes=[1]) + + def test_plotly_restyle_multi_trace(self): + self.figure.plotly_restyle( + {'marker': {'color': 'green'}, + 'name': 'MARKER 1'}, trace_indexes=[0, 1]) + + self.figure._send_restyle_msg.assert_called_once_with( + {'marker': {'color': 'green'}, + 'name': 'MARKER 1'}, trace_indexes=[0, 1]) diff --git a/plotly/tests/test_core/test_figure_messages/test_plotly_update.py b/plotly/tests/test_core/test_figure_messages/test_plotly_update.py new file mode 100644 index 0000000000..ff45a19a40 --- /dev/null +++ b/plotly/tests/test_core/test_figure_messages/test_plotly_update.py @@ -0,0 +1,80 @@ +import sys +from unittest import TestCase + +import plotly.graph_objs as go +from plotly.basedatatypes import Undefined + +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import MagicMock +else: + from mock import MagicMock + + +class TestBatchUpdateMessage(TestCase): + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[ + go.Scatter(y=[3, 2, 1], marker={'color': 'green'}), + go.Bar(y=[3, 2, 1, 0, -1], marker={'opacity': 0.5})], + layout={'xaxis': {'range': [-1, 4]}}, + frames=[go.Frame( + layout={'yaxis': + {'title': 'f1'}})]) + + # Mock out the message method + self.figure._send_update_msg = MagicMock() + + def test_batch_update(self): + + with self.figure.batch_update(): + + # Assign trace property + self.figure.data[0].marker.color = 'yellow' + self.figure.data[1].marker.opacity = 0.9 + + # Assign layout property + self.figure.layout.xaxis.range = [10, 20] + + # Assign frame property + self.figure.frames[0].layout.yaxis.title = 'f2' + + # Make sure that trace/layout assignments haven't been applied yet + self.assertEqual(self.figure.data[0].marker.color, 'green') + self.assertEqual(self.figure.data[1].marker.opacity, 0.5) + self.assertEqual(self.figure.layout.xaxis.range, (-1, 4)) + + # Expect the frame update to be applied immediately + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f2') + + # Make sure that trace/layout assignments have been applied after + # context exits + self.assertEqual(self.figure.data[0].marker.color, 'yellow') + self.assertEqual(self.figure.data[1].marker.opacity, 0.9) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + # Check that update message was sent + self.figure._send_update_msg.assert_called_once_with( + restyle_data={'marker.color': ['yellow', Undefined], + 'marker.opacity': [Undefined, 0.9]}, + relayout_data={'xaxis.range': [10, 20]}, + trace_indexes=[0, 1]) + + def test_plotly_update(self): + self.figure.plotly_update( + restyle_data={'marker.color': ['yellow', Undefined], + 'marker.opacity': [Undefined, 0.9]}, + relayout_data={'xaxis.range': [10, 20]}, + trace_indexes=[0, 1]) + + # Make sure that trace/layout assignments have been applied after + # context exits + self.assertEqual(self.figure.data[0].marker.color, 'yellow') + self.assertEqual(self.figure.data[1].marker.opacity, 0.9) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + # Check that update message was sent + self.figure._send_update_msg.assert_called_once_with( + restyle_data={'marker.color': ['yellow', Undefined], + 'marker.opacity': [Undefined, 0.9]}, + relayout_data={'xaxis.range': [10, 20]}, + trace_indexes=[0, 1]) diff --git a/plotly/tests/test_core/test_figure_widget_backend/__init__.py b/plotly/tests/test_core/test_figure_widget_backend/__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/plotly/tests/test_core/test_figure_widget_backend/test_validate_no_frames.py b/plotly/tests/test_core/test_figure_widget_backend/test_validate_no_frames.py new file mode 100644 index 0000000000..ea5ae9e1eb --- /dev/null +++ b/plotly/tests/test_core/test_figure_widget_backend/test_validate_no_frames.py @@ -0,0 +1,29 @@ +from unittest import TestCase +import plotly.graph_objs as go +from nose.tools import raises + + +class TestNoFrames(TestCase): + if 'FigureWidget' in go.__dict__.keys(): + @raises(ValueError) + def test_no_frames_in_constructor_kwarg(self): + go.FigureWidget(frames=[{}]) + + def test_emtpy_frames_ok_as_constructor_kwarg(self): + go.FigureWidget(frames=[]) + + @raises(ValueError) + def test_no_frames_in_constructor_dict(self): + go.FigureWidget({'frames': [{}]}) + + def test_emtpy_frames_ok_as_constructor_dict_key(self): + go.FigureWidget({'frames': []}) + + @raises(ValueError) + def test_no_frames_assignment(self): + fig = go.FigureWidget() + fig.frames = [{}] + + def test_emtpy_frames_assignment_ok(self): + fig = go.FigureWidget() + fig.frames = [] diff --git a/plotly/tests/test_core/test_file/test_file.py b/plotly/tests/test_core/test_file/test_file.py index 9392314035..6761336eb6 100644 --- a/plotly/tests/test_core/test_file/test_file.py +++ b/plotly/tests/test_core/test_file/test_file.py @@ -20,7 +20,7 @@ class FolderAPITestCase(PlotlyTestCase): def setUp(self): super(FolderAPITestCase, self).setUp() - py.sign_in('PythonTest', '9v9f20pext') + py.sign_in('PythonTest', 'xnyU0DEwvAQQCwHVseIL') def _random_filename(self): choice_chars = string.ascii_letters + string.digits @@ -50,6 +50,6 @@ def test_duplicate_folders(self): try: py.file_ops.mkdirs(first_folder) except PlotlyRequestError as e: - self.assertTrue(400 <= e.status_code < 500) + pass else: self.fail('Expected this to fail!') diff --git a/plotly/tests/test_core/test_get_figure/test_get_figure.py b/plotly/tests/test_core/test_get_figure/test_get_figure.py index 257d16769a..d4ce5efd92 100644 --- a/plotly/tests/test_core/test_get_figure/test_get_figure.py +++ b/plotly/tests/test_core/test_get_figure/test_get_figure.py @@ -42,7 +42,7 @@ class GetFigureTest(PlotlyTestCase): def test_get_figure(self): un = 'PlotlyImageTest' ak = '786r5mecv0' - file_id = 2 + file_id = 13183 py.sign_in(un, ak) py.get_figure('PlotlyImageTest', str(file_id)) @@ -50,7 +50,7 @@ def test_get_figure(self): def test_get_figure_with_url(self): un = 'PlotlyImageTest' ak = '786r5mecv0' - url = "https://plot.ly/~PlotlyImageTest/2/" + url = "https://plot.ly/~PlotlyImageTest/13183/" py.sign_in(un, ak) py.get_figure(url) @@ -71,6 +71,15 @@ def test_get_figure_invalid_2(self): with self.assertRaises(exceptions.PlotlyError): py.get_figure(url) + # demonstrates error if fig has invalid parts + def test_get_figure_invalid_3(self): + un = 'PlotlyImageTest' + ak = '786r5mecv0' + url = "https://plot.ly/~PlotlyImageTest/2/" + py.sign_in(un, ak) + with self.assertRaises(ValueError): + py.get_figure(url) + @attr('slow') def test_get_figure_does_not_exist(self): un = 'PlotlyImageTest' @@ -95,6 +104,6 @@ class TestBytesVStrings(TestCase): def test_proper_escaping(self): un = 'PlotlyImageTest' ak = '786r5mecv0' - url = "https://plot.ly/~PlotlyImageTest/91/" + url = "https://plot.ly/~PlotlyImageTest/13185/" py.sign_in(un, ak) py.get_figure(url) diff --git a/plotly/tests/test_core/test_graph_objs/test_annotations.py b/plotly/tests/test_core/test_graph_objs/test_annotations.py index 3e8eaec717..6dff760ec3 100644 --- a/plotly/tests/test_core/test_graph_objs/test_annotations.py +++ b/plotly/tests/test_core/test_graph_objs/test_annotations.py @@ -15,7 +15,6 @@ from plotly.graph_objs import Annotation, Annotations, Data, Figure, Layout - def setup(): import warnings warnings.filterwarnings('ignore') @@ -25,46 +24,26 @@ def test_trivial(): assert Annotations() == list() -@raises(PlotlyError) def test_weird_instantiation(): # Python allows this, but nonsensical for us. - print(Annotations({})) + assert Annotations({}) == list() def test_dict_instantiation(): Annotations([{'text': 'annotation text'}]) -@raises(PlotlyDictKeyError) def test_dict_instantiation_key_error(): - print(Annotations([{'not-a-key': 'anything'}])) + assert Annotations([{'not-a-key': 'anything'}]) == [{'not-a-key': 'anything'}] -@raises(PlotlyDictValueError) -def test_dict_instantiation_key_error(): - print(Annotations([{'font': 'not-a-dict'}])) +def test_dict_instantiation_key_error_2(): + assert Annotations([{'font': 'not-a-dict'}]) == [{'font': 'not-a-dict'}] -@raises(PlotlyListEntryError) def test_dict_instantiation_graph_obj_error_0(): - Annotations([Data()]) + assert Annotations([Data()]) == [[]] -@raises(PlotlyListEntryError) def test_dict_instantiation_graph_obj_error_2(): - Annotations([Annotations()]) - - -def test_validate(): - annotations = Annotations() - annotations.validate() - annotations += [{'text': 'some text'}] - annotations.validate() - annotations += [{}, {}, {}] - annotations.validate() - + assert Annotations([Annotations()]) == [[]] -@raises(PlotlyDictKeyError) -def test_validate_error(): - annotations = Annotations() - annotations.append({'not-a-key': 'anything'}) - annotations.validate() diff --git a/plotly/tests/test_core/test_graph_objs/test_append_trace.py b/plotly/tests/test_core/test_graph_objs/test_append_trace.py index e1a7f8ae16..40e5ac759a 100644 --- a/plotly/tests/test_core/test_graph_objs/test_append_trace.py +++ b/plotly/tests/test_core/test_graph_objs/test_append_trace.py @@ -4,8 +4,12 @@ from plotly.graph_objs import (Data, Figure, Layout, Scatter, Scatter3d, Scene, XAxis, YAxis) +from plotly.tests.utils import strip_dict_params + import plotly.tools as tls +import copy + @raises(Exception) def test_print_grid_before_make_subplots(): @@ -99,7 +103,12 @@ def test_append_scatter(): trace = Scatter(x=[1, 2, 3], y=[2, 3, 4]) fig = tls.make_subplots(rows=2, cols=3) fig.append_trace(trace, 2, 2) - assert fig == expected + + d1, d2 = strip_dict_params(fig['data'][0], expected['data'][0]) + assert d1 == d2 + + d1, d2 = strip_dict_params(fig['layout'], expected['layout']) + assert d1 == d2 @raises(Exception) @@ -150,7 +159,15 @@ def test_append_scatter3d(): trace = Scatter3d(x=[1, 2, 3], y=[2, 3, 4], z=[1, 2, 3]) fig.append_trace(trace, 1, 1) fig.append_trace(trace, 2, 1) - assert fig == expected + + d1, d2 = strip_dict_params(fig['data'][0], expected['data'][0]) + assert d1 == d2 + + d1, d2 = strip_dict_params(fig['data'][1], expected['data'][1]) + assert d1 == d2 + + d1, d2 = strip_dict_params(fig['layout'], expected['layout']) + assert d1 == d2 @raises(Exception) diff --git a/plotly/tests/test_core/test_graph_objs/test_constructor.py b/plotly/tests/test_core/test_graph_objs/test_constructor.py new file mode 100644 index 0000000000..2bf7703f7c --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_constructor.py @@ -0,0 +1,52 @@ +from unittest import TestCase +import plotly.graph_objs as go +from nose.tools import raises + + +class TestGraphObjConstructor(TestCase): + + def test_kwarg(self): + m = go.scatter.Marker(color='green') + self.assertEqual(m.to_plotly_json(), + {'color': 'green'}) + + def test_valid_arg_dict(self): + m = go.scatter.Marker(dict(color='green')) + self.assertEqual(m.to_plotly_json(), + {'color': 'green'}) + + def test_valid_arg_obj(self): + m = go.scatter.Marker( + go.scatter.Marker(color='green')) + + self.assertEqual(m.to_plotly_json(), + {'color': 'green'}) + + def test_kwarg_takes_precedence(self): + m = go.scatter.Marker( + dict(color='green', + size=12), + color='blue', + opacity=0.6 + ) + + self.assertEqual(m.to_plotly_json(), + {'color': 'blue', + 'size': 12, + 'opacity': 0.6}) + + @raises(ValueError) + def test_invalid_kwarg(self): + go.scatter.Marker(bogus=[1, 2, 3]) + + @raises(ValueError) + def test_invalid_arg(self): + go.scatter.Marker([1, 2, 3]) + + @raises(ValueError) + def test_valid_arg_with_invalid_key_name(self): + go.scatter.Marker({'bogus': 12}) + + @raises(ValueError) + def test_valid_arg_with_invalid_key_value(self): + go.scatter.Marker({'color': 'bogus'}) diff --git a/plotly/tests/test_core/test_graph_objs/test_data.py b/plotly/tests/test_core/test_graph_objs/test_data.py index a9e45bcbc9..81b7ed526b 100644 --- a/plotly/tests/test_core/test_graph_objs/test_data.py +++ b/plotly/tests/test_core/test_graph_objs/test_data.py @@ -25,55 +25,39 @@ def test_trivial(): assert Data() == list() -@raises(PlotlyError) +#@raises(PlotlyError) def test_weird_instantiation(): # Python allows this... - print(Data({})) + assert Data({}) == [] def test_default_scatter(): - assert Data([{}]) == list([{'type': 'scatter'}]) + assert Data([{}]) == list([{}]) def test_dict_instantiation(): Data([{'type': 'scatter'}]) -@raises(PlotlyDictKeyError) +# @raises(PlotlyDictKeyError) def test_dict_instantiation_key_error(): - print(Data([{'not-a-key': 'anything'}])) + assert Data([{'not-a-key': 'anything'}]) == [{'not-a-key': 'anything'}] -@raises(PlotlyDictValueError) -def test_dict_instantiation_key_error(): - print(Data([{'marker': 'not-a-dict'}])) +# @raises(PlotlyDictValueError) +def test_dict_instantiation_key_error_2(): + assert Data([{'marker': 'not-a-dict'}]) == [{'marker': 'not-a-dict'}] -@raises(PlotlyDataTypeError) +# @raises(PlotlyDataTypeError) def test_dict_instantiation_type_error(): - Data([{'type': 'invalid_type'}]) + assert Data([{'type': 'invalid_type'}]) == [{'type': 'invalid_type'}] -@raises(PlotlyListEntryError) +# @raises(PlotlyListEntryError) def test_dict_instantiation_graph_obj_error_0(): - Data([Data()]) + assert Data([Data()]) == [[]] -@raises(PlotlyListEntryError) +# raises(PlotlyListEntryError) def test_dict_instantiation_graph_obj_error_2(): - Data([Annotations()]) - - -def test_validate(): - data = Data() - data.validate() - data += [{'type': 'scatter'}] - data.validate() - data += [{}, {}, {}] - data.validate() - - -@raises(PlotlyDictKeyError) -def test_validate_error(): - data = Data() - data.append({'not-a-key': 'anything'}) - data.validate() + assert Data([Annotations()]) == [[]] diff --git a/plotly/tests/test_core/test_graph_objs/test_error_bars.py b/plotly/tests/test_core/test_graph_objs/test_error_bars.py index ef3746cf86..2e5ed33547 100644 --- a/plotly/tests/test_core/test_graph_objs/test_error_bars.py +++ b/plotly/tests/test_core/test_graph_objs/test_error_bars.py @@ -41,6 +41,5 @@ def test_instantiate_error_y(): width=5) -@raises(PlotlyDictKeyError) def test_key_error(): - ErrorX(value=0.1, typ='percent', color='red') + assert ErrorX(value=0.1, typ='percent', color='red') == {'color': 'red', 'typ': 'percent', 'value': 0.1} diff --git a/plotly/tests/test_core/test_graph_objs/test_figure.py b/plotly/tests/test_core/test_graph_objs/test_figure.py index 6bf007c4ca..3f94a424c6 100644 --- a/plotly/tests/test_core/test_graph_objs/test_figure.py +++ b/plotly/tests/test_core/test_graph_objs/test_figure.py @@ -2,7 +2,6 @@ from unittest import TestCase -from plotly import exceptions from plotly.graph_objs import Figure @@ -23,15 +22,17 @@ def test_access_top_level(self): # Figure is special, we define top-level objects that always exist. - self.assertEqual(Figure().data, []) - self.assertEqual(Figure().layout, {}) - self.assertEqual(Figure().frames, []) + self.assertEqual(Figure().data, ()) + self.assertEqual(Figure().layout.to_plotly_json(), {}) + self.assertEqual(Figure().frames, ()) def test_nested_frames(self): - with self.assertRaisesRegexp(exceptions.PlotlyDictKeyError, 'frames'): + with self.assertRaisesRegexp(ValueError, 'frames'): Figure({'frames': [{'frames': []}]}) figure = Figure() figure.frames = [{}] - with self.assertRaisesRegexp(exceptions.PlotlyDictKeyError, 'frames'): + + with self.assertRaisesRegexp(ValueError, 'frames'): + figure.to_plotly_json()['frames'][0]['frames'] = [] figure.frames[0].frames = [] diff --git a/plotly/tests/test_core/test_graph_objs/test_figure_properties.py b/plotly/tests/test_core/test_graph_objs/test_figure_properties.py new file mode 100644 index 0000000000..69551b7c8e --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_figure_properties.py @@ -0,0 +1,215 @@ +from unittest import TestCase +import plotly.graph_objs as go +from nose.tools import raises + + +class TestFigureProperties(TestCase): + + def setUp(self): + # Construct initial scatter object + self.figure = go.Figure(data=[go.Scatter(y=[3, 2, 1], + marker={'color': 'green'})], + layout={'xaxis': {'range': [-1, 4]}}, + frames=[go.Frame( + layout={'yaxis': + {'title': 'f1'}})]) + + def test_attr_access(self): + scatt_uid = self.figure.data[0].uid + self.assertEqual(self.figure.data, + (go.Scatter(y=[3, 2, 1], + marker={'color': 'green'}, + uid=scatt_uid),)) + + self.assertEqual(self.figure.layout, + go.Layout(xaxis={'range': [-1, 4]})) + + self.assertEqual(self.figure.frames, + (go.Frame( + layout={'yaxis': {'title': 'f1'}}),)) + + def test_contains(self): + self.assertIn('data', self.figure) + self.assertIn('layout', self.figure) + self.assertIn('frames', self.figure) + + def test_iter(self): + self.assertEqual(set(self.figure), {'data', 'layout', 'frames'}) + + def test_attr_item(self): + + # test that equal objects can be retrieved using attr or item + # syntax + self.assertEqual(self.figure.data, self.figure['data']) + self.assertEqual(self.figure.layout, self.figure['layout']) + self.assertEqual(self.figure.frames, self.figure['frames']) + + def test_property_assignment_tuple(self): + + # Empty + self.assertIs(self.figure[()], self.figure) + + # Layout + self.figure[('layout', 'xaxis', 'range')] = (-10, 10) + self.assertEqual(self.figure[('layout', 'xaxis', 'range')], (-10, 10)) + + # Data + self.figure[('data', 0, 'marker', 'color')] = 'red' + self.assertEqual(self.figure[('data', 0, 'marker', 'color')], 'red') + + # Frames + self.figure[('frames', 0, 'layout', 'yaxis', 'title')] = 'f2' + self.assertEqual( + self.figure[('frames', 0, 'layout', 'yaxis', 'title')], 'f2') + + def test_property_assignment_dots(self): + # Layout + self.figure['layout.xaxis.range'] = (-10, 10) + self.assertEqual(self.figure['layout.xaxis.range'], (-10, 10)) + + # Data + self.figure['data.0.marker.color'] = 'red' + self.assertEqual(self.figure['data[0].marker.color'], 'red') + + # Frames + self.figure['frames[0].layout.yaxis.title'] = 'f2' + self.assertEqual( + self.figure['frames.0.layout.yaxis.title'], 'f2') + + @raises(AttributeError) + def test_access_invalid_attr(self): + self.figure.bogus + + @raises(KeyError) + def test_access_invalid_item(self): + self.figure['bogus'] + + @raises(AttributeError) + def test_assign_invalid_attr(self): + self.figure.bogus = 'val' + + @raises(KeyError) + def test_access_invalid_item(self): + self.figure['bogus'] = 'val' + + # Update + def test_update_layout(self): + # Check initial x-range + self.assertEqual(self.figure.layout.xaxis.range, (-1, 4)) + + # Update with kwarg + self.figure.update(layout={'xaxis': {'range': [10, 20]}}) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + # Update with dict + self.figure.update({'layout': {'xaxis': {'range': [100, 200]}}}) + self.assertEqual(self.figure.layout.xaxis.range, (100, 200)) + + def test_update_data(self): + # Check initial marker color + self.assertEqual(self.figure.data[0].marker.color, 'green') + + # Update with dict kwarg + self.figure.update(data={0: {'marker': {'color': 'blue'}}}) + self.assertEqual(self.figure.data[0].marker.color, 'blue') + + # Update with list kwarg + self.figure.update(data=[{'marker': {'color': 'red'}}]) + self.assertEqual(self.figure.data[0].marker.color, 'red') + + # Update with dict + self.figure.update({'data': {0: {'marker': {'color': 'yellow'}}}}) + self.assertEqual(self.figure.data[0].marker.color, 'yellow') + + def test_update_frames(self): + # Check initial frame axis title + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f1') + + # Update with dict kwarg + self.figure.update(frames={0: {'layout': {'yaxis': {'title': 'f2'}}}}) + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f2') + + # Update with list kwarg + self.figure.update(frames=[{'layout': {'yaxis': {'title': 'f3'}}}]) + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f3') + + # Update with dict + self.figure.update({'frames': + [{'layout': {'yaxis': {'title': 'f4'}}}]}) + self.assertEqual(self.figure.frames[0].layout.yaxis.title, 'f4') + + @raises(ValueError) + def test_update_invalid_attr(self): + self.figure.layout.update({'xaxis': {'bogus': 32}}) + + # plotly_restyle + def test_plotly_restyle(self): + # Check initial marker color + self.assertEqual(self.figure.data[0].marker.color, 'green') + + # Update with dict kwarg + self.figure.plotly_restyle( + restyle_data={'marker.color': 'blue'}, + trace_indexes=0) + + self.assertEqual(self.figure.data[0].marker.color, 'blue') + + @raises(ValueError) + def test_restyle_validate_property(self): + self.figure.plotly_restyle({'bogus': 3}, trace_indexes=[0]) + + @raises(ValueError) + def test_restyle_validate_property_nested(self): + self.figure.plotly_restyle({'marker.bogus': 3}, trace_indexes=[0]) + + # plotly_relayout + def test_plotly_relayout(self): + # Check initial x-range + self.assertEqual(self.figure.layout.xaxis.range, (-1, 4)) + + # Update with kwarg + self.figure.plotly_relayout( + relayout_data={'xaxis.range': [10, 20]}) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + @raises(ValueError) + def test_relayout_validate_property(self): + self.figure.plotly_relayout({'bogus': [1, 3]}) + + @raises(ValueError) + def test_relayout_validate_property_nested(self): + self.figure.plotly_relayout({'xaxis.bogus': [1, 3]}) + + @raises(ValueError) + def test_relayout_validate_unintialized_subplot(self): + self.figure.plotly_relayout({'xaxis2.range': [1, 3]}) + + # plotly_update + def test_plotly_update_layout(self): + # Check initial x-range + self.assertEqual(self.figure.layout.xaxis.range, (-1, 4)) + + # Update with kwarg + self.figure.plotly_update( + relayout_data={'xaxis.range': [10, 20]}) + self.assertEqual(self.figure.layout.xaxis.range, (10, 20)) + + def test_plotly_update_data(self): + # Check initial marker color + self.assertEqual(self.figure.data[0].marker.color, 'green') + + # Update with dict kwarg + self.figure.plotly_update( + restyle_data={'marker.color': 'blue'}, + trace_indexes=0) + + self.assertEqual(self.figure.data[0].marker.color, 'blue') + + @raises(ValueError) + def test_plotly_update_validate_property_trace(self): + self.figure.plotly_update(restyle_data={'bogus': 3}, + trace_indexes=[0]) + + @raises(ValueError) + def test_plotly_update_validate_property_layout(self): + self.figure.plotly_update(relayout_data={'xaxis.bogus': [1, 3]}) \ No newline at end of file diff --git a/plotly/tests/test_core/test_graph_objs/test_frames.py b/plotly/tests/test_core/test_graph_objs/test_frames.py index 2b105c6ec4..98e7daccb9 100644 --- a/plotly/tests/test_core/test_graph_objs/test_frames.py +++ b/plotly/tests/test_core/test_graph_objs/test_frames.py @@ -2,8 +2,21 @@ from unittest import TestCase -from plotly import exceptions -from plotly.graph_objs import Bar, Frames +from plotly.graph_objs import Bar, Frames, Frame, Layout + +import re + + +def return_prop_descriptions(prop_descrip_text): + raw_matches = re.findall( + "\n [a-z]+| [a-z]+\n", prop_descrip_text + ) + matches = [] + for r in raw_matches: + r = r.replace(' ', '') + r = r.replace('\n', '') + matches.append(r) + return matches class FramesTest(TestCase): @@ -20,60 +33,58 @@ def test_instantiation(self): Frames(native_frames) Frames() - def test_string_frame(self): - frames = Frames() - frames.append({'group': 'baz', 'data': []}) - frames.append('foobar') - self.assertEqual(frames[1], 'foobar') - self.assertEqual(frames.to_string(), - "Frames([\n" - " dict(\n" - " data=Data(),\n" - " group='baz'\n" - " ),\n" - " 'foobar'\n" - "])") - def test_non_string_frame(self): frames = Frames() frames.append({}) - with self.assertRaises(exceptions.PlotlyListEntryError): - frames.append([]) + # TODO: Decide if errors should be thrown + # with self.assertRaises(exceptions.PlotlyListEntryError): + # frames.append([]) - with self.assertRaises(exceptions.PlotlyListEntryError): - frames.append(0) + # with self.assertRaises(exceptions.PlotlyListEntryError): + # frames.append(0) def test_deeply_nested_layout_attributes(self): - frames = Frames() - frames.append({}) - frames[0].layout.xaxis.showexponent = 'all' + frames = Frame + frames.layout = [Layout()] + frames.layout[0].xaxis.showexponent = 'all' + prop_descrip_text = frames.layout[0].font._prop_descriptions + + matches = return_prop_descriptions(prop_descrip_text) # It's OK if this needs to change, but we should check *something*. self.assertEqual( - frames[0].layout.font._get_valid_attributes(), + set(matches), {'color', 'family', 'size'} ) def test_deeply_nested_data_attributes(self): - frames = Frames() - frames.append({}) - frames[0].data = [Bar()] - frames[0].data[0].marker.color = 'red' + frames = Frame + frames.data = [Bar()] + frames.data[0].marker.color = 'red' + + # parse out valid attrs from ._prop_descriptions + prop_descrip_text = frames.data[0].marker.line._prop_descriptions + + matches = return_prop_descriptions(prop_descrip_text) # It's OK if this needs to change, but we should check *something*. self.assertEqual( - frames[0].data[0].marker.line._get_valid_attributes(), + set(matches), {'colorsrc', 'autocolorscale', 'cmin', 'colorscale', 'color', 'reversescale', 'width', 'cauto', 'widthsrc', 'cmax'} ) def test_frame_only_attrs(self): - frames = Frames() - frames.append({}) + frames = Frame + frames.frame = [Frame()] # It's OK if this needs to change, but we should check *something*. + prop_descrip_text = frames.frame[0]._prop_descriptions + + matches = return_prop_descriptions(prop_descrip_text) + self.assertEqual( - frames[0]._get_valid_attributes(), + set(matches), {'group', 'name', 'data', 'layout', 'baseframe', 'traces'} ) diff --git a/plotly/tests/test_core/test_graph_objs/test_get_data.py b/plotly/tests/test_core/test_graph_objs/test_get_data.py deleted file mode 100644 index 981ec0a906..0000000000 --- a/plotly/tests/test_core/test_graph_objs/test_get_data.py +++ /dev/null @@ -1,175 +0,0 @@ -from __future__ import absolute_import - -from unittest import TestCase - -from plotly.graph_objs import (Data, Figure, Layout, Line, Margin, Marker, - Scatter, XAxis, YAxis) - - -class TestGetData(TestCase): - - fig = None - - def setUp(self): - super(TestGetData, self).setUp() - self.fig = Figure( - data=Data([ - Scatter( - x=[52698, 43117], - y=[53, 31], - mode='markers', - name='North America', - text=['United States', 'Canada'], - marker=Marker( - color='rgb(164, 194, 244)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, - 18007], - y=[33, 20, 13, 19, 27, 19, 49, 44, 38], - mode='markers', - name='Europe', - text=['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - marker=Marker( - color='rgb(255, 217, 102)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899], - y=[23, 42, 54, 89, 14, 99, 93, 70], - mode='markers', - name='Asia/Pacific', - text=['Australia', 'Japan', 'South Korea', 'Malaysia', - 'China', 'Indonesia', 'Philippines', 'India'], - marker=Marker( - color='rgb(234, 153, 153)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[19097, 18601, 15595, 13546, 12026, 7434, 5419], - y=[43, 47, 56, 80, 86, 93, 80], - mode='markers', - name='Latin America', - text=['Chile', 'Argentina', 'Mexico', 'Venezuela', - 'Venezuela', 'El Salvador', 'Bolivia'], - marker=Marker( - color='rgb(142, 124, 195)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ) - ]), - layout=Layout( - title='Quarter 1 Growth', - autosize=False, - width=500, - height=500, - xaxis=XAxis( - title='GDP per Capita', - showgrid=False, - zeroline=False - ), - yaxis=YAxis( - title='Percent', - showline=False - ), - margin=Margin( - l=65, - r=50, - b=65, - t=90 - ) - ) - ) - - def test_get_data(self): - data = self.fig.get_data() - comp_data = [ - { - 'name': 'North America', - 'text': ['United States', 'Canada'], - 'x': [52698, 43117], - 'y': [53, 31] - }, - { - 'name': 'Europe', - 'text': ['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - 'x': [39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, - 18007], - 'y': [33, 20, 13, 19, 27, 19, 49, 44, 38] - }, - { - 'name': 'Asia/Pacific', - 'text': ['Australia', 'Japan', 'South Korea', 'Malaysia', - 'China', 'Indonesia', 'Philippines', 'India'], - 'x': [42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899], - 'y': [23, 42, 54, 89, 14, 99, 93, 70]}, - { - 'name': 'Latin America', - 'text': ['Chile', 'Argentina', 'Mexico', 'Venezuela', - 'Venezuela', 'El Salvador', 'Bolivia'], - 'x': [19097, 18601, 15595, 13546, 12026, 7434, 5419], - 'y': [43, 47, 56, 80, 86, 93, 80] - } - ] - self.assertEqual(data, comp_data) - - def test_get_data_flatten(self): - - # this is similar to above, except nested objects are flattened - - flat_data = self.fig.get_data(flatten=True) - comp_data = { - 'Europe.x': [39317, 37236, 35650, 30066, 29570, 27159, 23557, - 21046, 18007], - 'Europe.y': [33, 20, 13, 19, 27, 19, 49, 44, 38], - 'Asia/Pacific.x': [42952, 37037, 33106, 17478, 9813, 5253, 4692, - 3899], - 'Latin America.text': ['Chile', 'Argentina', 'Mexico', 'Venezuela', - 'Venezuela', 'El Salvador', 'Bolivia'], - 'North America.x': [52698, 43117], - 'Asia/Pacific.y': [23, 42, 54, 89, 14, 99, 93, 70], - 'Asia/Pacific.text': ['Australia', 'Japan', 'South Korea', - 'Malaysia', 'China', 'Indonesia', - 'Philippines', 'India'], - 'North America.y': [53, 31], - 'North America.text': ['United States', 'Canada'], - 'Europe.text': ['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - 'Latin America.x': [19097, 18601, 15595, 13546, 12026, 7434, 5419], - 'Latin America.y': [43, 47, 56, 80, 86, 93, 80] - } - self.assertEqual(flat_data, comp_data) - - # TODO test for Data, Scatter, etc.. - - def test_flatten_repeated_trace_names(self): - dl = Data([Scatter(name='thesame', x=[1, 2, 3]) for _ in range(3)]) - data = dl.get_data(flatten=True) - comp_data = { - 'thesame.x': [1, 2, 3], - 'thesame_1.x': [1, 2, 3], - 'thesame_2.x': [1, 2, 3] - } - self.assertEqual(data, comp_data) diff --git a/plotly/tests/test_core/test_graph_objs/test_graph_objs.py b/plotly/tests/test_core/test_graph_objs/test_graph_objs.py index 01c55aa970..2ce67762ea 100644 --- a/plotly/tests/test_core/test_graph_objs/test_graph_objs.py +++ b/plotly/tests/test_core/test_graph_objs/test_graph_objs.py @@ -6,9 +6,9 @@ OLD_CLASS_NAMES = ['AngularAxis', 'Annotation', 'Annotations', 'Area', 'Bar', 'Box', 'ColorBar', 'Contour', 'Contours', 'Data', 'ErrorX', 'ErrorY', 'ErrorZ', 'Figure', - 'Font', 'Frames', 'Heatmap', 'Histogram', 'Histogram2d', - 'Histogram2dContour', 'Layout', 'Legend', 'Line', - 'Margin', 'Marker', 'RadialAxis', 'Scatter', + 'Font', 'Frame', 'Frames', 'Heatmap', 'Histogram', + 'Histogram2d', 'Histogram2dContour', 'Layout', 'Legend', + 'Line', 'Margin', 'Marker', 'RadialAxis', 'Scatter', 'Scatter3d', 'Scene', 'Stream', 'Surface', 'Trace', 'XAxis', 'XBins', 'YAxis', 'YBins', 'ZAxis'] @@ -46,4 +46,6 @@ def test_no_new_classes(self): # assume that CapitalCased keys are the classes we defined current_class_names = {key for key in go.__dict__.keys() if key[0].isupper()} + if 'FigureWidget' in go.__dict__.keys(): + expected_class_names.add('FigureWidget') self.assertEqual(current_class_names, expected_class_names) diff --git a/plotly/tests/test_core/test_graph_objs/test_graph_objs_tools.py b/plotly/tests/test_core/test_graph_objs/test_graph_objs_tools.py deleted file mode 100644 index d3a4f857e9..0000000000 --- a/plotly/tests/test_core/test_graph_objs/test_graph_objs_tools.py +++ /dev/null @@ -1,32 +0,0 @@ -from __future__ import absolute_import - -from unittest import TestCase - -from plotly import graph_reference as gr -from plotly.graph_objs import graph_objs_tools as got - - -class TestGetHelp(TestCase): - - def test_get_help_does_not_raise(self): - - msg = None - try: - for object_name in gr.OBJECTS: - msg = object_name - got.get_help(object_name) - - for object_name in gr.ARRAYS: - msg = object_name - got.get_help(object_name) - - for object_name in gr.OBJECTS: - attributes = gr.get_valid_attributes(object_name) - for attribute in attributes: - msg = (object_name, attribute) - got.get_help(object_name, attribute=attribute) - fake_attribute = 'fake attribute' - msg = (object_name, fake_attribute) - got.get_help(object_name, attribute=fake_attribute) - except: - self.fail(msg=msg) diff --git a/plotly/tests/test_core/test_graph_objs/test_layout_subplots.py b/plotly/tests/test_core/test_graph_objs/test_layout_subplots.py new file mode 100644 index 0000000000..6641a91e07 --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_layout_subplots.py @@ -0,0 +1,155 @@ +from unittest import TestCase +import plotly.graph_objs as go +from nose.tools import raises + + +class TestLayoutSubplots(TestCase): + + def setUp(self): + # Construct initial scatter object + self.layout = go.Layout() + + def test_initial_access_subplots(self): + + # It should be possible to access base subplots initially + self.assertEqual(self.layout.xaxis, go.layout.XAxis()) + self.assertEqual(self.layout.yaxis, go.layout.YAxis()) + self.assertEqual(self.layout['geo'], go.layout.Geo()) + self.assertEqual(self.layout.scene, go.layout.Scene()) + + # Subplot ids of 1 should be mapped to the same object as the base + # subplot. Notice we're using assertIs not assertEqual here + self.assertIs(self.layout.xaxis, self.layout.xaxis1) + self.assertIs(self.layout.yaxis, self.layout.yaxis1) + self.assertIs(self.layout.geo, self.layout.geo1) + self.assertIs(self.layout.scene, self.layout.scene1) + + @raises(AttributeError) + def test_initial_access_subplot2(self): + self.layout.xaxis2 + + @raises(KeyError) + def test_initial_access_subplot2(self): + self.layout['xaxis2'] + + def test_assign_subplots(self): + self.assertIsNone(self.layout.xaxis.title) + self.assertIsNone(self.layout.xaxis1.title) + + title_str = 'xaxis title' + self.layout.xaxis.title = title_str + self.assertEqual(self.layout.xaxis.title, title_str) + self.assertEqual(self.layout.xaxis1.title, title_str) + + def test_assign_subplot2(self): + # Init xaxis2 + self.layout.xaxis2 = go.layout.XAxis() + + # Properties are initially None + self.assertIsNone(self.layout.xaxis2.range) + + # Set range + xrange = [0, 1] + self.layout.xaxis2.range = [0, 1] + self.assertEqual(self.layout.xaxis2.range, tuple(xrange)) + + # Make sure range isn't shared with xaxis, or xaxis1 + self.assertIsNone(self.layout.xaxis.range) + self.assertIsNone(self.layout.xaxis1.range) + + def test_contains(self): + + # Initially xaxis and xaxis1 are `in` layout, but xaxis2 and 3 are not + self.assertTrue('xaxis' in self.layout) + self.assertTrue('xaxis1' in self.layout) + self.assertFalse('xaxis2' in self.layout) + self.assertFalse('xaxis3' in self.layout) + + # xaxis is in iter props, but xaxis1, 2, and 3 are not + iter_props = list(self.layout) + self.assertIn('xaxis', iter_props) + self.assertNotIn('xaxis1', iter_props) + self.assertNotIn('xaxis2', iter_props) + self.assertNotIn('xaxis3', iter_props) + + # test dir props (these drive ipython tab completion) + dir_props = self.layout.__dir__() + self.assertIn('xaxis', dir_props) + self.assertNotIn('xaxis1', dir_props) + self.assertNotIn('xaxis2', dir_props) + self.assertNotIn('xaxis3', dir_props) + + # Initialize xaxis2 + self.layout.xaxis2 = {} + self.assertTrue('xaxis' in self.layout) + self.assertTrue('xaxis1' in self.layout) + self.assertTrue('xaxis2' in self.layout) + self.assertFalse('xaxis3' in self.layout) + + # xaxis and xaxis2 are in iter props + iter_props = list(self.layout) + self.assertIn('xaxis', iter_props) + self.assertNotIn('xaxis1', iter_props) + self.assertIn('xaxis2', iter_props) + self.assertNotIn('xaxis3', iter_props) + + # test dir props + dir_props = self.layout.__dir__() + self.assertIn('xaxis', dir_props) + self.assertNotIn('xaxis1', dir_props) + self.assertIn('xaxis2', dir_props) + self.assertNotIn('xaxis3', dir_props) + + # Initialize xaxis3 + self.layout['xaxis3'] = {} + self.assertTrue('xaxis' in self.layout) + self.assertTrue('xaxis1' in self.layout) + self.assertTrue('xaxis2' in self.layout) + self.assertTrue('xaxis3' in self.layout) + + # xaxis, xaxis2, and xaxis3 are in iter props + iter_props = list(self.layout) + self.assertIn('xaxis', iter_props) + self.assertNotIn('xaxis1', iter_props) + self.assertIn('xaxis2', iter_props) + self.assertIn('xaxis3', iter_props) + + # test dir props + dir_props = self.layout.__dir__() + self.assertIn('xaxis', dir_props) + self.assertNotIn('xaxis1', dir_props) + self.assertIn('xaxis2', dir_props) + self.assertIn('xaxis3', dir_props) + + def test_subplot_objs_have_proper_type(self): + self.layout.xaxis2 = {} + self.assertIsInstance(self.layout.xaxis2, go.layout.XAxis) + + self.layout.yaxis3 = {} + self.assertIsInstance(self.layout.yaxis3, go.layout.YAxis) + + self.layout.geo4 = {} + self.assertIsInstance(self.layout.geo4, go.layout.Geo) + + self.layout.ternary5 = {} + self.assertIsInstance(self.layout.ternary5, go.layout.Ternary) + + self.layout.scene6 = {} + self.assertIsInstance(self.layout.scene6, go.layout.Scene) + + def test_subplot_1_in_constructor(self): + layout = go.Layout(xaxis1=go.layout.XAxis(title='xaxis 1')) + self.assertEqual(layout.xaxis1.title, 'xaxis 1') + + def test_subplot_props_in_constructor(self): + layout = go.Layout(xaxis2=go.layout.XAxis(title='xaxis 2'), + yaxis3=go.layout.YAxis(title='yaxis 3'), + geo4=go.layout.Geo(bgcolor='blue'), + ternary5=go.layout.Ternary(sum=120), + scene6=go.layout.Scene(dragmode='zoom')) + + self.assertEqual(layout.xaxis2.title, 'xaxis 2') + self.assertEqual(layout.yaxis3.title, 'yaxis 3') + self.assertEqual(layout.geo4.bgcolor, 'blue') + self.assertEqual(layout.ternary5.sum, 120) + self.assertEqual(layout.scene6.dragmode, 'zoom') diff --git a/plotly/tests/test_core/test_graph_objs/test_plotly_base_classes.py b/plotly/tests/test_core/test_graph_objs/test_plotly_base_classes.py deleted file mode 100644 index a707d5d5c2..0000000000 --- a/plotly/tests/test_core/test_graph_objs/test_plotly_base_classes.py +++ /dev/null @@ -1,23 +0,0 @@ -""" -test_plotly_dict: -================= - -A module intended for use with Nose. - -""" -from __future__ import absolute_import - -from nose.tools import raises - -from plotly.exceptions import PlotlyError -from plotly.graph_objs.graph_objs import PlotlyDict, PlotlyList - - -@raises(PlotlyError) -def test_instantiate_plotly_dict(): - PlotlyDict() - - -@raises(PlotlyError) -def test_instantiate_plotly_list(): - PlotlyList() diff --git a/plotly/tests/test_core/test_graph_objs/test_properties_validated.py b/plotly/tests/test_core/test_graph_objs/test_properties_validated.py new file mode 100644 index 0000000000..a7e25c9902 --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_properties_validated.py @@ -0,0 +1,147 @@ +from unittest import TestCase +import plotly.graph_objs as go +from nose.tools import raises + + +class TestPropertyValidation(TestCase): + + def setUp(self): + # Construct initial scatter object + self.scatter = go.Scatter() + self.scatter.name = 'Scatter 1' + + @raises(ValueError) + def test_validators_work_attr(self): + """ + Note: all of the individual validators are tested in + `_plotly_utils/tests/validators`. Here we're just making sure that + datatypes make use of validators + """ + self.scatter.name = [1, 2, 3] + + @raises(ValueError) + def test_validators_work_item(self): + """ + Note: all of the individual validators are tested in + `_plotly_utils/tests/validators`. Here we're just making sure that + datatypes make use of validators + """ + self.scatter['name'] = [1, 2, 3] + + @raises(ValueError) + def test_invalid_attr_assignment(self): + self.scatter.bogus = 87 + + @raises(ValueError) + def test_invalid_item_assignment(self): + self.scatter['bogus'] = 87 + + @raises(ValueError) + def test_invalid_dot_assignment(self): + self.scatter['marker.bogus'] = 87 + + @raises(ValueError) + def test_invalid_tuple_assignment(self): + self.scatter[('marker', 'bogus')] = 87 + + @raises(ValueError) + def test_invalid_constructor_kwarg(self): + go.Scatter(bogus=87) + + +class TestPropertyPresentation(TestCase): + + def setUp(self): + # Construct initial scatter object + self.scatter = go.Scatter() + self.scatter.name = 'Scatter 1' + + self.layout = go.Layout() + + def test_present_dataarray(self): + self.assertIsNone(self.scatter.x) + + # Assign list + self.scatter.x = [1, 2, 3, 4] + + # Stored as list + self.assertEqual(self.scatter.to_plotly_json()['x'], + [1, 2, 3, 4]) + + # Returned as tuple + self.assertEqual(self.scatter.x, + (1, 2, 3, 4)) + + def test_present_compound_array(self): + self.assertEqual(self.layout.images, ()) + + # Assign compound list + self.layout.images = [go.layout.Image(layer='above'), + go.layout.Image(layer='below')] + + # Stored as list of dicts + self.assertEqual(self.layout.to_plotly_json()['images'], + [{'layer': 'above'}, {'layer': 'below'}]) + + # Presented as compound tuple + self.assertEqual(self.layout.images, + (go.layout.Image(layer='above'), + go.layout.Image(layer='below'))) + + def test_present_colorscale(self): + self.assertIsNone(self.scatter.marker.colorscale) + + # Assign list of tuples + self.scatter.marker.colorscale = [(0, 'red'), (1, 'green')] + + # Stored as list of lists + self.assertEqual( + self.scatter.to_plotly_json()['marker']['colorscale'], + [[0, 'red'], [1, 'green']]) + + # Presented as tuple of tuples + self.assertEqual(self.scatter.marker.colorscale, + ((0, 'red'), (1, 'green'))) + + +class TestPropertyIterContains(TestCase): + + def setUp(self): + # Construct initial scatter object + self.parcoords = go.Parcoords() + self.parcoords.name = 'Scatter 1' + + def test_contains(self): + + # Primitive property + self.assertTrue('name' in self.parcoords) + + # Compound property + self.assertTrue('line' in self.parcoords) + + # Literal + self.assertTrue('type' in self.parcoords) + + # Compound array property + self.assertTrue('dimensions' in self.parcoords) + + # Bogus + self.assertFalse('bogus' in self.parcoords) + + def test_iter(self): + parcoords_list = list(self.parcoords) + + # Primitive property + self.assertTrue('name' in parcoords_list) + + # Compound property + self.assertTrue('line' in parcoords_list) + + # Literal + self.assertTrue('type' in parcoords_list) + + # Compound array property + self.assertTrue('dimensions' in parcoords_list) + + # Bogus + self.assertFalse('bogus' in parcoords_list) diff --git a/plotly/tests/test_core/test_graph_objs/test_property_assignment.py b/plotly/tests/test_core/test_graph_objs/test_property_assignment.py new file mode 100644 index 0000000000..7f34df4a6b --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_property_assignment.py @@ -0,0 +1,454 @@ +from unittest import TestCase +import plotly.graph_objs as go + +from plotly.tests.utils import strip_dict_params + + +class TestAssignmentPrimitive(TestCase): + + def setUp(self): + # Construct initial scatter object + self.scatter = go.Scatter(name='scatter A') + + # Assert initial state + d1, d2 = strip_dict_params( + self.scatter, + {'type': 'scatter', + 'name': 'scatter A'} + ) + assert d1 == d2 + + # Construct expected results + self.expected_toplevel = { + 'type': 'scatter', + 'name': 'scatter A', + 'fillcolor': 'green'} + + self.expected_nested = { + 'type': 'scatter', + 'name': 'scatter A', + 'marker': {'colorbar': {'titlefont': + {'family': 'courier'}}}} + + def test_toplevel_attr(self): + assert self.scatter.fillcolor is None + self.scatter.fillcolor = 'green' + assert self.scatter.fillcolor == 'green' + + d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel) + assert d1 == d2 + + def test_toplevel_item(self): + assert self.scatter['fillcolor'] is None + self.scatter['fillcolor'] = 'green' + assert self.scatter['fillcolor'] == 'green' + + d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel) + assert d1 == d2 + + def test_nested_attr(self): + assert self.scatter.marker.colorbar.titlefont.family is None + self.scatter.marker.colorbar.titlefont.family = 'courier' + assert self.scatter.marker.colorbar.titlefont.family == 'courier' + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_item(self): + assert (self.scatter['marker']['colorbar']['titlefont']['family'] + is None) + self.scatter['marker']['colorbar']['titlefont']['family'] = 'courier' + assert (self.scatter['marker']['colorbar']['titlefont']['family'] + == 'courier') + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_item_dots(self): + assert self.scatter['marker.colorbar.titlefont.family'] is None + self.scatter['marker.colorbar.titlefont.family'] = 'courier' + assert self.scatter['marker.colorbar.titlefont.family'] == 'courier' + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_item_tuple(self): + assert self.scatter['marker.colorbar.titlefont.family'] is None + self.scatter[('marker', 'colorbar', 'titlefont', 'family')] = 'courier' + assert (self.scatter[('marker', 'colorbar', 'titlefont', 'family')] + == 'courier') + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_update(self): + self.scatter.update( + marker={'colorbar': {'titlefont': {'family': 'courier'}}}) + assert (self.scatter[('marker', 'colorbar', 'titlefont', 'family')] + == 'courier') + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + +class TestAssignmentCompound(TestCase): + + def setUp(self): + # Construct initial scatter object + self.scatter = go.Scatter(name='scatter A') + + # Assert initial state + d1, d2 = strip_dict_params( + self.scatter, + {'type': 'scatter', + 'name': 'scatter A'} + ) + assert d1 == d2 + + # Construct expected results + self.expected_toplevel = { + 'type': 'scatter', + 'name': 'scatter A', + 'marker': {'color': 'yellow', + 'size': 10}} + + self.expected_nested = { + 'type': 'scatter', + 'name': 'scatter A', + 'marker': {'colorbar': { + 'bgcolor': 'yellow', + 'thickness': 5}}} + + def test_toplevel_obj(self): + d1, d2 = strip_dict_params(self.scatter.marker, {}) + assert d1 == d2 + self.scatter.marker = go.scatter.Marker(color='yellow', size=10) + + assert isinstance(self.scatter.marker, go.scatter.Marker) + d1, d2 = strip_dict_params(self.scatter.marker, + self.expected_toplevel['marker']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel) + assert d1 == d2 + + def test_toplevel_dict(self): + d1, d2 = strip_dict_params(self.scatter['marker'], {}) + assert d1 == d2 + self.scatter['marker'] = dict(color='yellow', size=10) + + assert isinstance(self.scatter['marker'], go.scatter.Marker) + d1, d2 = strip_dict_params(self.scatter.marker, + self.expected_toplevel['marker']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel) + assert d1 == d2 + + def test_nested_obj(self): + d1, d2 = strip_dict_params(self.scatter.marker.colorbar, {}) + assert d1 == d2 + self.scatter.marker.colorbar = go.scatter.marker.ColorBar( + bgcolor='yellow', thickness=5) + + assert isinstance(self.scatter.marker.colorbar, + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter.marker.colorbar, + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_dict(self): + d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'], {}) + assert d1 == d2 + self.scatter['marker']['colorbar'] = dict( + bgcolor='yellow', thickness=5) + + assert isinstance(self.scatter['marker']['colorbar'], + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'], + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_dict_dot(self): + d1, d2 = strip_dict_params(self.scatter.marker.colorbar, {}) + assert d1 == d2 + self.scatter['marker.colorbar'] = dict( + bgcolor='yellow', thickness=5) + + assert isinstance(self.scatter['marker.colorbar'], + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter['marker.colorbar'], + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_dict_tuple(self): + d1, d2 = strip_dict_params(self.scatter[('marker', 'colorbar')], {}) + assert d1 == d2 + self.scatter[('marker', 'colorbar')] = dict( + bgcolor='yellow', thickness=5) + + assert isinstance(self.scatter[('marker', 'colorbar')], + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter[('marker', 'colorbar')], + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_update_obj(self): + + self.scatter.update( + marker={'colorbar': + go.scatter.marker.ColorBar(bgcolor='yellow', + thickness=5)}) + + assert isinstance(self.scatter['marker']['colorbar'], + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'], + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + def test_nested_update_dict(self): + + self.scatter.update( + marker={'colorbar': dict(bgcolor='yellow', thickness=5)}) + + assert isinstance(self.scatter['marker']['colorbar'], + go.scatter.marker.ColorBar) + d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'], + self.expected_nested['marker']['colorbar']) + assert d1 == d2 + + d1, d2 = strip_dict_params(self.scatter, self.expected_nested) + assert d1 == d2 + + +class TestAssignmnetNone(TestCase): + + def test_toplevel(self): + # Initialize scatter + scatter = go.Scatter(name='scatter A', + y=[3, 2, 4], + marker={ + 'colorbar': {'titlefont': + {'family': 'courier'}}}) + expected = { + 'type': 'scatter', + 'name': 'scatter A', + 'y': [3, 2, 4], + 'marker': {'colorbar': {'titlefont': + {'family': 'courier'}}}} + + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + # Set property not defined to None + scatter.x = None + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + scatter['line.width'] = None + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + # Set defined property to None + scatter.y = None + expected.pop('y') + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + # Set compound properties to None + scatter[('marker', 'colorbar', 'titlefont')] = None + expected['marker']['colorbar'].pop('titlefont') + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + scatter.marker = None + expected.pop('marker') + d1, d2 = strip_dict_params(scatter, expected) + assert d1 == d2 + + +class TestAssignCompoundArray(TestCase): + + def setUp(self): + # Construct initial scatter object + self.parcoords = go.Parcoords(name='parcoords A') + + # Assert initial state + d1, d2 = strip_dict_params( + self.parcoords, + {'type': 'parcoords', + 'name': 'parcoords A'} + ) + assert d1 == d2 + + # Construct expected results + self.expected_toplevel = { + 'type': 'parcoords', + 'name': 'parcoords A', + 'dimensions': [ + {'values': [2, 3, 1], 'visible': True}, + {'values': [1, 2, 3], 'label': 'dim1'}]} + + self.layout = go.Layout() + + self.expected_layout1 = { + 'updatemenus': [{}, + {'font': {'family': 'courier'}}] + } + + self.expected_layout2 = { + 'updatemenus': [{}, + {'buttons': [ + {}, {}, {'method': 'restyle'}]}] + } + + def test_assign_toplevel_array(self): + self.assertEqual(self.parcoords.dimensions, ()) + + self.parcoords['dimensions'] = [ + go.parcoords.Dimension(values=[2, 3, 1], visible=True), + dict(values=[1, 2, 3], label='dim1')] + + self.assertEqual(self.parcoords.to_plotly_json(), + self.expected_toplevel) + + def test_assign_nested_attr(self): + self.assertEqual(self.layout.updatemenus, ()) + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + self.assertEqual(self.layout['updatemenus'], + (go.layout.Updatemenu(), go.layout.Updatemenu())) + + self.layout.updatemenus[1].font.family = 'courier' + d1, d2 = strip_dict_params(self.layout, self.expected_layout1) + assert d1 == d2 + + def test_assign_double_nested_attr(self): + self.assertEqual(self.layout.updatemenus, ()) + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout.updatemenus[1].buttons = [{}, {}, {}] + + # Assign + self.layout.updatemenus[1].buttons[2].method = 'restyle' + + # Check + self.assertEqual( + self.layout.updatemenus[1].buttons[2].method, + 'restyle') + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + def test_assign_double_nested_item(self): + self.assertEqual(self.layout.updatemenus, ()) + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout['updatemenus'][1]['buttons'] = [{}, {}, {}] + + # Assign + self.layout['updatemenus'][1]['buttons'][2]['method'] = 'restyle' + + # Check + self.assertEqual( + self.layout['updatemenus'][1]['buttons'][2]['method'], + 'restyle' + ) + + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + def test_assign_double_nested_tuple(self): + self.assertEqual(self.layout.updatemenus, ()) + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout[('updatemenus', 1, 'buttons')] = [{}, {}, {}] + + # Assign + self.layout[('updatemenus', 1, 'buttons', 2, 'method')] = 'restyle' + + # Check + self.assertEqual( + self.layout[('updatemenus', 1, 'buttons', 2, 'method')], + 'restyle') + + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + def test_assign_double_nested_dot(self): + self.assertEqual(self.layout.updatemenus, ()) + + # Initialize empty updatemenus + self.layout['updatemenus'] = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout['updatemenus.1.buttons'] = [{}, {}, {}] + + # Assign + self.layout['updatemenus[1].buttons[2].method'] = 'restyle' + + # Check + self.assertEqual( + self.layout['updatemenus[1].buttons[2].method'], + 'restyle') + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + def test_assign_double_nested_update_dict(self): + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout.updatemenus[1].buttons = [{}, {}, {}] + + # Update + self.layout.update( + updatemenus={1: {'buttons': {2: {'method': 'restyle'}}}}) + + # Check + self.assertEqual( + self.layout.updatemenus[1].buttons[2].method, + 'restyle') + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + def test_assign_double_nested_update_array(self): + + # Initialize empty updatemenus + self.layout.updatemenus = [{}, {}] + + # Initialize empty buttons in updatemenu[1] + self.layout.updatemenus[1].buttons = [{}, {}, {}] + + # Update + self.layout.update( + updatemenus=[{}, {'buttons': [{}, {}, {'method': 'restyle'}]}]) + + # Check + self.assertEqual( + self.layout.updatemenus[1].buttons[2].method, + 'restyle') + d1, d2 = strip_dict_params(self.layout, self.expected_layout2) + assert d1 == d2 + + diff --git a/plotly/tests/test_core/test_graph_objs/test_repr.py b/plotly/tests/test_core/test_graph_objs/test_repr.py new file mode 100644 index 0000000000..317660eb80 --- /dev/null +++ b/plotly/tests/test_core/test_graph_objs/test_repr.py @@ -0,0 +1,52 @@ +from __future__ import absolute_import, division +from unittest import TestCase, SkipTest +import plotly.graph_objs as go + + +class TestGraphObjRepr(TestCase): + + def test_trace_repr(self): + N = 100 + scatt = go.Scatter( + y=list(range(N)), + marker={'color': 'green', + 'opacity': [e / N for e in range(N)]}) + + expected = """\ +Scatter({ + 'marker': {'color': 'green', + 'opacity': [0.0, 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, + 0.09, 0.1, 0.11, 0.12, 0.13, 0.14, 0.15, 0.16, 0.17, + 0.18, 0.19, 0.2, 0.21, 0.22, 0.23, 0.24, 0.25, 0.26, + 0.27, 0.28, 0.29, 0.3, 0.31, 0.32, 0.33, 0.34, 0.35, + 0.36, 0.37, 0.38, 0.39, 0.4, 0.41, 0.42, 0.43, 0.44, + 0.45, 0.46, 0.47, 0.48, 0.49, 0.5, 0.51, 0.52, 0.53, + 0.54, 0.55, 0.56, 0.57, 0.58, 0.59, 0.6, 0.61, 0.62, + 0.63, 0.64, 0.65, 0.66, 0.67, 0.68, 0.69, 0.7, 0.71, + 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.8, + 0.81, 0.82, 0.83, 0.84, 0.85, 0.86, 0.87, 0.88, 0.89, + 0.9, 0.91, 0.92, 0.93, 0.94, 0.95, 0.96, 0.97, 0.98, + 0.99]}, + 'y': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, + 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, + 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, + 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, + 92, 93, 94, 95, 96, 97, 98, 99] +})""" + self.assertEqual(scatt.__repr__(), expected) + + def test_trace_repr_elided(self): + N = 1000 + scatt = go.Scatter( + y=list(range(N)), + marker={'color': 'green', + 'opacity': [e / N for e in range(N)]}) + + expected = """\ +Scatter({ + 'marker': {'color': 'green', + 'opacity': [0.0, 0.001, 0.002, ..., 0.997, 0.998, 0.999]}, + 'y': [0, 1, 2, ..., 997, 998, 999] +})""" + self.assertEqual(scatt.__repr__(), expected) diff --git a/plotly/tests/test_core/test_graph_objs/test_scatter.py b/plotly/tests/test_core/test_graph_objs/test_scatter.py index 13af593784..1f7e04ae0c 100644 --- a/plotly/tests/test_core/test_graph_objs/test_scatter.py +++ b/plotly/tests/test_core/test_graph_objs/test_scatter.py @@ -14,20 +14,20 @@ def test_trivial(): print(Scatter()) - assert Scatter() == dict(type='scatter') - + assert Scatter().to_plotly_json() == dict(type='scatter') # @raises(PlotlyError) # TODO: decide if this SHOULD raise error... # def test_instantiation_error(): # print(PlotlyDict(anything='something')) -def test_validate(): - Scatter().validate() +# TODO: decide if this should raise error +#def test_validate(): +# Scatter().validate() -@raises(PlotlyError) -def test_validate_error(): - scatter = Scatter() - scatter['invalid'] = 'something' - scatter.validate() +# @raises(PlotlyError) +# def test_validate_error(): +# scatter = Scatter() +# scatter['invalid'] = 'something' +# scatter.validate() diff --git a/plotly/tests/test_core/test_graph_objs/test_strip_style.py b/plotly/tests/test_core/test_graph_objs/test_strip_style.py deleted file mode 100644 index 51d96b17b3..0000000000 --- a/plotly/tests/test_core/test_graph_objs/test_strip_style.py +++ /dev/null @@ -1,170 +0,0 @@ -from __future__ import absolute_import - -from plotly.graph_objs import (Data, Figure, Layout, Line, Margin, Marker, - Scatter, XAxis, YAxis) -from plotly.tests.utils import compare_dict - - -def test_strip_style(): - fig = Figure( - data=Data([ - Scatter( - x=[52698, 43117], - y=[53, 31], - mode='markers', - name='North America', - text=['United States', 'Canada'], - marker=Marker( - color='rgb(164, 194, 244)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, - 18007], - y=[33, 20, 13, 19, 27, 19, 49, 44, 38], - mode='markers', - name='Europe', - text=['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - marker=Marker( - color='rgb(255, 217, 102)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899], - y=[23, 42, 54, 89, 14, 99, 93, 70], - mode='markers', - name='Asia/Pacific', - text=['Australia', 'Japan', 'South Korea', 'Malaysia', 'China', - 'Indonesia', 'Philippines', 'India'], - marker=Marker( - color='rgb(234, 153, 153)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[19097, 18601, 15595, 13546, 12026, 7434, 5419], - y=[43, 47, 56, 80, 86, 93, 80], - mode='markers', - name='Latin America', - text=['Chile', 'Argentina', 'Mexico', 'Venezuela', 'Venezuela', - 'El Salvador', 'Bolivia'], - marker=Marker( - color='rgb(142, 124, 195)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ) - ]), - layout=Layout( - title='Quarter 1 Growth', - autosize=False, - width=500, - height=500, - xaxis=XAxis( - title='GDP per Capita', - showgrid=False, - zeroline=False - ), - yaxis=YAxis( - title='Percent', - showline=False - ), - margin=Margin( - l=65, - r=50, - b=65, - t=90 - ) - ) - ) - print(fig) - print('\n\n') - fig.strip_style() - print(fig) - print('\n\n') - comp_fig = Figure( - data=Data([ - Scatter( - x=[52698, 43117], - y=[53, 31], - mode='markers', - name='North America', - text=['United States', 'Canada'], - marker=Marker( - line=Line() - ) - ), - Scatter( - x=[39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, - 18007], - y=[33, 20, 13, 19, 27, 19, 49, 44, 38], - mode='markers', - name='Europe', - text=['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - marker=Marker( - line=Line() - ) - ), - Scatter( - x=[42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899], - y=[23, 42, 54, 89, 14, 99, 93, 70], - mode='markers', - name='Asia/Pacific', - text=['Australia', 'Japan', 'South Korea', 'Malaysia', 'China', - 'Indonesia', 'Philippines', 'India'], - marker=Marker( - line=Line() - ) - ), - Scatter( - x=[19097, 18601, 15595, 13546, 12026, 7434, 5419], - y=[43, 47, 56, 80, 86, 93, 80], - mode='markers', - name='Latin America', - text=['Chile', 'Argentina', 'Mexico', 'Venezuela', 'Venezuela', - 'El Salvador', 'Bolivia'], - marker=Marker( - line=Line() - ) - ) - ]), - layout=Layout( - title='Quarter 1 Growth', - width=500, - height=500, - xaxis=XAxis( - title='GDP per Capita' - ), - yaxis=YAxis( - title='Percent' - ), - margin=Margin( - l=65, - r=50, - b=65, - t=90 - ) - ) - ) - equivalent, msg = compare_dict(fig, comp_fig) - print(msg) - assert equivalent diff --git a/plotly/tests/test_core/test_graph_objs/test_to_string.py b/plotly/tests/test_core/test_graph_objs/test_to_string.py deleted file mode 100644 index 63d2dad4d4..0000000000 --- a/plotly/tests/test_core/test_graph_objs/test_to_string.py +++ /dev/null @@ -1,60 +0,0 @@ -from __future__ import absolute_import - -from plotly.graph_objs import Contour, Data, Figure, Layout, Margin, Scatter - - -def test_to_string(): - fig = Figure( - data=Data([ - Scatter( - x=[1, 2, 3, 4], - y=[10, 15, 13, 17] - ), - Scatter( - x=[1, 2, 3, 4], - y=[16, 5, 11, 9] - ) - ]), - layout=Layout( - autosize=False, - width=500, - height=500, - margin=Margin( - l=65, - r=50, - b=65, - t=65 - ) - ) - ) - fig_string = fig.to_string(pretty=False) - comp_string = ('Figure(\n' - ' data=Data([\n' - ' Scatter(\n' - ' x=[1, 2, 3, 4],\n' - ' y=[10, 15, 13, 17]\n' - ' ),\n' - ' Scatter(\n' - ' x=[1, 2, 3, 4],\n' - ' y=[16, 5, 11, 9]\n' - ' )\n' - ' ]),\n' - ' layout=Layout(\n' - ' autosize=False,\n' - ' height=500,\n' - ' margin=Margin(\n' - ' r=50,\n' - ' t=65,\n' - ' b=65,\n' - ' l=65\n' - ' ),\n' - ' width=500\n' - ' )\n' - ')') - assert fig_string == comp_string - - -def test_nested_list(): - z = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, - 13, 14, 15, 16, 17, 18, 19, 20, 21]] - print(Contour(z=z).to_string()) diff --git a/plotly/tests/test_core/test_graph_objs/test_update.py b/plotly/tests/test_core/test_graph_objs/test_update.py index 5d769532e5..9f181d32b9 100644 --- a/plotly/tests/test_core/test_graph_objs/test_update.py +++ b/plotly/tests/test_core/test_graph_objs/test_update.py @@ -1,7 +1,8 @@ from __future__ import absolute_import from unittest import skip -from plotly.graph_objs import Data, Figure, Layout, Line, Scatter, XAxis +from plotly.graph_objs import Data, Figure, Layout, Line, Scatter, scatter, XAxis +from plotly.tests.utils import strip_dict_params def test_update_dict(): @@ -16,31 +17,37 @@ def test_update_dict(): def test_update_list(): trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2]) trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1]) - data = Data([trace1, trace2]) + fig = Figure([trace1, trace2]) update = dict(x=[2, 3, 4], y=[1, 2, 3]) - data.update(update) - assert data[0] == Scatter(x=[2, 3, 4], y=[1, 2, 3]) - assert data[1] == Scatter(x=[2, 3, 4], y=[1, 2, 3]) + fig.data[0].update(update) + fig.data[1].update(update) + + d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[2, 3, 4], y=[1, 2, 3])) + assert d1 == d2 + d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[2, 3, 4], y=[1, 2, 3])) + assert d1 == d2 def test_update_dict_empty(): trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2]) trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1]) - data = Data([trace1, trace2]) - data.update({}) - print(data.to_string()) - assert data[0] == Scatter(x=[1, 2, 3], y=[2, 1, 2]) - assert data[1] == Scatter(x=[1, 2, 3], y=[3, 2, 1]) + fig = Figure([trace1, trace2]) + fig.update({}) + d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[1, 2, 3], y=[2, 1, 2])) + assert d1 == d2 + d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[1, 2, 3], y=[3, 2, 1])) + assert d1 == d2 def test_update_list_empty(): trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2]) trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1]) - data = Data([trace1, trace2]) - data.update([]) - print(data.to_string()) - assert data[0] == Scatter(x=[1, 2, 3], y=[2, 1, 2]) - assert data[1] == Scatter(x=[1, 2, 3], y=[3, 2, 1]) + fig = Figure([trace1, trace2]) + fig.update([]) + d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[1, 2, 3], y=[2, 1, 2])) + assert d1 == d2 + d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[1, 2, 3], y=[3, 2, 1])) + assert d1 == d2 @skip('See https://github.com/plotly/python-api/issues/291') @@ -51,12 +58,3 @@ def test_update_list_make_copies_false(): update = dict(x=[2, 3, 4], y=[1, 2, 3], line=Line()) data.update(update, make_copies=False) assert data[0]['line'] is data[1]['line'] - - -def test_update_list_make_copies_true(): - trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2]) - trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1]) - data = Data([trace1, trace2]) - update = dict(x=[2, 3, 4], y=[1, 2, 3], line=Line()) - data.update(update, make_copies=True) - assert data[0]['line'] is not data[1]['line'] diff --git a/plotly/tests/test_core/test_graph_reference/test_graph_reference.py b/plotly/tests/test_core/test_graph_reference/test_graph_reference.py index 005d33a7c0..f81cc79e9f 100644 --- a/plotly/tests/test_core/test_graph_reference/test_graph_reference.py +++ b/plotly/tests/test_core/test_graph_reference/test_graph_reference.py @@ -19,23 +19,23 @@ FAKE_API_DOMAIN = 'https://api.am.not.here.ly' -class TestGraphReferenceCaching(PlotlyTestCase): - - @attr('slow') - def test_default_schema_is_up_to_date(self): - response = v2.plot_schema.retrieve('') - schema = response.json()['schema'] - - path = os.path.join('package_data', 'default-schema.json') - s = resource_string('plotly', path).decode('utf-8') - default_schema = _json.loads(s) - - msg = ( - 'The default, hard-coded plot schema we ship with pip is out of ' - 'sync with the prod plot schema!\n' - 'Run `make update_default_schema` to fix it!' - ) - self.assertEqual(schema, default_schema, msg=msg) +#class TestGraphReferenceCaching(PlotlyTestCase): + + # @attr('slow') + # def test_default_schema_is_up_to_date(self): + # response = v2.plot_schema.retrieve('') + # schema = response.json()['schema'] + + # path = os.path.join('package_data', 'plot-schema.json') + # s = resource_string('plotly', path).decode('utf-8') + # default_schema = _json.loads(s) + + # msg = ( + # 'The default, hard-coded plot schema we ship with pip is out of ' + # 'sync with the prod plot schema!\n' + # 'Run `make update_default_schema` to fix it!' + # ) + # self.assertEqual(schema, default_schema, msg=msg) class TestStringToClass(PlotlyTestCase): diff --git a/plotly/tests/test_core/test_grid/test_grid.py b/plotly/tests/test_core/test_grid/test_grid.py index 37abd7b81d..f756266a32 100644 --- a/plotly/tests/test_core/test_grid/test_grid.py +++ b/plotly/tests/test_core/test_grid/test_grid.py @@ -38,7 +38,7 @@ class GridTest(PlotlyTestCase): def setUp(self): super(GridTest, self).setUp() - py.sign_in('PythonTest', '9v9f20pext') + py.sign_in('PythonTest', 'xnyU0DEwvAQQCwHVseIL') def get_grid(self): c1 = Column([1, 2, 3, 4], 'first column') @@ -93,7 +93,7 @@ def test_row_append(self): @attr('slow') def test_plot_from_grid(self): g = self.upload_and_return_grid() - url = py.plot([Scatter(xsrc=g[0], ysrc=g[1])], + url = py.plot([Scatter(xsrc=g[0].id, ysrc=g[1].id)], auto_open=False, filename='plot from grid') return url, g @@ -103,8 +103,8 @@ def test_get_figure_from_references(self): fig = py.get_figure(url) data = fig['data'] trace = data[0] - assert(g[0].data == trace['x']) - assert(g[1].data == trace['y']) + assert(tuple(g[0].data) == tuple(trace['x'])) + assert(tuple(g[1].data) == tuple(trace['y'])) def test_grid_id_args(self): self.assertEqual(parse_grid_id_args(self._grid, None), @@ -118,13 +118,13 @@ def test_overspecified_grid_args(self): with self.assertRaises(InputError): parse_grid_id_args(self._grid, self._grid_url) - # Out of order usage - def test_scatter_from_non_uploaded_grid(self): - c1 = Column([1, 2, 3, 4], 'first column') - c2 = Column(['a', 'b', 'c', 'd'], 'second column') - g = Grid([c1, c2]) - with self.assertRaises(InputError): - Scatter(xsrc=g[0], ysrc=g[1]) + # not broken anymore since plotly 3.0.0 + # def test_scatter_from_non_uploaded_grid(self): + # c1 = Column([1, 2, 3, 4], 'first column') + # c2 = Column(['a', 'b', 'c', 'd'], 'second column') + # g = Grid([c1, c2]) + # with self.assertRaises(ValueError): + # Scatter(xsrc=g[0], ysrc=g[1]) def test_column_append_of_non_uploaded_grid(self): c1 = Column([1, 2, 3, 4], 'first column') @@ -178,4 +178,6 @@ def test_duplicate_filenames(self): try: py.grid_ops.upload(g, unique_filename, auto_open=False) except PlotlyRequestError as e: - assert(e.status_code == 409) + pass + else: + self.fail('Expected this to fail!') diff --git a/plotly/tests/test_core/test_meta/test_meta.py b/plotly/tests/test_core/test_meta/test_meta.py index e2bec3afe1..65a0ba5122 100644 --- a/plotly/tests/test_core/test_meta/test_meta.py +++ b/plotly/tests/test_core/test_meta/test_meta.py @@ -26,7 +26,7 @@ class MetaTest(PlotlyTestCase): def setUp(self): super(MetaTest, self).setUp() - py.sign_in('PythonTest', '9v9f20pext') + py.sign_in('PythonTest', 'xnyU0DEwvAQQCwHVseIL') def random_filename(self): random_chars = [random.choice(string.ascii_uppercase) for _ in range(5)] diff --git a/plotly/tests/test_core/test_offline/test_offline.py b/plotly/tests/test_core/test_offline/test_offline.py index a4aca7ddfe..cf4f67d5fd 100644 --- a/plotly/tests/test_core/test_offline/test_offline.py +++ b/plotly/tests/test_core/test_offline/test_offline.py @@ -10,7 +10,6 @@ from requests.compat import json as _json import plotly -from plotly.tests.utils import PlotlyTestCase fig = { @@ -46,8 +45,6 @@ def _read_html(self, file_url): return f.read() def test_default_plot_generates_expected_html(self): - data_json = _json.dumps(fig['data'], - cls=plotly.utils.PlotlyJSONEncoder) layout_json = _json.dumps( fig['layout'], cls=plotly.utils.PlotlyJSONEncoder) @@ -57,7 +54,11 @@ def test_default_plot_generates_expected_html(self): # I don't really want to test the entire script output, so # instead just make sure a few of the parts are in here? self.assertIn('Plotly.newPlot', html) # plot command is in there - self.assertIn(data_json, html) # data is in there + + x_data = '"x": [1, 2, 3]' + y_data = '"y": [10, 20, 30]' + + self.assertTrue(x_data in html and y_data in html) # data in there self.assertIn(layout_json, html) # so is layout self.assertIn(PLOTLYJS, html) # and the source code # and it's an doc diff --git a/plotly/tests/test_core/test_plotly/test_credentials.py b/plotly/tests/test_core/test_plotly/test_credentials.py index 73b9eca876..36b08822ba 100644 --- a/plotly/tests/test_core/test_plotly/test_credentials.py +++ b/plotly/tests/test_core/test_plotly/test_credentials.py @@ -1,13 +1,19 @@ from __future__ import absolute_import -from mock import patch - import plotly.plotly.plotly as py import plotly.session as session import plotly.tools as tls from plotly import exceptions from plotly.tests.utils import PlotlyTestCase +import sys + +# import from mock +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import patch +else: + from mock import patch + class TestSignIn(PlotlyTestCase): diff --git a/plotly/tests/test_core/test_plotly/test_plot.py b/plotly/tests/test_core/test_plotly/test_plot.py index 4d5a8eb0b3..d93f0c9739 100644 --- a/plotly/tests/test_core/test_plotly/test_plot.py +++ b/plotly/tests/test_core/test_plotly/test_plot.py @@ -9,9 +9,9 @@ import requests import six +import sys from requests.compat import json as _json -from mock import patch from nose.plugins.attrib import attr import plotly.tools as tls @@ -22,6 +22,13 @@ from plotly.files import CONFIG_FILE +# import from mock +if sys.version_info.major == 3 and sys.version_info.minor >= 3: + from unittest.mock import patch +else: + from mock import patch + + class TestPlot(PlotlyTestCase): def setUp(self): @@ -34,8 +41,8 @@ def test_plot_valid(self): fig = { 'data': [ { - 'x': [1, 2, 3], - 'y': [2, 1, 2] + 'x': (1, 2, 3), + 'y': (2, 1, 2) } ], 'layout': {'title': 'simple'} @@ -56,7 +63,7 @@ def test_plot_invalid(self): } ] } - with self.assertRaises(PlotlyError): + with self.assertRaises(ValueError): py.plot(fig, auto_open=False, filename='plot_invalid') def test_plot_invalid_args_1(self): @@ -65,7 +72,7 @@ def test_plot_invalid_args_1(self): filename='plot_invalid') def test_plot_invalid_args_2(self): - with self.assertRaises(PlotlyError): + with self.assertRaises(ValueError): py.plot([1, 2, 3], [2, 1, 2], auto_open=False, filename='plot_invalid') diff --git a/plotly/tests/test_core/test_stream/test_stream.py b/plotly/tests/test_core/test_stream/test_stream.py index 869fd8d2d3..3b286288f3 100644 --- a/plotly/tests/test_core/test_stream/test_stream.py +++ b/plotly/tests/test_core/test_stream/test_stream.py @@ -10,7 +10,6 @@ import plotly.plotly as py from plotly.graph_objs import (Layout, Scatter, Stream) -from plotly import exceptions from plotly.tests.utils import PlotlyTestCase un = 'PythonAPI' @@ -28,7 +27,7 @@ def setUp(self): super(TestStreaming, self).setUp() py.sign_in(un, ak, **config) - @attr('slow') + #@attr('slow') def test_initialize_stream_plot(self): py.sign_in(un, ak) stream = Stream(token=tk, maxpoints=50) @@ -50,7 +49,7 @@ def test_stream_single_points(self): time.sleep(.5) my_stream = py.Stream(tk) my_stream.open() - my_stream.write(Scatter(x=1, y=10)) + my_stream.write(Scatter(x=[1], y=[10])) time.sleep(.5) my_stream.close() @@ -82,29 +81,29 @@ def test_stream_layout(self): title_1 = "this other title i picked second" my_stream = py.Stream(tk) my_stream.open() - my_stream.write(Scatter(x=1, y=10), layout=Layout(title=title_0)) + my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_0)) time.sleep(.5) my_stream.close() my_stream.open() - my_stream.write(Scatter(x=1, y=10), layout=Layout(title=title_1)) + my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(title=title_1)) my_stream.close() @attr('slow') def test_stream_validate_data(self): - with self.assertRaises(exceptions.PlotlyError): + with self.assertRaises(ValueError): py.sign_in(un, ak) my_stream = py.Stream(tk) my_stream.open() - my_stream.write(dict(x=1, y=10, z=[1])) # assumes scatter... + my_stream.write(dict(x=[1], y=[10], z=[1])) # assumes scatter... my_stream.close() @attr('slow') def test_stream_validate_layout(self): - with self.assertRaises(exceptions.PlotlyError): + with self.assertRaises(ValueError): py.sign_in(un, ak) my_stream = py.Stream(tk) my_stream.open() - my_stream.write(Scatter(x=1, y=10), layout=Layout(legend=True)) + my_stream.write(Scatter(x=[1], y=[10]), layout=Layout(legend=True)) my_stream.close() @attr('slow') @@ -115,7 +114,7 @@ def test_stream_unstreamable(self): py.sign_in(un, ak) my_stream = py.Stream(tk) my_stream.open() - my_stream.write(Scatter(x=1, y=10, name='nope')) + my_stream.write(Scatter(x=[1], y=[10], name='nope')) my_stream.close() def test_stream_no_scheme(self): @@ -150,7 +149,7 @@ def test_stream_http(self): 'server': 'stream.plot.ly', 'port': 80, 'ssl_enabled': False, - 'ssl_verification_enabled': False, + 'ssl_verification_enabled': False, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk @@ -175,7 +174,7 @@ def test_stream_https(self): 'server': 'stream.plot.ly', 'port': 443, 'ssl_enabled': True, - 'ssl_verification_enabled': True, + 'ssl_verification_enabled': True, 'headers': { 'Host': 'stream.plot.ly', 'plotly-streamtoken': tk diff --git a/plotly/tests/test_core/test_tools/test_make_subplots.py b/plotly/tests/test_core/test_tools/test_make_subplots.py index 70916540ba..903ca36968 100644 --- a/plotly/tests/test_core/test_tools/test_make_subplots.py +++ b/plotly/tests/test_core/test_tools/test_make_subplots.py @@ -3,7 +3,7 @@ from unittest import TestCase from plotly.graph_objs import (Annotation, Annotations, Data, Figure, Font, - Layout, Scene, XAxis, YAxis) + Layout, layout, Scene, XAxis, YAxis) import plotly.tools as tls @@ -105,15 +105,16 @@ def test_single_plot(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), yaxis1=YAxis( domain=[0.0, 1.0], - anchor='x1' + anchor='x' ) ) ) - self.assertEqual(tls.make_subplots(), expected) + self.assertEqual(tls.make_subplots().to_plotly_json(), + expected.to_plotly_json()) def test_two_row(self): expected = Figure( @@ -121,7 +122,7 @@ def test_two_row(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 1.0], @@ -129,7 +130,7 @@ def test_two_row(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -137,32 +138,32 @@ def test_two_row(self): ) ) ) - self.assertEqual(tls.make_subplots(rows=2), expected) + self.assertEqual(tls.make_subplots(rows=2).to_plotly_json(), expected.to_plotly_json()) def test_two_row_bottom_left(self): expected = Figure( data=Data(), layout=Layout( - xaxis1=XAxis( + xaxis1=layout.XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), - xaxis2=XAxis( + xaxis2=layout.XAxis( domain=[0.0, 1.0], anchor='y2' ), - yaxis1=YAxis( + yaxis1=layout.YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), - yaxis2=YAxis( + yaxis2=layout.YAxis( domain=[0.575, 1.0], anchor='x2' - ) + ), ) ) fig = tls.make_subplots(rows=2, start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_two_column(self): expected = Figure( @@ -170,7 +171,7 @@ def test_two_column(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -178,7 +179,7 @@ def test_two_column(self): ), yaxis1=YAxis( domain=[0.0, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 1.0], @@ -186,7 +187,7 @@ def test_two_column(self): ) ) ) - self.assertEqual(tls.make_subplots(cols=2), expected) + self.assertEqual(tls.make_subplots(cols=2).to_plotly_json(), expected.to_plotly_json()) def test_a_lot(self): expected = Figure( @@ -194,7 +195,7 @@ def test_a_lot(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.1183673469387755], - anchor='y1' + anchor='y' ), xaxis10=XAxis( domain=[0.29387755102040813, 0.4122448979591836], @@ -306,7 +307,7 @@ def test_a_lot(self): ), yaxis1=YAxis( domain=[0.80625, 1.0], - anchor='x1' + anchor='x' ), yaxis10=YAxis( domain=[0.5375, 0.73125], @@ -419,7 +420,7 @@ def test_a_lot(self): ) ) fig = tls.make_subplots(rows=4, cols=7) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_a_lot_bottom_left(self): expected = Figure( @@ -427,7 +428,7 @@ def test_a_lot_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.1183673469387755], - anchor='y1' + anchor='y' ), xaxis10=XAxis( domain=[0.29387755102040813, 0.4122448979591836], @@ -539,7 +540,7 @@ def test_a_lot_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.19375], - anchor='x1' + anchor='x' ), yaxis10=YAxis( domain=[0.26875, 0.4625], @@ -652,7 +653,7 @@ def test_a_lot_bottom_left(self): ) ) fig = tls.make_subplots(rows=4, cols=7, start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_spacing(self): expected = Figure( @@ -660,7 +661,7 @@ def test_spacing(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.3], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35, 0.6499999999999999], @@ -684,7 +685,7 @@ def test_spacing(self): ), yaxis1=YAxis( domain=[0.55, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.55, 1.0], @@ -711,7 +712,7 @@ def test_spacing(self): fig = tls.make_subplots(rows=2, cols=3, horizontal_spacing=.05, vertical_spacing=.1) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs(self): expected = Figure( @@ -719,7 +720,7 @@ def test_specs(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 0.2888888888888889], @@ -735,7 +736,7 @@ def test_specs(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -754,7 +755,7 @@ def test_specs(self): fig = tls.make_subplots(rows=2, cols=3, specs=[[{}, None, None], [{}, {}, {}]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_bottom_left(self): expected = Figure( @@ -762,7 +763,7 @@ def test_specs_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 0.2888888888888889], @@ -778,7 +779,7 @@ def test_specs_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.575, 1.0], @@ -798,7 +799,7 @@ def test_specs_bottom_left(self): specs=[[{}, None, None], [{}, {}, {}]], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_colspan(self): expected = Figure( @@ -806,7 +807,7 @@ def test_specs_colspan(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 0.45], @@ -826,7 +827,7 @@ def test_specs_colspan(self): ), yaxis1=YAxis( domain=[0.7333333333333333, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.36666666666666664, 0.6333333333333333], @@ -850,7 +851,7 @@ def test_specs_colspan(self): specs=[[{'colspan': 2}, None], [{}, {}], [{}, {}]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_rowspan(self): expected = Figure( @@ -858,7 +859,7 @@ def test_specs_rowspan(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -882,7 +883,7 @@ def test_specs_rowspan(self): ), yaxis1=YAxis( domain=[0.0, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.7333333333333333, 1.0], @@ -908,8 +909,8 @@ def test_specs_rowspan(self): ) fig = tls.make_subplots(rows=3, cols=3, specs=[[{'rowspan': 3}, {}, {}], - [None, {}, {}], [None, {'colspan': 2}, None]]) - self.assertEqual(fig, expected) + [None, {}, {}], [None, {'colspan': 2}, None]]) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_rowspan2(self): expected = Figure( @@ -917,7 +918,7 @@ def test_specs_rowspan2(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -937,7 +938,7 @@ def test_specs_rowspan2(self): ), yaxis1=YAxis( domain=[0.7333333333333333, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.7333333333333333, 1.0], @@ -960,7 +961,7 @@ def test_specs_rowspan2(self): fig = tls.make_subplots(rows=3, cols=3, specs=[[{}, {}, {'rowspan': 2}], [{'colspan': 2}, None, None], [{'colspan': 3}, None, None]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_colspan_rowpan(self): expected = Figure( @@ -968,7 +969,7 @@ def test_specs_colspan_rowpan(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.6444444444444445], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.7111111111111111, 1.0], @@ -992,7 +993,7 @@ def test_specs_colspan_rowpan(self): ), yaxis1=YAxis( domain=[0.36666666666666664, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.7333333333333333, 1.0], @@ -1019,7 +1020,7 @@ def test_specs_colspan_rowpan(self): fig = tls.make_subplots(rows=3, cols=3, specs=[[{'colspan': 2, 'rowspan': 2}, None, {}], [None, None, {}], [{}, {}, {}]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_colspan_rowpan_bottom_left(self): expected = Figure( @@ -1027,7 +1028,7 @@ def test_specs_colspan_rowpan_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.6444444444444445], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.7111111111111111, 1.0], @@ -1051,7 +1052,7 @@ def test_specs_colspan_rowpan_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.6333333333333333], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.26666666666666666], @@ -1079,13 +1080,13 @@ def test_specs_colspan_rowpan_bottom_left(self): specs=[[{'colspan': 2, 'rowspan': 2}, None, {}], [None, None, {}], [{}, {}, {}]], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_is_3d(self): expected = Figure( data=Data(), layout=Layout( - scene1=Scene( + scene=Scene( domain={'y': [0.575, 1.0], 'x': [0.0, 0.45]} ), scene2=Scene( @@ -1093,7 +1094,7 @@ def test_specs_is_3d(self): ), xaxis1=XAxis( domain=[0.55, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -1101,7 +1102,7 @@ def test_specs_is_3d(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1111,7 +1112,7 @@ def test_specs_is_3d(self): ) fig = tls.make_subplots(rows=2, cols=2, specs=[[{'is_3d': True}, {}], [{'is_3d': True}, {}]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_padding(self): expected = Figure( @@ -1119,7 +1120,7 @@ def test_specs_padding(self): layout=Layout( xaxis1=XAxis( domain=[0.1, 0.5], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.5, 1.0], @@ -1135,7 +1136,7 @@ def test_specs_padding(self): ), yaxis1=YAxis( domain=[0.5, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.7, 1.0], @@ -1155,7 +1156,7 @@ def test_specs_padding(self): vertical_spacing=0, specs=[[{'l': 0.1}, {'b': 0.2}], [{'t': 0.2}, {'r': 0.1}]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_specs_padding_bottom_left(self): expected = Figure( @@ -1163,7 +1164,7 @@ def test_specs_padding_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.1, 0.5], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.5, 1.0], @@ -1179,7 +1180,7 @@ def test_specs_padding_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.5], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.2, 0.5], @@ -1200,7 +1201,7 @@ def test_specs_padding_bottom_left(self): specs=[[{'l': 0.1}, {'b': 0.2}], [{'t': 0.2}, {'r': 0.1}]], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_xaxes(self): expected = Figure( @@ -1235,7 +1236,7 @@ def test_shared_xaxes(self): ), yaxis4=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis5=YAxis( domain=[0.0, 0.425], @@ -1248,7 +1249,7 @@ def test_shared_xaxes(self): ) ) fig = tls.make_subplots(rows=2, cols=3, shared_xaxes=True) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_xaxes_bottom_left(self): expected = Figure( @@ -1256,7 +1257,7 @@ def test_shared_xaxes_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -1268,7 +1269,7 @@ def test_shared_xaxes_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1297,7 +1298,7 @@ def test_shared_xaxes_bottom_left(self): ) fig = tls.make_subplots(rows=2, cols=3, shared_xaxes=True, start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_yaxes(self): expected = Figure( @@ -1305,7 +1306,7 @@ def test_shared_yaxes(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis10=XAxis( domain=[0.55, 1.0], @@ -1350,7 +1351,7 @@ def test_shared_yaxes(self): ), yaxis1=YAxis( domain=[0.848, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.6359999999999999, 0.7879999999999999], @@ -1371,7 +1372,7 @@ def test_shared_yaxes(self): ) ) fig = tls.make_subplots(rows=5, cols=2, shared_yaxes=True) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_xaxes_yaxes(self): expected = Figure( @@ -1403,13 +1404,13 @@ def test_shared_xaxes_yaxes(self): ), yaxis3=YAxis( domain=[0.0, 0.26666666666666666], - anchor='x1' + anchor='x' ) ) ) fig = tls.make_subplots(rows=3, cols=3, shared_xaxes=True, shared_yaxes=True) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_xaxes_yaxes_bottom_left(self): expected = Figure( @@ -1417,7 +1418,7 @@ def test_shared_xaxes_yaxes_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -1431,7 +1432,7 @@ def test_shared_xaxes_yaxes_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.26666666666666666], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.36666666666666664, 0.6333333333333333], @@ -1448,7 +1449,7 @@ def test_shared_xaxes_yaxes_bottom_left(self): fig = tls.make_subplots(rows=3, cols=3, shared_xaxes=True, shared_yaxes=True, start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_axes_list(self): expected = Figure( @@ -1456,7 +1457,7 @@ def test_shared_axes_list(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -1469,7 +1470,7 @@ def test_shared_axes_list(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1484,7 +1485,7 @@ def test_shared_axes_list(self): ) fig = tls.make_subplots(rows=2, cols=2, shared_xaxes=[(1, 1), (2, 1)], shared_yaxes=[(1, 1), (1, 2)]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_axes_list_bottom_left(self): expected = Figure( @@ -1492,7 +1493,7 @@ def test_shared_axes_list_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -1505,7 +1506,7 @@ def test_shared_axes_list_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.575, 1.0], @@ -1521,7 +1522,7 @@ def test_shared_axes_list_bottom_left(self): fig = tls.make_subplots(rows=2, cols=2, shared_xaxes=[(1, 1), (2, 1)], shared_yaxes=[(1, 1), (1, 2)], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_axes_list_of_lists(self): expected = Figure( @@ -1529,7 +1530,7 @@ def test_shared_axes_list_of_lists(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -1545,7 +1546,7 @@ def test_shared_axes_list_of_lists(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.575, 1.0], @@ -1574,7 +1575,7 @@ def test_shared_axes_list_of_lists(self): fig = tls.make_subplots( rows=2, cols=3, shared_xaxes=[[(1, 1), (2, 1)], [(1, 3), (2, 3)]] ) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_shared_axes_list_of_lists_bottom_left(self): expected = Figure( @@ -1582,7 +1583,7 @@ def test_shared_axes_list_of_lists_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -1598,7 +1599,7 @@ def test_shared_axes_list_of_lists_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1627,7 +1628,7 @@ def test_shared_axes_list_of_lists_bottom_left(self): fig = tls.make_subplots(rows=2, cols=3, shared_xaxes=[[(1, 1), (2, 1)], [(1, 3), (2, 3)]], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_insets(self): expected = Figure( @@ -1635,7 +1636,7 @@ def test_insets(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -1655,7 +1656,7 @@ def test_insets(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.575, 1.0], @@ -1678,7 +1679,7 @@ def test_insets(self): fig = tls.make_subplots(rows=2, cols=2, insets=[{'cell': (2, 2), 'l': 0.7, 'w': 0.2, 'b': 0.2, 'h': 0.5}]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_insets_bottom_left(self): expected = Figure( @@ -1686,7 +1687,7 @@ def test_insets_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -1706,7 +1707,7 @@ def test_insets_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1730,7 +1731,7 @@ def test_insets_bottom_left(self): insets=[{'cell': (2, 2), 'l': 0.7, 'w': 0.2, 'b': 0.2, 'h': 0.5}], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_insets_multiple(self): expected = Figure( @@ -1738,7 +1739,7 @@ def test_insets_multiple(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 1.0], @@ -1754,7 +1755,7 @@ def test_insets_multiple(self): ), yaxis1=YAxis( domain=[0.575, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.425], @@ -1772,7 +1773,7 @@ def test_insets_multiple(self): ) fig = tls.make_subplots(rows=2, insets=[{'cell': (1, 1), 'l': 0.8}, {'cell': (2, 1), 'l': 0.8}]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_insets_multiple_bottom_left(self): expected = Figure( @@ -1780,7 +1781,7 @@ def test_insets_multiple_bottom_left(self): layout=Layout( xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 1.0], @@ -1796,7 +1797,7 @@ def test_insets_multiple_bottom_left(self): ), yaxis1=YAxis( domain=[0.0, 0.425], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.575, 1.0], @@ -1816,7 +1817,7 @@ def test_insets_multiple_bottom_left(self): insets=[{'cell': (1, 1), 'l': 0.8}, {'cell': (2, 1), 'l': 0.8}], start_cell='bottom-left') - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_subplot_titles_2x1(self): # make a title for each subplot when the layout is 2 rows and 1 column @@ -1849,7 +1850,7 @@ def test_subplot_titles_2x1(self): ]), xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.0, 1.0], @@ -1857,7 +1858,7 @@ def test_subplot_titles_2x1(self): ), yaxis1=YAxis( domain=[0.625, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 0.375], @@ -1866,7 +1867,7 @@ def test_subplot_titles_2x1(self): ) ) fig = tls.make_subplots(rows=2, subplot_titles=('Title 1', 'Title 2')) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_subplot_titles_1x3(self): # make a title for each subplot when the layout is 1 row and 3 columns @@ -1910,7 +1911,7 @@ def test_subplot_titles_1x3(self): ]), xaxis1=XAxis( domain=[0.0, 0.2888888888888889], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.35555555555555557, 0.6444444444444445], @@ -1922,7 +1923,7 @@ def test_subplot_titles_1x3(self): ), yaxis1=YAxis( domain=[0.0, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.0, 1.0], @@ -1936,7 +1937,7 @@ def test_subplot_titles_1x3(self): ) fig = tls.make_subplots(cols=3, subplot_titles=('Title 1', 'Title 2', 'Title 3')) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_subplot_titles_shared_axes(self): # make a title for each subplot when the layout is 1 row and 3 columns @@ -2005,7 +2006,7 @@ def test_subplot_titles_shared_axes(self): ), yaxis2=YAxis( domain=[0.0, 0.375], - anchor='x1' + anchor='x' ) ) ) @@ -2013,7 +2014,7 @@ def test_subplot_titles_shared_axes(self): subplot_titles=('Title 1', 'Title 2', 'Title 3', 'Title 4'), shared_xaxes=True, shared_yaxes=True) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_subplot_titles_irregular_layout(self): @@ -2058,7 +2059,7 @@ def test_subplot_titles_irregular_layout(self): ]), xaxis1=XAxis( domain=[0.0, 0.45], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.55, 1.0], @@ -2070,7 +2071,7 @@ def test_subplot_titles_irregular_layout(self): ), yaxis1=YAxis( domain=[0.625, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.625, 1.0], @@ -2085,7 +2086,7 @@ def test_subplot_titles_irregular_layout(self): fig = tls.make_subplots(rows=2, cols=2, subplot_titles=('Title 1', 'Title 2', 'Title 3'), specs=[[{}, {}], [{'colspan': 2}, None]]) - self.assertEqual(fig, expected) + self.assertEqual(fig.to_plotly_json(), expected.to_plotly_json()) def test_subplot_titles_insets(self): # This should make a title for the inset plot @@ -2108,7 +2109,7 @@ def test_subplot_titles_insets(self): ]), xaxis1=XAxis( domain=[0.0, 1.0], - anchor='y1' + anchor='y' ), xaxis2=XAxis( domain=[0.7, 1.0], @@ -2116,7 +2117,7 @@ def test_subplot_titles_insets(self): ), yaxis1=YAxis( domain=[0.0, 1.0], - anchor='x1' + anchor='x' ), yaxis2=YAxis( domain=[0.3, 1.0], diff --git a/plotly/tests/test_core/test_tools/test_validate.py b/plotly/tests/test_core/test_tools/test_validate.py index d1b0dc2579..1dce95f2fa 100644 --- a/plotly/tests/test_core/test_tools/test_validate.py +++ b/plotly/tests/test_core/test_tools/test_validate.py @@ -8,28 +8,28 @@ def test_validate_valid_fig(): fig = { - 'layout':{ - 'title':'something' + 'layout': { + 'title': 'something' }, - 'data':[ + 'data': [ { - 'x':[1,2,3], - 'y':[2,1,2] + 'x': [1, 2, 3], + 'y': [2, 1, 2] } ] } tls.validate(fig, 'Figure') -@raises(PlotlyError) +@raises(ValueError) def test_validate_invalid_fig(): fig = { - 'layout':{ - 'title':'something' + 'layout': { + 'title': 'something' }, - 'data':{ - 'x':[1,2,3], - 'y':[2,1,2] + 'data': { + 'x': [1, 2, 3], + 'y': [2, 1, 2] } } tls.validate(fig, 'Figure') diff --git a/plotly/tests/test_optional/optional_utils.py b/plotly/tests/test_optional/optional_utils.py index 76941b1b1f..b6b6327445 100644 --- a/plotly/tests/test_optional/optional_utils.py +++ b/plotly/tests/test_optional/optional_utils.py @@ -6,6 +6,8 @@ from plotly.tests.utils import is_num_list from plotly.utils import get_by_path, node_generator +import copy + matplotlylib = optional_imports.get_module('plotly.matplotlylib') if matplotlylib: @@ -18,6 +20,7 @@ def run_fig(fig): renderer = PlotlyRenderer() exporter = Exporter(renderer) + print(exporter) exporter.run(fig) return renderer @@ -29,6 +32,36 @@ def _format_path(self, path): str_path = [repr(p) for p in path] return '[' + ']['.join(sp for sp in str_path) + ']' + def assert_fig_equal(self, d1, d2, msg=None, ignore=['uid']): + """ + Helper function for assert_dict_equal + + By defualt removes uid from d1 and/or d2 if present + then calls assert_dict_equal. + + :param (list|tuple) ignore: sequence of key names as + strings that are removed from both d1 and d2 if + they exist + """ + # deep copy d1 and d2 + if 'to_plotly_json' in dir(d1): + d1_copy = copy.deepcopy(d1.to_plotly_json()) + else: + d1_copy = copy.deepcopy(d1) + + if 'to_plotly_json' in dir(d2): + d2_copy = copy.deepcopy(d2.to_plotly_json()) + else: + d2_copy = copy.deepcopy(d2) + + for key in ignore: + if key in d1_copy.keys(): + del d1_copy[key] + if key in d2_copy.keys(): + del d2_copy[key] + + self.assert_dict_equal(d1_copy, d2_copy, msg=None) + def assert_dict_equal(self, d1, d2, msg=None): """ Uses `np.allclose()` on number arrays. diff --git a/plotly/tests/test_optional/test_figure_factory/test_figure_factory.py b/plotly/tests/test_optional/test_figure_factory/test_figure_factory.py index 4ab145bdac..32c2511385 100644 --- a/plotly/tests/test_optional/test_figure_factory/test_figure_factory.py +++ b/plotly/tests/test_optional/test_figure_factory/test_figure_factory.py @@ -1,20 +1,21 @@ from unittest import TestCase +from plotly import optional_imports from plotly.graph_objs import graph_objs as go from plotly.exceptions import PlotlyError -import plotly.tools as tls import plotly.figure_factory as ff -import plotly.figure_factory.utils as utils from plotly.tests.test_optional.optional_utils import NumpyTestUtilsMixin -import math -from nose.tools import raises import numpy as np from scipy.spatial import Delaunay import pandas as pd +shapely = optional_imports.get_module('shapely') +shapefile = optional_imports.get_module('shapefile') +gp = optional_imports.get_module('geopandas') -class TestDistplot(TestCase): + +class TestDistplot(NumpyTestUtilsMixin, TestCase): def test_wrong_curve_type(self): @@ -54,13 +55,10 @@ def test_simple_distplot_prob_density(self): expected_dp_layout = {'barmode': 'overlay', 'hovermode': 'closest', 'legend': {'traceorder': 'reversed'}, - 'xaxis1': {'anchor': 'y2', 'domain': [0.0, 1.0], 'zeroline': False}, - 'yaxis1': {'anchor': 'free', 'domain': [0.35, 1], 'position': 0.0}, - 'yaxis2': {'anchor': 'x1', - 'domain': [0, 0.25], - 'dtick': 1, - 'showticklabels': False}} - self.assertEqual(dp['layout'], expected_dp_layout) + 'xaxis': {'anchor': 'y2', 'domain': [0.0, 1.0], 'zeroline': False}, + 'yaxis': {'anchor': 'free', 'domain': [0.35, 1], 'position': 0.0}, + 'yaxis2': {'anchor': 'x', 'domain': [0, 0.25], 'dtick': 1, 'showticklabels': False}} + self.assert_fig_equal(dp['layout'], expected_dp_layout) expected_dp_data_hist = {'autobinx': False, 'histnorm': 'probability density', @@ -70,10 +68,10 @@ def test_simple_distplot_prob_density(self): 'opacity': 0.7, 'type': 'histogram', 'x': [1, 2, 2, 3], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 3.0, 'size': 1.0, 'start': 1.0}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist) expected_dp_data_rug = {'legendgroup': 'distplot', 'marker': {'color': 'rgb(31, 119, 180)', @@ -81,14 +79,13 @@ def test_simple_distplot_prob_density(self): 'mode': 'markers', 'name': 'distplot', 'showlegend': False, - 'text': None, 'type': 'scatter', 'x': [1, 2, 2, 3], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': ['distplot', 'distplot', 'distplot', 'distplot'], 'yaxis': 'y2'} - self.assertEqual(dp['data'][2], expected_dp_data_rug) + self.assert_fig_equal(dp['data'][2], expected_dp_data_rug) def test_simple_distplot_prob(self): @@ -100,13 +97,17 @@ def test_simple_distplot_prob(self): expected_dp_layout = {'barmode': 'overlay', 'hovermode': 'closest', 'legend': {'traceorder': 'reversed'}, - 'xaxis1': {'anchor': 'y2', 'domain': [0.0, 1.0], 'zeroline': False}, - 'yaxis1': {'anchor': 'free', 'domain': [0.35, 1], 'position': 0.0}, - 'yaxis2': {'anchor': 'x1', + 'xaxis': {'anchor': 'y2', + 'domain': [0.0, 1.0], + 'zeroline': False}, + 'yaxis': {'anchor': 'free', + 'domain': [0.35, 1], + 'position': 0.0}, + 'yaxis2': {'anchor': 'x', 'domain': [0, 0.25], 'dtick': 1, 'showticklabels': False}} - self.assertEqual(dp['layout'], expected_dp_layout) + self.assert_fig_equal(dp['layout'], expected_dp_layout) expected_dp_data_hist = {'autobinx': False, 'histnorm': 'probability', @@ -116,10 +117,10 @@ def test_simple_distplot_prob(self): 'opacity': 0.7, 'type': 'histogram', 'x': [1, 2, 2, 3], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 3.0, 'size': 1.0, 'start': 1.0}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist) expected_dp_data_rug = {'legendgroup': 'distplot', 'marker': {'color': 'rgb(31, 119, 180)', @@ -127,14 +128,13 @@ def test_simple_distplot_prob(self): 'mode': 'markers', 'name': 'distplot', 'showlegend': False, - 'text': None, 'type': 'scatter', 'x': [1, 2, 2, 3], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': ['distplot', 'distplot', 'distplot', 'distplot'], 'yaxis': 'y2'} - self.assertEqual(dp['data'][2], expected_dp_data_rug) + self.assert_fig_equal(dp['data'][2], expected_dp_data_rug) def test_distplot_more_args_prob_dens(self): @@ -159,12 +159,14 @@ def test_distplot_more_args_prob_dens(self): expected_dp_layout = {'barmode': 'overlay', 'hovermode': 'closest', 'legend': {'traceorder': 'reversed'}, - 'title': 'Dist Plot', - 'xaxis1': {'anchor': 'y2', 'domain': [0.0, 1.0], - 'zeroline': False}, - 'yaxis1': {'anchor': 'free', 'domain': [0.0, 1], - 'position': 0.0}} - self.assertEqual(dp['layout'], expected_dp_layout) + 'xaxis': {'anchor': 'y2', + 'domain': [0.0, 1.0], + 'zeroline': False}, + 'yaxis': {'anchor': 'free', + 'domain': [0.0, 1], + 'position': 0.0}, + 'title': 'Dist Plot'} + self.assert_fig_equal(dp['layout'], expected_dp_layout) expected_dp_data_hist_1 = {'autobinx': False, 'histnorm': 'probability density', @@ -176,11 +178,11 @@ def test_distplot_more_args_prob_dens(self): 'x': [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, -0.5, 0.3, 0.4, -0.37, 0.6], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 1.95, 'size': 0.2, 'start': -0.9}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist_1) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist_1) expected_dp_data_hist_2 = {'autobinx': False, 'histnorm': 'probability density', @@ -192,11 +194,11 @@ def test_distplot_more_args_prob_dens(self): 'x': [0.8, 1.5, 1.5, 0.6, 0.59, 1.0, 0.8, 1.7, 0.5, 0.8, -0.3, 1.2, 0.56, 0.3, 2.2], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 2.2, 'size': 0.2, 'start': -0.3}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][1], expected_dp_data_hist_2) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][1], expected_dp_data_hist_2) def test_distplot_more_args_prob(self): @@ -222,11 +224,13 @@ def test_distplot_more_args_prob(self): 'hovermode': 'closest', 'legend': {'traceorder': 'reversed'}, 'title': 'Dist Plot', - 'xaxis1': {'anchor': 'y2', 'domain': [0.0, 1.0], - 'zeroline': False}, - 'yaxis1': {'anchor': 'free', 'domain': [0.0, 1], - 'position': 0.0}} - self.assertEqual(dp['layout'], expected_dp_layout) + 'xaxis': {'anchor': 'y2', + 'domain': [0.0, 1.0], + 'zeroline': False}, + 'yaxis': {'anchor': 'free', + 'domain': [0.0, 1], + 'position': 0.0}} + self.assert_fig_equal(dp['layout'], expected_dp_layout) expected_dp_data_hist_1 = {'autobinx': False, 'histnorm': 'probability', @@ -238,11 +242,11 @@ def test_distplot_more_args_prob(self): 'x': [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, -0.5, 0.3, 0.4, -0.37, 0.6], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 1.95, 'size': 0.2, 'start': -0.9}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist_1) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist_1) expected_dp_data_hist_2 = {'autobinx': False, 'histnorm': 'probability', @@ -254,11 +258,11 @@ def test_distplot_more_args_prob(self): 'x': [0.8, 1.5, 1.5, 0.6, 0.59, 1.0, 0.8, 1.7, 0.5, 0.8, -0.3, 1.2, 0.56, 0.3, 2.2], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 2.2, 'size': 0.2, 'start': -0.3}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][1], expected_dp_data_hist_2) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][1], expected_dp_data_hist_2) def test_distplot_binsize_array_prob(self): hist1_x = [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, @@ -278,35 +282,35 @@ def test_distplot_binsize_array_prob(self): 'histnorm': 'probability density', 'legendgroup': '2012', 'marker': - {'color': 'rgb(31, 119, 180)'}, + {'color': 'rgb(31,119,180)'}, 'name': '2012', 'opacity': 0.7, 'type': 'histogram', 'x': [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, -0.5, 0.3, 0.4, -0.37, 0.6], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 1.95, 'size': 0.2, 'start': -0.9}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist_1) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist_1) expected_dp_data_hist_2 = {'autobinx': False, 'histnorm': 'probability density', 'legendgroup': '2013', 'marker': - {'color': 'rgb(255, 127, 14)'}, + {'color': 'rgb(255,127,14)'}, 'name': '2013', 'opacity': 0.7, 'type': 'histogram', 'x': [0.8, 1.5, 1.5, 0.6, 0.59, 1.0, 0.8, 1.7, 0.5, 0.8, -0.3, 1.2, 0.56, 0.3, 2.2], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 2.2, 'size': 0.2, 'start': -0.3}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][1], expected_dp_data_hist_2) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][1], expected_dp_data_hist_2) def test_distplot_binsize_array_prob_density(self): hist1_x = [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, @@ -326,35 +330,35 @@ def test_distplot_binsize_array_prob_density(self): 'histnorm': 'probability density', 'legendgroup': '2012', 'marker': - {'color': 'rgb(31, 119, 180)'}, + {'color': 'rgb(31,119,180)'}, 'name': '2012', 'opacity': 0.7, 'type': 'histogram', 'x': [0.8, 1.2, 0.2, 0.6, 1.6, -0.9, -0.07, 1.95, 0.9, -0.2, -0.5, 0.3, 0.4, -0.37, 0.6], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 1.95, 'size': 0.2, 'start': -0.9}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][0], expected_dp_data_hist_1) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][0], expected_dp_data_hist_1) expected_dp_data_hist_2 = {'autobinx': False, 'histnorm': 'probability density', 'legendgroup': '2013', 'marker': - {'color': 'rgb(255, 127, 14)'}, + {'color': 'rgb(255,127,14)'}, 'name': '2013', 'opacity': 0.7, 'type': 'histogram', 'x': [0.8, 1.5, 1.5, 0.6, 0.59, 1.0, 0.8, 1.7, 0.5, 0.8, -0.3, 1.2, 0.56, 0.3, 2.2], - 'xaxis': 'x1', + 'xaxis': 'x', 'xbins': {'end': 2.2, 'size': 0.2, 'start': -0.3}, - 'yaxis': 'y1'} - self.assertEqual(dp['data'][1], expected_dp_data_hist_2) + 'yaxis': 'y'} + self.assert_fig_equal(dp['data'][1], expected_dp_data_hist_2) class TestStreamline(TestCase): @@ -442,9 +446,9 @@ def test_simple_streamline(self): 'type': 'scatter', 'mode': 'lines' } - self.assertListEqual(strln['data'][0]['y'][0:100], + self.assertListEqual(list(strln['data'][0]['y'][0:100]), expected_strln_0_100['y']) - self.assertListEqual(strln['data'][0]['x'][0:100], + self.assertListEqual(list(strln['data'][0]['x'][0:100]), expected_strln_0_100['x']) @@ -455,11 +459,11 @@ def test_default_dendrogram(self): dendro = ff.create_dendrogram(X=X) expected_dendro = go.Figure( - data=go.Data([ + data=[ go.Scatter( x=np.array([25., 25., 35., 35.]), y=np.array([0., 1., 1., 0.]), - marker=go.Marker(color='rgb(61,153,112)'), + marker=go.scatter.Marker(color='rgb(61,153,112)'), mode='lines', xaxis='x', yaxis='y', @@ -469,7 +473,7 @@ def test_default_dendrogram(self): go.Scatter( x=np.array([15., 15., 30., 30.]), y=np.array([0., 2.23606798, 2.23606798, 1.]), - marker=go.Marker(color='rgb(61,153,112)'), + marker=go.scatter.Marker(color='rgb(61,153,112)'), mode='lines', xaxis='x', yaxis='y', @@ -479,21 +483,21 @@ def test_default_dendrogram(self): go.Scatter( x=np.array([5., 5., 22.5, 22.5]), y=np.array([0., 3.60555128, 3.60555128, 2.23606798]), - marker=go.Marker(color='rgb(0,116,217)'), + marker=go.scatter.Marker(color='rgb(0,116,217)'), mode='lines', xaxis='x', yaxis='y', hoverinfo='text', text=None ) - ]), + ], layout=go.Layout( autosize=False, - height='100%', + height=np.inf, hovermode='closest', showlegend=False, - width='100%', - xaxis=go.XAxis( + width=np.inf, + xaxis=go.layout.XAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -506,7 +510,7 @@ def test_default_dendrogram(self): type='linear', zeroline=False ), - yaxis=go.YAxis( + yaxis=go.layout.YAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -522,11 +526,15 @@ def test_default_dendrogram(self): self.assertEqual(len(dendro['data']), 3) # this is actually a bit clearer when debugging tests. - self.assert_dict_equal(dendro['data'][0], expected_dendro['data'][0]) - self.assert_dict_equal(dendro['data'][1], expected_dendro['data'][1]) - self.assert_dict_equal(dendro['data'][2], expected_dendro['data'][2]) + self.assert_fig_equal(dendro['data'][0], + expected_dendro['data'][0]) + self.assert_fig_equal(dendro['data'][1], + expected_dendro['data'][1]) + self.assert_fig_equal(dendro['data'][2], + expected_dendro['data'][2]) - self.assert_dict_equal(dendro['layout'], expected_dendro['layout']) + self.assert_fig_equal(dendro['layout'], + expected_dendro['layout']) def test_dendrogram_random_matrix(self): @@ -540,9 +548,9 @@ def test_dendrogram_random_matrix(self): dendro = ff.create_dendrogram(X, labels=names) expected_dendro = go.Figure( - data=go.Data([ + data=[ go.Scatter( - marker=go.Marker(color='rgb(61,153,112)'), + marker=go.scatter.Marker(color='rgb(61,153,112)'), mode='lines', xaxis='x', yaxis='y', @@ -550,7 +558,7 @@ def test_dendrogram_random_matrix(self): text=None ), go.Scatter( - marker=go.Marker( + marker=go.scatter.Marker( color='rgb(61,153,112)' ), mode='lines', @@ -560,7 +568,7 @@ def test_dendrogram_random_matrix(self): text=None ), go.Scatter( - marker=go.Marker(color='rgb(61,153,112)'), + marker=go.scatter.Marker(color='rgb(61,153,112)'), mode='lines', xaxis='x', yaxis='y', @@ -568,21 +576,21 @@ def test_dendrogram_random_matrix(self): text=None ), go.Scatter( - marker=go.Marker(color='rgb(0,116,217)'), + marker=go.scatter.Marker(color='rgb(0,116,217)'), mode='lines', xaxis='x', yaxis='y', hoverinfo='text', text=None ) - ]), + ], layout=go.Layout( autosize=False, - height='100%', + height=np.inf, hovermode='closest', showlegend=False, - width='100%', - xaxis=go.XAxis( + width=np.inf, + xaxis=go.layout.XAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -594,7 +602,7 @@ def test_dendrogram_random_matrix(self): type='linear', zeroline=False ), - yaxis=go.YAxis( + yaxis=go.layout.YAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -610,31 +618,51 @@ def test_dendrogram_random_matrix(self): self.assertEqual(len(dendro['data']), 4) # it's random, so we can only check that the values aren't equal - y_vals = [dendro['data'][0].pop('y'), dendro['data'][1].pop('y'), - dendro['data'][2].pop('y'), dendro['data'][3].pop('y')] + y_vals = [dendro['data'][0].to_plotly_json().pop('y'), + dendro['data'][1].to_plotly_json().pop('y'), + dendro['data'][2].to_plotly_json().pop('y'), + dendro['data'][3].to_plotly_json().pop('y')] for i in range(len(y_vals)): for j in range(len(y_vals)): if i != j: self.assertFalse(np.allclose(y_vals[i], y_vals[j])) - x_vals = [dendro['data'][0].pop('x'), dendro['data'][1].pop('x'), - dendro['data'][2].pop('x'), dendro['data'][3].pop('x')] + x_vals = [dendro['data'][0].to_plotly_json().pop('x'), + dendro['data'][1].to_plotly_json().pop('x'), + dendro['data'][2].to_plotly_json().pop('x'), + dendro['data'][3].to_plotly_json().pop('x')] for i in range(len(x_vals)): for j in range(len(x_vals)): if i != j: self.assertFalse(np.allclose(x_vals[i], x_vals[j])) # we also need to check the ticktext manually - xaxis_ticktext = dendro['layout']['xaxis'].pop('ticktext') + xaxis_ticktext = dendro['layout'].to_plotly_json()['xaxis'].pop('ticktext') self.assertEqual(xaxis_ticktext[0], 'John') # this is actually a bit clearer when debugging tests. - self.assert_dict_equal(dendro['data'][0], expected_dendro['data'][0]) - self.assert_dict_equal(dendro['data'][1], expected_dendro['data'][1]) - self.assert_dict_equal(dendro['data'][2], expected_dendro['data'][2]) - self.assert_dict_equal(dendro['data'][3], expected_dendro['data'][3]) - - self.assert_dict_equal(dendro['layout'], expected_dendro['layout']) + self.assert_fig_equal(dendro['data'][0], + expected_dendro['data'][0], + ignore=['uid', 'x', 'y']) + self.assert_fig_equal(dendro['data'][1], + expected_dendro['data'][1], + ignore=['uid', 'x', 'y']) + self.assert_fig_equal(dendro['data'][2], + expected_dendro['data'][2], + ignore=['uid', 'x', 'y']) + self.assert_fig_equal(dendro['data'][3], + expected_dendro['data'][3], + ignore=['uid', 'x', 'y']) + + # layout except xaxis + self.assert_fig_equal(dendro['layout'], + expected_dendro['layout'], + ignore=['xaxis']) + + # xaxis + self.assert_fig_equal(dendro['layout']['xaxis'], + expected_dendro['layout']['xaxis'], + ignore=['ticktext']) def test_dendrogram_orientation(self): X = np.random.rand(5, 5) @@ -665,23 +693,24 @@ def test_dendrogram_colorscale(self): [1, 2, 1, 4], [1, 2, 3, 1]]) greyscale = [ - 'rgb(0,0,0)', # black - 'rgb(05,105,105)', # dim grey - 'rgb(128,128,128)', # grey - 'rgb(169,169,169)', # dark grey - 'rgb(192,192,192)', # silver - 'rgb(211,211,211)', # light grey - 'rgb(220,220,220)', # gainsboro - 'rgb(245,245,245)'] # white smoke + 'rgb(0,0,0)', # black + 'rgb(05,105,105)', # dim grey + 'rgb(128,128,128)', # grey + 'rgb(169,169,169)', # dark grey + 'rgb(192,192,192)', # silver + 'rgb(211,211,211)', # light grey + 'rgb(220,220,220)', # gainsboro + 'rgb(245,245,245)' # white smoke + ] dendro = ff.create_dendrogram(X, colorscale=greyscale) expected_dendro = go.Figure( - data=go.Data([ + data=[ go.Scatter( x=np.array([25., 25., 35., 35.]), y=np.array([0., 1., 1., 0.]), - marker=go.Marker(color='rgb(128,128,128)'), + marker=go.scatter.Marker(color='rgb(128,128,128)'), mode='lines', xaxis='x', yaxis='y', @@ -691,7 +720,7 @@ def test_dendrogram_colorscale(self): go.Scatter( x=np.array([15., 15., 30., 30.]), y=np.array([0., 2.23606798, 2.23606798, 1.]), - marker=go.Marker(color='rgb(128,128,128)'), + marker=go.scatter.Marker(color='rgb(128,128,128)'), mode='lines', xaxis='x', yaxis='y', @@ -701,21 +730,21 @@ def test_dendrogram_colorscale(self): go.Scatter( x=np.array([5., 5., 22.5, 22.5]), y=np.array([0., 3.60555128, 3.60555128, 2.23606798]), - marker=go.Marker(color='rgb(0,0,0)'), + marker=go.scatter.Marker(color='rgb(0,0,0)'), mode='lines', xaxis='x', yaxis='y', hoverinfo='text', text=None ) - ]), + ], layout=go.Layout( autosize=False, - height='100%', + height=np.inf, hovermode='closest', showlegend=False, - width='100%', - xaxis=go.XAxis( + width=np.inf, + xaxis=go.layout.XAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -728,7 +757,7 @@ def test_dendrogram_colorscale(self): type='linear', zeroline=False ), - yaxis=go.YAxis( + yaxis=go.layout.YAxis( mirror='allticks', rangemode='tozero', showgrid=False, @@ -744,9 +773,9 @@ def test_dendrogram_colorscale(self): self.assertEqual(len(dendro['data']), 3) # this is actually a bit clearer when debugging tests. - self.assert_dict_equal(dendro['data'][0], expected_dendro['data'][0]) - self.assert_dict_equal(dendro['data'][1], expected_dendro['data'][1]) - self.assert_dict_equal(dendro['data'][2], expected_dendro['data'][2]) + self.assert_fig_equal(dendro['data'][0], expected_dendro['data'][0]) + self.assert_fig_equal(dendro['data'][1], expected_dendro['data'][1]) + self.assert_fig_equal(dendro['data'][2], expected_dendro['data'][2]) class TestTrisurf(NumpyTestUtilsMixin, TestCase): @@ -883,7 +912,7 @@ def test_trisurf_all_args(self): -1.0, 0.0, None, 0.0, -0.0, 0.0, 0.0, None, -0.0, 0.0, -1.0, -0.0, None, 0.0, 0.0, 0.0, 0.0, None, 0.0, 0.0, 1.0, 0.0, None]}, - {'hoverinfo': 'None', + {'hoverinfo': 'none', 'marker': {'color': [-0.33333333333333331, 0.33333333333333331], 'colorscale': [[0.0, 'rgb(31, 119, 180)'], @@ -914,17 +943,17 @@ def test_trisurf_all_args(self): 'width': 800} } - self.assert_dict_equal(test_trisurf_plot['data'][0], + self.assert_fig_equal(test_trisurf_plot['data'][0], exp_trisurf_plot['data'][0]) - self.assert_dict_equal(test_trisurf_plot['data'][1], + self.assert_fig_equal(test_trisurf_plot['data'][1], exp_trisurf_plot['data'][1]) - self.assert_dict_equal(test_trisurf_plot['data'][2], - exp_trisurf_plot['data'][2]) + self.assert_fig_equal(test_trisurf_plot['data'][2], + exp_trisurf_plot['data'][2]) - self.assert_dict_equal(test_trisurf_plot['layout'], - exp_trisurf_plot['layout']) + self.assert_fig_equal(test_trisurf_plot['layout'], + exp_trisurf_plot['layout']) # Test passing custom colors colors_raw = np.random.randn(simplices.shape[0]) @@ -1157,12 +1186,11 @@ def test_scatter_plot_matrix(self): ) exp_scatter_plot_matrix = { - 'data': [{'name': None, - 'showlegend': False, + 'data': [{'showlegend': False, 'type': 'box', - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [2, 6, -15, 5, -2, 0], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'marker': {'size': 13}, 'mode': 'markers', 'showlegend': False, @@ -1192,7 +1220,7 @@ def test_scatter_plot_matrix(self): 'showlegend': True, 'title': 'Scatterplot Matrix', 'width': 1000, - 'xaxis1': {'anchor': 'y1', + 'xaxis': {'anchor': 'y', 'domain': [0.0, 0.45], 'showticklabels': False}, 'xaxis2': {'anchor': 'y2', @@ -1204,7 +1232,7 @@ def test_scatter_plot_matrix(self): 'domain': [0.55, 1.0], 'showticklabels': False, 'title': 'Fruit'}, - 'yaxis1': {'anchor': 'x1', + 'yaxis': {'anchor': 'x', 'domain': [0.575, 1.0], 'title': 'Numbers'}, 'yaxis2': {'anchor': 'x2', @@ -1216,14 +1244,14 @@ def test_scatter_plot_matrix(self): 'domain': [0.0, 0.425]}} } - self.assert_dict_equal(test_scatter_plot_matrix['data'][0], - exp_scatter_plot_matrix['data'][0]) + self.assert_fig_equal(test_scatter_plot_matrix['data'][0], + exp_scatter_plot_matrix['data'][0]) - self.assert_dict_equal(test_scatter_plot_matrix['data'][1], - exp_scatter_plot_matrix['data'][1]) + self.assert_fig_equal(test_scatter_plot_matrix['data'][1], + exp_scatter_plot_matrix['data'][1]) - self.assert_dict_equal(test_scatter_plot_matrix['layout'], - exp_scatter_plot_matrix['layout']) + self.assert_fig_equal(test_scatter_plot_matrix['layout'], + exp_scatter_plot_matrix['layout']) def test_scatter_plot_matrix_kwargs(self): @@ -1245,34 +1273,34 @@ def test_scatter_plot_matrix_kwargs(self): 'showlegend': False, 'type': 'histogram', 'x': [2, -15, -2, 0], - 'xaxis': 'x1', - 'yaxis': 'y1'}, + 'xaxis': 'x', + 'yaxis': 'y'}, {'marker': {'color': 'rgb(255, 255, 204)'}, 'showlegend': False, 'type': 'histogram', 'x': [6, 5], - 'xaxis': 'x1', - 'yaxis': 'y1'}], + 'xaxis': 'x', + 'yaxis': 'y'}], 'layout': {'barmode': 'stack', 'height': 1000, 'showlegend': True, 'title': 'Scatterplot Matrix', 'width': 1000, - 'xaxis1': {'anchor': 'y1', + 'xaxis': {'anchor': 'y', 'domain': [0.0, 1.0], 'title': 'Numbers'}, - 'yaxis1': {'anchor': 'x1', + 'yaxis': {'anchor': 'x', 'domain': [0.0, 1.0], 'title': 'Numbers'}} } - self.assert_dict_equal(test_scatter_plot_matrix['data'][0], - exp_scatter_plot_matrix['data'][0]) + self.assert_fig_equal(test_scatter_plot_matrix['data'][0], + exp_scatter_plot_matrix['data'][0]) - self.assert_dict_equal(test_scatter_plot_matrix['data'][1], + self.assert_fig_equal(test_scatter_plot_matrix['data'][1], exp_scatter_plot_matrix['data'][1]) - self.assert_dict_equal(test_scatter_plot_matrix['layout'], + self.assert_fig_equal(test_scatter_plot_matrix['layout'], exp_scatter_plot_matrix['layout']) @@ -1360,10 +1388,10 @@ def test_df_dataframe_all_args(self): 'tickvals': [0, 1], 'zeroline': False}}} - self.assertEqual(test_gantt_chart['data'][0], - exp_gantt_chart['data'][0]) + self.assert_fig_equal(test_gantt_chart['data'][0], + exp_gantt_chart['data'][0]) - self.assert_dict_equal(test_gantt_chart['layout'], + self.assert_fig_equal(test_gantt_chart['layout'], exp_gantt_chart['layout']) @@ -1890,14 +1918,14 @@ def test_violin_fig(self): 1.93939394, 1.94949495, 1.95959596, 1.96969697, 1.97979798, 1.98989899, 2.])}, - {'line': {'color': 'rgb(0,0,0)', 'width': 1.5}, + {'line': {'color': 'rgb(0, 0, 0)', 'width': 1.5}, 'mode': 'lines', 'name': '', 'type': 'scatter', 'x': [0, 0], 'y': [1.0, 2.0]}, {'hoverinfo': 'text', - 'line': {'color': 'rgb(0,0,0)', 'width': 4}, + 'line': {'color': 'rgb(0, 0, 0)', 'width': 4}, 'mode': 'lines', 'text': ['lower-quartile: 1.00', 'upper-quartile: 2.00'], @@ -1905,7 +1933,7 @@ def test_violin_fig(self): 'x': [0, 0], 'y': [1.0, 2.0]}, {'hoverinfo': 'text', - 'marker': {'color': 'rgb(255,255,255)', + 'marker': {'color': 'rgb(255, 255, 255)', 'symbol': 'square'}, 'mode': 'markers', 'text': ['median: 1.50'], @@ -1947,14 +1975,15 @@ def test_violin_fig(self): 'title': '', 'zeroline': False}}} - self.assert_dict_equal(test_violin['data'][0], - exp_violin['data'][0]) - - self.assert_dict_equal(test_violin['data'][1], - exp_violin['data'][1]) + # test both items in 'data' + for i in [0, 1]: + self.assert_fig_equal( + test_violin['data'][i], + exp_violin['data'][i] + ) - self.assert_dict_equal(test_violin['layout'], - exp_violin['layout']) + self.assert_fig_equal(test_violin['layout'], + exp_violin['layout']) class TestFacetGrid(NumpyTestUtilsMixin, TestCase): @@ -2051,9 +2080,24 @@ def test_valid_colorscale_name(self): color_name='c', colormap=colormap) def test_valid_facet_grid_fig(self): - mpg = pd.read_table('https://raw.githubusercontent.com/plotly/datasets/master/mpg_2017.txt') - df = mpg.head(10) + mpg = [ + ["audi", "a4", 1.8, 1999, 4, "auto(15)", "f", 18, 29, "p", "compact"], + ["audi", "a4", 1.8, 1999, 4, "auto(l5)", "f", 18, 29, "p", "compact"], + ["audi", "a4", 2, 2008, 4, "manual(m6)", "f", 20, 31, "p", "compact"], + ["audi", "a4", 2, 2008, 4, "auto(av)", "f", 21, 30, "p", "compact"], + ["audi", "a4", 2.8, 1999, 6, "auto(l5)", "f", 16, 26, "p", "compact"], + ["audi", "a4", 2.8, 1999, 6, "manual(m5)", "f", 18, 26, "p", "compact"], + ["audi", "a4", 3.1, 2008, 6, "auto(av)", "f", 18, 27, "p", "compact"], + ["audi", "a4 quattro", 1.8, 1999, 4, "manual(m5)", "4", 18, 26, "p", "compact"], + ["audi", "a4 quattro", 1.8, 1999, 4, "auto(l5)", "4", 16, 25, "p", "compact"], + ["audi", "a4 quattro", 2, 2008, 4, "manual(m6)", "4", 20, 28, "p", "compact"], + ] + df = pd.DataFrame( + mpg, + columns=["manufacturer", "model", "displ", "year", "cyl", "trans", + "drv", "cty", "hwy", "fl", "class"] + ) test_facet_grid = ff.create_facet_grid( df, x='displ', @@ -2062,45 +2106,30 @@ def test_valid_facet_grid_fig(self): ) exp_facet_grid = { - 'data': [{'marker': {'color': 'rgb(31, 119, 180)', - 'line': {'color': 'darkgrey', 'width': 1}, - 'size': 8}, + 'data': [ + {'marker': {'color': 'rgb(31, 119, 180)', + 'line': {'color': 'darkgrey', 'width': 1}, + 'size': 8}, 'mode': 'markers', 'opacity': 0.6, 'type': 'scatter', - 'x': [1.8, - 1.8, - 2.0, - 2.0, - 1.8, - 1.8, - 2.0], - 'xaxis': 'x1', - 'y': [18, - 21, - 20, - 21, - 18, - 16, - 20], - 'yaxis': 'y1'}, + 'x': [1.8, 1.8, 2.0, 2.0, 1.8, 1.8, 2.0], + 'xaxis': 'x', + 'y': [18, 18, 20, 21, 18, 16, 20], + 'yaxis': 'y'}, {'marker': {'color': 'rgb(31, 119, 180)', 'line': {'color': 'darkgrey', 'width': 1}, 'size': 8}, 'mode': 'markers', 'opacity': 0.6, 'type': 'scatter', - 'x': [2.8, - 2.8, - 3.1], + 'x': [2.8, 2.8, 3.1], 'xaxis': 'x2', - 'y': [16, - 18, - 18], - 'yaxis': 'y1'}], + 'y': [16, 18, 18], + 'yaxis': 'y'}], 'layout': {'annotations': [{'font': {'color': '#0f0f0f', 'size': 13}, 'showarrow': False, - 'text': 4, + 'text': '4', 'textangle': 0, 'x': 0.24625, 'xanchor': 'center', @@ -2110,7 +2139,7 @@ def test_valid_facet_grid_fig(self): 'yref': 'paper'}, {'font': {'color': '#0f0f0f', 'size': 13}, 'showarrow': False, - 'text': 6, + 'text': '6', 'textangle': 0, 'x': 0.7537499999999999, 'xanchor': 'center', @@ -2131,7 +2160,7 @@ def test_valid_facet_grid_fig(self): {'font': {'color': '#000000', 'size': 12}, 'showarrow': False, 'text': 'cty', - 'textangle': 270, + 'textangle': -90, 'x': -0.1, 'xanchor': 'center', 'xref': 'paper', @@ -2148,7 +2177,7 @@ def test_valid_facet_grid_fig(self): 'showlegend': False, 'title': '', 'width': 600, - 'xaxis1': {'anchor': 'y1', + 'xaxis': {'anchor': 'y', 'domain': [0.0, 0.4925], 'dtick': 0.0, 'range': [0.85, 4.1575], @@ -2161,28 +2190,23 @@ def test_valid_facet_grid_fig(self): 'range': [0.85, 4.1575], 'ticklen': 0, 'zeroline': False}, - 'yaxis1': {'anchor': 'x1', + 'yaxis': {'anchor': 'x', 'domain': [0.0, 1.0], 'dtick': 1.0, 'range': [15.75, 21.2625], 'ticklen': 0, 'zeroline': False}}} - # data - data_keys = test_facet_grid['data'][0].keys() - - for j in range(len(test_facet_grid['data'])): - for key in data_keys: - if key != 'x' and key != 'y': - self.assertEqual(test_facet_grid['data'][j][key], - exp_facet_grid['data'][j][key]) - else: - self.assertEqual(list(test_facet_grid['data'][j][key]), - list(exp_facet_grid['data'][j][key])) + for j in [0, 1]: + self.assert_fig_equal( + test_facet_grid['data'][j], + exp_facet_grid['data'][j] + ) - # layout - self.assert_dict_equal(test_facet_grid['layout'], - exp_facet_grid['layout']) + self.assert_fig_equal( + test_facet_grid['layout'], + exp_facet_grid['layout'] + ) class TestBullet(NumpyTestUtilsMixin, TestCase): @@ -2287,9 +2311,9 @@ def test_full_bullet(self): 'type': 'bar', 'width': 2, 'x': [0], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [300], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'base': 0, 'hoverinfo': 'y', 'marker': {'color': 'rgb(149.5, 143.5, 29.0)'}, @@ -2298,9 +2322,9 @@ def test_full_bullet(self): 'type': 'bar', 'width': 2, 'x': [0], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [225], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'base': 0, 'hoverinfo': 'y', 'marker': {'color': 'rgb(255.0, 127.0, 14.0)'}, @@ -2309,9 +2333,9 @@ def test_full_bullet(self): 'type': 'bar', 'width': 2, 'x': [0], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [150], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'base': 0, 'hoverinfo': 'y', 'marker': {'color': 'rgb(44.0, 160.0, 44.0)'}, @@ -2320,9 +2344,9 @@ def test_full_bullet(self): 'type': 'bar', 'width': 0.4, 'x': [0.5], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [270], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'base': 0, 'hoverinfo': 'y', 'marker': {'color': 'rgb(255.0, 127.0, 14.0)'}, @@ -2331,9 +2355,9 @@ def test_full_bullet(self): 'type': 'bar', 'width': 0.4, 'x': [0.5], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [220], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'hoverinfo': 'y', 'marker': {'color': 'rgb(0, 0, 0)', 'size': 30, @@ -2341,9 +2365,9 @@ def test_full_bullet(self): 'name': 'markers', 'type': 'scatter', 'x': [0.5], - 'xaxis': 'x1', + 'xaxis': 'x', 'y': [250], - 'yaxis': 'y1'}, + 'yaxis': 'y'}, {'base': 0, 'hoverinfo': 'y', 'marker': {'color': 'rgb(44.0, 160.0, 44.0)'}, @@ -2661,7 +2685,7 @@ def test_full_bullet(self): 'showlegend': False, 'title': 'new title', 'width': 1000, - 'xaxis1': {'anchor': 'y1', + 'xaxis1': {'anchor': 'y', 'domain': [0.0, 0.039999999999999994], 'range': [0, 1], 'showgrid': False, @@ -2691,7 +2715,7 @@ def test_full_bullet(self): 'showgrid': False, 'showticklabels': False, 'zeroline': False}, - 'yaxis1': {'anchor': 'x1', + 'yaxis1': {'anchor': 'x', 'domain': [0.0, 1.0], 'showgrid': False, 'tickwidth': 1, @@ -2717,106 +2741,110 @@ def test_full_bullet(self): 'tickwidth': 1, 'zeroline': False}} } - self.assert_dict_equal(fig, exp_fig) + for i in range(len(fig['data'])): + self.assert_fig_equal(fig['data'][i], + exp_fig['data'][i]) -class TestChoropleth(NumpyTestUtilsMixin, TestCase): - def test_fips_values_same_length(self): - pattern = 'fips and values must be the same length' - self.assertRaisesRegexp( - PlotlyError, pattern, ff.create_choropleth, - fips=[1001], values=[4004, 40004] - ) +class TestChoropleth(NumpyTestUtilsMixin, TestCase): + # run tests if required packages are installed + if shapely and shapefile and gp: + def test_fips_values_same_length(self): + pattern = 'fips and values must be the same length' + self.assertRaisesRegexp( + PlotlyError, pattern, ff.create_choropleth, + fips=[1001], values=[4004, 40004] + ) - def test_correct_order_param(self): - pattern = ( - 'if you are using a custom order of unique values from ' - 'your color column, you must: have all the unique values ' - 'in your order and have no duplicate items' - ) + def test_correct_order_param(self): + pattern = ( + 'if you are using a custom order of unique values from ' + 'your color column, you must: have all the unique values ' + 'in your order and have no duplicate items' + ) - self.assertRaisesRegexp( - PlotlyError, pattern, ff.create_choropleth, - fips=[1], values=[1], order=[1, 1, 1] - ) + self.assertRaisesRegexp( + PlotlyError, pattern, ff.create_choropleth, + fips=[1], values=[1], order=[1, 1, 1] + ) - def test_colorscale_and_levels_same_length(self): - self.assertRaises( - PlotlyError, ff.create_choropleth, - fips=[1001, 1003, 1005], values=[5, 2, 1], - colorscale=['rgb(0,0,0)'] - ) + def test_colorscale_and_levels_same_length(self): + self.assertRaises( + PlotlyError, ff.create_choropleth, + fips=[1001, 1003, 1005], values=[5, 2, 1], + colorscale=['rgb(0,0,0)'] + ) - def test_scope_is_not_list(self): + def test_scope_is_not_list(self): - pattern = "'scope' must be a list/tuple/sequence" + pattern = "'scope' must be a list/tuple/sequence" - self.assertRaisesRegexp( - PlotlyError, pattern, ff.create_choropleth, - fips=[1001, 1003], values=[5, 2], scope='foo', - ) + self.assertRaisesRegexp( + PlotlyError, pattern, ff.create_choropleth, + fips=[1001, 1003], values=[5, 2], scope='foo', + ) - def test_full_choropleth(self): - fips = [1001] - values = [1] - fig = ff.create_choropleth( - fips=fips, values=values, - simplify_county=1 - ) + def test_full_choropleth(self): + fips = [1001] + values = [1] + fig = ff.create_choropleth( + fips=fips, values=values, + simplify_county=1 + ) - exp_fig_head = [ - -88.053375, - -88.02916499999999, - -88.02432999999999, - -88.04504299999999, - -88.053375, - np.nan, - -88.211209, - -88.209999, - -88.208733, - -88.209559, - -88.211209, - np.nan, - -88.22511999999999, - -88.22128099999999, - -88.218694, - -88.22465299999999, - -88.22511999999999, - np.nan, - -88.264659, - -88.25782699999999, - -88.25947, - -88.255659, - -88.264659, - np.nan, - -88.327302, - -88.20146799999999, - -88.141143, - -88.124658, - -88.074854, - -88.12493599999999, - -88.10665399999999, - -88.149812, - -88.327302, - np.nan, - -88.346745, - -88.341235, - -88.33288999999999, - -88.346823, - -88.346745, - np.nan, - -88.473227, - -88.097888, - -88.154617, - -88.20295899999999, - -85.605165, - -85.18440000000001, - -85.12218899999999, - -85.142567, - -85.113329, - -85.10533699999999 - ] - - self.assertEqual(fig['data'][2]['x'][:50], exp_fig_head) + exp_fig_head = [ + -88.053375, + -88.02916499999999, + -88.02432999999999, + -88.04504299999999, + -88.053375, + np.nan, + -88.211209, + -88.209999, + -88.208733, + -88.209559, + -88.211209, + np.nan, + -88.22511999999999, + -88.22128099999999, + -88.218694, + -88.22465299999999, + -88.22511999999999, + np.nan, + -88.264659, + -88.25782699999999, + -88.25947, + -88.255659, + -88.264659, + np.nan, + -88.327302, + -88.20146799999999, + -88.141143, + -88.124658, + -88.074854, + -88.12493599999999, + -88.10665399999999, + -88.149812, + -88.327302, + np.nan, + -88.346745, + -88.341235, + -88.33288999999999, + -88.346823, + -88.346745, + np.nan, + -88.473227, + -88.097888, + -88.154617, + -88.20295899999999, + -85.605165, + -85.18440000000001, + -85.12218899999999, + -85.142567, + -85.113329, + -85.10533699999999 + ] + + self.assertEqual(fig['data'][2]['x'][:50], exp_fig_head) diff --git a/plotly/tests/test_optional/test_graph_objs/test_to_dataframe.py b/plotly/tests/test_optional/test_graph_objs/test_to_dataframe.py deleted file mode 100644 index a789fe5805..0000000000 --- a/plotly/tests/test_optional/test_graph_objs/test_to_dataframe.py +++ /dev/null @@ -1,108 +0,0 @@ -from __future__ import absolute_import - -from unittest import TestCase - -from plotly.graph_objs import (Data, Figure, Layout, Line, Margin, Marker, - Scatter, XAxis, YAxis) - - -class TestToDataframe(TestCase): - - fig = None - - def setUp(self): - super(TestToDataframe, self).setUp() - self.fig = Figure( - data=Data([ - Scatter( - x=[52698, 43117], - y=[53, 31], - mode='markers', - name='North America', - text=['United States', 'Canada'], - marker=Marker( - color='rgb(164, 194, 244)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[39317, 37236, 35650, 30066, 29570, 27159, 23557, 21046, - 18007], - y=[33, 20, 13, 19, 27, 19, 49, 44, 38], - mode='markers', - name='Europe', - text=['Germany', 'Britain', 'France', 'Spain', 'Italy', - 'Czech Rep.', 'Greece', 'Poland'], - marker=Marker( - color='rgb(255, 217, 102)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[42952, 37037, 33106, 17478, 9813, 5253, 4692, 3899], - y=[23, 42, 54, 89, 14, 99, 93, 70], - mode='markers', - name='Asia/Pacific', - text=['Australia', 'Japan', 'South Korea', 'Malaysia', - 'China', 'Indonesia', 'Philippines', 'India'], - marker=Marker( - color='rgb(234, 153, 153)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ), - Scatter( - x=[19097, 18601, 15595, 13546, 12026, 7434, 5419], - y=[43, 47, 56, 80, 86, 93, 80], - mode='markers', - name='Latin America', - text=['Chile', 'Argentina', 'Mexico', 'Venezuela', - 'Venezuela', 'El Salvador', 'Bolivia'], - marker=Marker( - color='rgb(142, 124, 195)', - size=12, - line=Line( - color='white', - width=0.5 - ) - ) - ) - ]), - layout=Layout( - title='Quarter 1 Growth', - autosize=False, - width=500, - height=500, - xaxis=XAxis( - title='GDP per Capita', - showgrid=False, - zeroline=False - ), - yaxis=YAxis( - title='Percent', - showline=False - ), - margin=Margin( - l=65, - r=50, - b=65, - t=90 - ) - ) - ) - - def test_figure_to_dataframe(self): - df = self.fig.to_dataframe() - self.assertEqual(len(df), 9) - self.assertEqual(len(df.columns), 12) diff --git a/plotly/tests/test_optional/test_jupyter/package-lock.json b/plotly/tests/test_optional/test_jupyter/package-lock.json new file mode 100644 index 0000000000..bc44080157 --- /dev/null +++ b/plotly/tests/test_optional/test_jupyter/package-lock.json @@ -0,0 +1,2190 @@ +{ + "name": "plotly.py-jupyter-tests", + "version": "1.0.0", + "lockfileVersion": 1, + "requires": true, + "dependencies": { + "JSONStream": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.2.tgz", + "integrity": "sha1-wQI3G27Dp887hHygDCC7D85Mbeo=", + "requires": { + "jsonparse": "1.3.1", + "through": "2.3.8" + } + }, + "abab": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/abab/-/abab-1.0.4.tgz", + "integrity": "sha1-X6rZwsB/YN12dw9xzwJbYqY8/U4=", + "optional": true + }, + "acorn": { + "version": "4.0.13", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-4.0.13.tgz", + "integrity": "sha1-EFSVrlNh1pe9GVyCUZLhrX8lN4c=" + }, + "acorn-globals": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/acorn-globals/-/acorn-globals-1.0.9.tgz", + "integrity": "sha1-VbtemGkVB7dFedBRNBMhfDgMVM8=", + "optional": true, + "requires": { + "acorn": "2.7.0" + }, + "dependencies": { + "acorn": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-2.7.0.tgz", + "integrity": "sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=", + "optional": true + } + } + }, + "acorn-node": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/acorn-node/-/acorn-node-1.3.0.tgz", + "integrity": "sha512-efP54n3d1aLfjL2UMdaXa6DsswwzJeI5rqhbFvXMrKiJ6eJFpf+7R0zN7t8IC+XKn2YOAFAv6xbBNgHUkoHWLw==", + "requires": { + "acorn": "5.5.3", + "xtend": "4.0.1" + }, + "dependencies": { + "acorn": { + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.5.3.tgz", + "integrity": "sha512-jd5MkIUlbbmb07nXH0DT3y7rDVtkzDi4XZOUVWAer8ajmF/DTSSbl5oNFyDOl/OXA33Bl79+ypHhl2pN20VeOQ==" + } + } + }, + "ajv": { + "version": "5.5.2", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-5.5.2.tgz", + "integrity": "sha1-c7Xuyj+rZT49P5Qis0GtQiBdyWU=", + "optional": true, + "requires": { + "co": "4.6.0", + "fast-deep-equal": "1.1.0", + "fast-json-stable-stringify": "2.0.0", + "json-schema-traverse": "0.3.1" + } + }, + "argparse": { + "version": "1.0.10", + "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz", + "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==", + "requires": { + "sprintf-js": "1.0.3" + } + }, + "array-filter": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/array-filter/-/array-filter-0.0.1.tgz", + "integrity": "sha1-fajPLiZijtcygDWB/SH2fKzS7uw=" + }, + "array-map": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/array-map/-/array-map-0.0.0.tgz", + "integrity": "sha1-iKK6tz0c97zVwbEYoAP2b2ZfpmI=" + }, + "array-reduce": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/array-reduce/-/array-reduce-0.0.0.tgz", + "integrity": "sha1-FziZ0//Rx9k4PkR5Ul2+J4yrXys=" + }, + "asn1": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/asn1/-/asn1-0.2.3.tgz", + "integrity": "sha1-2sh4dxPJlmhJ/IGAd36+nB3fO4Y=", + "optional": true + }, + "asn1.js": { + "version": "4.10.1", + "resolved": "https://registry.npmjs.org/asn1.js/-/asn1.js-4.10.1.tgz", + "integrity": "sha512-p32cOF5q0Zqs9uBiONKYLm6BClCoBCM5O9JfeUSlnQLBTxYdTK+pW+nXflm8UkKd2UYlEbYz5qEi0JuZR9ckSw==", + "requires": { + "bn.js": "4.11.8", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "assert": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/assert/-/assert-1.4.1.tgz", + "integrity": "sha1-mZEtWRg2tab1s0XA8H7vwI/GXZE=", + "requires": { + "util": "0.10.3" + } + }, + "assert-plus": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz", + "integrity": "sha1-8S4PPF13sLHN2RRpQuTpbB5N1SU=" + }, + "astw": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/astw/-/astw-2.2.0.tgz", + "integrity": "sha1-e9QXhNMkk5h66yOba04cV6hzuRc=", + "requires": { + "acorn": "4.0.13" + } + }, + "asynckit": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz", + "integrity": "sha1-x57Zf380y48robyXkLzDZkdLS3k=", + "optional": true + }, + "aws-sign2": { + "version": "0.7.0", + "resolved": "https://registry.npmjs.org/aws-sign2/-/aws-sign2-0.7.0.tgz", + "integrity": "sha1-tG6JCTSpWR8tL2+G1+ap8bP+dqg=", + "optional": true + }, + "aws4": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.6.0.tgz", + "integrity": "sha1-g+9cqGCysy5KDe7e6MdxudtXRx4=", + "optional": true + }, + "balanced-match": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.0.tgz", + "integrity": "sha1-ibTRmasr7kneFk6gK4nORi1xt2c=" + }, + "base64-js": { + "version": "1.2.3", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.2.3.tgz", + "integrity": "sha512-MsAhsUW1GxCdgYSO6tAfZrNapmUKk7mWx/k5mFY/A1gBtkaCaNapTg+FExCw1r9yeaZhqx/xPg43xgTFH6KL5w==" + }, + "bcrypt-pbkdf": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/bcrypt-pbkdf/-/bcrypt-pbkdf-1.0.1.tgz", + "integrity": "sha1-Y7xdy2EzG5K8Bf1SiVPDNGKgb40=", + "optional": true, + "requires": { + "tweetnacl": "0.14.5" + } + }, + "bn.js": { + "version": "4.11.8", + "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.11.8.tgz", + "integrity": "sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==" + }, + "boolbase": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-1.0.0.tgz", + "integrity": "sha1-aN/1++YMUes3cl6p4+0xDcwed24=" + }, + "boom": { + "version": "4.3.1", + "resolved": "https://registry.npmjs.org/boom/-/boom-4.3.1.tgz", + "integrity": "sha1-T4owBctKfjiJ90kDD9JbluAdLjE=", + "optional": true, + "requires": { + "hoek": "4.2.1" + } + }, + "brace-expansion": { + "version": "1.1.11", + "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz", + "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==", + "requires": { + "balanced-match": "1.0.0", + "concat-map": "0.0.1" + } + }, + "brorand": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/brorand/-/brorand-1.1.0.tgz", + "integrity": "sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=" + }, + "browser-pack": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/browser-pack/-/browser-pack-6.0.4.tgz", + "integrity": "sha512-Q4Rvn7P6ObyWfc4stqLWHtG1MJ8vVtjgT24Zbu+8UTzxYuZouqZsmNRRTFVMY/Ux0eIKv1d+JWzsInTX+fdHPQ==", + "requires": { + "JSONStream": "1.3.2", + "combine-source-map": "0.8.0", + "defined": "1.0.0", + "safe-buffer": "5.1.1", + "through2": "2.0.3", + "umd": "3.0.3" + } + }, + "browser-resolve": { + "version": "1.11.2", + "resolved": "https://registry.npmjs.org/browser-resolve/-/browser-resolve-1.11.2.tgz", + "integrity": "sha1-j/CbCixCFxihBRwmCzLkj0QpOM4=", + "requires": { + "resolve": "1.1.7" + }, + "dependencies": { + "resolve": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.1.7.tgz", + "integrity": "sha1-IDEU2CrSxe2ejgQRs5ModeiJ6Xs=" + } + } + }, + "browserify": { + "version": "13.3.0", + "resolved": "https://registry.npmjs.org/browserify/-/browserify-13.3.0.tgz", + "integrity": "sha1-tanJAgJD8McORnW+yCI7xifkFc4=", + "requires": { + "JSONStream": "1.3.2", + "assert": "1.4.1", + "browser-pack": "6.0.4", + "browser-resolve": "1.11.2", + "browserify-zlib": "0.1.4", + "buffer": "4.9.1", + "cached-path-relative": "1.0.1", + "concat-stream": "1.5.2", + "console-browserify": "1.1.0", + "constants-browserify": "1.0.0", + "crypto-browserify": "3.12.0", + "defined": "1.0.0", + "deps-sort": "2.0.0", + "domain-browser": "1.1.7", + "duplexer2": "0.1.4", + "events": "1.1.1", + "glob": "7.1.2", + "has": "1.0.1", + "htmlescape": "1.1.1", + "https-browserify": "0.0.1", + "inherits": "2.0.3", + "insert-module-globals": "7.0.2", + "labeled-stream-splicer": "2.0.0", + "module-deps": "4.1.1", + "os-browserify": "0.1.2", + "parents": "1.0.1", + "path-browserify": "0.0.0", + "process": "0.11.10", + "punycode": "1.4.1", + "querystring-es3": "0.2.1", + "read-only-stream": "2.0.0", + "readable-stream": "2.3.5", + "resolve": "1.5.0", + "shasum": "1.0.2", + "shell-quote": "1.6.1", + "stream-browserify": "2.0.1", + "stream-http": "2.8.1", + "string_decoder": "0.10.31", + "subarg": "1.0.0", + "syntax-error": "1.4.0", + "through2": "2.0.3", + "timers-browserify": "1.4.2", + "tty-browserify": "0.0.1", + "url": "0.11.0", + "util": "0.10.3", + "vm-browserify": "0.0.4", + "xtend": "4.0.1" + } + }, + "browserify-aes": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/browserify-aes/-/browserify-aes-1.1.1.tgz", + "integrity": "sha512-UGnTYAnB2a3YuYKIRy1/4FB2HdM866E0qC46JXvVTYKlBlZlnvfpSfY6OKfXZAkv70eJ2a1SqzpAo5CRhZGDFg==", + "requires": { + "buffer-xor": "1.0.3", + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "browserify-cipher": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-cipher/-/browserify-cipher-1.0.0.tgz", + "integrity": "sha1-mYgkSHS/XtTijalWZtzWasj8Njo=", + "requires": { + "browserify-aes": "1.1.1", + "browserify-des": "1.0.0", + "evp_bytestokey": "1.0.3" + } + }, + "browserify-des": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/browserify-des/-/browserify-des-1.0.0.tgz", + "integrity": "sha1-2qJ3cXRwki7S/hhZQRihdUOXId0=", + "requires": { + "cipher-base": "1.0.4", + "des.js": "1.0.0", + "inherits": "2.0.3" + } + }, + "browserify-rsa": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/browserify-rsa/-/browserify-rsa-4.0.1.tgz", + "integrity": "sha1-IeCr+vbyApzy+vsTNWenAdQTVSQ=", + "requires": { + "bn.js": "4.11.8", + "randombytes": "2.0.6" + } + }, + "browserify-sign": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/browserify-sign/-/browserify-sign-4.0.4.tgz", + "integrity": "sha1-qk62jl17ZYuqa/alfmMMvXqT0pg=", + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "elliptic": "6.4.0", + "inherits": "2.0.3", + "parse-asn1": "5.1.0" + } + }, + "browserify-zlib": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/browserify-zlib/-/browserify-zlib-0.1.4.tgz", + "integrity": "sha1-uzX4pRn2AOD6a4SFJByXnQFB+y0=", + "requires": { + "pako": "0.2.9" + } + }, + "buffer": { + "version": "4.9.1", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-4.9.1.tgz", + "integrity": "sha1-bRu2AbB6TvztlwlBMgkwJ8lbwpg=", + "requires": { + "base64-js": "1.2.3", + "ieee754": "1.1.9", + "isarray": "1.0.0" + } + }, + "buffer-xor": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/buffer-xor/-/buffer-xor-1.0.3.tgz", + "integrity": "sha1-JuYe0UIvtw3ULm42cp7VHYVf6Nk=" + }, + "builtin-status-codes": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz", + "integrity": "sha1-hZgoeOIbmOHGZCXgPQF0eI9Wnug=" + }, + "cached-path-relative": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/cached-path-relative/-/cached-path-relative-1.0.1.tgz", + "integrity": "sha1-0JxLUoAKpMB44t2BqGmqyQ0uVOc=" + }, + "caseless": { + "version": "0.12.0", + "resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz", + "integrity": "sha1-G2gcIf+EAzyCZUMJBolCDRhxUdw=", + "optional": true + }, + "cheerio": { + "version": "0.20.0", + "resolved": "https://registry.npmjs.org/cheerio/-/cheerio-0.20.0.tgz", + "integrity": "sha1-XHEPK6uVZTJyhCugHG6mGzVF7DU=", + "requires": { + "css-select": "1.2.0", + "dom-serializer": "0.1.0", + "entities": "1.1.1", + "htmlparser2": "3.8.3", + "jsdom": "7.2.2", + "lodash": "4.17.5" + } + }, + "chrome-launch": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/chrome-launch/-/chrome-launch-1.1.4.tgz", + "integrity": "sha1-yJhb0CJjWlzIlwmbr9GYMYOKclI=", + "requires": { + "chrome-location": "1.2.1", + "quick-tmp": "0.0.0", + "rimraf": "2.6.2", + "shallow-copy": "0.0.1" + } + }, + "chrome-location": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/chrome-location/-/chrome-location-1.2.1.tgz", + "integrity": "sha1-aRFRGk6sVQJ2Jcc7k3ylynq5SZU=", + "requires": { + "userhome": "1.0.0", + "which": "1.3.0" + } + }, + "cipher-base": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz", + "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "co": { + "version": "4.6.0", + "resolved": "https://registry.npmjs.org/co/-/co-4.6.0.tgz", + "integrity": "sha1-bqa989hTrlTMuOR7+gvz+QMfsYQ=", + "optional": true + }, + "combine-source-map": { + "version": "0.8.0", + "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.8.0.tgz", + "integrity": "sha1-pY0N8ELBhvz4IqjoAV9UUNLXmos=", + "requires": { + "convert-source-map": "1.1.3", + "inline-source-map": "0.6.2", + "lodash.memoize": "3.0.4", + "source-map": "0.5.7" + } + }, + "combined-stream": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.6.tgz", + "integrity": "sha1-cj599ugBrFYTETp+RFqbactjKBg=", + "requires": { + "delayed-stream": "1.0.0" + } + }, + "concat-map": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz", + "integrity": "sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=" + }, + "concat-stream": { + "version": "1.5.2", + "resolved": "https://registry.npmjs.org/concat-stream/-/concat-stream-1.5.2.tgz", + "integrity": "sha1-cIl4Yk2FavQaWnQd790mHadSwmY=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.0.6", + "typedarray": "0.0.6" + }, + "dependencies": { + "process-nextick-args": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-1.0.7.tgz", + "integrity": "sha1-FQ4gt1ZZCtP5EJPyWk8q2L/zC6M=" + }, + "readable-stream": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.0.6.tgz", + "integrity": "sha1-j5A0HmilPMySh4jaz80Rs265t44=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "1.0.7", + "string_decoder": "0.10.31", + "util-deprecate": "1.0.2" + } + } + } + }, + "console-browserify": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/console-browserify/-/console-browserify-1.1.0.tgz", + "integrity": "sha1-8CQcRXMKn8YyOyBtvzjtx0HQuxA=", + "requires": { + "date-now": "0.1.4" + } + }, + "constants-browserify": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/constants-browserify/-/constants-browserify-1.0.0.tgz", + "integrity": "sha1-wguW2MYXdIqvHBYCF2DNJ/y4y3U=" + }, + "convert-source-map": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.1.3.tgz", + "integrity": "sha1-SCnId+n+SbMWHzvzZziI4gRpmGA=" + }, + "core-util-is": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz", + "integrity": "sha1-tf1UIgqivFq1eqtxQMlAdUUDwac=" + }, + "create-ecdh": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/create-ecdh/-/create-ecdh-4.0.0.tgz", + "integrity": "sha1-iIxyNZbN92EvZJgjPuvXo1MBc30=", + "requires": { + "bn.js": "4.11.8", + "elliptic": "6.4.0" + } + }, + "create-hash": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/create-hash/-/create-hash-1.1.3.tgz", + "integrity": "sha1-YGBCrIuSYnUPSDyt2rD1gZFy2P0=", + "requires": { + "cipher-base": "1.0.4", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "sha.js": "2.4.10" + } + }, + "create-hmac": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/create-hmac/-/create-hmac-1.1.6.tgz", + "integrity": "sha1-rLniIaThe9sHbpBlfEK5PjcmzwY=", + "requires": { + "cipher-base": "1.0.4", + "create-hash": "1.1.3", + "inherits": "2.0.3", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.10" + } + }, + "cryptiles": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/cryptiles/-/cryptiles-3.1.2.tgz", + "integrity": "sha1-qJ+7Ig9c4l7FboxKqKT9e1sNKf4=", + "optional": true, + "requires": { + "boom": "5.2.0" + }, + "dependencies": { + "boom": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/boom/-/boom-5.2.0.tgz", + "integrity": "sha512-Z5BTk6ZRe4tXXQlkqftmsAUANpXmuwlsF5Oov8ThoMbQRzdGTA1ngYRW160GexgOgjsFOKJz0LYhoNi+2AMBUw==", + "optional": true, + "requires": { + "hoek": "4.2.1" + } + } + } + }, + "crypto-browserify": { + "version": "3.12.0", + "resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "requires": { + "browserify-cipher": "1.0.0", + "browserify-sign": "4.0.4", + "create-ecdh": "4.0.0", + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "diffie-hellman": "5.0.2", + "inherits": "2.0.3", + "pbkdf2": "3.0.14", + "public-encrypt": "4.0.0", + "randombytes": "2.0.6", + "randomfill": "1.0.4" + } + }, + "css-select": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/css-select/-/css-select-1.2.0.tgz", + "integrity": "sha1-KzoRBTnFNV8c2NMUYj6HCxIeyFg=", + "requires": { + "boolbase": "1.0.0", + "css-what": "2.1.0", + "domutils": "1.5.1", + "nth-check": "1.0.1" + } + }, + "css-what": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/css-what/-/css-what-2.1.0.tgz", + "integrity": "sha1-lGfQMsOM+u+58teVASUwYvh/ob0=" + }, + "cssom": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.3.2.tgz", + "integrity": "sha1-uANhcMefB6kP8vFuIihAJ6JDhIs=" + }, + "cssstyle": { + "version": "0.2.37", + "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-0.2.37.tgz", + "integrity": "sha1-VBCXI0yyUTyDzu06zdwn/yeYfVQ=", + "optional": true, + "requires": { + "cssom": "0.3.2" + } + }, + "dashdash": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/dashdash/-/dashdash-1.14.1.tgz", + "integrity": "sha1-hTz6D3y+L+1d4gMmuN1YEDX24vA=", + "optional": true, + "requires": { + "assert-plus": "1.0.0" + } + }, + "date-now": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/date-now/-/date-now-0.1.4.tgz", + "integrity": "sha1-6vQ5/U1ISK105cx9vvIAZyueNFs=" + }, + "deep-equal": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/deep-equal/-/deep-equal-1.0.1.tgz", + "integrity": "sha1-9dJgKStmDghO/0zbyfCK0yR0SLU=" + }, + "deep-is": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.3.tgz", + "integrity": "sha1-s2nW+128E+7PUk+RsHD+7cNXzzQ=", + "optional": true + }, + "define-properties": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.1.2.tgz", + "integrity": "sha1-g6c/L+pWmJj7c3GTyPhzyvbUXJQ=", + "requires": { + "foreach": "2.0.5", + "object-keys": "1.0.11" + } + }, + "defined": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/defined/-/defined-1.0.0.tgz", + "integrity": "sha1-yY2bzvdWdBiOEQlpFRGZ45sfppM=" + }, + "delayed-stream": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz", + "integrity": "sha1-3zrhmayt+31ECqrgsp4icrJOxhk=" + }, + "deps-sort": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/deps-sort/-/deps-sort-2.0.0.tgz", + "integrity": "sha1-CRckkC6EZYJg65EHSMzNGvbiH7U=", + "requires": { + "JSONStream": "1.3.2", + "shasum": "1.0.2", + "subarg": "1.0.0", + "through2": "2.0.3" + } + }, + "des.js": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/des.js/-/des.js-1.0.0.tgz", + "integrity": "sha1-wHTS4qpqipoH29YfmhXCzYPsjsw=", + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "detective": { + "version": "4.7.1", + "resolved": "https://registry.npmjs.org/detective/-/detective-4.7.1.tgz", + "integrity": "sha512-H6PmeeUcZloWtdt4DAkFyzFL94arpHr3NOwwmVILFiy+9Qd4JTxxXrzfyGk/lmct2qVGBwTSwSXagqu2BxmWig==", + "requires": { + "acorn": "5.5.3", + "defined": "1.0.0" + }, + "dependencies": { + "acorn": { + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-5.5.3.tgz", + "integrity": "sha512-jd5MkIUlbbmb07nXH0DT3y7rDVtkzDi4XZOUVWAer8ajmF/DTSSbl5oNFyDOl/OXA33Bl79+ypHhl2pN20VeOQ==" + } + } + }, + "diffie-hellman": { + "version": "5.0.2", + "resolved": "https://registry.npmjs.org/diffie-hellman/-/diffie-hellman-5.0.2.tgz", + "integrity": "sha1-tYNXOScM/ias9jIJn97SoH8gnl4=", + "requires": { + "bn.js": "4.11.8", + "miller-rabin": "4.0.1", + "randombytes": "2.0.6" + } + }, + "dom-serializer": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-0.1.0.tgz", + "integrity": "sha1-BzxpdUbOB4DOI75KKOKT5AvDDII=", + "requires": { + "domelementtype": "1.1.3", + "entities": "1.1.1" + }, + "dependencies": { + "domelementtype": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.1.3.tgz", + "integrity": "sha1-vSh3PiZCiBrsUVRJJCmcXNgiGFs=" + } + } + }, + "dom-walk": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.1.tgz", + "integrity": "sha1-ZyIm3HTI95mtNTB9+TaroRrNYBg=" + }, + "domain-browser": { + "version": "1.1.7", + "resolved": "https://registry.npmjs.org/domain-browser/-/domain-browser-1.1.7.tgz", + "integrity": "sha1-hnqksJP6oF8d4IwG9NeyH9+GmLw=" + }, + "domelementtype": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-1.3.0.tgz", + "integrity": "sha1-sXrtguirWeUt2cGbF1bg/BhyBMI=" + }, + "domhandler": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-2.3.0.tgz", + "integrity": "sha1-LeWaCCLVAn+r/28DLCsloqir5zg=", + "requires": { + "domelementtype": "1.3.0" + } + }, + "domready": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/domready/-/domready-1.0.8.tgz", + "integrity": "sha1-kfJS5Ze2Wvd+dFriTdAYXV4m1Yw=" + }, + "domutils": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/domutils/-/domutils-1.5.1.tgz", + "integrity": "sha1-3NhIiib1Y9YQeeSMn3t+Mjc2gs8=", + "requires": { + "dom-serializer": "0.1.0", + "domelementtype": "1.3.0" + } + }, + "duplexer2": { + "version": "0.1.4", + "resolved": "https://registry.npmjs.org/duplexer2/-/duplexer2-0.1.4.tgz", + "integrity": "sha1-ixLauHjA1p4+eJEFFmKjL8a93ME=", + "requires": { + "readable-stream": "2.3.5" + } + }, + "ecc-jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/ecc-jsbn/-/ecc-jsbn-0.1.1.tgz", + "integrity": "sha1-D8c6ntXw1Tw4GTOYUj735UN3dQU=", + "optional": true, + "requires": { + "jsbn": "0.1.1" + } + }, + "ecstatic": { + "version": "2.2.1", + "resolved": "https://registry.npmjs.org/ecstatic/-/ecstatic-2.2.1.tgz", + "integrity": "sha512-ztE4WqheoWLh3wv+HQwy7dACnvNY620coWpa+XqY6R2cVWgaAT2lUISU1Uf7JpdLLJCURktJOaA9av2AOzsyYQ==", + "requires": { + "he": "1.1.1", + "mime": "1.6.0", + "minimist": "1.2.0", + "url-join": "2.0.5" + } + }, + "elliptic": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.4.0.tgz", + "integrity": "sha1-ysmvh2LIWDYYcAPI3+GT5eLq5d8=", + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0", + "hash.js": "1.1.3", + "hmac-drbg": "1.0.1", + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "entities": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.1.1.tgz", + "integrity": "sha1-blwtClYhtdra7O+AuQ7ftc13cvA=" + }, + "es-abstract": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/es-abstract/-/es-abstract-1.10.0.tgz", + "integrity": "sha512-/uh/DhdqIOSkAWifU+8nG78vlQxdLckUdI/sPgy0VhuXi2qJ7T8czBmqIYtLQVpCIFYafChnsRsB5pyb1JdmCQ==", + "requires": { + "es-to-primitive": "1.1.1", + "function-bind": "1.1.1", + "has": "1.0.1", + "is-callable": "1.1.3", + "is-regex": "1.0.4" + } + }, + "es-to-primitive": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.1.1.tgz", + "integrity": "sha1-RTVSSKiJeQNLZ5Lhm7gfK3l13Q0=", + "requires": { + "is-callable": "1.1.3", + "is-date-object": "1.0.1", + "is-symbol": "1.0.1" + } + }, + "escodegen": { + "version": "1.9.1", + "resolved": "https://registry.npmjs.org/escodegen/-/escodegen-1.9.1.tgz", + "integrity": "sha512-6hTjO1NAWkHnDk3OqQ4YrCuwwmGHL9S3nPlzBOUG/R44rda3wLNrfvQ5fkSGjyhHFKM7ALPKcKGrwvCLe0lC7Q==", + "optional": true, + "requires": { + "esprima": "3.1.3", + "estraverse": "4.2.0", + "esutils": "2.0.2", + "optionator": "0.8.2", + "source-map": "0.6.1" + }, + "dependencies": { + "source-map": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz", + "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==", + "optional": true + } + } + }, + "esprima": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-3.1.3.tgz", + "integrity": "sha1-/cpRzuYTOJXjyI1TXOSdv/YqRjM=", + "optional": true + }, + "estraverse": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/estraverse/-/estraverse-4.2.0.tgz", + "integrity": "sha1-De4/7TH81GlhjOc0IJn8GvoL2xM=", + "optional": true + }, + "esutils": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.2.tgz", + "integrity": "sha1-Cr9PHKpbyx96nYrMbepPqqBLrJs=", + "optional": true + }, + "events": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/events/-/events-1.1.1.tgz", + "integrity": "sha1-nr23Y1rQmccNzEwqH1AEKI6L2SQ=" + }, + "events-to-array": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/events-to-array/-/events-to-array-1.1.2.tgz", + "integrity": "sha1-LUH1Y+H+QA7Uli/hpNXGp1Od9/Y=" + }, + "evp_bytestokey": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", + "integrity": "sha512-/f2Go4TognH/KvCISP7OUsHn85hT9nUkxxA9BEWxFn+Oj9o8ZNLm/40hdlgSLyuOimsrTKLUMEorQexp/aPQeA==", + "requires": { + "md5.js": "1.3.4", + "safe-buffer": "5.1.1" + } + }, + "extend": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.1.tgz", + "integrity": "sha1-p1Xqe8Gt/MWjHOfnYtuq3F5jZEQ=", + "optional": true + }, + "extsprintf": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.3.0.tgz", + "integrity": "sha1-lpGEQOMEGnpBT4xS48V06zw+HgU=" + }, + "fast-deep-equal": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-1.1.0.tgz", + "integrity": "sha1-wFNHeBfIa1HaqFPIHgWbcz0CNhQ=", + "optional": true + }, + "fast-json-stable-stringify": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/fast-json-stable-stringify/-/fast-json-stable-stringify-2.0.0.tgz", + "integrity": "sha1-1RQsDK7msRifh9OnYREGT4bIu/I=", + "optional": true + }, + "fast-levenshtein": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz", + "integrity": "sha1-PYpcZog6FqMMqGQ+hR8Zuqd5eRc=", + "optional": true + }, + "first-match": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/first-match/-/first-match-0.0.1.tgz", + "integrity": "sha1-pg7GQnAPD0NyNOu37D84JHblQv0=" + }, + "for-each": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/for-each/-/for-each-0.3.2.tgz", + "integrity": "sha1-LEBFC5NI6X8oEyJZO6lnBLmr1NQ=", + "requires": { + "is-function": "1.0.1" + } + }, + "foreach": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/foreach/-/foreach-2.0.5.tgz", + "integrity": "sha1-C+4AUBiusmDQo6865ljdATbsG5k=" + }, + "forever-agent": { + "version": "0.6.1", + "resolved": "https://registry.npmjs.org/forever-agent/-/forever-agent-0.6.1.tgz", + "integrity": "sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=", + "optional": true + }, + "form-data": { + "version": "2.3.2", + "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.3.2.tgz", + "integrity": "sha1-SXBJi+YEwgwAXU9cI67NIda0kJk=", + "optional": true, + "requires": { + "asynckit": "0.4.0", + "combined-stream": "1.0.6", + "mime-types": "2.1.18" + } + }, + "fs.realpath": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz", + "integrity": "sha1-FQStJSMVjKpA20onh8sBQRmU6k8=" + }, + "function-bind": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", + "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==" + }, + "getpass": { + "version": "0.1.7", + "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", + "integrity": "sha1-Xv+OPmhNVprkyysSgmBOi6YhSfo=", + "optional": true, + "requires": { + "assert-plus": "1.0.0" + } + }, + "glob": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.2.tgz", + "integrity": "sha512-MJTUg1kjuLeQCJ+ccE4Vpa6kKVXkPYJ2mOCQyUuKLcLQsdrMCpBPUi8qVE6+YuaJkozeA9NusTAw3hLr8Xe5EQ==", + "requires": { + "fs.realpath": "1.0.0", + "inflight": "1.0.6", + "inherits": "2.0.3", + "minimatch": "3.0.4", + "once": "1.4.0", + "path-is-absolute": "1.0.1" + } + }, + "global": { + "version": "4.3.2", + "resolved": "https://registry.npmjs.org/global/-/global-4.3.2.tgz", + "integrity": "sha1-52mJJopsdMOJCLEwWxD8DjlOnQ8=", + "requires": { + "min-document": "2.19.0", + "process": "0.5.2" + }, + "dependencies": { + "process": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/process/-/process-0.5.2.tgz", + "integrity": "sha1-FjjYqONML0QKkduVq5rrZ3/Bhc8=" + } + } + }, + "har-schema": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/har-schema/-/har-schema-2.0.0.tgz", + "integrity": "sha1-qUwiJOvKwEeCoNkDVSHyRzW37JI=", + "optional": true + }, + "har-validator": { + "version": "5.0.3", + "resolved": "https://registry.npmjs.org/har-validator/-/har-validator-5.0.3.tgz", + "integrity": "sha1-ukAsJmGU8VlW7xXg/PJCmT9qff0=", + "optional": true, + "requires": { + "ajv": "5.5.2", + "har-schema": "2.0.0" + } + }, + "has": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/has/-/has-1.0.1.tgz", + "integrity": "sha1-hGFzP1OLCDfJNh45qauelwTcLyg=", + "requires": { + "function-bind": "1.1.1" + } + }, + "hash-base": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-2.0.2.tgz", + "integrity": "sha1-ZuodhW206KVHDK32/OI65SRO8uE=", + "requires": { + "inherits": "2.0.3" + } + }, + "hash.js": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/hash.js/-/hash.js-1.1.3.tgz", + "integrity": "sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==", + "requires": { + "inherits": "2.0.3", + "minimalistic-assert": "1.0.0" + } + }, + "hawk": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/hawk/-/hawk-6.0.2.tgz", + "integrity": "sha512-miowhl2+U7Qle4vdLqDdPt9m09K6yZhkLDTWGoUiUzrQCn+mHHSmfJgAyGaLRZbPmTqfFFjRV1QWCW0VWUJBbQ==", + "optional": true, + "requires": { + "boom": "4.3.1", + "cryptiles": "3.1.2", + "hoek": "4.2.1", + "sntp": "2.1.0" + } + }, + "he": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/he/-/he-1.1.1.tgz", + "integrity": "sha1-k0EP0hsAlzUVH4howvJx80J+I/0=" + }, + "hmac-drbg": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/hmac-drbg/-/hmac-drbg-1.0.1.tgz", + "integrity": "sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=", + "requires": { + "hash.js": "1.1.3", + "minimalistic-assert": "1.0.0", + "minimalistic-crypto-utils": "1.0.1" + } + }, + "hoek": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/hoek/-/hoek-4.2.1.tgz", + "integrity": "sha512-QLg82fGkfnJ/4iy1xZ81/9SIJiq1NGFUMGs6ParyjBZr6jW2Ufj/snDqTHixNlHdPNwN2RLVD0Pi3igeK9+JfA==" + }, + "htmlescape": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/htmlescape/-/htmlescape-1.1.1.tgz", + "integrity": "sha1-OgPtwiFLyjtmQko+eVk0lQnLA1E=" + }, + "htmlparser2": { + "version": "3.8.3", + "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-3.8.3.tgz", + "integrity": "sha1-mWwosZFRaovoZQGn15dX5ccMEGg=", + "requires": { + "domelementtype": "1.3.0", + "domhandler": "2.3.0", + "domutils": "1.5.1", + "entities": "1.0.0", + "readable-stream": "1.1.14" + }, + "dependencies": { + "entities": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/entities/-/entities-1.0.0.tgz", + "integrity": "sha1-sph6o4ITR/zeZCsk/fyeT7cSvyY=" + }, + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + }, + "readable-stream": { + "version": "1.1.14", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.1.14.tgz", + "integrity": "sha1-fPTFTvZI44EwhMY23SB54WbAgdk=", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "0.0.1", + "string_decoder": "0.10.31" + } + } + } + }, + "http-signature": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/http-signature/-/http-signature-1.2.0.tgz", + "integrity": "sha1-muzZJRFHcvPZW2WmCruPfBj7rOE=", + "optional": true, + "requires": { + "assert-plus": "1.0.0", + "jsprim": "1.4.1", + "sshpk": "1.14.1" + } + }, + "https-browserify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/https-browserify/-/https-browserify-0.0.1.tgz", + "integrity": "sha1-P5E2XKvmC3ftDruiS0VOPgnZWoI=" + }, + "ieee754": { + "version": "1.1.9", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.1.9.tgz", + "integrity": "sha512-yWDsidMaZHbeTa0a1iSFpK8QhzicsFxo8zKxH0YU2g47rNUZql5+2o3DSc5Z070kjGPLP292BWiF4bd8Q+G87g==" + }, + "indexof": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/indexof/-/indexof-0.0.1.tgz", + "integrity": "sha1-gtwzbSMrkGIXnQWrMpOmYFn9Q10=" + }, + "inflight": { + "version": "1.0.6", + "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz", + "integrity": "sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=", + "requires": { + "once": "1.4.0", + "wrappy": "1.0.2" + } + }, + "inherits": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.3.tgz", + "integrity": "sha1-Yzwsg+PaQqUC9SRmAiSA9CCCYd4=" + }, + "inline-source-map": { + "version": "0.6.2", + "resolved": "https://registry.npmjs.org/inline-source-map/-/inline-source-map-0.6.2.tgz", + "integrity": "sha1-+Tk0ccGKedFyT4Y/o4tYY3Ct4qU=", + "requires": { + "source-map": "0.5.7" + } + }, + "insert-module-globals": { + "version": "7.0.2", + "resolved": "https://registry.npmjs.org/insert-module-globals/-/insert-module-globals-7.0.2.tgz", + "integrity": "sha512-p3s7g96Nm62MbHRuj9ZXab0DuJNWD7qcmdUXCOQ/ZZn42DtDXfsLill7bq19lDCx3K3StypqUnuE3H2VmIJFUw==", + "requires": { + "JSONStream": "1.3.2", + "combine-source-map": "0.7.2", + "concat-stream": "1.5.2", + "is-buffer": "1.1.6", + "lexical-scope": "1.2.0", + "process": "0.11.10", + "through2": "2.0.3", + "xtend": "4.0.1" + }, + "dependencies": { + "combine-source-map": { + "version": "0.7.2", + "resolved": "https://registry.npmjs.org/combine-source-map/-/combine-source-map-0.7.2.tgz", + "integrity": "sha1-CHAxKFazB6h8xKxIbzqaYq7MwJ4=", + "requires": { + "convert-source-map": "1.1.3", + "inline-source-map": "0.6.2", + "lodash.memoize": "3.0.4", + "source-map": "0.5.7" + } + } + } + }, + "is-buffer": { + "version": "1.1.6", + "resolved": "https://registry.npmjs.org/is-buffer/-/is-buffer-1.1.6.tgz", + "integrity": "sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==" + }, + "is-callable": { + "version": "1.1.3", + "resolved": "https://registry.npmjs.org/is-callable/-/is-callable-1.1.3.tgz", + "integrity": "sha1-hut1OSgF3cM69xySoO7fdO52BLI=" + }, + "is-date-object": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-date-object/-/is-date-object-1.0.1.tgz", + "integrity": "sha1-mqIOtq7rv/d/vTPnTKAbM1gdOhY=" + }, + "is-function": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-function/-/is-function-1.0.1.tgz", + "integrity": "sha1-Es+5i2W1fdPRk6MSH19uL0N2ArU=" + }, + "is-regex": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/is-regex/-/is-regex-1.0.4.tgz", + "integrity": "sha1-VRdIm1RwkbCTDglWVM7SXul+lJE=", + "requires": { + "has": "1.0.1" + } + }, + "is-symbol": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/is-symbol/-/is-symbol-1.0.1.tgz", + "integrity": "sha1-PMWfAAJRlLarLjjbrmaJJWtmBXI=" + }, + "is-typedarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/is-typedarray/-/is-typedarray-1.0.0.tgz", + "integrity": "sha1-5HnICFjfDBsR3dppQPlgEfzaSpo=", + "optional": true + }, + "isarray": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz", + "integrity": "sha1-u5NdSFgsuhaMBoNJV6VKPgcSTxE=" + }, + "isexe": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz", + "integrity": "sha1-6PvzdNxVb/iUehDcsFctYz8s+hA=" + }, + "isstream": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/isstream/-/isstream-0.1.2.tgz", + "integrity": "sha1-R+Y/evVa+m+S4VAOaQ64uFKcCZo=", + "optional": true + }, + "js-yaml": { + "version": "3.11.0", + "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.11.0.tgz", + "integrity": "sha512-saJstZWv7oNeOyBh3+Dx1qWzhW0+e6/8eDzo7p5rDFqxntSztloLtuKu+Ejhtq82jsilwOIZYsCz+lIjthg1Hw==", + "requires": { + "argparse": "1.0.10", + "esprima": "4.0.0" + }, + "dependencies": { + "esprima": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.0.tgz", + "integrity": "sha512-oftTcaMu/EGrEIu904mWteKIv8vMuOgGYo7EhVJJN00R/EED9DCua/xxHRdYnKtcECzVg7xOWhflvJMnqcFZjw==" + } + } + }, + "jsbn": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/jsbn/-/jsbn-0.1.1.tgz", + "integrity": "sha1-peZUwuWi3rXyAdls77yoDA7y9RM=", + "optional": true + }, + "jsdom": { + "version": "7.2.2", + "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-7.2.2.tgz", + "integrity": "sha1-QLQCdwwr2iNGkJa+6Rq2deOx/G4=", + "optional": true, + "requires": { + "abab": "1.0.4", + "acorn": "2.7.0", + "acorn-globals": "1.0.9", + "cssom": "0.3.2", + "cssstyle": "0.2.37", + "escodegen": "1.9.1", + "nwmatcher": "1.4.4", + "parse5": "1.5.1", + "request": "2.85.0", + "sax": "1.2.4", + "symbol-tree": "3.2.2", + "tough-cookie": "2.3.4", + "webidl-conversions": "2.0.1", + "whatwg-url-compat": "0.6.5", + "xml-name-validator": "2.0.1" + }, + "dependencies": { + "acorn": { + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-2.7.0.tgz", + "integrity": "sha1-q259nYhqrKiwhbwzEreaGYQz8Oc=", + "optional": true + } + } + }, + "json-schema": { + "version": "0.2.3", + "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.2.3.tgz", + "integrity": "sha1-tIDIkuWaLwWVTOcnvT8qTogvnhM=", + "optional": true + }, + "json-schema-traverse": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.3.1.tgz", + "integrity": "sha1-NJptRMU6Ud6JtAgFxdXlm0F9M0A=", + "optional": true + }, + "json-stable-stringify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/json-stable-stringify/-/json-stable-stringify-0.0.1.tgz", + "integrity": "sha1-YRwj6BTbN1Un34URk9tZ3Sryf0U=", + "requires": { + "jsonify": "0.0.0" + } + }, + "json-stringify-safe": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz", + "integrity": "sha1-Epai1Y/UXxmg9s4B1lcB4sc1tus=", + "optional": true + }, + "jsonify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/jsonify/-/jsonify-0.0.0.tgz", + "integrity": "sha1-LHS27kHZPKUbe1qu6PUDYx0lKnM=" + }, + "jsonparse": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/jsonparse/-/jsonparse-1.3.1.tgz", + "integrity": "sha1-P02uSpH6wxX3EGL4UhzCOfE2YoA=" + }, + "jsprim": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/jsprim/-/jsprim-1.4.1.tgz", + "integrity": "sha1-MT5mvB5cwG5Di8G3SZwuXFastqI=", + "optional": true, + "requires": { + "assert-plus": "1.0.0", + "extsprintf": "1.3.0", + "json-schema": "0.2.3", + "verror": "1.10.0" + } + }, + "labeled-stream-splicer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/labeled-stream-splicer/-/labeled-stream-splicer-2.0.0.tgz", + "integrity": "sha1-pS4dE4AkwAuGscDJH2d5GLiuClk=", + "requires": { + "inherits": "2.0.3", + "isarray": "0.0.1", + "stream-splicer": "2.0.0" + }, + "dependencies": { + "isarray": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz", + "integrity": "sha1-ihis/Kmo9Bd+Cav8YDiTmwXR7t8=" + } + } + }, + "levn": { + "version": "0.3.0", + "resolved": "https://registry.npmjs.org/levn/-/levn-0.3.0.tgz", + "integrity": "sha1-OwmSTt+fCDwEkP3UwLxEIeBHZO4=", + "optional": true, + "requires": { + "prelude-ls": "1.1.2", + "type-check": "0.3.2" + } + }, + "lexical-scope": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/lexical-scope/-/lexical-scope-1.2.0.tgz", + "integrity": "sha1-/Ope3HBKSzqHls3KQZw6CvryLfQ=", + "requires": { + "astw": "2.2.0" + } + }, + "lodash": { + "version": "4.17.5", + "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.17.5.tgz", + "integrity": "sha512-svL3uiZf1RwhH+cWrfZn3A4+U58wbP0tGVTLQPbjplZxZ8ROD9VLuNgsRniTlLe7OlSqR79RUehXgpBW/s0IQw==" + }, + "lodash.memoize": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/lodash.memoize/-/lodash.memoize-3.0.4.tgz", + "integrity": "sha1-LcvSwofLwKVcxCMovQxzYVDVPj8=" + }, + "md5.js": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.4.tgz", + "integrity": "sha1-6b296UogpawYsENA/Fdk1bCdkB0=", + "requires": { + "hash-base": "3.0.4", + "inherits": "2.0.3" + }, + "dependencies": { + "hash-base": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/hash-base/-/hash-base-3.0.4.tgz", + "integrity": "sha1-X8hoaEfs1zSZQDMZprCj8/auSRg=", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + } + } + }, + "miller-rabin": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/miller-rabin/-/miller-rabin-4.0.1.tgz", + "integrity": "sha512-115fLhvZVqWwHPbClyntxEVfVDfl9DLLTuJvq3g2O/Oxi8AiNouAHvDSzHS0viUJc+V5vm3eq91Xwqn9dp4jRA==", + "requires": { + "bn.js": "4.11.8", + "brorand": "1.1.0" + } + }, + "mime": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz", + "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==" + }, + "mime-db": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.33.0.tgz", + "integrity": "sha512-BHJ/EKruNIqJf/QahvxwQZXKygOQ256myeN/Ew+THcAa5q+PjyTTMMeNQC4DZw5AwfvelsUrA6B67NKMqXDbzQ==" + }, + "mime-types": { + "version": "2.1.18", + "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.18.tgz", + "integrity": "sha512-lc/aahn+t4/SWV/qcmumYjymLsWfN3ELhpmVuUFjgsORruuZPVSwAQryq+HHGvO/SI2KVX26bx+En+zhM8g8hQ==", + "requires": { + "mime-db": "1.33.0" + } + }, + "min-document": { + "version": "2.19.0", + "resolved": "https://registry.npmjs.org/min-document/-/min-document-2.19.0.tgz", + "integrity": "sha1-e9KC4/WELtKVu3SM3Z8f+iyCRoU=", + "requires": { + "dom-walk": "0.1.1" + } + }, + "minimalistic-assert": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/minimalistic-assert/-/minimalistic-assert-1.0.0.tgz", + "integrity": "sha1-cCvi3aazf0g2vLP121ZkG2Sh09M=" + }, + "minimalistic-crypto-utils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz", + "integrity": "sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=" + }, + "minimatch": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.0.4.tgz", + "integrity": "sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==", + "requires": { + "brace-expansion": "1.1.11" + } + }, + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=" + }, + "module-deps": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/module-deps/-/module-deps-4.1.1.tgz", + "integrity": "sha1-IyFYM/HaE/1gbMuAh7RIUty4If0=", + "requires": { + "JSONStream": "1.3.2", + "browser-resolve": "1.11.2", + "cached-path-relative": "1.0.1", + "concat-stream": "1.5.2", + "defined": "1.0.0", + "detective": "4.7.1", + "duplexer2": "0.1.4", + "inherits": "2.0.3", + "parents": "1.0.1", + "readable-stream": "2.3.5", + "resolve": "1.5.0", + "stream-combiner2": "1.1.1", + "subarg": "1.0.0", + "through2": "2.0.3", + "xtend": "4.0.1" + } + }, + "nth-check": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-1.0.1.tgz", + "integrity": "sha1-mSms32KPwsQQmN6rgqxYDPFJquQ=", + "requires": { + "boolbase": "1.0.0" + } + }, + "nwmatcher": { + "version": "1.4.4", + "resolved": "https://registry.npmjs.org/nwmatcher/-/nwmatcher-1.4.4.tgz", + "integrity": "sha512-3iuY4N5dhgMpCUrOVnuAdGrgxVqV2cJpM+XNccjR2DKOB1RUP0aA+wGXEiNziG/UKboFyGBIoKOaNlJxx8bciQ==", + "optional": true + }, + "oauth-sign": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/oauth-sign/-/oauth-sign-0.8.2.tgz", + "integrity": "sha1-Rqarfwrq2N6unsBWV4C31O/rnUM=", + "optional": true + }, + "object-inspect": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.5.0.tgz", + "integrity": "sha512-UmOFbHbwvv+XHj7BerrhVq+knjceBdkvU5AriwLMvhv2qi+e7DJzxfBeFpILEjVzCp+xA+W/pIf06RGPWlZNfw==" + }, + "object-keys": { + "version": "1.0.11", + "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.0.11.tgz", + "integrity": "sha1-xUYBd4rVYPEULODgG8yotW0TQm0=" + }, + "once": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz", + "integrity": "sha1-WDsap3WWHUsROsF9nFC6753Xa9E=", + "requires": { + "wrappy": "1.0.2" + } + }, + "optionator": { + "version": "0.8.2", + "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.2.tgz", + "integrity": "sha1-NkxeQJ0/TWMB1sC0wFu6UBgK62Q=", + "optional": true, + "requires": { + "deep-is": "0.1.3", + "fast-levenshtein": "2.0.6", + "levn": "0.3.0", + "prelude-ls": "1.1.2", + "type-check": "0.3.2", + "wordwrap": "1.0.0" + } + }, + "os-browserify": { + "version": "0.1.2", + "resolved": "https://registry.npmjs.org/os-browserify/-/os-browserify-0.1.2.tgz", + "integrity": "sha1-ScoCk+CxlZCl9d4Qx/JlphfY/lQ=" + }, + "osenv": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/osenv/-/osenv-0.0.3.tgz", + "integrity": "sha1-zWrY3bKQkVrZ4idlV2Al1BHynLY=" + }, + "pako": { + "version": "0.2.9", + "resolved": "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz", + "integrity": "sha1-8/dSL073gjSNqBYbrZ7P1Rv4OnU=" + }, + "parents": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parents/-/parents-1.0.1.tgz", + "integrity": "sha1-/t1NK/GTp3dF/nHjcdc8MwfZx1E=", + "requires": { + "path-platform": "0.11.15" + } + }, + "parse-asn1": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/parse-asn1/-/parse-asn1-5.1.0.tgz", + "integrity": "sha1-N8T5t+06tlx0gXtfJICTf7+XxxI=", + "requires": { + "asn1.js": "4.10.1", + "browserify-aes": "1.1.1", + "create-hash": "1.1.3", + "evp_bytestokey": "1.0.3", + "pbkdf2": "3.0.14" + } + }, + "parse-headers": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/parse-headers/-/parse-headers-2.0.1.tgz", + "integrity": "sha1-aug6eqJanZtwCswoaYzR8e1+lTY=", + "requires": { + "for-each": "0.3.2", + "trim": "0.0.1" + } + }, + "parse5": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/parse5/-/parse5-1.5.1.tgz", + "integrity": "sha1-m387DeMr543CQBsXVzzK8Pb1nZQ=", + "optional": true + }, + "path-browserify": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-0.0.0.tgz", + "integrity": "sha1-oLhwcpquIUAFt9UDLsLLuw+0RRo=" + }, + "path-is-absolute": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz", + "integrity": "sha1-F0uSaHNVNP+8es5r9TpanhtcX18=" + }, + "path-parse": { + "version": "1.0.5", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.5.tgz", + "integrity": "sha1-PBrfhx6pzWyUMbbqK9dKD/BVxME=" + }, + "path-platform": { + "version": "0.11.15", + "resolved": "https://registry.npmjs.org/path-platform/-/path-platform-0.11.15.tgz", + "integrity": "sha1-6GQhf3TDaFDwhSt43Hv31KVyG/I=" + }, + "pbkdf2": { + "version": "3.0.14", + "resolved": "https://registry.npmjs.org/pbkdf2/-/pbkdf2-3.0.14.tgz", + "integrity": "sha512-gjsZW9O34fm0R7PaLHRJmLLVfSoesxztjPjE9o6R+qtVJij90ltg1joIovN9GKrRW3t1PzhDDG3UMEMFfZ+1wA==", + "requires": { + "create-hash": "1.1.3", + "create-hmac": "1.1.6", + "ripemd160": "2.0.1", + "safe-buffer": "5.1.1", + "sha.js": "2.4.10" + } + }, + "performance-now": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/performance-now/-/performance-now-2.1.0.tgz", + "integrity": "sha1-Ywn04OX6kT7BxpMHrjZLSzd8nns=", + "optional": true + }, + "prelude-ls": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.1.2.tgz", + "integrity": "sha1-IZMqVJ9eUv/ZqCf1cOBL5iqX2lQ=" + }, + "process": { + "version": "0.11.10", + "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz", + "integrity": "sha1-czIwDoQBYb2j5podHZGn1LwW8YI=" + }, + "process-nextick-args": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.0.tgz", + "integrity": "sha512-MtEC1TqN0EU5nephaJ4rAtThHtC86dNN9qCuEhtshvpVBkAW5ZO7BASN9REnF9eoXGcRub+pFuKEpOHE+HbEMw==" + }, + "public-encrypt": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/public-encrypt/-/public-encrypt-4.0.0.tgz", + "integrity": "sha1-OfaZ86RlYN1eusvKaTyvfGXBjMY=", + "requires": { + "bn.js": "4.11.8", + "browserify-rsa": "4.0.1", + "create-hash": "1.1.3", + "parse-asn1": "5.1.0", + "randombytes": "2.0.6" + } + }, + "punycode": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz", + "integrity": "sha1-wNWmOycYgArY4esPpSachN1BhF4=" + }, + "qs": { + "version": "6.5.1", + "resolved": "https://registry.npmjs.org/qs/-/qs-6.5.1.tgz", + "integrity": "sha512-eRzhrN1WSINYCDCbrz796z37LOe3m5tmW7RQf6oBntukAG1nmovJvhnwHHRMAfeoItc1m2Hk02WER2aQ/iqs+A==", + "optional": true + }, + "querystring": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/querystring/-/querystring-0.2.0.tgz", + "integrity": "sha1-sgmEkgO7Jd+CDadW50cAWHhSFiA=" + }, + "querystring-es3": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/querystring-es3/-/querystring-es3-0.2.1.tgz", + "integrity": "sha1-nsYfeQSYdXB9aUFFlv2Qek1xHnM=" + }, + "quick-tmp": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/quick-tmp/-/quick-tmp-0.0.0.tgz", + "integrity": "sha1-QWXmYyDqBfnLzM874fj9X9sF998=", + "requires": { + "first-match": "0.0.1", + "osenv": "0.0.3" + } + }, + "randombytes": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/randombytes/-/randombytes-2.0.6.tgz", + "integrity": "sha512-CIQ5OFxf4Jou6uOKe9t1AOgqpeU5fd70A8NPdHSGeYXqXsPe6peOwI0cUl88RWZ6sP1vPMV3avd/R6cZ5/sP1A==", + "requires": { + "safe-buffer": "5.1.1" + } + }, + "randomfill": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/randomfill/-/randomfill-1.0.4.tgz", + "integrity": "sha512-87lcbR8+MhcWcUiQ+9e+Rwx8MyR2P7qnt15ynUlbm3TU/fjbgz4GsvfSUDTemtCCtVCqb4ZcEFlyPNTh9bBTLw==", + "requires": { + "randombytes": "2.0.6", + "safe-buffer": "5.1.1" + } + }, + "read-only-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/read-only-stream/-/read-only-stream-2.0.0.tgz", + "integrity": "sha1-JyT9aoET1zdkrCiNQ4YnDB2/F/A=", + "requires": { + "readable-stream": "2.3.5" + } + }, + "readable-stream": { + "version": "2.3.5", + "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.5.tgz", + "integrity": "sha512-tK0yDhrkygt/knjowCUiWP9YdV7c5R+8cR0r/kt9ZhBU906Fs6RpQJCEilamRJj1Nx2rWI6LkW9gKqjTkshhEw==", + "requires": { + "core-util-is": "1.0.2", + "inherits": "2.0.3", + "isarray": "1.0.0", + "process-nextick-args": "2.0.0", + "safe-buffer": "5.1.1", + "string_decoder": "1.0.3", + "util-deprecate": "1.0.2" + }, + "dependencies": { + "string_decoder": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.0.3.tgz", + "integrity": "sha512-4AH6Z5fzNNBcH+6XDMfA/BTt87skxqJlO0lAh3Dker5zThcAxG6mKz+iGu308UKoPPQ8Dcqx/4JhujzltRa+hQ==", + "requires": { + "safe-buffer": "5.1.1" + } + } + } + }, + "request": { + "version": "2.85.0", + "resolved": "https://registry.npmjs.org/request/-/request-2.85.0.tgz", + "integrity": "sha512-8H7Ehijd4js+s6wuVPLjwORxD4zeuyjYugprdOXlPSqaApmL/QOy+EB/beICHVCHkGMKNh5rvihb5ov+IDw4mg==", + "optional": true, + "requires": { + "aws-sign2": "0.7.0", + "aws4": "1.6.0", + "caseless": "0.12.0", + "combined-stream": "1.0.6", + "extend": "3.0.1", + "forever-agent": "0.6.1", + "form-data": "2.3.2", + "har-validator": "5.0.3", + "hawk": "6.0.2", + "http-signature": "1.2.0", + "is-typedarray": "1.0.0", + "isstream": "0.1.2", + "json-stringify-safe": "5.0.1", + "mime-types": "2.1.18", + "oauth-sign": "0.8.2", + "performance-now": "2.1.0", + "qs": "6.5.1", + "safe-buffer": "5.1.1", + "stringstream": "0.0.5", + "tough-cookie": "2.3.4", + "tunnel-agent": "0.6.0", + "uuid": "3.2.1" + } + }, + "resolve": { + "version": "1.5.0", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.5.0.tgz", + "integrity": "sha512-hgoSGrc3pjzAPHNBg+KnFcK2HwlHTs/YrAGUr6qgTVUZmXv1UEXXl0bZNBKMA9fud6lRYFdPGz0xXxycPzmmiw==", + "requires": { + "path-parse": "1.0.5" + } + }, + "resumer": { + "version": "0.0.0", + "resolved": "https://registry.npmjs.org/resumer/-/resumer-0.0.0.tgz", + "integrity": "sha1-8ej0YeQGS6Oegq883CqMiT0HZ1k=", + "requires": { + "through": "2.3.8" + } + }, + "rimraf": { + "version": "2.6.2", + "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.2.tgz", + "integrity": "sha512-lreewLK/BlghmxtfH36YYVg1i8IAce4TI7oao75I1g245+6BctqTVQiBP3YUJ9C6DQOXJmkYR9X9fCLtCOJc5w==", + "requires": { + "glob": "7.1.2" + } + }, + "ripemd160": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ripemd160/-/ripemd160-2.0.1.tgz", + "integrity": "sha1-D0WEKVxTo2KK9+bXmsohzlfRxuc=", + "requires": { + "hash-base": "2.0.2", + "inherits": "2.0.3" + } + }, + "safe-buffer": { + "version": "5.1.1", + "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.1.tgz", + "integrity": "sha512-kKvNJn6Mm93gAczWVJg7wH+wGYWNrDHdWvpUmHyEsgCtIwwo3bqPtV4tR5tuPaUhTOo/kvhVwd8XwwOllGYkbg==" + }, + "sax": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/sax/-/sax-1.2.4.tgz", + "integrity": "sha512-NqVDv9TpANUjFm0N8uM5GxL36UgKi9/atZw+x7YFnQ8ckwFGKrl4xX4yWtrey3UJm5nP1kUbnYgLopqWNSRhWw==", + "optional": true + }, + "sha.js": { + "version": "2.4.10", + "resolved": "https://registry.npmjs.org/sha.js/-/sha.js-2.4.10.tgz", + "integrity": "sha512-vnwmrFDlOExK4Nm16J2KMWHLrp14lBrjxMxBJpu++EnsuBmpiYaM/MEs46Vxxm/4FvdP5yTwuCTO9it5FSjrqA==", + "requires": { + "inherits": "2.0.3", + "safe-buffer": "5.1.1" + } + }, + "shallow-copy": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/shallow-copy/-/shallow-copy-0.0.1.tgz", + "integrity": "sha1-QV9CcC1z2BAzApLMXuhurhoRoXA=" + }, + "shasum": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/shasum/-/shasum-1.0.2.tgz", + "integrity": "sha1-5wEjENj0F/TetXEhUOVni4euVl8=", + "requires": { + "json-stable-stringify": "0.0.1", + "sha.js": "2.4.10" + } + }, + "shell-quote": { + "version": "1.6.1", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.6.1.tgz", + "integrity": "sha1-9HgZSczkAmlxJ0MOo7PFR29IF2c=", + "requires": { + "array-filter": "0.0.1", + "array-map": "0.0.0", + "array-reduce": "0.0.0", + "jsonify": "0.0.0" + } + }, + "sntp": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/sntp/-/sntp-2.1.0.tgz", + "integrity": "sha512-FL1b58BDrqS3A11lJ0zEdnJ3UOKqVxawAkF3k7F0CVN7VQ34aZrV+G8BZ1WC9ZL7NyrwsW0oviwsWDgRuVYtJg==", + "optional": true, + "requires": { + "hoek": "4.2.1" + } + }, + "source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha1-igOdLRAh0i0eoUyA2OpGi6LvP8w=" + }, + "sprintf-js": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz", + "integrity": "sha1-BOaSb2YolTVPPdAVIDYzuFcpfiw=" + }, + "sshpk": { + "version": "1.14.1", + "resolved": "https://registry.npmjs.org/sshpk/-/sshpk-1.14.1.tgz", + "integrity": "sha1-Ew9Zde3a2WPx1W+SuaxsUfqfg+s=", + "optional": true, + "requires": { + "asn1": "0.2.3", + "assert-plus": "1.0.0", + "bcrypt-pbkdf": "1.0.1", + "dashdash": "1.14.1", + "ecc-jsbn": "0.1.1", + "getpass": "0.1.7", + "jsbn": "0.1.1", + "tweetnacl": "0.14.5" + } + }, + "stream-browserify": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/stream-browserify/-/stream-browserify-2.0.1.tgz", + "integrity": "sha1-ZiZu5fm9uZQKTkUUyvtDu3Hlyds=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.5" + } + }, + "stream-combiner2": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/stream-combiner2/-/stream-combiner2-1.1.1.tgz", + "integrity": "sha1-+02KFCDqNidk4hrUeAOXvry0HL4=", + "requires": { + "duplexer2": "0.1.4", + "readable-stream": "2.3.5" + } + }, + "stream-http": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/stream-http/-/stream-http-2.8.1.tgz", + "integrity": "sha512-cQ0jo17BLca2r0GfRdZKYAGLU6JRoIWxqSOakUMuKOT6MOK7AAlE856L33QuDmAy/eeOrhLee3dZKX0Uadu93A==", + "requires": { + "builtin-status-codes": "3.0.0", + "inherits": "2.0.3", + "readable-stream": "2.3.5", + "to-arraybuffer": "1.0.1", + "xtend": "4.0.1" + } + }, + "stream-splicer": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/stream-splicer/-/stream-splicer-2.0.0.tgz", + "integrity": "sha1-G2O+Q4oTPktnHMGTUZdgAXWRDYM=", + "requires": { + "inherits": "2.0.3", + "readable-stream": "2.3.5" + } + }, + "string.prototype.trim": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.1.2.tgz", + "integrity": "sha1-0E3iyJ4Tf019IG8Ia17S+ua+jOo=", + "requires": { + "define-properties": "1.1.2", + "es-abstract": "1.10.0", + "function-bind": "1.1.1" + } + }, + "string_decoder": { + "version": "0.10.31", + "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz", + "integrity": "sha1-YuIDvEF2bGwoyfyEMB2rHFMQ+pQ=" + }, + "stringstream": { + "version": "0.0.5", + "resolved": "https://registry.npmjs.org/stringstream/-/stringstream-0.0.5.tgz", + "integrity": "sha1-TkhM1N5aC7vuGORjB3EKioFiGHg=", + "optional": true + }, + "subarg": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/subarg/-/subarg-1.0.0.tgz", + "integrity": "sha1-9izxdYHplrSPyWVpn1TAauJouNI=", + "requires": { + "minimist": "1.2.0" + } + }, + "symbol-tree": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.2.tgz", + "integrity": "sha1-rifbOPZgp64uHDt9G8KQgZuFGeY=", + "optional": true + }, + "syntax-error": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/syntax-error/-/syntax-error-1.4.0.tgz", + "integrity": "sha512-YPPlu67mdnHGTup2A8ff7BC2Pjq0e0Yp/IyTFN03zWO0RcK07uLcbi7C2KpGR2FvWbaB0+bfE27a+sBKebSo7w==", + "requires": { + "acorn-node": "1.3.0" + } + }, + "tap-parser": { + "version": "2.2.3", + "resolved": "https://registry.npmjs.org/tap-parser/-/tap-parser-2.2.3.tgz", + "integrity": "sha1-rebpbje/04zg8WLaBn80A08GiwE=", + "requires": { + "events-to-array": "1.1.2", + "js-yaml": "3.11.0", + "readable-stream": "2.3.5" + } + }, + "tape": { + "version": "4.9.0", + "resolved": "https://registry.npmjs.org/tape/-/tape-4.9.0.tgz", + "integrity": "sha512-j0jO9BiScfqtPBb9QmPLL0qvxXMz98xjkMb7x8lKipFlJZwNJkqkWPou+NU4V6T9RnVh1kuSthLE8gLrN8bBfw==", + "requires": { + "deep-equal": "1.0.1", + "defined": "1.0.0", + "for-each": "0.3.2", + "function-bind": "1.1.1", + "glob": "7.1.2", + "has": "1.0.1", + "inherits": "2.0.3", + "minimist": "1.2.0", + "object-inspect": "1.5.0", + "resolve": "1.5.0", + "resumer": "0.0.0", + "string.prototype.trim": "1.1.2", + "through": "2.3.8" + } + }, + "through": { + "version": "2.3.8", + "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz", + "integrity": "sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=" + }, + "through2": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/through2/-/through2-2.0.3.tgz", + "integrity": "sha1-AARWmzfHx0ujnEPzzteNGtlBQL4=", + "requires": { + "readable-stream": "2.3.5", + "xtend": "4.0.1" + } + }, + "timers-browserify": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/timers-browserify/-/timers-browserify-1.4.2.tgz", + "integrity": "sha1-ycWLV1voQHN1y14kYtrO50NZ9B0=", + "requires": { + "process": "0.11.10" + } + }, + "to-arraybuffer": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/to-arraybuffer/-/to-arraybuffer-1.0.1.tgz", + "integrity": "sha1-fSKbH8xjfkZsoIEYCDanqr/4P0M=" + }, + "tough-cookie": { + "version": "2.3.4", + "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-2.3.4.tgz", + "integrity": "sha512-TZ6TTfI5NtZnuyy/Kecv+CnoROnyXn2DN97LontgQpCwsX2XyLYCC0ENhYkehSOwAp8rTQKc/NUIF7BkQ5rKLA==", + "requires": { + "punycode": "1.4.1" + } + }, + "tr46": { + "version": "0.0.3", + "resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz", + "integrity": "sha1-gYT9NH2snNwYWZLzpmIuFLnZq2o=", + "optional": true + }, + "trim": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/trim/-/trim-0.0.1.tgz", + "integrity": "sha1-WFhUf2spB1fulczMZm+1AITEYN0=" + }, + "tty-browserify": { + "version": "0.0.1", + "resolved": "https://registry.npmjs.org/tty-browserify/-/tty-browserify-0.0.1.tgz", + "integrity": "sha512-C3TaO7K81YvjCgQH9Q1S3R3P3BtN3RIM8n+OvX4il1K1zgE8ZhI0op7kClgkxtutIE8hQrcrHBXvIheqKUUCxw==" + }, + "tunnel-agent": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/tunnel-agent/-/tunnel-agent-0.6.0.tgz", + "integrity": "sha1-J6XeoGs2sEoKmWZ3SykIaPD8QP0=", + "optional": true, + "requires": { + "safe-buffer": "5.1.1" + } + }, + "tweetnacl": { + "version": "0.14.5", + "resolved": "https://registry.npmjs.org/tweetnacl/-/tweetnacl-0.14.5.tgz", + "integrity": "sha1-WuaBd/GS1EViadEIr6k/+HQ/T2Q=", + "optional": true + }, + "type-check": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/type-check/-/type-check-0.3.2.tgz", + "integrity": "sha1-WITKtRLPHTVeP7eE8wgEsrUg23I=", + "requires": { + "prelude-ls": "1.1.2" + } + }, + "typedarray": { + "version": "0.0.6", + "resolved": "https://registry.npmjs.org/typedarray/-/typedarray-0.0.6.tgz", + "integrity": "sha1-hnrHTjhkGHsdPUfZlqeOxciDB3c=" + }, + "umd": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/umd/-/umd-3.0.3.tgz", + "integrity": "sha512-4IcGSufhFshvLNcMCV80UnQVlZ5pMOC8mvNPForqwA4+lzYQuetTESLDQkeLmihq8bRcnpbQa48Wb8Lh16/xow==" + }, + "url": { + "version": "0.11.0", + "resolved": "https://registry.npmjs.org/url/-/url-0.11.0.tgz", + "integrity": "sha1-ODjpfPxgUh63PFJajlW/3Z4uKPE=", + "requires": { + "punycode": "1.3.2", + "querystring": "0.2.0" + }, + "dependencies": { + "punycode": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.3.2.tgz", + "integrity": "sha1-llOgNvt8HuQjQvIyXM7v6jkmxI0=" + } + } + }, + "url-join": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/url-join/-/url-join-2.0.5.tgz", + "integrity": "sha1-WvIvGMBSoACkjXuCxenC4v7tpyg=" + }, + "userhome": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/userhome/-/userhome-1.0.0.tgz", + "integrity": "sha1-tkkf8S0hpecmcd+czIcX4cZojAs=" + }, + "util": { + "version": "0.10.3", + "resolved": "https://registry.npmjs.org/util/-/util-0.10.3.tgz", + "integrity": "sha1-evsa/lCAUkZInj23/g7TeTNqwPk=", + "requires": { + "inherits": "2.0.1" + }, + "dependencies": { + "inherits": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz", + "integrity": "sha1-sX0I0ya0Qj5Wjv9xn5GwscvfafE=" + } + } + }, + "util-deprecate": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz", + "integrity": "sha1-RQ1Nyfpw3nMnYvvS1KKJgUGaDM8=" + }, + "uuid": { + "version": "3.2.1", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-3.2.1.tgz", + "integrity": "sha512-jZnMwlb9Iku/O3smGWvZhauCf6cvvpKi4BKRiliS3cxnI+Gz9j5MEpTz2UFuXiKPJocb7gnsLHwiS05ige5BEA==", + "optional": true + }, + "verror": { + "version": "1.10.0", + "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.0.tgz", + "integrity": "sha1-OhBcoXBTr1XW4nDB+CiGguGNpAA=", + "optional": true, + "requires": { + "assert-plus": "1.0.0", + "core-util-is": "1.0.2", + "extsprintf": "1.3.0" + } + }, + "vm-browserify": { + "version": "0.0.4", + "resolved": "https://registry.npmjs.org/vm-browserify/-/vm-browserify-0.0.4.tgz", + "integrity": "sha1-XX6kW7755Kb/ZflUOOCofDV9WnM=", + "requires": { + "indexof": "0.0.1" + } + }, + "webidl-conversions": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-2.0.1.tgz", + "integrity": "sha1-O/glj30xjHRDw28uFpQCoaZwNQY=", + "optional": true + }, + "whatwg-url-compat": { + "version": "0.6.5", + "resolved": "https://registry.npmjs.org/whatwg-url-compat/-/whatwg-url-compat-0.6.5.tgz", + "integrity": "sha1-AImBEa9om7CXVBzVpFymyHmERb8=", + "optional": true, + "requires": { + "tr46": "0.0.3" + } + }, + "which": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/which/-/which-1.3.0.tgz", + "integrity": "sha512-xcJpopdamTuY5duC/KnTTNBraPK54YwpenP4lzxU8H91GudWpFv38u0CKjclE1Wi2EH2EDz5LRcHcKbCIzqGyg==", + "requires": { + "isexe": "2.0.0" + } + }, + "wordwrap": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/wordwrap/-/wordwrap-1.0.0.tgz", + "integrity": "sha1-J1hIEIkUVqQXHI0CJkQa3pDLyus=", + "optional": true + }, + "wrappy": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz", + "integrity": "sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=" + }, + "xhr": { + "version": "2.4.1", + "resolved": "https://registry.npmjs.org/xhr/-/xhr-2.4.1.tgz", + "integrity": "sha512-pAIU5vBr9Hiy5cpFIbPnwf0C18ZF86DBsZKrlsf87N5De/JbA6RJ83UP/cv+aljl4S40iRVMqP4pr4sF9Dnj0A==", + "requires": { + "global": "4.3.2", + "is-function": "1.0.1", + "parse-headers": "2.0.1", + "xtend": "4.0.1" + } + }, + "xml-name-validator": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-2.0.1.tgz", + "integrity": "sha1-TYuPHszTQZqjYgYb7O9RXh5VljU=", + "optional": true + }, + "xtend": { + "version": "4.0.1", + "resolved": "https://registry.npmjs.org/xtend/-/xtend-4.0.1.tgz", + "integrity": "sha1-pcbVMr5lbiPbgg77lDofBJmNY68=" + } + } +} diff --git a/plotly/tests/test_optional/test_matplotlylib/data/annotations.py b/plotly/tests/test_optional/test_matplotlylib/data/annotations.py index a89a0c15cf..3103274c21 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/annotations.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/annotations.py @@ -1,42 +1,41 @@ from __future__ import absolute_import -from plotly.graph_objs import (Annotation, Annotations, Data, Figure, Font, - Layout, Line, Margin, Scatter, XAxis, YAxis) +import plotly.graph_objs as go -ANNOTATIONS = Figure( - data=Data([ - Scatter( +ANNOTATIONS = go.Figure( + data=[ + go.Scatter( x=[0.0, 1.0, 2.0], y=[1.0, 2.0, 3.0], name='_line0', mode='lines', - line=Line( + line=go.scatter.Line( dash='solid', color='rgba (0, 0, 255, 1)', - width=1.0 + width=1.5 ), xaxis='x1', yaxis='y1' ), - Scatter( + go.Scatter( x=[0.0, 1.0, 2.0], y=[3.0, 2.0, 1.0], name='_line1', mode='lines', - line=Line( + line=go.scatter.Line( dash='solid', color='rgba (0, 0, 255, 1)', - width=1.0 + width=1.5 ), xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, b=47, @@ -45,73 +44,73 @@ ), hovermode='closest', showlegend=False, - annotations=Annotations([ - Annotation( + annotations=[ + go.layout.Annotation( x=0.000997987927565, - y=0.996414507772, + y=0.9973865229110511, text='top-left', xref='paper', yref='paper', showarrow=False, align='left', - font=Font( - size=12.0, + font=dict( + size=10.0, color='#000000' ), opacity=1, xanchor='left', yanchor='top' ), - Annotation( + go.layout.Annotation( x=0.000997987927565, - y=0.00358549222798, + y=0.0031525606469002573, text='bottom-left', xref='paper', yref='paper', align='left', showarrow=False, - font=Font( - size=12.0, + font=dict( + size=10.0, color='#000000' ), opacity=1, xanchor='left', yanchor='bottom' ), - Annotation( + go.layout.Annotation( x=0.996989939638, - y=0.996414507772, + y=0.9973865229110511, text='top-right', xref='paper', yref='paper', align='right', showarrow=False, - font=Font( - size=12.0, + font=dict( + size=10.0, color='#000000' ), opacity=1, xanchor='right', yanchor='top' ), - Annotation( + go.layout.Annotation( x=0.996989939638, - y=0.00358549222798, + y=0.0031525606469002573, text='bottom-right', xref='paper', yref='paper', align='right', showarrow=False, - font=Font( - size=12.0, + font=dict( + size=10.0, color='#000000' ), opacity=1, xanchor='right', yanchor='bottom' ) - ]), - xaxis1=XAxis( + ], + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], range=(0.0, 2.0), showline=True, @@ -121,7 +120,7 @@ anchor='y1', mirror=True ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], range=(1.0, 3.0), showline=True, diff --git a/plotly/tests/test_optional/test_matplotlylib/data/axis_scales.py b/plotly/tests/test_optional/test_matplotlylib/data/axis_scales.py index 3f51bd8de7..ba113d85d8 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/axis_scales.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/axis_scales.py @@ -1,72 +1,68 @@ from __future__ import absolute_import -from plotly.graph_objs import (Data, Figure, Font, Layout, Line, Margin, - Scatter, XAxis, YAxis) +import plotly.graph_objs as go D = dict( x=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], y=[10, 3, 100, 6, 45, 4, 80, 45, 3, 59]) -EVEN_LINEAR_SCALE = Figure( - data=Data([ - Scatter( + +EVEN_LINEAR_SCALE = go.Figure( + data=[ + go.Scatter( x=[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], y=[10.0, 3.0, 100.0, 6.0, 45.0, 4.0, 80.0, 45.0, 3.0, 59.0], name='_line0', mode='lines', - line=Line( + line=go.scatter.Line( dash='solid', - color='rgba (0, 0, 255, 1)', - width=1.0 + color='rgba (31, 119, 180, 1)', + width=1.5 ), xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], range=[0.0, 18.0], type='linear', showline=True, - tick0=0, - dtick=3, + nticks=10, ticks='inside', showgrid=False, - tickmode=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 195.0], + range=[-1.8500000000000005, 195.0], type='linear', showline=True, - tick0=0, - dtick=13, + nticks=10, ticks='inside', showgrid=False, - tickmode=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', diff --git a/plotly/tests/test_optional/test_matplotlylib/data/bars.py b/plotly/tests/test_optional/test_matplotlylib/data/bars.py index 57856ed4bc..5a6c2cdfd0 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/bars.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/bars.py @@ -1,7 +1,6 @@ from __future__ import absolute_import -from plotly.graph_objs import (Bar, Data, Figure, Font, Margin, Marker, Layout, - Line, XAxis, YAxis) +import plotly.graph_objs as go D = dict( left=[0, 1, 2, 3, 4, 5], @@ -14,64 +13,64 @@ multi_width=[30, 60, 20, 50, 60, 30] ) -VERTICAL_BAR = Figure( - data=Data([ - Bar( - x=[0.40000000000000002, 1.3999999999999999, 2.3999999999999999, 3.3999999999999999, 4.4000000000000004, 5.4000000000000004], +VERTICAL_BAR = go.Figure( + data=[ + go.Bar( + x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], y=[10.0, 20.0, 50.0, 80.0, 100.0, 200.0], orientation='v', - marker=Marker( - line=Line( + marker=go.bar.Marker( + line=dict( width=1.0 ), - color='#0000FF' + color='#1F77B4' ), opacity=1, xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, bargap=0.2, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 6.0], + range=[-0.68999999999999995, 5.6899999999999995], type='linear', showline=True, ticks='inside', - nticks=7, + nticks=8, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 200.0], + range=[0.0, 210.0], type='linear', showline=True, ticks='inside', - nticks=5, + nticks=10, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', @@ -80,64 +79,64 @@ ) ) -HORIZONTAL_BAR = Figure( - data=Data([ - Bar( +HORIZONTAL_BAR = go.Figure( + data=[ + go.Bar( x=[1.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0], - y=[0.40000000000000002, 1.3999999999999999, 2.3999999999999999, 3.3999999999999999, 4.4000000000000004, 5.4000000000000004, 6.4000000000000004], + y=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], orientation='h', - marker=Marker( - line=Line( + marker=go.bar.Marker( + line=dict( width=1.0 ), - color='#0000FF' + color='#1F77B4' ), opacity=1, xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - bargap=0.2, - xaxis1=XAxis( + bargap=0.19999999999999996, + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 140.0], + range=[0.0, 134.40000000000001], type='linear', showline=True, ticks='inside', nticks=8, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 7.0], + range=[-0.73999999999999999, 6.7399999999999993], type='linear', showline=True, ticks='inside', - nticks=8, + nticks=9, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', @@ -146,14 +145,14 @@ ) ) -H_AND_V_BARS = Figure( - data=Data([ - Bar( - x=[5.0, 15.0, 25.0, 35.0, 45.0, 55.0], +H_AND_V_BARS = go.Figure( + data=[ + go.Bar( + x=[0.0, 10.0, 20.0, 30.0, 40.0, 50.0], y=[1.0, 4.0, 8.0, 16.0, 32.0, 64.0], orientation='v', - marker=Marker( - line=Line( + marker=go.bar.Marker( + line=dict( width=1.0 ), color='#008000' @@ -162,12 +161,12 @@ xaxis='x1', yaxis='y1' ), - Bar( + go.Bar( x=[30.0, 60.0, 20.0, 50.0, 60.0, 30.0], - y=[20.0, 35.0, 50.0, 65.0, 80.0, 95.0], + y=[15.0, 30.0, 45.0, 60.0, 75.0, 90.0], orientation='h', - marker=Marker( - line=Line( + marker=go.bar.Marker( + line=dict( width=1.0 ), color='#FF0000' @@ -176,48 +175,48 @@ xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - bargap=5, - xaxis1=XAxis( + bargap=1, + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 60.0], + range=[-8.25, 63.25], type='linear', showline=True, ticks='inside', - nticks=7, + nticks=9, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 100.0], + range=[0.0, 101.84999999999999], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=7, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', diff --git a/plotly/tests/test_optional/test_matplotlylib/data/lines.py b/plotly/tests/test_optional/test_matplotlylib/data/lines.py index f4492bf91f..4441554d1c 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/lines.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/lines.py @@ -1,7 +1,6 @@ from __future__ import absolute_import -from plotly.graph_objs import (Data, Figure, Font, Layout, Line, Margin, - Marker, Scatter, XAxis, YAxis) +import plotly.graph_objs as go D = dict( x1=[0, 1, 2, 3, 4, 5], @@ -10,62 +9,62 @@ y2=[1, 4, 8, 16, 32, 64, 128] ) -SIMPLE_LINE = Figure( - data=Data([ - Scatter( +SIMPLE_LINE = go.Figure( + data=[ + go.Scatter( x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], y=[10.0, 20.0, 50.0, 80.0, 100.0, 200.0], name='simple', mode='lines', - line=Line( + line=go.scatter.Line( dash='solid', - color='rgba (0, 0, 255, 1)', - width=1.0 + color='rgba (31, 119, 180, 1)', + width=1.5 ), xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 5.0], + range=[-0.25, 5.25], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=8, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 200.0], + range=[0.5, 209.5], type='linear', showline=True, ticks='inside', - nticks=5, + nticks=10, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', @@ -74,18 +73,18 @@ ) ) -COMPLICATED_LINE = Figure( - data=Data([ - Scatter( +COMPLICATED_LINE = go.Figure( + data=[ + go.Scatter( x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], y=[10.0, 20.0, 50.0, 80.0, 100.0, 200.0], name='one', mode='markers', - marker=Marker( - symbol='dot', - line=Line( - color='#000000', - width=0.5 + marker=go.scatter.Marker( + symbol='circle', + line=dict( + color='#FF0000', + width=1.0 ), size=10, color='#FF0000', @@ -94,12 +93,12 @@ xaxis='x1', yaxis='y1' ), - Scatter( + go.Scatter( x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0], y=[10.0, 20.0, 50.0, 80.0, 100.0, 200.0], name='two', mode='lines', - line=Line( + line=dict( dash='solid', color='rgba (0, 0, 255, 0.7)', width=2 @@ -107,14 +106,14 @@ xaxis='x1', yaxis='y1' ), - Scatter( + go.Scatter( x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], y=[1.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0], name='three', mode='markers', - marker=Marker( + marker=go.scatter.Marker( symbol='cross', - line=Line( + line=dict( color='#0000FF', width=2 ), @@ -125,12 +124,12 @@ xaxis='x1', yaxis='y1' ), - Scatter( + go.Scatter( x=[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0], y=[1.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0], name='four', mode='lines', - line=Line( + line=go.scatter.Line( dash='dash', color='rgba (255, 0, 0, 0.8)', width=2 @@ -138,51 +137,51 @@ xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 6.0], + range=[-0.30000000000000004, 6.2999999999999998], type='linear', showline=True, ticks='inside', - nticks=7, + nticks=9, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[0.0, 200.0], + range=[-8.9500000000000011, 209.94999999999999], type='linear', showline=True, ticks='inside', - nticks=5, + nticks=11, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', mirror='ticks' ) ) -) +) \ No newline at end of file diff --git a/plotly/tests/test_optional/test_matplotlylib/data/scatter.py b/plotly/tests/test_optional/test_matplotlylib/data/scatter.py index 28106aabd3..17cbcb4514 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/scatter.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/scatter.py @@ -1,75 +1,74 @@ from __future__ import absolute_import -from plotly.graph_objs import (Data, Figure, Font, Layout, Line, Margin, - Marker, Scatter, XAxis, YAxis) +import plotly.graph_objs as go D = dict( - x1=[1, 2, 2, 4, 5, 6, 1, 7, 8, 5 ,3], + x1=[1, 2, 2, 4, 5, 6, 1, 7, 8, 5, 3], y1=[5, 3, 7, 2, 9, 7, 8, 4, 5, 9, 2], x2=[-1, 1, -0.3, -0.6, 0.4, 0.8, -0.1, 0.7], y2=[-0.5, 0.4, 0.7, -0.6, 0.3, -1, 0, 0.3] ) -SIMPLE_SCATTER = Figure( - data=Data([ - Scatter( + +SIMPLE_SCATTER = go.Figure( + data=[ + go.Scatter( x=[1.0, 2.0, 2.0, 4.0, 5.0, 6.0, 1.0, 7.0, 8.0, 5.0, 3.0], y=[5.0, 3.0, 7.0, 2.0, 9.0, 7.0, 8.0, 4.0, 5.0, 9.0, 2.0], mode='markers', - marker=Marker( - symbol='dot', - line=Line( - color='rgba(0,0,0,1.0)', + marker=go.scatter.Marker( + symbol='circle', + line=dict( + color='rgba(31,119,180,1.0)', width=1.0 ), - size=4.4721359549995796, - color='rgba(0,0,255,1.0)', - opacity=1.0 + size=6.0, + color='rgba(31,119,180,1.0)', ), xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[0.0, 9.0], + range=[0.64334677419354847, 8.3566532258064505], type='linear', showline=True, ticks='inside', nticks=10, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[1.0, 10.0], + range=[1.6410714285714287, 9.3589285714285726], type='linear', showline=True, ticks='inside', nticks=10, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', @@ -78,87 +77,81 @@ ) ) -DOUBLE_SCATTER = Figure( - data=Data([ - Scatter( +DOUBLE_SCATTER = go.Figure( + data=[ + go.Scatter( x=[1.0, 2.0, 2.0, 4.0, 5.0, 6.0, 1.0, 7.0, 8.0, 5.0, 3.0], y=[5.0, 3.0, 7.0, 2.0, 9.0, 7.0, 8.0, 4.0, 5.0, 9.0, 2.0], mode='markers', - marker=Marker( + marker=go.scatter.Marker( symbol='triangle-up', - line=Line( + line=dict( color='rgba(255,0,0,0.5)', width=1.0 ), size=11.0, color='rgba(255,0,0,0.5)', - opacity=0.5 ), xaxis='x1', yaxis='y1' ), - Scatter( - x=[-1.0, 1.0, -0.29999999999999999, -0.59999999999999998, - 0.40000000000000002, 0.80000000000000004, -0.10000000000000001, - 0.69999999999999996], - y=[-0.5, 0.40000000000000002, 0.69999999999999996, - -0.59999999999999998, 0.29999999999999999, -1.0, 0.0, - 0.29999999999999999], + go.Scatter( + x=[-1.0, 1.0, -0.3, -0.6, 0.4, 0.8, -0.1, 0.7], + y=[-0.5, 0.4, 0.7, -0.6, 0.3, -1.0, 0.0, 0.3], mode='markers', - marker=Marker( + marker=go.scatter.Marker( symbol='square', - line=Line( + line=dict( color='rgba(128,0,128,0.5)', width=1.0 ), size=8.0, color='rgba(128,0,128,0.5)', - opacity=0.5 ), xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=80, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 1.0], - range=[-2.0, 10.0], + range=[-1.5159626203173777, 8.4647578206295506], type='linear', showline=True, ticks='inside', nticks=7, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - yaxis1=YAxis( + yaxis1=go.layout.YAxis( domain=[0.0, 1.0], - range=[-2.0, 10.0], + range=[-1.588616071428572, 9.5198093820861693], type='linear', showline=True, ticks='inside', nticks=7, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', diff --git a/plotly/tests/test_optional/test_matplotlylib/data/subplots.py b/plotly/tests/test_optional/test_matplotlylib/data/subplots.py index fd8adc8e8d..b2a981eb4a 100644 --- a/plotly/tests/test_optional/test_matplotlylib/data/subplots.py +++ b/plotly/tests/test_optional/test_matplotlylib/data/subplots.py @@ -1,21 +1,20 @@ from __future__ import absolute_import -from plotly.graph_objs import (Data, Figure, Font, Layout, Line, Margin, - Scatter, XAxis, YAxis) +import plotly.graph_objs as go D = dict( x1=[0, 1], y1=[1, 2] ) -BLANK_SUBPLOTS = Figure( - data=Data([ - Scatter( +BLANK_SUBPLOTS = go.Figure( + data=[ + go.Scatter( x=[0.0, 1.0], y=[1.0, 2.0], name='_line0', mode='lines', - line=Line( + line=go.scatter.Line( dash='solid', color='#0000FF', width=1.0 @@ -23,69 +22,69 @@ xaxis='x1', yaxis='y1' ) - ]), - layout=Layout( + ], + layout=go.Layout( width=640, height=480, autosize=False, - margin=Margin( + margin=go.layout.Margin( l=168, r=63, - b=47, - t=47, + b=52, + t=57, pad=0 ), hovermode='closest', showlegend=False, - xaxis1=XAxis( + xaxis1=go.layout.XAxis( domain=[0.0, 0.13513513513513517], - range=[0.0, 1.0], + range=[-0.050000000000000003, 1.05], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=4, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y1', side='bottom', mirror='ticks' ), - xaxis2=XAxis( + xaxis2=go.layout.XAxis( domain=[0.0, 0.13513513513513517], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=2, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y2', side='bottom', mirror='ticks' ), - xaxis3=XAxis( + xaxis3=go.layout.XAxis( domain=[0.0, 0.13513513513513517], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=2, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y3', side='bottom', mirror='ticks' ), - xaxis4=XAxis( + xaxis4=go.layout.XAxis( domain=[0.2162162162162162, 1.0], range=[0.0, 1.0], type='linear', @@ -94,30 +93,30 @@ nticks=6, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y4', side='bottom', mirror='ticks' ), - xaxis5=XAxis( + xaxis5=go.layout.XAxis( domain=[0.2162162162162162, 0.56756756756756754], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y5', side='bottom', mirror='ticks' ), - xaxis6=XAxis( + xaxis6=go.layout.XAxis( domain=[0.2162162162162162, 0.78378378378378377], range=[0.0, 1.0], type='linear', @@ -126,79 +125,79 @@ nticks=6, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y6', side='bottom', mirror='ticks' ), - xaxis7=XAxis( + xaxis7=go.layout.XAxis( domain=[0.64864864864864857, 1.0], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y7', side='bottom', mirror='ticks' ), - xaxis8=XAxis( + xaxis8=go.layout.XAxis( domain=[0.8648648648648648, 1.0], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=2, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='y8', side='bottom', mirror='ticks' ), - yaxis1=YAxis( - domain=[0.82758620689655182, 1.0], - range=[1.0, 2.2000000000000002], + yaxis1=go.layout.YAxis( + domain=[0.82758620689655171, 1.0], + range=[0.94999999999999996, 2.0499999999999998], type='linear', showline=True, ticks='inside', - nticks=8, + nticks=4, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x1', side='left', mirror='ticks' ), - yaxis2=YAxis( - domain=[0.55172413793103459, 0.72413793103448276], + yaxis2=go.layout.YAxis( + domain=[0.55172413793103448, 0.72413793103448265], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x2', side='left', mirror='ticks' ), - yaxis3=YAxis( - domain=[0.0, 0.44827586206896558], + yaxis3=go.layout.YAxis( + domain=[0.0, 0.44827586206896547], range=[0.0, 1.0], type='linear', showline=True, @@ -206,31 +205,31 @@ nticks=6, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x3', side='left', mirror='ticks' ), - yaxis4=YAxis( - domain=[0.82758620689655182, 1.0], + yaxis4=go.layout.YAxis( + domain=[0.82758620689655171, 1.0], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x4', side='left', mirror='ticks' ), - yaxis5=YAxis( - domain=[0.27586206896551724, 0.72413793103448276], + yaxis5=go.layout.YAxis( + domain=[0.27586206896551713, 0.72413793103448265], range=[0.0, 1.0], type='linear', showline=True, @@ -238,31 +237,31 @@ nticks=6, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x5', side='left', mirror='ticks' ), - yaxis6=YAxis( - domain=[0.0, 0.17241379310344834], + yaxis6=go.layout.YAxis( + domain=[0.0, 0.17241379310344826], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x6', side='left', mirror='ticks' ), - yaxis7=YAxis( - domain=[0.27586206896551724, 0.72413793103448276], + yaxis7=go.layout.YAxis( + domain=[0.27586206896551713, 0.72413793103448265], range=[0.0, 1.0], type='linear', showline=True, @@ -270,24 +269,24 @@ nticks=6, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x7', side='left', mirror='ticks' ), - yaxis8=YAxis( - domain=[0.0, 0.17241379310344834], + yaxis8=go.layout.YAxis( + domain=[0.0, 0.17241379310344826], range=[0.0, 1.0], type='linear', showline=True, ticks='inside', - nticks=6, + nticks=3, showgrid=False, zeroline=False, - tickfont=Font( - size=12.0 + tickfont=dict( + size=10.0 ), anchor='x8', side='left', diff --git a/plotly/tests/test_optional/test_matplotlylib/test_annotations.py b/plotly/tests/test_optional/test_matplotlylib/test_annotations.py index b0e238416b..4f399211c2 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_annotations.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_annotations.py @@ -12,7 +12,7 @@ matplotlib.use('Agg') import matplotlib.pyplot as plt - from plotly.tests.utils import compare_dict + from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.annotations import * @@ -32,8 +32,8 @@ def test_annotations(): 'bottom-right', transform=ax.transAxes, va='baseline', ha='right') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - ANNOTATIONS['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, ANNOTATIONS['data'][data_no], ignore=['uid']) + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg for no, note in enumerate(renderer.plotly_fig['layout']['annotations']): equivalent, msg = compare_dict(note, diff --git a/plotly/tests/test_optional/test_matplotlylib/test_axis_scales.py b/plotly/tests/test_optional/test_matplotlylib/test_axis_scales.py index 2b62f28cea..97b4df83c0 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_axis_scales.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_axis_scales.py @@ -3,7 +3,7 @@ from nose.plugins.attrib import attr from plotly import optional_imports -from plotly.tests.utils import compare_dict +from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.axis_scales import * @@ -22,13 +22,18 @@ def test_even_linear_scale(): x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] y = [10, 3, 100, 6, 45, 4, 80, 45, 3, 59] ax.plot(x, y) - _ = ax.set_xticks(list(range(0, 20, 3))) - _ = ax.set_yticks(list(range(0, 200, 13))) + _ = ax.set_xticks(list(range(0, 20, 3)), True) + _ = ax.set_yticks(list(range(0, 200, 13)), True) renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - EVEN_LINEAR_SCALE['data'][data_no]) + # equivalent, msg = compare_dict(data_dict.to_plotly_json(), + # EVEN_LINEAR_SCALE['data'][data_no].to_plotly_json()) + # assert equivalent, msg + d1, d2 = strip_dict_params(data_dict, EVEN_LINEAR_SCALE['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], EVEN_LINEAR_SCALE['layout']) assert equivalent, msg diff --git a/plotly/tests/test_optional/test_matplotlylib/test_bars.py b/plotly/tests/test_optional/test_matplotlylib/test_bars.py index c89bfb3a8f..2348eaab55 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_bars.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_bars.py @@ -3,7 +3,7 @@ from nose.plugins.attrib import attr from plotly import optional_imports -from plotly.tests.utils import compare_dict +from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.bars import * @@ -21,10 +21,13 @@ def test_vertical_bar(): fig, ax = plt.subplots() ax.bar(left=D['left'], height=D['height']) renderer = run_fig(fig) + for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - VERTICAL_BAR['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, VERTICAL_BAR['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], VERTICAL_BAR['layout']) assert equivalent, msg @@ -35,10 +38,13 @@ def test_horizontal_bar(): fig, ax = plt.subplots() ax.barh(bottom=D['bottom'], width=D['width']) renderer = run_fig(fig) + for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - HORIZONTAL_BAR['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, HORIZONTAL_BAR['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], HORIZONTAL_BAR['layout']) assert equivalent, msg @@ -49,13 +55,16 @@ def test_h_and_v_bars(): fig, ax = plt.subplots() ax.bar(left=D['multi_left'], height=D['multi_height'], width=10, color='green', alpha=.5) + # changing height 10 -> 14 because ValueError if bargap not in [0, 1] ax.barh(bottom=D['multi_bottom'], width=D['multi_width'], - height=10, color='red', alpha=.5) + height=14, color='red', alpha=.5) renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - H_AND_V_BARS['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, H_AND_V_BARS['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], H_AND_V_BARS['layout']) assert equivalent, msg diff --git a/plotly/tests/test_optional/test_matplotlylib/test_date_times.py b/plotly/tests/test_optional/test_matplotlylib/test_date_times.py index 5f1bf59aef..f3264fdc4e 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_date_times.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_date_times.py @@ -52,7 +52,7 @@ def test_normal_mpl_dates(self): self.assertEqual( fig.axes[0].lines[0].get_xydata()[0][0], 7.33776000e+05 ) - self.assertEqual(pfig['data'][0]['x'], date_strings) + self.assertEqual(tuple(pfig['data'][0]['x']), tuple(date_strings)) def test_pandas_time_series_date_formatter(self): ndays = 3 @@ -66,9 +66,9 @@ def test_pandas_time_series_date_formatter(self): fig = plt.gcf() pfig = tls.mpl_to_plotly(fig) - expected_x = ['2001-01-01 00:00:00', + expected_x = ('2001-01-01 00:00:00', '2001-01-02 00:00:00', - '2001-01-03 00:00:00'] + '2001-01-03 00:00:00') expected_x0 = 11323.0 # this is floating point days since epoch x0 = fig.axes[0].lines[0].get_xydata()[0][0] diff --git a/plotly/tests/test_optional/test_matplotlylib/test_lines.py b/plotly/tests/test_optional/test_matplotlylib/test_lines.py index b7355cccc2..59998e4d58 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_lines.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_lines.py @@ -3,7 +3,7 @@ from nose.plugins.attrib import attr from plotly import optional_imports -from plotly.tests.utils import compare_dict +from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.lines import * @@ -23,7 +23,9 @@ def test_simple_line(): ax.plot(D['x1'], D['y1'], label='simple') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, SIMPLE_LINE['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, SIMPLE_LINE['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg equivalent, msg = compare_dict(renderer.plotly_fig['layout'], SIMPLE_LINE['layout']) @@ -40,9 +42,11 @@ def test_complicated_line(): ax.plot(D['x2'], D['y2'], '--r', linewidth=2, alpha=.8, label='four') renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - COMPLICATED_LINE['data'][data_no]) + d1, d2 = strip_dict_params(data_dict, COMPLICATED_LINE['data'][data_no], ignore=['uid']) + + equivalent, msg = compare_dict(d1, d2) assert equivalent, msg + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], COMPLICATED_LINE['layout']) assert equivalent, msg diff --git a/plotly/tests/test_optional/test_matplotlylib/test_scatter.py b/plotly/tests/test_optional/test_matplotlylib/test_scatter.py index 80774c079e..c14efa4b8e 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_scatter.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_scatter.py @@ -3,7 +3,7 @@ from nose.plugins.attrib import attr from plotly import optional_imports -from plotly.tests.utils import compare_dict +from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.scatter import * @@ -23,9 +23,12 @@ def test_simple_scatter(): ax.scatter(D['x1'], D['y1']) renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - SIMPLE_SCATTER['data'][data_no]) - assert equivalent, msg + d1, d2 = strip_dict_params(data_dict, SIMPLE_SCATTER['data'][data_no], ignore=['uid']) + print(d1) + print('\n') + print(d2) + assert d1 == d2 + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], SIMPLE_SCATTER['layout']) assert equivalent, msg @@ -38,9 +41,12 @@ def test_double_scatter(): ax.scatter(D['x2'], D['y2'], color='purple', s=64, marker='s', alpha=0.5) renderer = run_fig(fig) for data_no, data_dict in enumerate(renderer.plotly_fig['data']): - equivalent, msg = compare_dict(data_dict, - DOUBLE_SCATTER['data'][data_no]) - assert equivalent, msg + d1, d2 = strip_dict_params(data_dict, DOUBLE_SCATTER['data'][data_no], ignore=['uid']) + print(d1) + print('\n') + print(d2) + assert d1 == d2 + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], DOUBLE_SCATTER['layout']) assert equivalent, msg diff --git a/plotly/tests/test_optional/test_matplotlylib/test_subplots.py b/plotly/tests/test_optional/test_matplotlylib/test_subplots.py index c30ae23bbf..029d863dee 100644 --- a/plotly/tests/test_optional/test_matplotlylib/test_subplots.py +++ b/plotly/tests/test_optional/test_matplotlylib/test_subplots.py @@ -3,7 +3,7 @@ from nose.plugins.attrib import attr from plotly import optional_imports -from plotly.tests.utils import compare_dict +from plotly.tests.utils import compare_dict, strip_dict_params from plotly.tests.test_optional.optional_utils import run_fig from plotly.tests.test_optional.test_matplotlylib.data.subplots import * @@ -33,6 +33,12 @@ def test_blank_subplots(): fig.add_subplot(gs[3, 5]) gs.update(hspace=.6, wspace=.6) renderer = run_fig(fig) + + for data_no, data_dict in enumerate(renderer.plotly_fig['data']): + d1, d2 = strip_dict_params(data_dict, BLANK_SUBPLOTS['data'][data_no], + ignore=['uid']) + equivalent, msg = compare_dict(d1, d2) + equivalent, msg = compare_dict(renderer.plotly_fig['layout'], BLANK_SUBPLOTS['layout']) assert equivalent, msg diff --git a/plotly/tests/test_optional/test_offline/test_offline.py b/plotly/tests/test_optional/test_offline/test_offline.py index ebb2f53805..7f01e4fe3c 100644 --- a/plotly/tests/test_optional/test_offline/test_offline.py +++ b/plotly/tests/test_optional/test_offline/test_offline.py @@ -40,16 +40,17 @@ def test_iplot_works_after_you_call_init_notebook_mode(self): plotly.offline.init_notebook_mode() plotly.offline.iplot([{}]) - @attr('matplotlib') - def test_iplot_mpl_works(self): - # Generate matplotlib plot for tests - fig = plt.figure() + if matplotlylib: + @attr('matplotlib') + def test_iplot_mpl_works(self): + # Generate matplotlib plot for tests + fig = plt.figure() - x = [10, 20, 30] - y = [100, 200, 300] - plt.plot(x, y, "o") + x = [10, 20, 30] + y = [100, 200, 300] + plt.plot(x, y) - plotly.offline.iplot_mpl(fig) + plotly.offline.iplot_mpl(fig) class PlotlyOfflineMPLTestCase(TestCase): @@ -63,27 +64,27 @@ def _read_html(self, file_url): with open(file_url.replace('file://', '').replace(' ', '')) as f: return f.read() - @attr('matplotlib') - def test_default_mpl_plot_generates_expected_html(self): - # Generate matplotlib plot for tests - fig = plt.figure() - - x = [10, 20, 30] - y = [100, 200, 300] - plt.plot(x, y, "o") - - figure = plotly.tools.mpl_to_plotly(fig) - data = figure['data'] - layout = figure['layout'] - data_json = _json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder) - layout_json = _json.dumps(layout, cls=plotly.utils.PlotlyJSONEncoder) - html = self._read_html(plotly.offline.plot_mpl(fig)) - - # just make sure a few of the parts are in here - # like PlotlyOfflineTestCase(TestCase) in test_core - self.assertTrue('Plotly.newPlot' in html) # plot command is in there - self.assertTrue(data_json in html) # data is in there - self.assertTrue(layout_json in html) # layout is in there too - self.assertTrue(PLOTLYJS in html) # and the source code - # and it's an doc - self.assertTrue(html.startswith('') and html.endswith('')) + if matplotlylib: + @attr('matplotlib') + def test_default_mpl_plot_generates_expected_html(self): + # Generate matplotlib plot for tests + fig = plt.figure() + + x = [10, 20, 30] + y = [100, 200, 300] + plt.plot(x, y) + + figure = plotly.tools.mpl_to_plotly(fig) + data = figure['data'] + layout = figure['layout'] + data_json = _json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder) + layout_json = _json.dumps(layout, cls=plotly.utils.PlotlyJSONEncoder) + html = self._read_html(plotly.offline.plot_mpl(fig)) + + # just make sure a few of the parts are in here + # like PlotlyOfflineTestCase(TestCase) in test_core + self.assertTrue(data_json.split('"uid":')[0] in html) # data is in there + self.assertTrue(layout_json in html) # layout is in there too + self.assertTrue(PLOTLYJS in html) # and the source code + # and it's an doc + self.assertTrue(html.startswith('') and html.endswith('')) diff --git a/plotly/tests/test_optional/test_plotly/test_plot_mpl.py b/plotly/tests/test_optional/test_plotly/test_plot_mpl.py index 876f7f4b9b..96082cbb82 100644 --- a/plotly/tests/test_optional/test_plotly/test_plot_mpl.py +++ b/plotly/tests/test_optional/test_plotly/test_plot_mpl.py @@ -30,14 +30,14 @@ def setUp(self): py.sign_in('PlotlyImageTest', '786r5mecv0', plotly_domain='https://plot.ly') - @raises(exceptions.PlotlyError) + @raises(exceptions.PlotlyGraphObjectError) def test_update_type_error(self): fig, ax = plt.subplots() ax.plot([1, 2, 3]) update = [] py.plot_mpl(fig, update=update, filename="nosetests", auto_open=False) - @raises(exceptions.PlotlyError) + @raises(KeyError) def test_update_validation_error(self): fig, ax = plt.subplots() ax.plot([1, 2, 3]) diff --git a/plotly/tests/test_optional/test_tools/test_figure_factory.py b/plotly/tests/test_optional/test_tools/test_figure_factory.py index 170920be19..0ad6ffc7fc 100644 --- a/plotly/tests/test_optional/test_tools/test_figure_factory.py +++ b/plotly/tests/test_optional/test_tools/test_figure_factory.py @@ -2,20 +2,21 @@ from unittest import TestCase import datetime -from nose.tools import raises -import plotly.tools as tls +import plotly.figure_factory as ff + from plotly.exceptions import PlotlyError +from plotly.tests.test_optional.optional_utils import NumpyTestUtilsMixin from plotly.graph_objs import graph_objs -class TestQuiver(TestCase): +class TestQuiver(TestCase, NumpyTestUtilsMixin): def test_unequal_xy_length(self): # check: PlotlyError if x and y are not the same length kwargs = {'x': [1, 2], 'y': [1], 'u': [1, 2], 'v': [1, 2]} - self.assertRaises(PlotlyError, tls.FigureFactory.create_quiver, + self.assertRaises(PlotlyError, ff.create_quiver, **kwargs) def test_wrong_scale(self): @@ -25,13 +26,13 @@ def test_wrong_scale(self): kwargs = {'x': [1, 2], 'y': [1, 2], 'u': [1, 2], 'v': [1, 2], 'scale': -1} - self.assertRaises(ValueError, tls.FigureFactory.create_quiver, + self.assertRaises(ValueError, ff.create_quiver, **kwargs) kwargs = {'x': [1, 2], 'y': [1, 2], 'u': [1, 2], 'v': [1, 2], 'scale': 0} - self.assertRaises(ValueError, tls.FigureFactory.create_quiver, + self.assertRaises(ValueError, ff.create_quiver, **kwargs) def test_wrong_arrow_scale(self): @@ -41,20 +42,20 @@ def test_wrong_arrow_scale(self): kwargs = {'x': [1, 2], 'y': [1, 2], 'u': [1, 2], 'v': [1, 2], 'arrow_scale': -1} - self.assertRaises(ValueError, tls.FigureFactory.create_quiver, + self.assertRaises(ValueError, ff.create_quiver, **kwargs) kwargs = {'x': [1, 2], 'y': [1, 2], 'u': [1, 2], 'v': [1, 2], 'arrow_scale': 0} - self.assertRaises(ValueError, tls.FigureFactory.create_quiver, + self.assertRaises(ValueError, ff.create_quiver, **kwargs) def test_one_arrow(self): # we should be able to create a single arrow using create_quiver - quiver = tls.FigureFactory.create_quiver(x=[1], y=[1], + quiver = ff.create_quiver(x=[1], y=[1], u=[1], v=[1], scale=1) expected_quiver = { @@ -65,23 +66,26 @@ def test_one_arrow(self): 'y': [1, 2, None, 1.615486170766527, 2, 1.820698256761928, None]}], 'layout': {'hovermode': 'closest'}} - self.assertEqual(quiver, expected_quiver) + self.assert_fig_equal(quiver['data'][0], + expected_quiver['data'][0]) + self.assert_fig_equal(quiver['layout'], + expected_quiver['layout']) def test_more_kwargs(self): # we should be able to create 2 arrows and change the arrow_scale, # angle, and arrow using create_quiver - quiver = tls.FigureFactory.create_quiver(x=[1, 2], - y=[1, 2], - u=[math.cos(1), - math.cos(2)], - v=[math.sin(1), - math.sin(2)], - arrow_scale=.4, - angle=math.pi / 6, - line=graph_objs.Line(color='purple', - width=3)) + quiver = ff.create_quiver(x=[1, 2], + y=[1, 2], + u=[math.cos(1), + math.cos(2)], + v=[math.sin(1), + math.sin(2)], + arrow_scale=.4, + angle=math.pi / 6, + line=graph_objs.scatter.Line(color='purple', + width=3)) expected_quiver = {'data': [{'line': {'color': 'purple', 'width': 3}, 'mode': 'lines', 'type': u'scatter', @@ -114,10 +118,13 @@ def test_more_kwargs(self): 2.051107819102551, None]}], 'layout': {'hovermode': 'closest'}} - self.assertEqual(quiver, expected_quiver) + self.assert_fig_equal(quiver['data'][0], + expected_quiver['data'][0]) + self.assert_fig_equal(quiver['layout'], + expected_quiver['layout']) -class TestFinanceCharts(TestCase): +class TestFinanceCharts(TestCase, NumpyTestUtilsMixin): def test_unequal_ohlc_length(self): @@ -127,27 +134,27 @@ def test_unequal_ohlc_length(self): kwargs = {'open': [1], 'high': [1, 3], 'low': [1, 2], 'close': [1, 2], 'direction': ['increasing']} - self.assertRaises(PlotlyError, tls.FigureFactory.create_ohlc, **kwargs) - self.assertRaises(PlotlyError, tls.FigureFactory.create_candlestick, + self.assertRaises(PlotlyError, ff.create_ohlc, **kwargs) + self.assertRaises(PlotlyError, ff.create_candlestick, **kwargs) kwargs = {'open': [1, 2], 'high': [1, 2, 3], 'low': [1, 2], 'close': [1, 2], 'direction': ['decreasing']} - self.assertRaises(PlotlyError, tls.FigureFactory.create_ohlc, **kwargs) - self.assertRaises(PlotlyError, tls.FigureFactory.create_candlestick, + self.assertRaises(PlotlyError, ff.create_ohlc, **kwargs) + self.assertRaises(PlotlyError, ff.create_candlestick, **kwargs) kwargs = {'open': [1, 2], 'high': [2, 3], 'low': [0], 'close': [1, 3]} - self.assertRaises(PlotlyError, tls.FigureFactory.create_ohlc, **kwargs) - self.assertRaises(PlotlyError, tls.FigureFactory.create_candlestick, + self.assertRaises(PlotlyError, ff.create_ohlc, **kwargs) + self.assertRaises(PlotlyError, ff.create_candlestick, **kwargs) kwargs = {'open': [1, 2], 'high': [2, 3], 'low': [1, 2], 'close': [1]} - self.assertRaises(PlotlyError, tls.FigureFactory.create_ohlc, **kwargs) - self.assertRaises(PlotlyError, tls.FigureFactory.create_candlestick, + self.assertRaises(PlotlyError, ff.create_ohlc, **kwargs) + self.assertRaises(PlotlyError, ff.create_candlestick, **kwargs) def test_direction_arg(self): @@ -162,11 +169,11 @@ def test_direction_arg(self): self.assertRaisesRegexp(PlotlyError, "direction must be defined as " "'increasing', 'decreasing', or 'both'", - tls.FigureFactory.create_ohlc, **kwargs) + ff.create_ohlc, **kwargs) self.assertRaisesRegexp(PlotlyError, "direction must be defined as " "'increasing', 'decreasing', or 'both'", - tls.FigureFactory.create_candlestick, **kwargs) + ff.create_candlestick, **kwargs) kwargs = {'open': [1, 2], 'high': [1, 3], 'low': [1, 2], 'close': [1, 2], @@ -174,11 +181,11 @@ def test_direction_arg(self): self.assertRaisesRegexp(PlotlyError, "direction must be defined as " "'increasing', 'decreasing', or 'both'", - tls.FigureFactory.create_ohlc, **kwargs) + ff.create_ohlc, **kwargs) self.assertRaisesRegexp(PlotlyError, "direction must be defined as " "'increasing', 'decreasing', or 'both'", - tls.FigureFactory.create_candlestick, **kwargs) + ff.create_candlestick, **kwargs) def test_high_highest_value(self): @@ -194,7 +201,7 @@ def test_high_highest_value(self): "low, or close values. " "Double check that your data " "is entered in O-H-L-C order", - tls.FigureFactory.create_ohlc, + ff.create_ohlc, **kwargs) self.assertRaisesRegexp(PlotlyError, "Oops! Looks like some of " "your high values are less " @@ -202,7 +209,7 @@ def test_high_highest_value(self): "low, or close values. " "Double check that your data " "is entered in O-H-L-C order", - tls.FigureFactory.create_candlestick, + ff.create_candlestick, **kwargs) def test_low_lowest_value(self): @@ -222,7 +229,7 @@ def test_low_lowest_value(self): ", open, or close values. " "Double check that your data " "is entered in O-H-L-C order", - tls.FigureFactory.create_ohlc, + ff.create_ohlc, **kwargs) self.assertRaisesRegexp(PlotlyError, "Oops! Looks like some of " @@ -231,14 +238,14 @@ def test_low_lowest_value(self): ", open, or close values. " "Double check that your data " "is entered in O-H-L-C order", - tls.FigureFactory.create_candlestick, + ff.create_candlestick, **kwargs) def test_one_ohlc(self): # This should create one "increase" (i.e. close > open) ohlc stick - ohlc = tls.FigureFactory.create_ohlc(open=[33.0], + ohlc = ff.create_ohlc(open=[33.0], high=[33.2], low=[32.7], close=[33.1]) @@ -251,8 +258,8 @@ def test_one_ohlc(self): 'color': '#3D9970'}, 'showlegend': False, 'name': 'Increasing', - 'text': ('Open', 'Open', 'High', 'Low', - 'Close', 'Close', ''), + 'text': ['Open', 'Open', 'High', 'Low', + 'Close', 'Close', ''], 'mode': 'lines', 'type': 'scatter', 'x': [-0.2, 0, 0, 0, 0, 0.2, None]}, {'y': [], 'line': {'width': 1, @@ -262,13 +269,22 @@ def test_one_ohlc(self): 'mode': 'lines', 'type': 'scatter', 'x': []}]} - self.assertEqual(ohlc, expected_ohlc) + self.assert_fig_equal(ohlc['data'][0], + expected_ohlc['data'][0], + ignore=['uid', 'text']) + + self.assert_fig_equal(ohlc['data'][1], + expected_ohlc['data'][1], + ignore=['uid', 'text']) + + self.assert_fig_equal(ohlc['layout'], + expected_ohlc['layout']) def test_one_ohlc_increase(self): # This should create one "increase" (i.e. close > open) ohlc stick - ohlc_incr = tls.FigureFactory.create_ohlc(open=[33.0], + ohlc_incr = ff.create_ohlc(open=[33.0], high=[33.2], low=[32.7], close=[33.1], @@ -279,21 +295,22 @@ def test_one_ohlc_increase(self): 'mode': 'lines', 'name': 'Increasing', 'showlegend': False, - 'text': ('Open', 'Open', 'High', - 'Low', 'Close', 'Close', ''), + 'text': ['Open', 'Open', 'High', + 'Low', 'Close', 'Close', ''], 'type': 'scatter', 'x': [-0.2, 0, 0, 0, 0, 0.2, None], 'y': [33.0, 33.0, 33.2, 32.7, 33.1, 33.1, None]}], 'layout': {'hovermode': 'closest', 'xaxis': {'zeroline': False}}} - self.assertEqual(ohlc_incr, expected_ohlc_incr) + self.assert_fig_equal(ohlc_incr['data'][0], expected_ohlc_incr['data'][0]) + self.assert_fig_equal(ohlc_incr['layout'], expected_ohlc_incr['layout']) def test_one_ohlc_decrease(self): # This should create one "increase" (i.e. close > open) ohlc stick - ohlc_decr = tls.FigureFactory.create_ohlc(open=[33.0], + ohlc_decr = ff.create_ohlc(open=[33.0], high=[33.2], low=[30.7], close=[31.1], @@ -304,22 +321,24 @@ def test_one_ohlc_decrease(self): 'mode': 'lines', 'name': 'Decreasing', 'showlegend': False, - 'text': ('Open', 'Open', 'High', 'Low', - 'Close', 'Close', ''), + 'text': ['Open', 'Open', 'High', 'Low', + 'Close', 'Close', ''], 'type': 'scatter', 'x': [-0.2, 0, 0, 0, 0, 0.2, None], 'y': [33.0, 33.0, 33.2, 30.7, 31.1, 31.1, None]}], 'layout': {'hovermode': 'closest', 'xaxis': {'zeroline': False}}} - self.assertEqual(ohlc_decr, expected_ohlc_decr) + + self.assert_fig_equal(ohlc_decr['data'][0], expected_ohlc_decr['data'][0]) + self.assert_fig_equal(ohlc_decr['layout'], expected_ohlc_decr['layout']) # TO-DO: put expected fig in a different file and then call to compare def test_one_candlestick(self): # This should create one "increase" (i.e. close > open) candlestick - can_inc = tls.FigureFactory.create_candlestick(open=[33.0], + can_inc = ff.create_candlestick(open=[33.0], high=[33.2], low=[32.7], close=[33.1]) @@ -334,8 +353,8 @@ def test_one_candlestick(self): 'x': [0, 0, 0, 0, 0, 0], 'y': [32.7, 33.0, 33.1, 33.1, 33.1, 33.2]}, {'boxpoints': False, - 'fillcolor': '#FF4136', - 'line': {'color': '#FF4136'}, + 'fillcolor': '#ff4136', + 'line': {'color': '#ff4136'}, 'name': 'Decreasing', 'showlegend': False, 'type': 'box', @@ -344,7 +363,10 @@ def test_one_candlestick(self): 'y': []}], 'layout': {}} - self.assertEqual(can_inc, exp_can_inc) + self.assert_fig_equal(can_inc['data'][0], + exp_can_inc['data'][0]) + self.assert_fig_equal(can_inc['layout'], + exp_can_inc['layout']) def test_datetime_ohlc(self): @@ -364,7 +386,7 @@ def test_datetime_ohlc(self): datetime.datetime(year=2014, month=9, day=4), datetime.datetime(year=2014, month=12, day=5)] - ohlc_d = tls.FigureFactory.create_ohlc(open_data, high_data, + ohlc_d = ff.create_ohlc(open_data, high_data, low_data, close_data, dates=x) @@ -372,7 +394,7 @@ def test_datetime_ohlc(self): 'mode': 'lines', 'name': 'Increasing', 'showlegend': False, - 'text': ('Open', + 'text': ['Open', 'Open', 'High', 'Low', @@ -399,7 +421,7 @@ def test_datetime_ohlc(self): 'Low', 'Close', 'Close', - ''), + ''], 'type': 'scatter', 'x': [datetime.datetime(2013, 2, 14, 4, 48), datetime.datetime(2013, 3, 4, 0, 0), @@ -461,7 +483,7 @@ def test_datetime_ohlc(self): 'mode': 'lines', 'name': 'Decreasing', 'showlegend': False, - 'text': ('Open', + 'text': ['Open', 'Open', 'High', 'Low', @@ -488,7 +510,7 @@ def test_datetime_ohlc(self): 'Low', 'Close', 'Close', - ''), + ''], 'type': 'scatter', 'x': [datetime.datetime(2013, 5, 18, 4, 48), datetime.datetime(2013, 6, 5, 0, 0), @@ -548,7 +570,9 @@ def test_datetime_ohlc(self): None]}], 'layout': {'hovermode': 'closest', 'xaxis': {'zeroline': False}}} - self.assertEqual(ohlc_d, ex_ohlc_d) + self.assert_fig_equal(ohlc_d['data'][0], ex_ohlc_d['data'][0]) + self.assert_fig_equal(ohlc_d['data'][1], ex_ohlc_d['data'][1]) + self.assert_fig_equal(ohlc_d['layout'], ex_ohlc_d['layout']) def test_datetime_candlestick(self): @@ -568,7 +592,7 @@ def test_datetime_candlestick(self): datetime.datetime(year=2014, month=9, day=4), datetime.datetime(year=2014, month=12, day=5)] - candle = tls.FigureFactory.create_candlestick(open_data, high_data, + candle = ff.create_candlestick(open_data, high_data, low_data, close_data, dates=x) exp_candle = {'data': [{'boxpoints': False, @@ -683,10 +707,12 @@ def test_datetime_candlestick(self): 35.37]}], 'layout': {}} - self.assertEqual(candle, exp_candle) + self.assert_fig_equal(candle['data'][0], exp_candle['data'][0]) + self.assert_fig_equal(candle['data'][1], exp_candle['data'][1]) + self.assert_fig_equal(candle['layout'], exp_candle['layout']) -class TestAnnotatedHeatmap(TestCase): +class TestAnnotatedHeatmap(TestCase, NumpyTestUtilsMixin): def test_unequal_z_text_size(self): @@ -694,12 +720,12 @@ def test_unequal_z_text_size(self): kwargs = {'z': [[1, 2], [1, 2]], 'annotation_text': [[1, 2, 3], [1]]} self.assertRaises(PlotlyError, - tls.FigureFactory.create_annotated_heatmap, + ff.create_annotated_heatmap, **kwargs) kwargs = {'z': [[1], [1]], 'annotation_text': [[1], [1], [1]]} self.assertRaises(PlotlyError, - tls.FigureFactory.create_annotated_heatmap, + ff.create_annotated_heatmap, **kwargs) def test_incorrect_x_size(self): @@ -708,7 +734,7 @@ def test_incorrect_x_size(self): kwargs = {'z': [[1, 2], [1, 2]], 'x': ['A']} self.assertRaises(PlotlyError, - tls.FigureFactory.create_annotated_heatmap, + ff.create_annotated_heatmap, **kwargs) def test_incorrect_y_size(self): @@ -717,7 +743,7 @@ def test_incorrect_y_size(self): kwargs = {'z': [[1, 2], [1, 2]], 'y': [1, 2, 3]} self.assertRaises(PlotlyError, - tls.FigureFactory.create_annotated_heatmap, + ff.create_annotated_heatmap, **kwargs) def test_simple_annotated_heatmap(self): @@ -726,7 +752,7 @@ def test_simple_annotated_heatmap(self): # logical text color z = [[1, 0, .5], [.25, .75, .45]] - a_heat = tls.FigureFactory.create_annotated_heatmap(z) + a_heat = ff.create_annotated_heatmap(z) expected_a_heat = { 'data': [{'colorscale': 'RdBu', 'showscale': False, @@ -736,51 +762,58 @@ def test_simple_annotated_heatmap(self): 'showarrow': False, 'text': '1', 'x': 0, - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#FFFFFF'}, 'showarrow': False, 'text': '0', 'x': 1, - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#FFFFFF'}, 'showarrow': False, 'text': '0.5', 'x': 2, - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#FFFFFF'}, 'showarrow': False, 'text': '0.25', 'x': 0, - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#000000'}, 'showarrow': False, 'text': '0.75', 'x': 1, - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#FFFFFF'}, 'showarrow': False, 'text': '0.45', 'x': 2, - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}], + 'yref': 'y'}], 'xaxis': {'gridcolor': 'rgb(0, 0, 0)', 'showticklabels': False, 'side': 'top', 'ticks': ''}, 'yaxis': {'showticklabels': False, 'ticks': '', 'ticksuffix': ' '}}} - self.assertEqual(a_heat, expected_a_heat) + + self.assert_fig_equal( + a_heat['data'][0], + expected_a_heat['data'][0], + ) + + self.assert_fig_equal(a_heat['layout'], + expected_a_heat['layout']) def test_annotated_heatmap_kwargs(self): @@ -789,7 +822,7 @@ def test_annotated_heatmap_kwargs(self): z = [[1, 0], [.25, .75], [.45, .5]] text = [['first', 'second'], ['third', 'fourth'], ['fifth', 'sixth']] - a = tls.FigureFactory.create_annotated_heatmap(z, x=['A', 'B'], + a = ff.create_annotated_heatmap(z, x=['A', 'B'], y=['One', 'Two', 'Three'], annotation_text=text, @@ -808,68 +841,74 @@ def test_annotated_heatmap_kwargs(self): 'showarrow': False, 'text': 'first', 'x': 'A', - 'xref': 'x1', + 'xref': 'x', 'y': 'One', - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#000000'}, 'showarrow': False, 'text': 'second', 'x': 'B', - 'xref': 'x1', + 'xref': 'x', 'y': 'One', - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#000000'}, 'showarrow': False, 'text': 'third', 'x': 'A', - 'xref': 'x1', + 'xref': 'x', 'y': 'Two', - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#FFFFFF'}, 'showarrow': False, 'text': 'fourth', 'x': 'B', - 'xref': 'x1', + 'xref': 'x', 'y': 'Two', - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#000000'}, 'showarrow': False, 'text': 'fifth', 'x': 'A', - 'xref': 'x1', + 'xref': 'x', 'y': 'Three', - 'yref': 'y1'}, + 'yref': 'y'}, {'font': {'color': '#000000'}, 'showarrow': False, 'text': 'sixth', 'x': 'B', - 'xref': 'x1', + 'xref': 'x', 'y': 'Three', - 'yref': 'y1'}], + 'yref': 'y'}], 'xaxis': {'dtick': 1, 'gridcolor': 'rgb(0, 0, 0)', 'side': 'top', 'ticks': ''}, 'yaxis': {'dtick': 1, 'ticks': '', 'ticksuffix': ' '}}} - self.assertEqual(a, expected_a) + self.assert_fig_equal( + a['data'][0], + expected_a['data'][0], + ) + + self.assert_fig_equal(a['layout'], + expected_a['layout']) -class TestTable(TestCase): +class TestTable(TestCase, NumpyTestUtilsMixin): def test_fontcolor_input(self): - # check: PlotlyError if fontcolor input is incorrect + # check: ValueError if fontcolor input is incorrect kwargs = {'table_text': [['one', 'two'], [1, 2], [1, 2], [1, 2]], 'fontcolor': '#000000'} - self.assertRaises(PlotlyError, - tls.FigureFactory.create_table, **kwargs) + self.assertRaises(ValueError, + ff.create_table, **kwargs) kwargs = {'table_text': [['one', 'two'], [1, 2], [1, 2], [1, 2]], 'fontcolor': ['red', 'blue']} - self.assertRaises(PlotlyError, - tls.FigureFactory.create_table, **kwargs) + self.assertRaises(ValueError, + ff.create_table, **kwargs) def test_simple_table(self): @@ -877,7 +916,7 @@ def test_simple_table(self): text = [['Country', 'Year', 'Population'], ['US', 2000, 282200000], ['Canada', 2000, 27790000], ['US', 1980, 226500000]] - table = tls.FigureFactory.create_table(text) + table = ff.create_table(text) expected_table = {'data': [{'colorscale': [[0, '#00083e'], [0.5, '#ededee'], [1, '#ffffff']], @@ -893,108 +932,108 @@ def test_simple_table(self): 'text': 'Country', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'Year', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'Population', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': 'US', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '2000', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '282200000', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': 'Canada', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '2000', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '27790000', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': 'US', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 3, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '1980', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 3, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '226500000', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 3, - 'yref': 'y1'}], + 'yref': 'y'}], 'height': 170, 'margin': {'b': 0, 'l': 0, 'r': 0, 't': 0}, 'xaxis': {'dtick': 1, @@ -1010,7 +1049,16 @@ def test_simple_table(self): 'tick0': 0.5, 'ticks': '', 'zeroline': False}}} - self.assertEqual(table, expected_table) + + self.assert_fig_equal( + table['data'][0], + expected_table['data'][0] + ) + + self.assert_fig_equal( + table['layout'], + expected_table['layout'] + ) def test_table_with_index(self): @@ -1019,8 +1067,7 @@ def test_table_with_index(self): text = [['Country', 'Year', 'Population'], ['US', 2000, 282200000], ['Canada', 2000, 27790000]] - index_table = tls.FigureFactory.create_table(text, index=True, - index_title='Title') + index_table = ff.create_table(text, index=True, index_title='Title') exp_index_table = {'data': [{'colorscale': [[0, '#00083e'], [0.5, '#ededee'], [1, '#ffffff']], 'hoverinfo': 'none', 'opacity': 0.75, @@ -1033,81 +1080,81 @@ def test_table_with_index(self): 'text': 'Country', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'Year', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'Population', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 0, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'US', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '2000', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '282200000', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 1, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#ffffff'}, 'showarrow': False, 'text': 'Canada', 'x': -0.45, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '2000', 'x': 0.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}, + 'yref': 'y'}, {'align': 'left', 'font': {'color': '#000000'}, 'showarrow': False, 'text': '27790000', 'x': 1.55, 'xanchor': 'left', - 'xref': 'x1', + 'xref': 'x', 'y': 2, - 'yref': 'y1'}], + 'yref': 'y'}], 'height': 140, 'margin': {'b': 0, 'l': 0, 'r': 0, 't': 0}, 'xaxis': {'dtick': 1, @@ -1123,7 +1170,16 @@ def test_table_with_index(self): 'tick0': 0.5, 'ticks': '', 'zeroline': False}}} - self.assertEqual(index_table, exp_index_table) + + self.assert_fig_equal( + index_table['data'][0], + exp_index_table['data'][0] + ) + + self.assert_fig_equal( + index_table['layout'], + exp_index_table['layout'] + ) class TestGantt(TestCase): @@ -1143,7 +1199,7 @@ def test_validate_gantt(self): 'dictionaries is being used.') self.assertRaisesRegexp(PlotlyError, pattern2, - tls.FigureFactory.create_gantt, + ff.create_gantt, df, index_col='foo') df = 'foo' @@ -1152,7 +1208,7 @@ def test_validate_gantt(self): 'dictionaries.') self.assertRaisesRegexp(PlotlyError, pattern3, - tls.FigureFactory.create_gantt, df) + ff.create_gantt, df) df = [] @@ -1160,14 +1216,14 @@ def test_validate_gantt(self): 'dictionary.') self.assertRaisesRegexp(PlotlyError, pattern4, - tls.FigureFactory.create_gantt, df) + ff.create_gantt, df) df = ['foo'] pattern5 = ('Your list must only include dictionaries.') self.assertRaisesRegexp(PlotlyError, pattern5, - tls.FigureFactory.create_gantt, df) + ff.create_gantt, df) def test_gantt_index(self): @@ -1184,7 +1240,7 @@ def test_gantt_index(self): 'dictionaries is being used.') self.assertRaisesRegexp(PlotlyError, pattern, - tls.FigureFactory.create_gantt, + ff.create_gantt, df, index_col='foo') df = [{'Task': 'Job A', 'Start': '2009-02-01', @@ -1196,7 +1252,7 @@ def test_gantt_index(self): 'column are all numbers or all strings.') self.assertRaisesRegexp(PlotlyError, pattern2, - tls.FigureFactory.create_gantt, + ff.create_gantt, df, index_col='Complete') def test_gantt_validate_colors(self): @@ -1212,17 +1268,17 @@ def test_gantt_validate_colors(self): 'exceed 255.0.') self.assertRaisesRegexp(PlotlyError, pattern, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, index_col='Complete', colors='rgb(300,1,1)') - self.assertRaises(PlotlyError, tls.FigureFactory.create_gantt, + self.assertRaises(PlotlyError, ff.create_gantt, df, index_col='Complete', colors='foo') pattern2 = ('Whoops! The elements in your colors tuples cannot ' 'exceed 1.0.') self.assertRaisesRegexp(PlotlyError, pattern2, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, index_col='Complete', colors=(2, 1, 1)) # verify that if colors is a dictionary, its keys span all the @@ -1233,7 +1289,7 @@ def test_gantt_validate_colors(self): 'keys must be all the values in the index column.') self.assertRaisesRegexp(PlotlyError, pattern3, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, index_col='Complete', colors=colors_dict) # check: index is set if colors is a dictionary @@ -1244,7 +1300,7 @@ def test_gantt_validate_colors(self): 'assigning colors to particular values in a dictioanry.') self.assertRaisesRegexp(PlotlyError, pattern4, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, colors=colors_dict_good) # check: number of colors is equal to or greater than number of @@ -1254,7 +1310,7 @@ def test_gantt_validate_colors(self): "column.") self.assertRaisesRegexp(PlotlyError, pattern5, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, index_col='Resource', colors=['#ffffff']) @@ -1265,29 +1321,28 @@ def test_gantt_validate_colors(self): "bounds on the colormap.") self.assertRaisesRegexp(PlotlyError, pattern6, - tls.FigureFactory.create_gantt, df, + ff.create_gantt, df, index_col='Complete', colors=['#ffffff']) - def test_gannt_groups_and_descriptions(self): # check if grouped gantt chart matches with expected output df = [ dict(Task='Task A', Description='Task A - 1', Start='2008-10-05', - Finish='2009-04-15', IndexCol = 'TA'), + Finish='2009-04-15', IndexCol='TA'), dict(Task="Task B", Description='Task B - 1', Start='2008-12-06', - Finish='2009-03-15', IndexCol = 'TB'), + Finish='2009-03-15', IndexCol='TB'), dict(Task="Task C", Description='Task C - 1', Start='2008-09-07', - Finish='2009-03-15', IndexCol = 'TC'), + Finish='2009-03-15', IndexCol='TC'), dict(Task="Task C", Description='Task C - 2', Start='2009-05-08', - Finish='2009-04-15', IndexCol = 'TC'), + Finish='2009-04-15', IndexCol='TC'), dict(Task="Task A", Description='Task A - 2', Start='2009-04-20', - Finish='2009-05-30', IndexCol = 'TA') + Finish='2009-05-30', IndexCol='TA') ] - test_gantt_chart = tls.FigureFactory.create_gantt( + test_gantt_chart = ff.create_gantt( df, colors=dict(TA='rgb(220, 0, 0)', TB='rgb(170, 14, 200)', TC=(1, 0.9, 0.16)), show_colorbar=True, index_col='IndexCol', group_tasks=True @@ -1442,8 +1497,6 @@ def test_gannt_groups_and_descriptions(self): self.assertEqual(test_gantt_chart['layout'], exp_gantt_chart['layout']) - - def test_gantt_all_args(self): # check if gantt chart matches with expected output @@ -1457,7 +1510,7 @@ def test_gantt_all_args(self): 'Finish': '2012-06-05', 'Complete': 25}] - test_gantt_chart = tls.FigureFactory.create_gantt( + test_gantt_chart = ff.create_gantt( df, colors='Blues', index_col='Complete', reverse_colors=True, title='Title', bar_width=0.5, showgrid_x=True, showgrid_y=True, height=500, width=500 @@ -1541,7 +1594,7 @@ def test_gantt_all_args(self): exp_gantt_chart['layout']) -class Test2D_Density(TestCase): +class Test2D_Density(TestCase, NumpyTestUtilsMixin): def test_validate_2D_density(self): @@ -1552,7 +1605,7 @@ def test_validate_2D_density(self): pattern = ("All elements of your 'x' and 'y' lists must be numbers.") self.assertRaisesRegexp(PlotlyError, pattern, - tls.FigureFactory.create_2D_density, x, y) + ff.create_2d_density, x, y) # validate that x and y are the same length x2 = [1] @@ -1561,7 +1614,7 @@ def test_validate_2D_density(self): pattern2 = ("Both lists 'x' and 'y' must be the same length.") self.assertRaisesRegexp(PlotlyError, pattern2, - tls.FigureFactory.create_2D_density, x2, y2) + ff.create_2d_density, x2, y2) def test_2D_density_all_args(self): @@ -1572,8 +1625,8 @@ def test_2D_density_all_args(self): colorscale = ['#7A4579', '#D56073', 'rgb(236,158,105)', (1, 1, 0.2), (0.98, 0.98, 0.98)] - test_2D_density_chart = tls.FigureFactory.create_2D_density( - x, y, colorscale=colorscale, hist_color='rgb(255, 237, 222)', + test_2D_density_chart = ff.create_2d_density( + x, y, colorscale=colorscale, hist_color='rgb(255,237,222)', point_size=3, height=800, width=800) exp_2D_density_chart = { @@ -1629,34 +1682,17 @@ def test_2D_density_all_args(self): 'zeroline': False}} } - self.assertEqual(test_2D_density_chart['data'][0], - exp_2D_density_chart['data'][0]) - - self.assertEqual(test_2D_density_chart['data'][1], - exp_2D_density_chart['data'][1]) - - self.assertEqual(test_2D_density_chart['data'][2], - exp_2D_density_chart['data'][2]) - - self.assertEqual(test_2D_density_chart['data'][3], - exp_2D_density_chart['data'][3]) - - self.assertEqual(test_2D_density_chart['layout'], - exp_2D_density_chart['layout']) - - -# class TestDistplot(TestCase): + self.assert_fig_equal(test_2D_density_chart['data'][0], + exp_2D_density_chart['data'][0]) -# def test_scipy_import_error(self): + self.assert_fig_equal(test_2D_density_chart['data'][1], + exp_2D_density_chart['data'][1]) -# hist_data = [[1.1, 1.1, 2.5, 3.0, 3.5, -# 3.5, 4.1, 4.4, 4.5, 4.5, -# 5.0, 5.0, 5.2, 5.5, 5.5, -# 5.5, 5.5, 5.5, 6.1, 7.0]] + self.assert_fig_equal(test_2D_density_chart['data'][2], + exp_2D_density_chart['data'][2]) -# group_labels = ['distplot example'] + self.assert_fig_equal(test_2D_density_chart['data'][3], + exp_2D_density_chart['data'][3]) -# self.assertRaisesRegexp(ImportError, -# "FigureFactory.create_distplot requires scipy", -# tls.FigureFactory.create_distplot, -# hist_data, group_labels) + self.assert_fig_equal(test_2D_density_chart['layout'], + exp_2D_density_chart['layout']) diff --git a/plotly/tests/test_optional/test_utils/test_utils.py b/plotly/tests/test_optional/test_utils/test_utils.py index 9531e12ad8..d9b463d3ca 100644 --- a/plotly/tests/test_optional/test_utils/test_utils.py +++ b/plotly/tests/test_optional/test_utils/test_utils.py @@ -96,20 +96,23 @@ def test_encode_as_numpy(self): res = utils.PlotlyJSONEncoder.encode_as_numpy(np.ma.core.masked) self.assertTrue(math.isnan(res)) - def test_encode_as_datetime(self): + def test_encode_valid_datetime(self): # should *fail* without 'utcoffset' and 'isoformat' and '__sub__' attrs - non_datetimes = [datetime.date(2013, 10, 1), 'noon', 56, '00:00:00'] + #non_datetimes = [datetime.date(2013, 10, 1), 'noon', 56, '00:00:00'] + non_datetimes = [datetime.date(2013, 10, 1)] for obj in non_datetimes: self.assertRaises(utils.NotEncodable, utils.PlotlyJSONEncoder.encode_as_datetime, obj) + def test_encode_as_datetime(self): # should succeed with 'utcoffset', 'isoformat' and '__sub__' attrs res = utils.PlotlyJSONEncoder.encode_as_datetime( datetime.datetime(2013, 10, 1) ) self.assertEqual(res, '2013-10-01') + def test_encode_as_datetime_with_microsecond(self): # should not include extraneous microsecond info if DNE res = utils.PlotlyJSONEncoder.encode_as_datetime( datetime.datetime(2013, 10, 1, microsecond=0) @@ -122,6 +125,7 @@ def test_encode_as_datetime(self): ) self.assertEqual(res, '2013-10-01 00:00:00.000010') + def test_encode_as_datetime_with_localized_tz(self): # should convert tzinfo to utc. Note that in october, we're in EDT! # therefore the 4 hour difference is correct. naive_datetime = datetime.datetime(2013, 10, 1) @@ -144,7 +148,6 @@ def test_encode_as_date(self): self.assertEqual(res, '2013-10-01') # should also work with a date time without a utc offset! - # TODO: is this OK? We could raise errors after checking isinstance... res = utils.PlotlyJSONEncoder.encode_as_date( datetime.datetime(2013, 10, 1, microsecond=10) ) @@ -155,7 +158,7 @@ def test_encode_as_decimal(self): # should work with decimal values res = utils.PlotlyJSONEncoder.encode_as_decimal(decimal.Decimal(1.023452)) - self.assertAlmostEqual(res, 1.023452) # Checks upto 7 decimal places + self.assertAlmostEqual(res, 1.023452) # Checks upto 7 decimal places self.assertIsInstance(res, float) ## JSON encoding @@ -212,9 +215,17 @@ def test_figure_json_encoding(): _json.dumps(figure, cls=utils.PlotlyJSONEncoder, sort_keys=True) # Test data wasn't mutated - assert(bool(np.asarray(np_list == - np.array([1, 2, 3, np.NaN, - np.NAN, np.Inf, dt(2014, 1, 5)])).all())) + np_array = np.array( + [1, 2, 3, np.NaN, np.NAN, np.Inf, dt(2014, 1, 5)] + ) + for k in range(len(np_array)): + if k in [3, 4]: + # check NaN + assert np.isnan(np_list[k]) and np.isnan(np_array[k]) + else: + # non-NaN + assert np_list[k] == np_array[k] + assert(set(data[0]['z']) == set([1, 'A', dt(2014, 1, 5), dt(2014, 1, 5, 1, 1, 1), dt(2014, 1, 5, 1, 1, 1, 1)])) @@ -233,6 +244,8 @@ def test_datetime_json_encoding(): def test_pandas_json_encoding(): j1 = _json.dumps(df['col 1'], cls=utils.PlotlyJSONEncoder) + print(j1) + print('\n') assert(j1 == '[1, 2, 3, "2014-01-05", null, null, null]') # Test that data wasn't mutated @@ -266,32 +279,33 @@ def test_numpy_masked_json_encoding(): assert(j1 == '[1, 2, null]') -@attr('matplotlib') -def test_masked_constants_example(): - # example from: https://gist.github.com/tschaume/d123d56bf586276adb98 - data = { - 'esN': [0, 1, 2, 3], - 'ewe_is0': [-398.11901997, -398.11902774, - -398.11897111, -398.11882215], - 'ewe_is1': [-398.11793027, -398.11792966, -398.11786308, None], - 'ewe_is2': [-398.11397008, -398.11396421, None, None] - } - df = pd.DataFrame.from_dict(data) - - plotopts = {'x': 'esN', 'marker': 'o'} - fig, ax = plt.subplots(1, 1) - df.plot(ax=ax, **plotopts) - - renderer = PlotlyRenderer() - Exporter(renderer).run(fig) - - _json.dumps(renderer.plotly_fig, cls=utils.PlotlyJSONEncoder) - - jy = _json.dumps(renderer.plotly_fig['data'][1]['y'], - cls=utils.PlotlyJSONEncoder) - print(jy) - array = _json.loads(jy) - assert(array == [-398.11793027, -398.11792966, -398.11786308, None]) +if matplotlylib: + @attr('matplotlib') + def test_masked_constants_example(): + # example from: https://gist.github.com/tschaume/d123d56bf586276adb98 + data = { + 'esN': [0, 1, 2, 3], + 'ewe_is0': [-398.11901997, -398.11902774, + -398.11897111, -398.11882215], + 'ewe_is1': [-398.11793027, -398.11792966, -398.11786308, None], + 'ewe_is2': [-398.11397008, -398.11396421, None, None] + } + df = pd.DataFrame.from_dict(data) + + plotopts = {'x': 'esN'} + fig, ax = plt.subplots(1, 1) + df.plot(ax=ax, **plotopts) + + renderer = PlotlyRenderer() + Exporter(renderer).run(fig) + + _json.dumps(renderer.plotly_fig, cls=utils.PlotlyJSONEncoder) + + jy = _json.dumps(renderer.plotly_fig['data'][1]['y'], + cls=utils.PlotlyJSONEncoder) + print(jy) + array = _json.loads(jy) + assert(array == [-398.11793027, -398.11792966, -398.11786308, None]) def test_numpy_dates(): diff --git a/plotly/tests/utils.py b/plotly/tests/utils.py index 267ca5ed21..43d2dbb04a 100644 --- a/plotly/tests/utils.py +++ b/plotly/tests/utils.py @@ -85,6 +85,38 @@ def compare_dict(dict1, dict2, equivalent=True, msg='', tol=10e-8): return equivalent, msg +def strip_dict_params(d1, d2, ignore=['uid']): + """ + Helper function for assert_dict_equal + + Nearly duplicate of assert_fig_equal in plotly/tests/test_optional/optional_utils.py + Removes `ignore` params from d1 and/or d2 if they exist + then returns stripped dictionaries + + :param (list|tuple) ignore: sequence of key names as + strings that are removed from both d1 and d2 if + they exist + """ + # deep copy d1 and d2 + if 'to_plotly_json' in dir(d1): + d1_copy = copy.deepcopy(d1.to_plotly_json()) + else: + d1_copy = copy.deepcopy(d1) + + if 'to_plotly_json' in dir(d2): + d2_copy = copy.deepcopy(d2.to_plotly_json()) + else: + d2_copy = copy.deepcopy(d2) + + for key in ignore: + if key in d1_copy.keys(): + del d1_copy[key] + if key in d2_copy.keys(): + del d2_copy[key] + + return d1_copy, d2_copy + + def comp_nums(num1, num2, tol=10e-8): return abs(num1 - num2) < tol diff --git a/plotly/tools.py b/plotly/tools.py index 00daae4c16..dffd60c9b6 100644 --- a/plotly/tools.py +++ b/plotly/tools.py @@ -57,7 +57,6 @@ def warning_on_one_line(message, category, filename, lineno, warnings.formatwarning = warning_on_one_line ipython_core_display = optional_imports.get_module('IPython.core.display') -matplotlylib = optional_imports.get_module('plotly.matplotlylib') sage_salvus = optional_imports.get_module('sage_salvus') @@ -92,9 +91,9 @@ def ensure_local_plotly_files(): for key in contents_keys: if key not in FILE_CONTENT[fn]: del contents[key] - # save only if contents has changed. + # save only if contents has changed. # This is to avoid .credentials or .config file to be overwritten randomly, - # which we constantly keep experiencing + # which we constantly keep experiencing # (sync issues? the file might be locked for writing by other process in file._permissions) if contents_orig.keys() != contents.keys(): utils.save_json_dict(fn, contents) @@ -460,6 +459,7 @@ def mpl_to_plotly(fig, resize=False, strip_style=False, verbose=False): {plotly_domain}/python/getting-started """ + matplotlylib = optional_imports.get_module('plotly.matplotlylib') if matplotlylib: renderer = matplotlylib.PlotlyRenderer() matplotlylib.Exporter(renderer).run(fig) @@ -1357,11 +1357,12 @@ def _pad(s, cell_len=cell_len): return fig -def get_valid_graph_obj(obj, obj_type=None): - """Returns a new graph object that won't raise. - - CAREFUL: this will *silently* strip out invalid pieces of the object. +def get_graph_obj(obj, obj_type=None): + """Returns a new graph object. + OLD FUNCTION: this will *silently* strip out invalid pieces of the object. + NEW FUNCTION: no striping of invalid pieces anymore - only raises error + on unrecognized graph_objs """ # TODO: Deprecate or move. #283 from plotly.graph_objs import graph_objs @@ -1371,7 +1372,7 @@ def get_valid_graph_obj(obj, obj_type=None): raise exceptions.PlotlyError( "'{}' is not a recognized graph_obj.".format(obj_type) ) - return cls(obj, _raise=False) + return cls(obj) def validate(obj, obj_type): @@ -1391,7 +1392,8 @@ def validate(obj, obj_type): try: cls = getattr(graph_objs, obj_type) - except AttributeError: + #except AttributeError: + except ValueError: raise exceptions.PlotlyError( "'{0}' is not a recognizable graph_obj.". format(obj_type)) @@ -1445,19 +1447,26 @@ def _repr_html_(self): def return_figure_from_figure_or_data(figure_or_data, validate_figure): - from plotly.graph_objs import graph_objs + from plotly.graph_objs import Figure + from plotly.basedatatypes import BaseFigure + + validated = False if isinstance(figure_or_data, dict): figure = figure_or_data elif isinstance(figure_or_data, list): figure = {'data': figure_or_data} + elif isinstance(figure_or_data, BaseFigure): + figure = figure_or_data.to_dict() + validated = True else: raise exceptions.PlotlyError("The `figure_or_data` positional " - "argument must be either " - "`dict`-like or `list`-like.") - if validate_figure: + "argument must be " + "`dict`-like, `list`-like, or an instance of plotly.graph_objs.Figure") + + if validate_figure and not validated: try: - graph_objs.Figure(figure) + figure = Figure(**figure).to_dict() except exceptions.PlotlyError as err: raise exceptions.PlotlyError("Invalid 'figure_or_data' argument. " "Plotly will not be able to properly " diff --git a/plotly/utils.py b/plotly/utils.py index b39426bf65..da0833cdc9 100644 --- a/plotly/utils.py +++ b/plotly/utils.py @@ -11,9 +11,12 @@ import os.path import re import sys +import textwrap import threading +import datetime import warnings from collections import deque +from pprint import PrettyPrinter import pytz from decorator import decorator @@ -32,6 +35,10 @@ ### incase people are using threading, we lock file reads lock = threading.Lock() +PY36 = ( + sys.version_info.major == 3 and sys.version_info.minor == 6 +) + http_msg = ( "The plotly_domain and plotly_api_domain of your config file must start " @@ -282,19 +289,21 @@ def encode_as_numpy(obj): @staticmethod def encode_as_datetime(obj): """Attempt to convert to utc-iso time string using datetime methods.""" - - # first we need to get this into utc - try: - obj = obj.astimezone(pytz.utc) - except ValueError: - # we'll get a value error if trying to convert with naive datetime - pass - except TypeError: - # pandas throws a typeerror here instead of a value error, it's OK - pass - except AttributeError: - # we'll get an attribute error if astimezone DNE - raise NotEncodable + # In PY36, isoformat() converts UTC + # datetime.datetime objs to UTC T04:00:00 + if not (PY36 and (isinstance(obj, datetime.datetime) and + obj.tzinfo is None)): + try: + obj = obj.astimezone(pytz.utc) + except ValueError: + # we'll get a value error if trying to convert with naive datetime + pass + except TypeError: + # pandas throws a typeerror here instead of a value error, it's OK + pass + except AttributeError: + # we'll get an attribute error if astimezone DNE + raise NotEncodable # now we need to get a nicely formatted time string try: @@ -526,3 +535,125 @@ def _memoize(*all_args, **kwargs): return result return decorator(_memoize) + + +def _list_repr_elided(v, threshold=200, edgeitems=3, indent=0, width=80): + """ + Return a string representation for of a list where list is elided if + it has more than n elements + + Parameters + ---------- + v : list + Input list + threshold : + Maximum number of elements to display + + Returns + ------- + str + """ + if isinstance(v, list): + open_char, close_char = '[', ']' + elif isinstance(v, tuple): + open_char, close_char = '(', ')' + else: + raise ValueError('Invalid value of type: %s' % type(v)) + + if len(v) <= threshold: + disp_v = v + else: + disp_v = (list(v[:edgeitems]) + + ['...'] + + list(v[-edgeitems:])) + + v_str = open_char + ', '.join([str(e) for e in disp_v]) + close_char + + v_wrapped = '\n'.join(textwrap.wrap(v_str, width=width, + initial_indent=' ' * (indent + 1), + subsequent_indent =' ' * (indent + 1))).strip() + return v_wrapped + + +class ElidedWrapper(object): + """ + Helper class that wraps values of certain types and produces a custom + __repr__() that may be elided and is suitable for use during pretty + printing + """ + def __init__(self, v, threshold, indent): + self.v = v + self.indent = indent + self.threshold = threshold + + @staticmethod + def is_wrappable(v): + if (isinstance(v, (list, tuple)) and + len(v) > 0 and + not isinstance(v[0], dict)): + return True + elif numpy and isinstance(v, numpy.ndarray): + return True + elif isinstance(v, str): + return True + else: + return False + + def __repr__(self): + if isinstance(self.v, (list, tuple)): + # Handle lists/tuples + res = _list_repr_elided(self.v, + threshold=self.threshold, + indent=self.indent) + return res + elif numpy and isinstance(self.v, numpy.ndarray): + # Handle numpy arrays + + # Get original print opts + orig_opts = numpy.get_printoptions() + + # Set threshold to self.max_list_elements + numpy.set_printoptions( + **dict(orig_opts, + threshold=self.threshold, + edgeitems=3, + linewidth=80)) + + res = self.v.__repr__() + + # Add indent to all but the first line + res_lines = res.split('\n') + res = ('\n' + ' '*self.indent).join(res_lines) + + # Restore print opts + numpy.set_printoptions(**orig_opts) + return res + elif isinstance(self.v, str): + # Handle strings + if len(self.v) > 80: + return ('(' + repr(self.v[:30]) + + ' ... ' + repr(self.v[-30:]) + ')') + else: + return self.v.__repr__() + else: + return self.v.__repr__() + + +class ElidedPrettyPrinter(PrettyPrinter): + """ + PrettyPrinter subclass that elides long lists/arrays/strings + """ + def __init__(self, *args, **kwargs): + self.threshold = kwargs.pop('threshold', 200) + PrettyPrinter.__init__(self, *args, **kwargs) + + def _format(self, val, stream, indent, allowance, context, level): + if ElidedWrapper.is_wrappable(val): + elided_val = ElidedWrapper( + val, self.threshold, indent) + + return self._format( + elided_val, stream, indent, allowance, context, level) + else: + return PrettyPrinter._format( + self, val, stream, indent, allowance, context, level) diff --git a/plotly/validators/__init__.py b/plotly/validators/__init__.py new file mode 100644 index 0000000000..9b3e7641aa --- /dev/null +++ b/plotly/validators/__init__.py @@ -0,0 +1,36 @@ +from ._violin import ViolinValidator +from ._table import TableValidator +from ._surface import SurfaceValidator +from ._splom import SplomValidator +from ._scatterternary import ScatterternaryValidator +from ._scatterpolargl import ScatterpolarglValidator +from ._scatterpolar import ScatterpolarValidator +from ._scattermapbox import ScattermapboxValidator +from ._scattergl import ScatterglValidator +from ._scattergeo import ScattergeoValidator +from ._scattercarpet import ScattercarpetValidator +from ._scatter3d import Scatter3dValidator +from ._scatter import ScatterValidator +from ._sankey import SankeyValidator +from ._pointcloud import PointcloudValidator +from ._pie import PieValidator +from ._parcoords import ParcoordsValidator +from ._ohlc import OhlcValidator +from ._mesh3d import Mesh3dValidator +from ._histogram2dcontour import Histogram2dContourValidator +from ._histogram2d import Histogram2dValidator +from ._histogram import HistogramValidator +from ._heatmapgl import HeatmapglValidator +from ._heatmap import HeatmapValidator +from ._contourcarpet import ContourcarpetValidator +from ._contour import ContourValidator +from ._cone import ConeValidator +from ._choropleth import ChoroplethValidator +from ._carpet import CarpetValidator +from ._candlestick import CandlestickValidator +from ._box import BoxValidator +from ._bar import BarValidator +from ._area import AreaValidator +from ._layout import LayoutValidator +from ._frames import FramesValidator +from ._data import DataValidator diff --git a/plotly/validators/_area.py b/plotly/validators/_area.py new file mode 100644 index 0000000000..368e0429c3 --- /dev/null +++ b/plotly/validators/_area.py @@ -0,0 +1,87 @@ +import _plotly_utils.basevalidators + + +class AreaValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='area', parent_name='', **kwargs): + super(AreaValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Area', + data_docs=""" + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.area.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.area.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial + coordinates. + rsrc + Sets the source reference on plot.ly for r . + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.area.Stream instance or dict + with compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular + coordinates. + tsrc + Sets the source reference on plot.ly for t . + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_bar.py b/plotly/validators/_bar.py new file mode 100644 index 0000000000..78d583de4d --- /dev/null +++ b/plotly/validators/_bar.py @@ -0,0 +1,214 @@ +import _plotly_utils.basevalidators + + +class BarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='bar', parent_name='', **kwargs): + super(BarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Bar', + data_docs=""" + base + Sets where the bar base is drawn (in position + axis units). In *stack* or *relative* barmode, + traces that set *base* will be excluded and + drawn in *overlay* mode instead. + basesrc + Sets the source reference on plot.ly for base + . + cliponaxis + Determines whether the text nodes are clipped + about the subplot axes. To show the text nodes + above axis lines and tick labels, make sure to + set `xaxis.layer` and `yaxis.layer` to *below + traces*. + constraintext + Constrain the size of text inside or outside a + bar to be no larger than the bar itself. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + error_x + plotly.graph_objs.bar.ErrorX instance or dict + with compatible properties + error_y + plotly.graph_objs.bar.ErrorY instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.bar.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each + (x,y) pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `text` lying inside the + bar. + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.bar.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + offset + Shifts the position where the bar is drawn (in + position axis units). In *group* barmode, + traces that set *offset* will be excluded and + drawn in *overlay* mode instead. + offsetsrc + Sets the source reference on plot.ly for + offset . + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* + (*h*), the value of the each bar spans along + the vertical (horizontal). + outsidetextfont + Sets the font used for `text` lying outside the + bar. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial + coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.bar.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.bar.Stream instance or dict + with compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular + coordinates. + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the font used for `text`. + textposition + Specifies the location of the `text`. *inside* + positions `text` inside, next to the bar end + (rotated and scaled if needed). *outside* + positions `text` outside, next to the bar end + (scaled if needed). *auto* positions `text` + inside or outside so that `text` size is + maximized. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.bar.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + width + Sets the bar width (in position axis units). + widthsrc + Sets the source reference on plot.ly for width + . + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_box.py b/plotly/validators/_box.py new file mode 100644 index 0000000000..14079ae1a2 --- /dev/null +++ b/plotly/validators/_box.py @@ -0,0 +1,183 @@ +import _plotly_utils.basevalidators + + +class BoxValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='box', parent_name='', **kwargs): + super(BoxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Box', + data_docs=""" + boxmean + If *true*, the mean of the box(es)' underlying + distribution is drawn as a dashed line inside + the box(es). If *sd* the standard deviation is + also drawn. + boxpoints + If *outliers*, only the sample points lying + outside the whiskers are shown If + *suspectedoutliers*, the outlier points are + shown and points either less than 4*Q1-3*Q3 or + greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are + shown If *false*, only the box(es) are shown + with no sample points + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.box.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual boxes + or sample points or both? + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points + drawn. If *0*, the sample points align along + the distribution axis. If *1*, the sample + points are drawn in a random jitter of width + equal to the width of the box(es). + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.box.Line instance or dict + with compatible properties + marker + plotly.graph_objs.box.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. For box traces, + the name will also be used for the position + coordinate, if `x` and `x0` (`y` and `y0` if + horizontal) are missing and the position axis + is categorical + notched + Determines whether or not notches should be + drawn. + notchwidth + Sets the width of the notches relative to the + box' width. For example, with 0, the notches + are as wide as the box(es). + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the box(es). If *v* + (*h*), the distribution is visualized along the + vertical (horizontal). + pointpos + Sets the position of the sample points in + relation to the box(es). If *0*, the sample + points are places over the center of the + box(es). Positive (negative) values correspond + to positions to the right (left) for vertical + boxes and above (below) for horizontal boxes + selected + plotly.graph_objs.box.Selected instance or dict + with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.box.Stream instance or dict + with compatible properties + text + Sets the text elements associated with each + sample value. If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to the this trace's (x,y) coordinates. To be + seen, trace `hoverinfo` must contain a *text* + flag. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.box.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + whiskerwidth + Sets the width of the whiskers relative to the + box' width. For example, with 1, the whiskers + are as wide as the box(es). + x + Sets the x sample data or coordinates. See + overview for more info. + x0 + Sets the x coordinate of the box. See overview + for more info. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See + overview for more info. + y0 + Sets the y coordinate of the box. See overview + for more info. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_candlestick.py b/plotly/validators/_candlestick.py new file mode 100644 index 0000000000..3d68859a4a --- /dev/null +++ b/plotly/validators/_candlestick.py @@ -0,0 +1,133 @@ +import _plotly_utils.basevalidators + + +class CandlestickValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='candlestick', parent_name='', **kwargs): + super(CandlestickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Candlestick', + data_docs=""" + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close + . + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + decreasing + plotly.graph_objs.candlestick.Decreasing + instance or dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high + . + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.candlestick.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.candlestick.Increasing + instance or dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.candlestick.Line instance or + dict with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open + . + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.candlestick.Stream instance + or dict with compatible properties + text + Sets hover text elements associated with each + sample point. If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text + . + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + whiskerwidth + Sets the width of the whiskers relative to the + box' width. For example, with 1, the whiskers + are as wide as the box(es). + x + Sets the x coordinates. If absent, linear + coordinate will be generated. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on.""", + **kwargs + ) diff --git a/plotly/validators/_carpet.py b/plotly/validators/_carpet.py new file mode 100644 index 0000000000..a52306cca8 --- /dev/null +++ b/plotly/validators/_carpet.py @@ -0,0 +1,143 @@ +import _plotly_utils.basevalidators + + +class CarpetValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='carpet', parent_name='', **kwargs): + super(CarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Carpet', + data_docs=""" + a + An array containing values of the first + parameter value + a0 + Alternate to `a`. Builds a linear space of a + coordinates. Use with `da` where `a0` is the + starting coordinate and `da` the step. + aaxis + plotly.graph_objs.carpet.Aaxis instance or dict + with compatible properties + asrc + Sets the source reference on plot.ly for a . + b + A two dimensional array of y coordinates at + each carpet point. + b0 + Alternate to `b`. Builds a linear space of a + coordinates. Use with `db` where `b0` is the + starting coordinate and `db` the step. + baxis + plotly.graph_objs.carpet.Baxis instance or dict + with compatible properties + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that + `scattercarpet` and `scattercontour` traces can + specify a carpet plot on which they lie + cheaterslope + The shift applied to each successive row of + data in creating a cheater plot. Only used if + `x` is been ommitted. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + da + Sets the a coordinate step. See `a0` for more + info. + db + Sets the b coordinate step. See `b0` for more + info. + font + The default font used for axis & tick labels on + this carpet + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.carpet.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.carpet.Stream instance or + dict with compatible properties + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + A two dimensional array of x coordinates at + each carpet point. If ommitted, the plot is a + cheater plot and the xaxis is hidden by + default. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + A two dimensional array of y coordinates at + each carpet point. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_choropleth.py b/plotly/validators/_choropleth.py new file mode 100644 index 0000000000..e64855c540 --- /dev/null +++ b/plotly/validators/_choropleth.py @@ -0,0 +1,134 @@ +import _plotly_utils.basevalidators + + +class ChoroplethValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='choropleth', parent_name='', **kwargs): + super(ChoroplethValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Choropleth', + data_docs=""" + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + colorbar + plotly.graph_objs.choropleth.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + geo + Sets a reference between this trace's + geospatial coordinates and a geographic map. If + *geo* (the default value), the geospatial + coordinates refer to `layout.geo`. If *geo2*, + the geospatial coordinates refer to + `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.choropleth.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + locationmode + Determines the set of locations used to match + entries in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + See `locationmode` for more info. + locationssrc + Sets the source reference on plot.ly for + locations . + marker + plotly.graph_objs.choropleth.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selected + plotly.graph_objs.choropleth.Selected instance + or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.choropleth.Stream instance or + dict with compatible properties + text + Sets the text elements associated with each + location. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.choropleth.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + z + Sets the color values. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_cone.py b/plotly/validators/_cone.py new file mode 100644 index 0000000000..4e03ba61f5 --- /dev/null +++ b/plotly/validators/_cone.py @@ -0,0 +1,205 @@ +import _plotly_utils.basevalidators + + +class ConeValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='cone', parent_name='', **kwargs): + super(ConeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Cone', + data_docs=""" + anchor + Sets the cones' anchor with respect to their + x/y/z positions. Note that *cm* denote the + cone's center of mass which corresponds to 1/4 + from the tail to tip. + autocolorscale + Has an effect only if `color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmin` must be + set as well. + cmin + Has an effect only if `color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmax` must be + set as well. + colorbar + plotly.graph_objs.cone.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `cmin` and `cmax`. Alternatively, + `colorscale` may be a palette name string of + the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, + Electric, Viridis, Cividis + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.cone.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + lighting + plotly.graph_objs.cone.Lighting instance or + dict with compatible properties + lightposition + plotly.graph_objs.cone.Lightposition instance + or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + scene + Sets a reference between this trace's 3D + coordinate system and a 3D scene. If *scene* + (the default value), the (x,y,z) coordinates + refer to `layout.scene`. If *scene2*, the + (x,y,z) coordinates refer to `layout.scene2`, + and so on. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + sizemode + Determines whether `sizeref` is set as a + *scaled* (i.e unitless) scalar (normalized by + the max u/v/w norm in the vector field) or as + *absolute* value (in the same units as the + vector field). + sizeref + Adjusts the cone size scaling. The size of the + cones is determined by their u/v/w norm + multiplied a factor and `sizeref`. This factor + (computed internally) corresponds to the + minimum "time" to travel across two successive + x/y/z positions at the average velocity of + those two successive positions. All cones in a + given trace use the same factor. With + `sizemode` set to *scaled*, `sizeref` is + unitless, its default value is *0.5* With + `sizemode` set to *absolute*, `sizeref` has the + same units as the u/v/w vector field, its the + default value is half the sample's maximum + vector norm. + stream + plotly.graph_objs.cone.Stream instance or dict + with compatible properties + text + Sets the text elements associated with the + cones. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + u + Sets the x components of the vector field. + uid + + usrc + Sets the source reference on plot.ly for u . + v + Sets the y components of the vector field. + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + vsrc + Sets the source reference on plot.ly for v . + w + Sets the z components of the vector field. + wsrc + Sets the source reference on plot.ly for w . + x + Sets the x coordinates of the vector field and + of the displayed cones. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates of the vector field and + of the displayed cones. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates of the vector field and + of the displayed cones. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_contour.py b/plotly/validators/_contour.py new file mode 100644 index 0000000000..2a76816d16 --- /dev/null +++ b/plotly/validators/_contour.py @@ -0,0 +1,196 @@ +import _plotly_utils.basevalidators + + +class ContourValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='contour', parent_name='', **kwargs): + super(ContourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contour', + data_docs=""" + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + autocontour + Determines whether or not the contour level + attributes are picked by an algorithm. If + *true*, the number of contour levels can be set + in `ncontours`. If *false*, set the contour + level attributes in `contours`. + colorbar + plotly.graph_objs.contour.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the `z` data are filled in. + contours + plotly.graph_objs.contour.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + fillcolor + Sets the fill color if `contours.type` is + *constraint*. Defaults to a half-transparent + variant of the line color, marker color, or + marker line color, whichever is available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.contour.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.contour.Line instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + ncontours + Sets the maximum number of contour levels. The + actual number of contours will be chosen + automatically to be less than or equal to the + value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` + is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.contour.Stream instance or + dict with compatible properties + text + Sets the text elements associated with each z + value. + textsrc + Sets the source reference on plot.ly for text + . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are + given by *x* (the default behavior when `x` is + provided). If *scaled*, the heatmap's x + coordinates are given by *x0* and *dx* (the + default behavior when `x` is not provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are + given by *y* (the default behavior when `y` is + provided) If *scaled*, the heatmap's y + coordinates are given by *y0* and *dy* (the + default behavior when `y` is not provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. See: https://github + .com/d3/d3-format/blob/master/README.md#locale_ + format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_contourcarpet.py b/plotly/validators/_contourcarpet.py new file mode 100644 index 0000000000..72cec6f9c9 --- /dev/null +++ b/plotly/validators/_contourcarpet.py @@ -0,0 +1,184 @@ +import _plotly_utils.basevalidators + + +class ContourcarpetValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='contourcarpet', parent_name='', **kwargs): + super(ContourcarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contourcarpet', + data_docs=""" + a + Sets the x coordinates. + a0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + asrc + Sets the source reference on plot.ly for a . + atype + If *array*, the heatmap's x coordinates are + given by *x* (the default behavior when `x` is + provided). If *scaled*, the heatmap's x + coordinates are given by *x0* and *dx* (the + default behavior when `x` is not provided). + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + autocontour + Determines whether or not the contour level + attributes are picked by an algorithm. If + *true*, the number of contour levels can be set + in `ncontours`. If *false*, set the contour + level attributes in `contours`. + b + Sets the y coordinates. + b0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + bsrc + Sets the source reference on plot.ly for b . + btype + If *array*, the heatmap's y coordinates are + given by *y* (the default behavior when `y` is + provided) If *scaled*, the heatmap's y + coordinates are given by *y0* and *dy* (the + default behavior when `y` is not provided) + carpet + The `carpet` of the carpet axes on which this + contour trace lies + colorbar + plotly.graph_objs.contourcarpet.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.contourcarpet.Contours + instance or dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + da + Sets the x coordinate step. See `x0` for more + info. + db + Sets the y coordinate step. See `y0` for more + info. + fillcolor + Sets the fill color if `contours.type` is + *constraint*. Defaults to a half-transparent + variant of the line color, marker color, or + marker line color, whichever is available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.contourcarpet.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.contourcarpet.Line instance + or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + ncontours + Sets the maximum number of contour levels. The + actual number of contours will be chosen + automatically to be less than or equal to the + value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` + is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.contourcarpet.Stream instance + or dict with compatible properties + text + Sets the text elements associated with each z + value. + textsrc + Sets the source reference on plot.ly for text + . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + z + Sets the z data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_data.py b/plotly/validators/_data.py new file mode 100644 index 0000000000..a3c13b240a --- /dev/null +++ b/plotly/validators/_data.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class DataValidator(_plotly_utils.basevalidators.BaseDataValidator): + + def __init__(self, plotly_name='data', parent_name='', **kwargs): + + super(DataValidator, self).__init__( + class_strs_map={ + 'area': 'Area', + 'bar': 'Bar', + 'box': 'Box', + 'candlestick': 'Candlestick', + 'carpet': 'Carpet', + 'choropleth': 'Choropleth', + 'cone': 'Cone', + 'contour': 'Contour', + 'contourcarpet': 'Contourcarpet', + 'heatmap': 'Heatmap', + 'heatmapgl': 'Heatmapgl', + 'histogram': 'Histogram', + 'histogram2d': 'Histogram2d', + 'histogram2dcontour': 'Histogram2dContour', + 'mesh3d': 'Mesh3d', + 'ohlc': 'Ohlc', + 'parcoords': 'Parcoords', + 'pie': 'Pie', + 'pointcloud': 'Pointcloud', + 'sankey': 'Sankey', + 'scatter': 'Scatter', + 'scatter3d': 'Scatter3d', + 'scattercarpet': 'Scattercarpet', + 'scattergeo': 'Scattergeo', + 'scattergl': 'Scattergl', + 'scattermapbox': 'Scattermapbox', + 'scatterpolar': 'Scatterpolar', + 'scatterpolargl': 'Scatterpolargl', + 'scatterternary': 'Scatterternary', + 'splom': 'Splom', + 'surface': 'Surface', + 'table': 'Table', + 'violin': 'Violin', + }, + plotly_name=plotly_name, + parent_name=parent_name, + **kwargs + ) diff --git a/plotly/validators/_frames.py b/plotly/validators/_frames.py new file mode 100644 index 0000000000..7bc480e8f0 --- /dev/null +++ b/plotly/validators/_frames.py @@ -0,0 +1,36 @@ +import _plotly_utils.basevalidators + + +class FramesValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__(self, plotly_name='frames', parent_name='', **kwargs): + super(FramesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Frame', + data_docs=""" + baseframe + The name of the frame into which this frame's + properties are merged before applying. This is + used to unify properties and avoid needing to + specify the same values for the same properties + in multiple frames. + data + A list of traces this frame modifies. The + format is identical to the normal trace + definition. + group + An identifier that specifies the group to which + the frame belongs, used by animate to select a + subset of frames. + layout + Layout properties which this frame modifies. + The format is identical to the normal layout + definition. + name + A label by which to identify the frame + traces + A list of trace indices that identify the + respective traces in the data attribute""", + **kwargs + ) diff --git a/plotly/validators/_heatmap.py b/plotly/validators/_heatmap.py new file mode 100644 index 0000000000..55a30d0777 --- /dev/null +++ b/plotly/validators/_heatmap.py @@ -0,0 +1,181 @@ +import _plotly_utils.basevalidators + + +class HeatmapValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='heatmap', parent_name='', **kwargs): + super(HeatmapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Heatmap', + data_docs=""" + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + colorbar + plotly.graph_objs.heatmap.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the `z` data are filled in. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.heatmap.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.heatmap.Stream instance or + dict with compatible properties + text + Sets the text elements associated with each z + value. + textsrc + Sets the source reference on plot.ly for text + . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xgap + Sets the horizontal gap (in pixels) between + bricks. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are + given by *x* (the default behavior when `x` is + provided). If *scaled*, the heatmap's x + coordinates are given by *x0* and *dx* (the + default behavior when `x` is not provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ygap + Sets the vertical gap (in pixels) between + bricks. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are + given by *y* (the default behavior when `y` is + provided) If *scaled*, the heatmap's y + coordinates are given by *y0* and *dy* (the + default behavior when `y` is not provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. See: https://github + .com/d3/d3-format/blob/master/README.md#locale_ + format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` + data. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_heatmapgl.py b/plotly/validators/_heatmapgl.py new file mode 100644 index 0000000000..ae452bb144 --- /dev/null +++ b/plotly/validators/_heatmapgl.py @@ -0,0 +1,157 @@ +import _plotly_utils.basevalidators + + +class HeatmapglValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='heatmapgl', parent_name='', **kwargs): + super(HeatmapglValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Heatmapgl', + data_docs=""" + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + colorbar + plotly.graph_objs.heatmapgl.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.heatmapgl.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.heatmapgl.Stream instance or + dict with compatible properties + text + Sets the text elements associated with each z + value. + textsrc + Sets the source reference on plot.ly for text + . + transpose + Transposes the z data. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + xtype + If *array*, the heatmap's x coordinates are + given by *x* (the default behavior when `x` is + provided). If *scaled*, the heatmap's x + coordinates are given by *x0* and *dx* (the + default behavior when `x` is not provided). + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y . + ytype + If *array*, the heatmap's y coordinates are + given by *y* (the default behavior when `y` is + provided) If *scaled*, the heatmap's y + coordinates are given by *y0* and *dy* (the + default behavior when `y` is not provided) + z + Sets the z data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_histogram.py b/plotly/validators/_histogram.py new file mode 100644 index 0000000000..07b0393eac --- /dev/null +++ b/plotly/validators/_histogram.py @@ -0,0 +1,191 @@ +import _plotly_utils.basevalidators + + +class HistogramValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='histogram', parent_name='', **kwargs): + super(HistogramValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Histogram', + data_docs=""" + autobinx + Determines whether or not the x axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in xbins. + autobiny + Determines whether or not the y axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in ybins. + cumulative + plotly.graph_objs.histogram.Cumulative instance + or dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + error_x + plotly.graph_objs.histogram.ErrorX instance or + dict with compatible properties + error_y + plotly.graph_objs.histogram.ErrorY instance or + dict with compatible properties + histfunc + Specifies the binning function used for this + histogram trace. If *count*, the histogram + values are computed by counting the number of + values lying inside each bin. If *sum*, *avg*, + *min*, *max*, the histogram values are computed + using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for + this histogram trace. If **, the span of each + bar corresponds to the number of occurrences + (i.e. the number of data points lying inside + the bins). If *percent* / *probability*, the + span of each bar corresponds to the percentage + / fraction of occurrences with respect to the + total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, + the span of each bar corresponds to the number + of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin + AREAS equals the total number of sample + points). If *probability density*, the area of + each bar corresponds to the probability that an + event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.histogram.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.histogram.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + nbinsy + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the bars. With *v* + (*h*), the value of the each bar spans along + the vertical (horizontal). + selected + plotly.graph_objs.histogram.Selected instance + or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.histogram.Stream instance or + dict with compatible properties + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.histogram.Unselected instance + or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the sample data to be binned on the x + axis. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y + axis. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_histogram2d.py b/plotly/validators/_histogram2d.py new file mode 100644 index 0000000000..818e80066e --- /dev/null +++ b/plotly/validators/_histogram2d.py @@ -0,0 +1,206 @@ +import _plotly_utils.basevalidators + + +class Histogram2dValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='histogram2d', parent_name='', **kwargs): + super(Histogram2dValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Histogram2d', + data_docs=""" + autobinx + Determines whether or not the x axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in xbins. + autobiny + Determines whether or not the y axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in ybins. + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + colorbar + plotly.graph_objs.histogram2d.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + histfunc + Specifies the binning function used for this + histogram trace. If *count*, the histogram + values are computed by counting the number of + values lying inside each bin. If *sum*, *avg*, + *min*, *max*, the histogram values are computed + using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for + this histogram trace. If **, the span of each + bar corresponds to the number of occurrences + (i.e. the number of data points lying inside + the bins). If *percent* / *probability*, the + span of each bar corresponds to the percentage + / fraction of occurrences with respect to the + total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, + the span of each bar corresponds to the number + of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin + AREAS equals the total number of sample + points). If *probability density*, the area of + each bar corresponds to the probability that an + event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.histogram2d.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.histogram2d.Marker instance + or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + nbinsy + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.histogram2d.Stream instance + or dict with compatible properties + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the sample data to be binned on the x + axis. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2d.XBins instance or + dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date + data. + xgap + Sets the horizontal gap (in pixels) between + bricks. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y + axis. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2d.YBins instance or + dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date + data. + ygap + Sets the vertical gap (in pixels) between + bricks. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. See: https://github + .com/d3/d3-format/blob/master/README.md#locale_ + format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsmooth + Picks a smoothing algorithm use to smooth `z` + data. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_histogram2dcontour.py b/plotly/validators/_histogram2dcontour.py new file mode 100644 index 0000000000..4d09c33ada --- /dev/null +++ b/plotly/validators/_histogram2dcontour.py @@ -0,0 +1,220 @@ +import _plotly_utils.basevalidators + + +class Histogram2dContourValidator( + _plotly_utils.basevalidators.CompoundValidator +): + + def __init__( + self, plotly_name='histogram2dcontour', parent_name='', **kwargs + ): + super(Histogram2dContourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Histogram2dContour', + data_docs=""" + autobinx + Determines whether or not the x axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in xbins. + autobiny + Determines whether or not the y axis bin + attributes are picked by an algorithm. Note + that this should be set to false if you want to + manually set the number of bins using the + attributes in ybins. + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + autocontour + Determines whether or not the contour level + attributes are picked by an algorithm. If + *true*, the number of contour levels can be set + in `ncontours`. If *false*, set the contour + level attributes in `contours`. + colorbar + plotly.graph_objs.histogram2dcontour.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.histogram2dcontour.Contours + instance or dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + histfunc + Specifies the binning function used for this + histogram trace. If *count*, the histogram + values are computed by counting the number of + values lying inside each bin. If *sum*, *avg*, + *min*, *max*, the histogram values are computed + using the sum, the average, the minimum or the + maximum of the values lying inside each bin + respectively. + histnorm + Specifies the type of normalization used for + this histogram trace. If **, the span of each + bar corresponds to the number of occurrences + (i.e. the number of data points lying inside + the bins). If *percent* / *probability*, the + span of each bar corresponds to the percentage + / fraction of occurrences with respect to the + total number of sample points (here, the sum of + all bin HEIGHTS equals 100% / 1). If *density*, + the span of each bar corresponds to the number + of occurrences in a bin divided by the size of + the bin interval (here, the sum of all bin + AREAS equals the total number of sample + points). If *probability density*, the area of + each bar corresponds to the probability that an + event will fall into the corresponding bin + (here, the sum of all bin AREAS equals 1). + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.histogram2dcontour.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.histogram2dcontour.Line + instance or dict with compatible properties + marker + plotly.graph_objs.histogram2dcontour.Marker + instance or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + nbinsx + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + nbinsy + Specifies the maximum number of desired bins. + This value will be used in an algorithm that + will decide the optimal bin size such that the + histogram best visualizes the distribution of + the data. + ncontours + Sets the maximum number of contour levels. The + actual number of contours will be chosen + automatically to be less than or equal to the + value of `ncontours`. Has an effect only if + `autocontour` is *true* or if `contours.size` + is missing. + opacity + Sets the opacity of the trace. + reversescale + Reverses the colorscale. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.histogram2dcontour.Stream + instance or dict with compatible properties + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the sample data to be binned on the x + axis. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xbins + plotly.graph_objs.histogram2dcontour.XBins + instance or dict with compatible properties + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the sample data to be binned on the y + axis. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ybins + plotly.graph_objs.histogram2dcontour.YBins + instance or dict with compatible properties + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the aggregation data. + zauto + Determines the whether or not the color domain + is computed with respect to the input data. + zhoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. See: https://github + .com/d3/d3-format/blob/master/README.md#locale_ + format + zmax + Sets the upper bound of color domain. + zmin + Sets the lower bound of color domain. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_layout.py b/plotly/validators/_layout.py new file mode 100644 index 0000000000..3962b4378a --- /dev/null +++ b/plotly/validators/_layout.py @@ -0,0 +1,218 @@ +import _plotly_utils.basevalidators + + +class LayoutValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='layout', parent_name='', **kwargs): + super(LayoutValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Layout', + data_docs=""" + angularaxis + plotly.graph_objs.layout.AngularAxis instance + or dict with compatible properties + annotations + plotly.graph_objs.layout.Annotation instance or + dict with compatible properties + autosize + Determines whether or not a layout width or + height that has been left undefined by the user + is initialized on each relayout. Note that, + regardless of this attribute, an undefined + layout width or height is always initialized on + the first call to plot. + bargap + Sets the gap (in plot fraction) between bars of + adjacent location coordinates. + bargroupgap + Sets the gap (in plot fraction) between bars of + the same location coordinate. + barmode + Determines how bars at the same location + coordinate are displayed on the graph. With + *stack*, the bars are stacked on top of one + another With *relative*, the bars are stacked + on top of one another, with negative values + below the axis, positive values above With + *group*, the bars are plotted next to one + another centered around the shared location. + With *overlay*, the bars are plotted over one + another, you might need to an *opacity* to see + multiple bars. + barnorm + Sets the normalization for bar traces on the + graph. With *fraction*, the value of each bar + is divide by the sum of the values at the + location coordinate. With *percent*, the + results form *fraction* are presented in + percents. + boxgap + Sets the gap (in plot fraction) between boxes + of adjacent location coordinates. + boxgroupgap + Sets the gap (in plot fraction) between boxes + of the same location coordinate. + boxmode + Determines how boxes at the same location + coordinate are displayed on the graph. If + *group*, the boxes are plotted next to one + another centered around the shared location. If + *overlay*, the boxes are plotted over one + another, you might need to set *opacity* to see + them multiple boxes. + calendar + Sets the default calendar system to use for + interpreting and displaying dates throughout + the plot. + colorway + Sets the default trace colors. + datarevision + If provided, a changed value tells + `Plotly.react` that one or more data arrays has + changed. This way you can modify arrays in- + place rather than making a complete new copy + for an incremental change. If NOT provided, + `Plotly.react` assumes that data arrays are + being treated as immutable, thus any data array + with a different identity from its predecessor + contains new data. + direction + For polar plots only. Sets the direction + corresponding to positive angles. + dragmode + Determines the mode of drag interactions. + *select* and *lasso* apply only to scatter + traces with markers or text. *orbit* and + *turntable* apply only to 3D scenes. + font + Sets the global font. Note that fonts used in + traces and other layout components inherit from + the global font. + geo + plotly.graph_objs.layout.Geo instance or dict + with compatible properties + grid + plotly.graph_objs.layout.Grid instance or dict + with compatible properties + height + Sets the plot's height (in px). + hiddenlabels + + hiddenlabelssrc + Sets the source reference on plot.ly for + hiddenlabels . + hidesources + Determines whether or not a text link citing + the data source is placed at the bottom-right + cored of the figure. Has only an effect only on + graphs that have been generated via forked + graphs from the plotly service (at + https://plot.ly or on-premise). + hoverdistance + Sets the default distance (in pixels) to look + for data to add hover labels (-1 means no + cutoff, 0 means no looking for data). This is + only a real distance for hovering on point-like + objects, like scatter points. For area-like + objects (bars, scatter fills, etc) hovering is + on inside the area and off outside, but these + objects will not supersede hover on point-like + objects in case of conflict. + hoverlabel + plotly.graph_objs.layout.Hoverlabel instance or + dict with compatible properties + hovermode + Determines the mode of hover interactions. + images + plotly.graph_objs.layout.Image instance or dict + with compatible properties + legend + plotly.graph_objs.layout.Legend instance or + dict with compatible properties + mapbox + plotly.graph_objs.layout.Mapbox instance or + dict with compatible properties + margin + plotly.graph_objs.layout.Margin instance or + dict with compatible properties + orientation + For polar plots only. Rotates the entire polar + by the given angle. + paper_bgcolor + Sets the color of paper where the graph is + drawn. + plot_bgcolor + Sets the color of plotting area in-between x + and y axes. + polar + plotly.graph_objs.layout.Polar instance or dict + with compatible properties + radialaxis + plotly.graph_objs.layout.RadialAxis instance or + dict with compatible properties + scene + plotly.graph_objs.layout.Scene instance or dict + with compatible properties + selectdirection + When "dragmode" is set to "select", this limits + the selection of the drag to horizontal, + vertical or diagonal. "h" only allows + horizontal selection, "v" only vertical, "d" + only diagonal and "any" sets no limit. + separators + Sets the decimal and thousand separators. For + example, *. * puts a '.' before decimals and a + space between thousands. In English locales, + dflt is *.,* but other locales may alter this + default. + shapes + plotly.graph_objs.layout.Shape instance or dict + with compatible properties + showlegend + Determines whether or not a legend is drawn. + sliders + plotly.graph_objs.layout.Slider instance or + dict with compatible properties + spikedistance + Sets the default distance (in pixels) to look + for data to draw spikelines to (-1 means no + cutoff, 0 means no looking for data). As with + hoverdistance, distance does not apply to area- + like objects. In addition, some objects can be + hovered on but will not generate spikelines, + such as scatter fills. + ternary + plotly.graph_objs.layout.Ternary instance or + dict with compatible properties + title + Sets the plot's title. + titlefont + Sets the title font. + updatemenus + plotly.graph_objs.layout.Updatemenu instance or + dict with compatible properties + violingap + Sets the gap (in plot fraction) between violins + of adjacent location coordinates. + violingroupgap + Sets the gap (in plot fraction) between violins + of the same location coordinate. + violinmode + Determines how violins at the same location + coordinate are displayed on the graph. If + *group*, the violins are plotted next to one + another centered around the shared location. If + *overlay*, the violins are plotted over one + another, you might need to set *opacity* to see + them multiple violins. + width + Sets the plot's width (in px). + xaxis + plotly.graph_objs.layout.XAxis instance or dict + with compatible properties + yaxis + plotly.graph_objs.layout.YAxis instance or dict + with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/_mesh3d.py b/plotly/validators/_mesh3d.py new file mode 100644 index 0000000000..66343c4435 --- /dev/null +++ b/plotly/validators/_mesh3d.py @@ -0,0 +1,274 @@ +import _plotly_utils.basevalidators + + +class Mesh3dValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='mesh3d', parent_name='', **kwargs): + super(Mesh3dValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Mesh3d', + data_docs=""" + alphahull + Determines how the mesh surface triangles are + derived from the set of vertices (points) + represented by the `x`, `y` and `z` arrays, if + the `i`, `j`, `k` arrays are not supplied. For + general use of `mesh3d` it is preferred that + `i`, `j`, `k` are supplied. If *-1*, Delaunay + triangulation is used, which is mainly suitable + if the mesh is a single, more or less layer + surface that is perpendicular to + `delaunayaxis`. In case the `delaunayaxis` + intersects the mesh surface at more than one + point it will result triangles that are very + long in the dimension of `delaunayaxis`. If + *>0*, the alpha-shape algorithm is used. In + this case, the positive `alphahull` value + signals the use of the alpha-shape algorithm, + _and_ its value acts as the parameter for the + mesh fitting. If *0*, the convex-hull + algorithm is used. It is suitable for convex + bodies or if the intention is to enclose the + `x`, `y` and `z` point set into a convex hull. + autocolorscale + Has an effect only if `color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmin` must be + set as well. + cmin + Has an effect only if `color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmax` must be + set as well. + color + Sets the color of the whole mesh + colorbar + plotly.graph_objs.mesh3d.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `cmin` and `cmax`. Alternatively, + `colorscale` may be a palette name string of + the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, + Electric, Viridis, Cividis + contour + plotly.graph_objs.mesh3d.Contour instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + delaunayaxis + Sets the Delaunay axis, which is the axis that + is perpendicular to the surface of the Delaunay + triangulation. It has an effect if `i`, `j`, + `k` are not provided and `alphahull` is set to + indicate Delaunay triangulation. + facecolor + Sets the color of each face Overrides *color* + and *vertexcolor*. + facecolorsrc + Sets the source reference on plot.ly for + facecolor . + flatshading + Determines whether or not normal smoothing is + applied to the meshes, creating meshes with an + angular, low-poly look via flat reflections. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.mesh3d.Hoverlabel instance or + dict with compatible properties + i + A vector of vertex indices, i.e. integer values + between 0 and the length of the vertex vectors, + representing the *first* vertex of a triangle. + For example, `{i[m], j[m], k[m]}` together + represent face m (triangle m) in the mesh, + where `i[m] = n` points to the triplet `{x[n], + y[n], z[n]}` in the vertex arrays. Therefore, + each element in `i` represents a point in + space, which is the first vertex of a triangle. + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + intensity + Sets the vertex intensity values, used for + plotting fields on meshes + intensitysrc + Sets the source reference on plot.ly for + intensity . + isrc + Sets the source reference on plot.ly for i . + j + A vector of vertex indices, i.e. integer values + between 0 and the length of the vertex vectors, + representing the *second* vertex of a triangle. + For example, `{i[m], j[m], k[m]}` together + represent face m (triangle m) in the mesh, + where `j[m] = n` points to the triplet `{x[n], + y[n], z[n]}` in the vertex arrays. Therefore, + each element in `j` represents a point in + space, which is the second vertex of a + triangle. + jsrc + Sets the source reference on plot.ly for j . + k + A vector of vertex indices, i.e. integer values + between 0 and the length of the vertex vectors, + representing the *third* vertex of a triangle. + For example, `{i[m], j[m], k[m]}` together + represent face m (triangle m) in the mesh, + where `k[m] = n` points to the triplet `{x[n], + y[n], z[n]}` in the vertex arrays. Therefore, + each element in `k` represents a point in + space, which is the third vertex of a triangle. + ksrc + Sets the source reference on plot.ly for k . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + lighting + plotly.graph_objs.mesh3d.Lighting instance or + dict with compatible properties + lightposition + plotly.graph_objs.mesh3d.Lightposition instance + or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Has an effect only if `color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + scene + Sets a reference between this trace's 3D + coordinate system and a 3D scene. If *scene* + (the default value), the (x,y,z) coordinates + refer to `layout.scene`. If *scene2*, the + (x,y,z) coordinates refer to `layout.scene2`, + and so on. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.mesh3d.Stream instance or + dict with compatible properties + text + Sets the text elements associated with the + vertices. If trace `hoverinfo` contains a + *text* flag and *hovertext* is not set, these + elements will be seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + uid + + vertexcolor + Sets the color of each vertex Overrides + *color*. + vertexcolorsrc + Sets the source reference on plot.ly for + vertexcolor . + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the X coordinates of the vertices. The nth + element of vectors `x`, `y` and `z` jointly + represent the X, Y and Z coordinates of the nth + vertex. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the Y coordinates of the vertices. The nth + element of vectors `x`, `y` and `z` jointly + represent the X, Y and Z coordinates of the nth + vertex. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the Z coordinates of the vertices. The nth + element of vectors `x`, `y` and `z` jointly + represent the X, Y and Z coordinates of the nth + vertex. + zcalendar + Sets the calendar system to use with `z` date + data. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_ohlc.py b/plotly/validators/_ohlc.py new file mode 100644 index 0000000000..00d42f5fb3 --- /dev/null +++ b/plotly/validators/_ohlc.py @@ -0,0 +1,132 @@ +import _plotly_utils.basevalidators + + +class OhlcValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='ohlc', parent_name='', **kwargs): + super(OhlcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Ohlc', + data_docs=""" + close + Sets the close values. + closesrc + Sets the source reference on plot.ly for close + . + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + decreasing + plotly.graph_objs.ohlc.Decreasing instance or + dict with compatible properties + high + Sets the high values. + highsrc + Sets the source reference on plot.ly for high + . + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.ohlc.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + increasing + plotly.graph_objs.ohlc.Increasing instance or + dict with compatible properties + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.ohlc.Line instance or dict + with compatible properties + low + Sets the low values. + lowsrc + Sets the source reference on plot.ly for low . + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + open + Sets the open values. + opensrc + Sets the source reference on plot.ly for open + . + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.ohlc.Stream instance or dict + with compatible properties + text + Sets hover text elements associated with each + sample point. If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to this trace's sample points. + textsrc + Sets the source reference on plot.ly for text + . + tickwidth + Sets the width of the open/close tick marks + relative to the *x* minimal interval. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. If absent, linear + coordinate will be generated. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on.""", + **kwargs + ) diff --git a/plotly/validators/_parcoords.py b/plotly/validators/_parcoords.py new file mode 100644 index 0000000000..4bfd68d1c0 --- /dev/null +++ b/plotly/validators/_parcoords.py @@ -0,0 +1,88 @@ +import _plotly_utils.basevalidators + + +class ParcoordsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='parcoords', parent_name='', **kwargs): + super(ParcoordsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Parcoords', + data_docs=""" + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dimensions + The dimensions (variables) of the parallel + coordinates chart. 2..60 dimensions are + supported. + domain + plotly.graph_objs.parcoords.Domain instance or + dict with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.parcoords.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + labelfont + Sets the font for the `dimension` labels. + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.parcoords.Line instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + rangefont + Sets the font for the `dimension` range values. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.parcoords.Stream instance or + dict with compatible properties + tickfont + Sets the font for the `dimension` tick values. + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_pie.py b/plotly/validators/_pie.py new file mode 100644 index 0000000000..ebe1272934 --- /dev/null +++ b/plotly/validators/_pie.py @@ -0,0 +1,164 @@ +import _plotly_utils.basevalidators + + +class PieValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='pie', parent_name='', **kwargs): + super(PieValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Pie', + data_docs=""" + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + direction + Specifies the direction at which succeeding + sectors follow one another. + dlabel + Sets the label step. See `label0` for more + info. + domain + plotly.graph_objs.pie.Domain instance or dict + with compatible properties + hole + Sets the fraction of the radius to cut out of + the pie. Use this to make a donut chart. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.pie.Hoverlabel instance or + dict with compatible properties + hovertext + Sets hover text elements associated with each + sector. If a single string, the same string + appears for all data points. If an array of + string, the items are mapped in order of this + trace's sectors. To be seen, trace `hoverinfo` + must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + insidetextfont + Sets the font used for `textinfo` lying inside + the pie. + label0 + Alternate to `labels`. Builds a numeric set of + labels. Use with `dlabel` where `label0` is the + starting label and `dlabel` the step. + labels + Sets the sector labels. If `labels` entries are + duplicated, we sum associated `values` or + simply count occurrences if `values` is not + provided. For other array attributes (including + color) we use the first non-empty entry among + all occurrences of the label. + labelssrc + Sets the source reference on plot.ly for + labels . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.pie.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + outsidetextfont + Sets the font used for `textinfo` lying outside + the pie. + pull + Sets the fraction of larger radius to pull the + sectors out from the center. This can be a + constant to pull all slices apart from each + other equally or an array to highlight one or + more slices. + pullsrc + Sets the source reference on plot.ly for pull + . + rotation + Instead of the first slice starting at 12 + o'clock, rotate to some other angle. + scalegroup + If there are multiple pies that should be sized + according to their totals, link them by + providing a non-empty group id here shared by + every trace in the same group. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + sort + Determines whether or not the sectors are + reordered from largest to smallest. + stream + plotly.graph_objs.pie.Stream instance or dict + with compatible properties + text + Sets text elements associated with each sector. + If trace `textinfo` contains a *text* flag, + these elements will seen on the chart. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the font used for `textinfo`. + textinfo + Determines which trace information appear on + the graph. + textposition + Specifies the location of the `textinfo`. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + uid + + values + Sets the values of the sectors of this pie + chart. If omitted, we count occurrences of each + label. + valuessrc + Sets the source reference on plot.ly for + values . + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_pointcloud.py b/plotly/validators/_pointcloud.py new file mode 100644 index 0000000000..2b6f5a9a76 --- /dev/null +++ b/plotly/validators/_pointcloud.py @@ -0,0 +1,145 @@ +import _plotly_utils.basevalidators + + +class PointcloudValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='pointcloud', parent_name='', **kwargs): + super(PointcloudValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Pointcloud', + data_docs=""" + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.pointcloud.Hoverlabel + instance or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + indices + A sequential value, 0..n, supply it to avoid + creating this array inside plotting. If + specified, it must be a typed `Int32Array` + array. Its length must be equal to or greater + than the number of points. For the best + performance and memory use, create one large + `indices` typed array that is guaranteed to be + at least as long as the largest number of + points during use, and reuse it on each + `Plotly.restyle()` call. + indicessrc + Sets the source reference on plot.ly for + indices . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.pointcloud.Marker instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.pointcloud.Stream instance or + dict with compatible properties + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xbounds + Specify `xbounds` in the shape of `[xMin, xMax] + to avoid looping through the `xy` typed array. + Use it in conjunction with `xy` and `ybounds` + for the performance benefits. + xboundssrc + Sets the source reference on plot.ly for + xbounds . + xsrc + Sets the source reference on plot.ly for x . + xy + Faster alternative to specifying `x` and `y` + separately. If supplied, it must be a typed + `Float32Array` array that represents points + such that `xy[i * 2] = x[i]` and `xy[i * 2 + 1] + = y[i]` + xysrc + Sets the source reference on plot.ly for xy . + y + Sets the y coordinates. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ybounds + Specify `ybounds` in the shape of `[yMin, yMax] + to avoid looping through the `xy` typed array. + Use it in conjunction with `xy` and `xbounds` + for the performance benefits. + yboundssrc + Sets the source reference on plot.ly for + ybounds . + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_sankey.py b/plotly/validators/_sankey.py new file mode 100644 index 0000000000..77ea311c9f --- /dev/null +++ b/plotly/validators/_sankey.py @@ -0,0 +1,102 @@ +import _plotly_utils.basevalidators + + +class SankeyValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='sankey', parent_name='', **kwargs): + super(SankeyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Sankey', + data_docs=""" + arrangement + If value is `snap` (the default), the node + arrangement is assisted by automatic snapping + of elements to preserve space between nodes + specified via `nodepad`. If value is + `perpendicular`, the nodes can only move along + a line perpendicular to the flow. If value is + `freeform`, the nodes can freely move on the + plane. If value is `fixed`, the nodes are + stationary. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + domain + plotly.graph_objs.sankey.Domain instance or + dict with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.sankey.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + link + The links of the Sankey plot. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + node + The nodes of the Sankey plot. + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the Sankey diagram. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.sankey.Stream instance or + dict with compatible properties + textfont + Sets the font for node labels + uid + + valueformat + Sets the value formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + valuesuffix + Adds a unit to follow the value in the hover + tooltip. Add a space if a separation is + necessary from the value. + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_scatter.py b/plotly/validators/_scatter.py new file mode 100644 index 0000000000..735f2f7795 --- /dev/null +++ b/plotly/validators/_scatter.py @@ -0,0 +1,220 @@ +import _plotly_utils.basevalidators + + +class ScatterValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scatter', parent_name='', **kwargs): + super(ScatterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scatter', + data_docs=""" + cliponaxis + Determines whether or not markers and text + nodes are clipped about the subplot axes. To + show markers and text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` + and `yaxis.layer` to *below traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + error_x + plotly.graph_objs.scatter.ErrorX instance or + dict with compatible properties + error_y + plotly.graph_objs.scatter.ErrorY instance or + dict with compatible properties + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. *tozerox* and + *tozeroy* fill to x=0 and y=0 respectively. + *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of + the trace before it, connecting those endpoints + with straight lines (to make a stacked area + graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* + connects the endpoints of the trace (or each + segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between + two traces if one completely encloses the other + (eg consecutive contour lines), and behaves + like *toself* if there is no trace before it. + *tonext* should not be used if one trace does + not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scatter.Hoverlabel instance + or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + hovertext + Sets hover text elements associated with each + (x,y) pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scatter.Line instance or dict + with compatible properties + marker + plotly.graph_objs.scatter.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + r + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the radial + coordinates. + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatter.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scatter.Stream instance or + dict with compatible properties + t + For legacy polar chart only.Please switch to + *scatterpolar* trace type.Sets the angular + coordinates. + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + tsrc + Sets the source reference on plot.ly for t . + uid + + unselected + plotly.graph_objs.scatter.Unselected instance + or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_scatter3d.py b/plotly/validators/_scatter3d.py new file mode 100644 index 0000000000..4c547a1e3c --- /dev/null +++ b/plotly/validators/_scatter3d.py @@ -0,0 +1,167 @@ +import _plotly_utils.basevalidators + + +class Scatter3dValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scatter3d', parent_name='', **kwargs): + super(Scatter3dValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scatter3d', + data_docs=""" + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + error_x + plotly.graph_objs.scatter3d.ErrorX instance or + dict with compatible properties + error_y + plotly.graph_objs.scatter3d.ErrorY instance or + dict with compatible properties + error_z + plotly.graph_objs.scatter3d.ErrorZ instance or + dict with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scatter3d.Hoverlabel instance + or dict with compatible properties + hovertext + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y,z) coordinates. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scatter3d.Line instance or + dict with compatible properties + marker + plotly.graph_objs.scatter3d.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + projection + plotly.graph_objs.scatter3d.Projection instance + or dict with compatible properties + scene + Sets a reference between this trace's 3D + coordinate system and a 3D scene. If *scene* + (the default value), the (x,y,z) coordinates + refer to `layout.scene`. If *scene2*, the + (x,y,z) coordinates refer to `layout.scene2`, + and so on. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scatter3d.Stream instance or + dict with compatible properties + surfaceaxis + If *-1*, the scatter points are not fill with a + surface If *0*, *1*, *2*, the scatter points + are filled with a Delaunay surface about the x, + y, z respectively. + surfacecolor + Sets the surface fill color. + text + Sets text elements associated with each (x,y,z) + triplet. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y,z) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date + data. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_scattercarpet.py b/plotly/validators/_scattercarpet.py new file mode 100644 index 0000000000..818900ab37 --- /dev/null +++ b/plotly/validators/_scattercarpet.py @@ -0,0 +1,171 @@ +import _plotly_utils.basevalidators + + +class ScattercarpetValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scattercarpet', parent_name='', **kwargs): + super(ScattercarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scattercarpet', + data_docs=""" + a + Sets the quantity of component `a` in each data + point. If `a`, `b`, and `c` are all provided, + they need not be normalized, only the relative + values matter. If only two arrays are provided + they must be normalized to match + `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data + point. If `a`, `b`, and `c` are all provided, + they need not be normalized, only the relative + values matter. If only two arrays are provided + they must be normalized to match + `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + carpet + An identifier for this carpet, so that + `scattercarpet` and `scattercontour` traces can + specify a carpet plot on which they lie + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. scatterternary + has a subset of the options available to + scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the + space between two traces if one completely + encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is + no trace before it. *tonext* should not be used + if one trace does not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scattercarpet.Hoverlabel + instance or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scattercarpet.Line instance + or dict with compatible properties + marker + plotly.graph_objs.scattercarpet.Marker instance + or dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattercarpet.Selected + instance or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scattercarpet.Stream instance + or dict with compatible properties + text + Sets text elements associated with each (a,b,c) + point. If a single string, the same string + appears over all the data points. If an array + of strings, the items are mapped in order to + the the data points in (a,b,c). + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.scattercarpet.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on.""", + **kwargs + ) diff --git a/plotly/validators/_scattergeo.py b/plotly/validators/_scattergeo.py new file mode 100644 index 0000000000..56c897d6ce --- /dev/null +++ b/plotly/validators/_scattergeo.py @@ -0,0 +1,168 @@ +import _plotly_utils.basevalidators + + +class ScattergeoValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scattergeo', parent_name='', **kwargs): + super(ScattergeoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scattergeo', + data_docs=""" + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. *toself* + connects the endpoints of the trace (or each + segment of the trace if it has gaps) into a + closed shape. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + geo + Sets a reference between this trace's + geospatial coordinates and a geographic map. If + *geo* (the default value), the geospatial + coordinates refer to `layout.geo`. If *geo2*, + the geospatial coordinates refer to + `layout.geo2`, and so on. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scattergeo.Hoverlabel + instance or dict with compatible properties + hovertext + Sets hover text elements associated with each + (lon,lat) pair or item in `locations`. If a + single string, the same string appears over all + the data points. If an array of string, the + items are mapped in order to the this trace's + (lon,lat) or `locations` coordinates. To be + seen, trace `hoverinfo` must contain a *text* + flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees + North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scattergeo.Line instance or + dict with compatible properties + locationmode + Determines the set of locations used to match + entries in `locations` to regions on the map. + locations + Sets the coordinates via location IDs or names. + Coordinates correspond to the centroid of each + location given. See `locationmode` for more + info. + locationssrc + Sets the source reference on plot.ly for + locations . + lon + Sets the longitude coordinates (in degrees + East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattergeo.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergeo.Selected instance + or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scattergeo.Stream instance or + dict with compatible properties + text + Sets text elements associated with each + (lon,lat) pair or item in `locations`. If a + single string, the same string appears over all + the data points. If an array of string, the + items are mapped in order to the this trace's + (lon,lat) or `locations` coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.scattergeo.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_scattergl.py b/plotly/validators/_scattergl.py new file mode 100644 index 0000000000..7143b30587 --- /dev/null +++ b/plotly/validators/_scattergl.py @@ -0,0 +1,177 @@ +import _plotly_utils.basevalidators + + +class ScatterglValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scattergl', parent_name='', **kwargs): + super(ScatterglValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scattergl', + data_docs=""" + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + dx + Sets the x coordinate step. See `x0` for more + info. + dy + Sets the y coordinate step. See `y0` for more + info. + error_x + plotly.graph_objs.scattergl.ErrorX instance or + dict with compatible properties + error_y + plotly.graph_objs.scattergl.ErrorY instance or + dict with compatible properties + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. *tozerox* and + *tozeroy* fill to x=0 and y=0 respectively. + *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of + the trace before it, connecting those endpoints + with straight lines (to make a stacked area + graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* + connects the endpoints of the trace (or each + segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between + two traces if one completely encloses the other + (eg consecutive contour lines), and behaves + like *toself* if there is no trace before it. + *tonext* should not be used if one trace does + not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scattergl.Hoverlabel instance + or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scattergl.Line instance or + dict with compatible properties + marker + plotly.graph_objs.scattergl.Marker instance or + dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattergl.Selected instance + or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scattergl.Stream instance or + dict with compatible properties + text + Sets text elements associated with each (x,y) + pair to appear on hover. If a single string, + the same string appears over all the data + points. If an array of string, the items are + mapped in order to the this trace's (x,y) + coordinates. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.scattergl.Unselected instance + or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + x0 + Alternate to `x`. Builds a linear space of x + coordinates. Use with `dx` where `x0` is the + starting coordinate and `dx` the step. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + y0 + Alternate to `y`. Builds a linear space of y + coordinates. Use with `dy` where `y0` is the + starting coordinate and `dy` the step. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/_scattermapbox.py b/plotly/validators/_scattermapbox.py new file mode 100644 index 0000000000..17a11ca067 --- /dev/null +++ b/plotly/validators/_scattermapbox.py @@ -0,0 +1,150 @@ +import _plotly_utils.basevalidators + + +class ScattermapboxValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scattermapbox', parent_name='', **kwargs): + super(ScattermapboxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scattermapbox', + data_docs=""" + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. *toself* + connects the endpoints of the trace (or each + segment of the trace if it has gaps) into a + closed shape. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scattermapbox.Hoverlabel + instance or dict with compatible properties + hovertext + Sets hover text elements associated with each + (lon,lat) pair If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to the this trace's (lon,lat) coordinates. To + be seen, trace `hoverinfo` must contain a + *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + lat + Sets the latitude coordinates (in degrees + North). + latsrc + Sets the source reference on plot.ly for lat . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scattermapbox.Line instance + or dict with compatible properties + lon + Sets the longitude coordinates (in degrees + East). + lonsrc + Sets the source reference on plot.ly for lon . + marker + plotly.graph_objs.scattermapbox.Marker instance + or dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scattermapbox.Selected + instance or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scattermapbox.Stream instance + or dict with compatible properties + subplot + Sets a reference between this trace's data + coordinates and a mapbox subplot. If *mapbox* + (the default value), the data refer to + `layout.mapbox`. If *mapbox2*, the data refer + to `layout.mapbox2`, and so on. + text + Sets text elements associated with each + (lon,lat) pair If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to the this trace's (lon,lat) coordinates. If + trace `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the icon text font. Has an effect only + when `type` is set to *symbol*. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.scattermapbox.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_scatterpolar.py b/plotly/validators/_scatterpolar.py new file mode 100644 index 0000000000..ea81a66ad4 --- /dev/null +++ b/plotly/validators/_scatterpolar.py @@ -0,0 +1,174 @@ +import _plotly_utils.basevalidators + + +class ScatterpolarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scatterpolar', parent_name='', **kwargs): + super(ScatterpolarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scatterpolar', + data_docs=""" + cliponaxis + Determines whether or not markers and text + nodes are clipped about the subplot axes. To + show markers and text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` + and `yaxis.layer` to *below traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. scatterpolar + has a subset of the options available to + scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the + space between two traces if one completely + encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is + no trace before it. *tonext* should not be used + if one trace does not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolar.Hoverlabel + instance or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + hovertext + Sets hover text elements associated with each + (x,y) pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scatterpolar.Line instance or + dict with compatible properties + marker + plotly.graph_objs.scatterpolar.Marker instance + or dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolar.Selected + instance or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scatterpolar.Stream instance + or dict with compatible properties + subplot + Sets a reference between this trace's data + coordinates and a polar subplot. If *polar* + (the default value), the data refer to + `layout.polar`. If *polar2*, the data refer to + `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta + . + thetaunit + Sets the unit of input *theta* values. Has an + effect only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolar.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_scatterpolargl.py b/plotly/validators/_scatterpolargl.py new file mode 100644 index 0000000000..6684dd4bf3 --- /dev/null +++ b/plotly/validators/_scatterpolargl.py @@ -0,0 +1,156 @@ +import _plotly_utils.basevalidators + + +class ScatterpolarglValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scatterpolargl', parent_name='', **kwargs): + super(ScatterpolarglValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scatterpolargl', + data_docs=""" + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. *tozerox* and + *tozeroy* fill to x=0 and y=0 respectively. + *tonextx* and *tonexty* fill between the + endpoints of this trace and the endpoints of + the trace before it, connecting those endpoints + with straight lines (to make a stacked area + graph); if there is no trace before it, they + behave like *tozerox* and *tozeroy*. *toself* + connects the endpoints of the trace (or each + segment of the trace if it has gaps) into a + closed shape. *tonext* fills the space between + two traces if one completely encloses the other + (eg consecutive contour lines), and behaves + like *toself* if there is no trace before it. + *tonext* should not be used if one trace does + not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scatterpolargl.Hoverlabel + instance or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scatterpolargl.Line instance + or dict with compatible properties + marker + plotly.graph_objs.scatterpolargl.Marker + instance or dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + r + Sets the radial coordinates + rsrc + Sets the source reference on plot.ly for r . + selected + plotly.graph_objs.scatterpolargl.Selected + instance or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scatterpolargl.Stream + instance or dict with compatible properties + subplot + Sets a reference between this trace's data + coordinates and a polar subplot. If *polar* + (the default value), the data refer to + `layout.polar`. If *polar2*, the data refer to + `layout.polar2`, and so on. + text + Sets text elements associated with each (x,y) + pair. If a single string, the same string + appears over all the data points. If an array + of string, the items are mapped in order to the + this trace's (x,y) coordinates. If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + theta + Sets the angular coordinates + thetasrc + Sets the source reference on plot.ly for theta + . + thetaunit + Sets the unit of input *theta* values. Has an + effect only when on *linear* angular axes. + uid + + unselected + plotly.graph_objs.scatterpolargl.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_scatterternary.py b/plotly/validators/_scatterternary.py new file mode 100644 index 0000000000..2299f2c696 --- /dev/null +++ b/plotly/validators/_scatterternary.py @@ -0,0 +1,196 @@ +import _plotly_utils.basevalidators + + +class ScatterternaryValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scatterternary', parent_name='', **kwargs): + super(ScatterternaryValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scatterternary', + data_docs=""" + a + Sets the quantity of component `a` in each data + point. If `a`, `b`, and `c` are all provided, + they need not be normalized, only the relative + values matter. If only two arrays are provided + they must be normalized to match + `ternary.sum`. + asrc + Sets the source reference on plot.ly for a . + b + Sets the quantity of component `a` in each data + point. If `a`, `b`, and `c` are all provided, + they need not be normalized, only the relative + values matter. If only two arrays are provided + they must be normalized to match + `ternary.sum`. + bsrc + Sets the source reference on plot.ly for b . + c + Sets the quantity of component `a` in each data + point. If `a`, `b`, and `c` are all provided, + they need not be normalized, only the relative + values matter. If only two arrays are provided + they must be normalized to match + `ternary.sum`. + cliponaxis + Determines whether or not markers and text + nodes are clipped about the subplot axes. To + show markers and text nodes above axis lines + and tick labels, make sure to set `xaxis.layer` + and `yaxis.layer` to *below traces*. + connectgaps + Determines whether or not gaps (i.e. {nan} or + missing values) in the provided data arrays are + connected. + csrc + Sets the source reference on plot.ly for c . + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fill + Sets the area to fill with a solid color. Use + with `fillcolor` if not *none*. scatterternary + has a subset of the options available to + scatter. *toself* connects the endpoints of the + trace (or each segment of the trace if it has + gaps) into a closed shape. *tonext* fills the + space between two traces if one completely + encloses the other (eg consecutive contour + lines), and behaves like *toself* if there is + no trace before it. *tonext* should not be used + if one trace does not enclose the other. + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.scatterternary.Hoverlabel + instance or dict with compatible properties + hoveron + Do the hover effects highlight individual + points (markers or line points) or do they + highlight filled regions? If the fill is + *toself* or *tonext* and there are no markers + or text, then the default is *fills*, otherwise + it is *points*. + hovertext + Sets hover text elements associated with each + (a,b,c) point. If a single string, the same + string appears over all the data points. If an + array of strings, the items are mapped in order + to the the data points in (a,b,c). To be seen, + trace `hoverinfo` must contain a *text* flag. + hovertextsrc + Sets the source reference on plot.ly for + hovertext . + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.scatterternary.Line instance + or dict with compatible properties + marker + plotly.graph_objs.scatterternary.Marker + instance or dict with compatible properties + mode + Determines the drawing mode for this scatter + trace. If the provided `mode` includes *text* + then the `text` elements appear at the + coordinates. Otherwise, the `text` elements + appear on hover. If there are less than 20 + points, then the default is *lines+markers*. + Otherwise, *lines*. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.scatterternary.Selected + instance or dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.scatterternary.Stream + instance or dict with compatible properties + subplot + Sets a reference between this trace's data + coordinates and a ternary subplot. If *ternary* + (the default value), the data refer to + `layout.ternary`. If *ternary2*, the data refer + to `layout.ternary2`, and so on. + sum + The number each triplet should sum to, if only + two of `a`, `b`, and `c` are provided. This + overrides `ternary.sum` to normalize this + specific trace, but does not affect the values + displayed on the axes. 0 (or missing) means to + use ternary.sum + text + Sets text elements associated with each (a,b,c) + point. If a single string, the same string + appears over all the data points. If an array + of strings, the items are mapped in order to + the the data points in (a,b,c). If trace + `hoverinfo` contains a *text* flag and + *hovertext* is not set, these elements will be + seen in the hover labels. + textfont + Sets the text font. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates. + textpositionsrc + Sets the source reference on plot.ly for + textposition . + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.scatterternary.Unselected + instance or dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_splom.py b/plotly/validators/_splom.py new file mode 100644 index 0000000000..35b4be723a --- /dev/null +++ b/plotly/validators/_splom.py @@ -0,0 +1,113 @@ +import _plotly_utils.basevalidators + + +class SplomValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='splom', parent_name='', **kwargs): + super(SplomValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Splom', + data_docs=""" + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + diagonal + plotly.graph_objs.splom.Diagonal instance or + dict with compatible properties + dimensions + plotly.graph_objs.splom.Dimension instance or + dict with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.splom.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + marker + plotly.graph_objs.splom.Marker instance or dict + with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selected + plotly.graph_objs.splom.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showlowerhalf + Determines whether or not subplots on the lower + half from the diagonal are displayed. + showupperhalf + Determines whether or not subplots on the upper + half from the diagonal are displayed. + stream + plotly.graph_objs.splom.Stream instance or dict + with compatible properties + text + Sets text elements associated with each (x,y) + pair to appear on hover. If a single string, + the same string appears over all the data + points. If an array of string, the items are + mapped in order to the this trace's (x,y) + coordinates. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.splom.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + xaxes + Sets the list of x axes corresponding to this + splom trace. By default, a splom will match the + first N xaxes where N is the number of input + dimensions. + yaxes + Sets the list of y axes corresponding to this + splom trace. By default, a splom will match the + first N yaxes where N is the number of input + dimensions.""", + **kwargs + ) diff --git a/plotly/validators/_surface.py b/plotly/validators/_surface.py new file mode 100644 index 0000000000..33d23082d8 --- /dev/null +++ b/plotly/validators/_surface.py @@ -0,0 +1,156 @@ +import _plotly_utils.basevalidators + + +class SurfaceValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='surface', parent_name='', **kwargs): + super(SurfaceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Surface', + data_docs=""" + autocolorscale + Determines whether or not the colorscale is + picked using the sign of the input z values. + cauto + Determines the whether or not the color domain + is computed with respect to the input data. + cmax + Sets the upper bound of color domain. + cmin + Sets the lower bound of color domain. + colorbar + plotly.graph_objs.surface.ColorBar instance or + dict with compatible properties + colorscale + Sets the colorscale. The colorscale must be an + array containing arrays mapping a normalized + value to an rgb, rgba, hex, hsl, hsv, or named + color string. At minimum, a mapping for the + lowest (0) and highest (1) values are required. + For example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in z space, use zmin and zmax + contours + plotly.graph_objs.surface.Contours instance or + dict with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + hidesurface + Determines whether or not a surface is drawn. + For example, set `hidesurface` to *false* + `contours.x.show` to *true* and + `contours.y.show` to *true* to draw a wire + frame plot. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.surface.Hoverlabel instance + or dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + lighting + plotly.graph_objs.surface.Lighting instance or + dict with compatible properties + lightposition + plotly.graph_objs.surface.Lightposition + instance or dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the surface. + reversescale + Reverses the colorscale. + scene + Sets a reference between this trace's 3D + coordinate system and a 3D scene. If *scene* + (the default value), the (x,y,z) coordinates + refer to `layout.scene`. If *scene2*, the + (x,y,z) coordinates refer to `layout.scene2`, + and so on. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + showscale + Determines whether or not a colorbar is + displayed for this trace. + stream + plotly.graph_objs.surface.Stream instance or + dict with compatible properties + surfacecolor + Sets the surface color values, used for setting + a color scale independent of `z`. + surfacecolorsrc + Sets the source reference on plot.ly for + surfacecolor . + text + Sets the text elements associated with each z + value. If trace `hoverinfo` contains a *text* + flag and *hovertext* is not set, these elements + will be seen in the hover labels. + textsrc + Sets the source reference on plot.ly for text + . + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x coordinates. + xcalendar + Sets the calendar system to use with `x` date + data. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y coordinates. + ycalendar + Sets the calendar system to use with `y` date + data. + ysrc + Sets the source reference on plot.ly for y . + z + Sets the z coordinates. + zcalendar + Sets the calendar system to use with `z` date + data. + zsrc + Sets the source reference on plot.ly for z .""", + **kwargs + ) diff --git a/plotly/validators/_table.py b/plotly/validators/_table.py new file mode 100644 index 0000000000..4b3de6cbff --- /dev/null +++ b/plotly/validators/_table.py @@ -0,0 +1,97 @@ +import _plotly_utils.basevalidators + + +class TableValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='table', parent_name='', **kwargs): + super(TableValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Table', + data_docs=""" + cells + plotly.graph_objs.table.Cells instance or dict + with compatible properties + columnorder + Specifies the rendered order of the data + columns; for example, a value `2` at position + `0` means that column index `0` in the data + will be rendered as the third column, as + columns have an index base of zero. + columnordersrc + Sets the source reference on plot.ly for + columnorder . + columnwidth + The width of columns expressed as a ratio. + Columns fill the available width in proportion + of their specified column widths. + columnwidthsrc + Sets the source reference on plot.ly for + columnwidth . + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + domain + plotly.graph_objs.table.Domain instance or dict + with compatible properties + header + plotly.graph_objs.table.Header instance or dict + with compatible properties + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.table.Hoverlabel instance or + dict with compatible properties + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + name + Sets the trace name. The trace name appear as + the legend item and on hover. + opacity + Sets the opacity of the trace. + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + stream + plotly.graph_objs.table.Stream instance or dict + with compatible properties + uid + + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible).""", + **kwargs + ) diff --git a/plotly/validators/_violin.py b/plotly/validators/_violin.py new file mode 100644 index 0000000000..804da5c726 --- /dev/null +++ b/plotly/validators/_violin.py @@ -0,0 +1,206 @@ +import _plotly_utils.basevalidators + + +class ViolinValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='violin', parent_name='', **kwargs): + super(ViolinValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Violin', + data_docs=""" + bandwidth + Sets the bandwidth used to compute the kernel + density estimate. By default, the bandwidth is + determined by Silverman's rule of thumb. + box + plotly.graph_objs.violin.Box instance or dict + with compatible properties + customdata + Assigns extra data each datum. This may be + useful when listening to hover, click and + selection events. Note that, *scatter* traces + also appends customdata items in the markers + DOM elements + customdatasrc + Sets the source reference on plot.ly for + customdata . + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + hoverinfo + Determines which trace information appear on + hover. If `none` or `skip` are set, no + information is displayed upon hovering. But, if + `none` is set, click and hover events are still + fired. + hoverinfosrc + Sets the source reference on plot.ly for + hoverinfo . + hoverlabel + plotly.graph_objs.violin.Hoverlabel instance or + dict with compatible properties + hoveron + Do the hover effects highlight individual + violins or sample points or the kernel density + estimate or any combination of them? + ids + Assigns id labels to each datum. These ids for + object constancy of data points during + animation. Should be an array of strings, not + numbers or any other type. + idssrc + Sets the source reference on plot.ly for ids . + jitter + Sets the amount of jitter in the sample points + drawn. If *0*, the sample points align along + the distribution axis. If *1*, the sample + points are drawn in a random jitter of width + equal to the width of the violins. + legendgroup + Sets the legend group for this trace. Traces + part of the same legend group hide/show at the + same time when toggling legend items. + line + plotly.graph_objs.violin.Line instance or dict + with compatible properties + marker + plotly.graph_objs.violin.Marker instance or + dict with compatible properties + meanline + plotly.graph_objs.violin.Meanline instance or + dict with compatible properties + name + Sets the trace name. The trace name appear as + the legend item and on hover. For box traces, + the name will also be used for the position + coordinate, if `x` and `x0` (`y` and `y0` if + horizontal) are missing and the position axis + is categorical + opacity + Sets the opacity of the trace. + orientation + Sets the orientation of the violin(s). If *v* + (*h*), the distribution is visualized along the + vertical (horizontal). + pointpos + Sets the position of the sample points in + relation to the violins. If *0*, the sample + points are places over the center of the + violins. Positive (negative) values correspond + to positions to the right (left) for vertical + violins and above (below) for horizontal + violins. + points + If *outliers*, only the sample points lying + outside the whiskers are shown If + *suspectedoutliers*, the outlier points are + shown and points either less than 4*Q1-3*Q3 or + greater than 4*Q3-3*Q1 are highlighted (see + `outliercolor`) If *all*, all sample points are + shown If *false*, only the violins are shown + with no sample points + scalegroup + If there are multiple violins that should be + sized according to to some metric (see + `scalemode`), link them by providing a non- + empty group id here shared by every trace in + the same group. + scalemode + Sets the metric by which the width of each + violin is determined.*width* means each violin + has the same (max) width*count* means the + violins are scaled by the number of sample + points makingup each violin. + selected + plotly.graph_objs.violin.Selected instance or + dict with compatible properties + selectedpoints + Array containing integer indices of selected + points. Has an effect only for traces that + support selections. Note that an empty array + means an empty selection where the `unselected` + are turned on for all points, whereas, any + other non-array values means no selection all + where the `selected` and `unselected` styles + have no effect. + showlegend + Determines whether or not an item corresponding + to this trace is shown in the legend. + side + Determines on which side of the position value + the density function making up one half of a + violin is plotted. Useful when comparing two + violin traces under *overlay* mode, where one + trace has `side` set to *positive* and the + other to *negative*. + span + Sets the span in data space for which the + density function will be computed. Has an + effect only when `spanmode` is set to *manual*. + spanmode + Sets the method by which the span in data space + where the density function will be computed. + *soft* means the span goes from the sample's + minimum value minus two bandwidths to the + sample's maximum value plus two bandwidths. + *hard* means the span goes from the sample's + minimum to its maximum value. For custom span + settings, use mode *manual* and fill in the + `span` attribute. + stream + plotly.graph_objs.violin.Stream instance or + dict with compatible properties + text + Sets the text elements associated with each + sample value. If a single string, the same + string appears over all the data points. If an + array of string, the items are mapped in order + to the this trace's (x,y) coordinates. To be + seen, trace `hoverinfo` must contain a *text* + flag. + textsrc + Sets the source reference on plot.ly for text + . + uid + + unselected + plotly.graph_objs.violin.Unselected instance or + dict with compatible properties + visible + Determines whether or not this trace is + visible. If *legendonly*, the trace is not + drawn, but can appear as a legend item + (provided that the legend itself is visible). + x + Sets the x sample data or coordinates. See + overview for more info. + x0 + Sets the x coordinate of the box. See overview + for more info. + xaxis + Sets a reference between this trace's x + coordinates and a 2D cartesian x axis. If *x* + (the default value), the x coordinates refer to + `layout.xaxis`. If *x2*, the x coordinates + refer to `layout.xaxis2`, and so on. + xsrc + Sets the source reference on plot.ly for x . + y + Sets the y sample data or coordinates. See + overview for more info. + y0 + Sets the y coordinate of the box. See overview + for more info. + yaxis + Sets a reference between this trace's y + coordinates and a 2D cartesian y axis. If *y* + (the default value), the y coordinates refer to + `layout.yaxis`. If *y2*, the y coordinates + refer to `layout.yaxis2`, and so on. + ysrc + Sets the source reference on plot.ly for y .""", + **kwargs + ) diff --git a/plotly/validators/area/__init__.py b/plotly/validators/area/__init__.py new file mode 100644 index 0000000000..54b2c156da --- /dev/null +++ b/plotly/validators/area/__init__.py @@ -0,0 +1,20 @@ +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._tsrc import TsrcValidator +from ._t import TValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._rsrc import RsrcValidator +from ._r import RValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator diff --git a/plotly/validators/area/_customdata.py b/plotly/validators/area/_customdata.py new file mode 100644 index 0000000000..5e8972d2f1 --- /dev/null +++ b/plotly/validators/area/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='area', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/area/_customdatasrc.py b/plotly/validators/area/_customdatasrc.py new file mode 100644 index 0000000000..b832d9c887 --- /dev/null +++ b/plotly/validators/area/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='area', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_hoverinfo.py b/plotly/validators/area/_hoverinfo.py new file mode 100644 index 0000000000..7b882971b3 --- /dev/null +++ b/plotly/validators/area/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='area', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_hoverinfosrc.py b/plotly/validators/area/_hoverinfosrc.py new file mode 100644 index 0000000000..b89b4b44bb --- /dev/null +++ b/plotly/validators/area/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='area', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_hoverlabel.py b/plotly/validators/area/_hoverlabel.py new file mode 100644 index 0000000000..805d8440f4 --- /dev/null +++ b/plotly/validators/area/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='area', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/area/_ids.py b/plotly/validators/area/_ids.py new file mode 100644 index 0000000000..1f7a640b8c --- /dev/null +++ b/plotly/validators/area/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='area', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/area/_idssrc.py b/plotly/validators/area/_idssrc.py new file mode 100644 index 0000000000..97de1af55f --- /dev/null +++ b/plotly/validators/area/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='area', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_legendgroup.py b/plotly/validators/area/_legendgroup.py new file mode 100644 index 0000000000..f5993361f0 --- /dev/null +++ b/plotly/validators/area/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='area', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_marker.py b/plotly/validators/area/_marker.py new file mode 100644 index 0000000000..486bf2810f --- /dev/null +++ b/plotly/validators/area/_marker.py @@ -0,0 +1,42 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='area', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color + . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + size + Sets the marker size (in px). + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/area/_name.py b/plotly/validators/area/_name.py new file mode 100644 index 0000000000..0eda172d6e --- /dev/null +++ b/plotly/validators/area/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='area', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_opacity.py b/plotly/validators/area/_opacity.py new file mode 100644 index 0000000000..783e566180 --- /dev/null +++ b/plotly/validators/area/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='area', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/area/_r.py b/plotly/validators/area/_r.py new file mode 100644 index 0000000000..d19421ecfa --- /dev/null +++ b/plotly/validators/area/_r.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='r', parent_name='area', **kwargs): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/area/_rsrc.py b/plotly/validators/area/_rsrc.py new file mode 100644 index 0000000000..c7f848e651 --- /dev/null +++ b/plotly/validators/area/_rsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='rsrc', parent_name='area', **kwargs): + super(RsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_selectedpoints.py b/plotly/validators/area/_selectedpoints.py new file mode 100644 index 0000000000..e9b3008fa4 --- /dev/null +++ b/plotly/validators/area/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='area', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_showlegend.py b/plotly/validators/area/_showlegend.py new file mode 100644 index 0000000000..ef351b799e --- /dev/null +++ b/plotly/validators/area/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='area', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_stream.py b/plotly/validators/area/_stream.py new file mode 100644 index 0000000000..fe8b56c62a --- /dev/null +++ b/plotly/validators/area/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='area', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/area/_t.py b/plotly/validators/area/_t.py new file mode 100644 index 0000000000..7c77140629 --- /dev/null +++ b/plotly/validators/area/_t.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='t', parent_name='area', **kwargs): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/area/_tsrc.py b/plotly/validators/area/_tsrc.py new file mode 100644 index 0000000000..d08082d6ab --- /dev/null +++ b/plotly/validators/area/_tsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='tsrc', parent_name='area', **kwargs): + super(TsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_uid.py b/plotly/validators/area/_uid.py new file mode 100644 index 0000000000..f96b16665e --- /dev/null +++ b/plotly/validators/area/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='area', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/_visible.py b/plotly/validators/area/_visible.py new file mode 100644 index 0000000000..075ad108a8 --- /dev/null +++ b/plotly/validators/area/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='area', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/__init__.py b/plotly/validators/area/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/area/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/area/hoverlabel/_bgcolor.py b/plotly/validators/area/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..124d4abb8f --- /dev/null +++ b/plotly/validators/area/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='area.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_bgcolorsrc.py b/plotly/validators/area/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..3e1ec8eaf7 --- /dev/null +++ b/plotly/validators/area/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='area.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_bordercolor.py b/plotly/validators/area/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..c8c3f5967d --- /dev/null +++ b/plotly/validators/area/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='area.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_bordercolorsrc.py b/plotly/validators/area/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..ce28a781d8 --- /dev/null +++ b/plotly/validators/area/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='area.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_font.py b/plotly/validators/area/hoverlabel/_font.py new file mode 100644 index 0000000000..17e4fb6bdd --- /dev/null +++ b/plotly/validators/area/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='area.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_namelength.py b/plotly/validators/area/hoverlabel/_namelength.py new file mode 100644 index 0000000000..f50642a006 --- /dev/null +++ b/plotly/validators/area/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='area.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/_namelengthsrc.py b/plotly/validators/area/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..6ba755a0f2 --- /dev/null +++ b/plotly/validators/area/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='area.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/__init__.py b/plotly/validators/area/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/area/hoverlabel/font/_color.py b/plotly/validators/area/hoverlabel/font/_color.py new file mode 100644 index 0000000000..3bd05ecf4f --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='area.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/_colorsrc.py b/plotly/validators/area/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..33c85f52da --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='area.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/_family.py b/plotly/validators/area/hoverlabel/font/_family.py new file mode 100644 index 0000000000..2aa18f1895 --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='area.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/_familysrc.py b/plotly/validators/area/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..ff37566ad7 --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='area.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/_size.py b/plotly/validators/area/hoverlabel/font/_size.py new file mode 100644 index 0000000000..6ea4488170 --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='area.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/area/hoverlabel/font/_sizesrc.py b/plotly/validators/area/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..43e8e4a5d7 --- /dev/null +++ b/plotly/validators/area/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='area.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/marker/__init__.py b/plotly/validators/area/marker/__init__.py new file mode 100644 index 0000000000..274a546c58 --- /dev/null +++ b/plotly/validators/area/marker/__init__.py @@ -0,0 +1,8 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/area/marker/_color.py b/plotly/validators/area/marker/_color.py new file mode 100644 index 0000000000..2ecf294d87 --- /dev/null +++ b/plotly/validators/area/marker/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='area.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/area/marker/_colorsrc.py b/plotly/validators/area/marker/_colorsrc.py new file mode 100644 index 0000000000..e1389e4673 --- /dev/null +++ b/plotly/validators/area/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='area.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/marker/_opacity.py b/plotly/validators/area/marker/_opacity.py new file mode 100644 index 0000000000..24b9fdbb55 --- /dev/null +++ b/plotly/validators/area/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='area.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/area/marker/_opacitysrc.py b/plotly/validators/area/marker/_opacitysrc.py new file mode 100644 index 0000000000..343bdc882a --- /dev/null +++ b/plotly/validators/area/marker/_opacitysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='opacitysrc', parent_name='area.marker', **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/marker/_size.py b/plotly/validators/area/marker/_size.py new file mode 100644 index 0000000000..f5902714b0 --- /dev/null +++ b/plotly/validators/area/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='area.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/area/marker/_sizesrc.py b/plotly/validators/area/marker/_sizesrc.py new file mode 100644 index 0000000000..3eedb56087 --- /dev/null +++ b/plotly/validators/area/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='area.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/marker/_symbol.py b/plotly/validators/area/marker/_symbol.py new file mode 100644 index 0000000000..8510a36a9a --- /dev/null +++ b/plotly/validators/area/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='area.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/area/marker/_symbolsrc.py b/plotly/validators/area/marker/_symbolsrc.py new file mode 100644 index 0000000000..14d7cb23b1 --- /dev/null +++ b/plotly/validators/area/marker/_symbolsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='symbolsrc', parent_name='area.marker', **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/area/stream/__init__.py b/plotly/validators/area/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/area/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/area/stream/_maxpoints.py b/plotly/validators/area/stream/_maxpoints.py new file mode 100644 index 0000000000..82921c0ca2 --- /dev/null +++ b/plotly/validators/area/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='area.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/area/stream/_token.py b/plotly/validators/area/stream/_token.py new file mode 100644 index 0000000000..862a27cced --- /dev/null +++ b/plotly/validators/area/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='area.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/__init__.py b/plotly/validators/bar/__init__.py new file mode 100644 index 0000000000..e1132f470e --- /dev/null +++ b/plotly/validators/bar/__init__.py @@ -0,0 +1,54 @@ +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._tsrc import TsrcValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._t import TValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._rsrc import RsrcValidator +from ._r import RValidator +from ._outsidetextfont import OutsidetextfontValidator +from ._orientation import OrientationValidator +from ._opacity import OpacityValidator +from ._offsetsrc import OffsetsrcValidator +from ._offset import OffsetValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._insidetextfont import InsidetextfontValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._error_y import ErrorYValidator +from ._error_x import ErrorXValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._constraintext import ConstraintextValidator +from ._cliponaxis import CliponaxisValidator +from ._basesrc import BasesrcValidator +from ._base import BaseValidator diff --git a/plotly/validators/bar/_base.py b/plotly/validators/bar/_base.py new file mode 100644 index 0000000000..f783c1846e --- /dev/null +++ b/plotly/validators/bar/_base.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BaseValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='base', parent_name='bar', **kwargs): + super(BaseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_basesrc.py b/plotly/validators/bar/_basesrc.py new file mode 100644 index 0000000000..8c9ca24636 --- /dev/null +++ b/plotly/validators/bar/_basesrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class BasesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='basesrc', parent_name='bar', **kwargs): + super(BasesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_cliponaxis.py b/plotly/validators/bar/_cliponaxis.py new file mode 100644 index 0000000000..18d7b8f2f0 --- /dev/null +++ b/plotly/validators/bar/_cliponaxis.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CliponaxisValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='cliponaxis', parent_name='bar', **kwargs): + super(CliponaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_constraintext.py b/plotly/validators/bar/_constraintext.py new file mode 100644 index 0000000000..930b959ee4 --- /dev/null +++ b/plotly/validators/bar/_constraintext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ConstraintextValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='constraintext', parent_name='bar', **kwargs + ): + super(ConstraintextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['inside', 'outside', 'both', 'none'], + **kwargs + ) diff --git a/plotly/validators/bar/_customdata.py b/plotly/validators/bar/_customdata.py new file mode 100644 index 0000000000..0fb892c154 --- /dev/null +++ b/plotly/validators/bar/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='bar', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_customdatasrc.py b/plotly/validators/bar/_customdatasrc.py new file mode 100644 index 0000000000..c41896a5d9 --- /dev/null +++ b/plotly/validators/bar/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='bar', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_dx.py b/plotly/validators/bar/_dx.py new file mode 100644 index 0000000000..b5179d06de --- /dev/null +++ b/plotly/validators/bar/_dx.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='bar', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_dy.py b/plotly/validators/bar/_dy.py new file mode 100644 index 0000000000..758ef35569 --- /dev/null +++ b/plotly/validators/bar/_dy.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='bar', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_error_x.py b/plotly/validators/bar/_error_x.py new file mode 100644 index 0000000000..b902a8a9c2 --- /dev/null +++ b/plotly/validators/bar/_error_x.py @@ -0,0 +1,70 @@ +import _plotly_utils.basevalidators + + +class ErrorXValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='error_x', parent_name='bar', **kwargs): + super(ErrorXValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorX', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/bar/_error_y.py b/plotly/validators/bar/_error_y.py new file mode 100644 index 0000000000..b635322568 --- /dev/null +++ b/plotly/validators/bar/_error_y.py @@ -0,0 +1,68 @@ +import _plotly_utils.basevalidators + + +class ErrorYValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='error_y', parent_name='bar', **kwargs): + super(ErrorYValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorY', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/bar/_hoverinfo.py b/plotly/validators/bar/_hoverinfo.py new file mode 100644 index 0000000000..db2a85fac0 --- /dev/null +++ b/plotly/validators/bar/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='bar', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_hoverinfosrc.py b/plotly/validators/bar/_hoverinfosrc.py new file mode 100644 index 0000000000..d231b03bc1 --- /dev/null +++ b/plotly/validators/bar/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='bar', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_hoverlabel.py b/plotly/validators/bar/_hoverlabel.py new file mode 100644 index 0000000000..a79d34b9f7 --- /dev/null +++ b/plotly/validators/bar/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='bar', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/bar/_hovertext.py b/plotly/validators/bar/_hovertext.py new file mode 100644 index 0000000000..8c2c119a49 --- /dev/null +++ b/plotly/validators/bar/_hovertext.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='hovertext', parent_name='bar', **kwargs): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_hovertextsrc.py b/plotly/validators/bar/_hovertextsrc.py new file mode 100644 index 0000000000..0e279634ad --- /dev/null +++ b/plotly/validators/bar/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='bar', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_ids.py b/plotly/validators/bar/_ids.py new file mode 100644 index 0000000000..3d298ab04f --- /dev/null +++ b/plotly/validators/bar/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='bar', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_idssrc.py b/plotly/validators/bar/_idssrc.py new file mode 100644 index 0000000000..d3b34d0e5b --- /dev/null +++ b/plotly/validators/bar/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='bar', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_insidetextfont.py b/plotly/validators/bar/_insidetextfont.py new file mode 100644 index 0000000000..b14706cf7d --- /dev/null +++ b/plotly/validators/bar/_insidetextfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class InsidetextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='insidetextfont', parent_name='bar', **kwargs + ): + super(InsidetextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Insidetextfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/bar/_legendgroup.py b/plotly/validators/bar/_legendgroup.py new file mode 100644 index 0000000000..2566939cf1 --- /dev/null +++ b/plotly/validators/bar/_legendgroup.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='legendgroup', parent_name='bar', **kwargs): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_marker.py b/plotly/validators/bar/_marker.py new file mode 100644 index 0000000000..a977207070 --- /dev/null +++ b/plotly/validators/bar/_marker.py @@ -0,0 +1,90 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='bar', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.bar.marker.ColorBar instance + or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.bar.marker.Line instance or + dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed.""", + **kwargs + ) diff --git a/plotly/validators/bar/_name.py b/plotly/validators/bar/_name.py new file mode 100644 index 0000000000..ac59d7998e --- /dev/null +++ b/plotly/validators/bar/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='bar', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_offset.py b/plotly/validators/bar/_offset.py new file mode 100644 index 0000000000..200ea76728 --- /dev/null +++ b/plotly/validators/bar/_offset.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class OffsetValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='offset', parent_name='bar', **kwargs): + super(OffsetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_offsetsrc.py b/plotly/validators/bar/_offsetsrc.py new file mode 100644 index 0000000000..d0e6729f26 --- /dev/null +++ b/plotly/validators/bar/_offsetsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class OffsetsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='offsetsrc', parent_name='bar', **kwargs): + super(OffsetsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_opacity.py b/plotly/validators/bar/_opacity.py new file mode 100644 index 0000000000..696a2aecf7 --- /dev/null +++ b/plotly/validators/bar/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='bar', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/_orientation.py b/plotly/validators/bar/_orientation.py new file mode 100644 index 0000000000..dc86eb5ff5 --- /dev/null +++ b/plotly/validators/bar/_orientation.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='orientation', parent_name='bar', **kwargs): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/bar/_outsidetextfont.py b/plotly/validators/bar/_outsidetextfont.py new file mode 100644 index 0000000000..bdd98d1022 --- /dev/null +++ b/plotly/validators/bar/_outsidetextfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class OutsidetextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='outsidetextfont', parent_name='bar', **kwargs + ): + super(OutsidetextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Outsidetextfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/bar/_r.py b/plotly/validators/bar/_r.py new file mode 100644 index 0000000000..ff7da345e2 --- /dev/null +++ b/plotly/validators/bar/_r.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='r', parent_name='bar', **kwargs): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_rsrc.py b/plotly/validators/bar/_rsrc.py new file mode 100644 index 0000000000..70c8a2a844 --- /dev/null +++ b/plotly/validators/bar/_rsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='rsrc', parent_name='bar', **kwargs): + super(RsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_selected.py b/plotly/validators/bar/_selected.py new file mode 100644 index 0000000000..e41695798f --- /dev/null +++ b/plotly/validators/bar/_selected.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='selected', parent_name='bar', **kwargs): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.bar.selected.Marker instance + or dict with compatible properties + textfont + plotly.graph_objs.bar.selected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/bar/_selectedpoints.py b/plotly/validators/bar/_selectedpoints.py new file mode 100644 index 0000000000..024a7d6104 --- /dev/null +++ b/plotly/validators/bar/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='bar', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_showlegend.py b/plotly/validators/bar/_showlegend.py new file mode 100644 index 0000000000..cc2f94a3f7 --- /dev/null +++ b/plotly/validators/bar/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='bar', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_stream.py b/plotly/validators/bar/_stream.py new file mode 100644 index 0000000000..859c9dfba5 --- /dev/null +++ b/plotly/validators/bar/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='bar', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/bar/_t.py b/plotly/validators/bar/_t.py new file mode 100644 index 0000000000..65d14cdfea --- /dev/null +++ b/plotly/validators/bar/_t.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='t', parent_name='bar', **kwargs): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_text.py b/plotly/validators/bar/_text.py new file mode 100644 index 0000000000..5a1515d411 --- /dev/null +++ b/plotly/validators/bar/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='bar', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_textfont.py b/plotly/validators/bar/_textfont.py new file mode 100644 index 0000000000..b2fa51f2fc --- /dev/null +++ b/plotly/validators/bar/_textfont.py @@ -0,0 +1,42 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='textfont', parent_name='bar', **kwargs): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/bar/_textposition.py b/plotly/validators/bar/_textposition.py new file mode 100644 index 0000000000..2bccc608f5 --- /dev/null +++ b/plotly/validators/bar/_textposition.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='bar', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + values=['inside', 'outside', 'auto', 'none'], + **kwargs + ) diff --git a/plotly/validators/bar/_textpositionsrc.py b/plotly/validators/bar/_textpositionsrc.py new file mode 100644 index 0000000000..7fb28c599f --- /dev/null +++ b/plotly/validators/bar/_textpositionsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textpositionsrc', parent_name='bar', **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_textsrc.py b/plotly/validators/bar/_textsrc.py new file mode 100644 index 0000000000..85a692f26b --- /dev/null +++ b/plotly/validators/bar/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='bar', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_tsrc.py b/plotly/validators/bar/_tsrc.py new file mode 100644 index 0000000000..61247903da --- /dev/null +++ b/plotly/validators/bar/_tsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='tsrc', parent_name='bar', **kwargs): + super(TsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_uid.py b/plotly/validators/bar/_uid.py new file mode 100644 index 0000000000..fe9e086805 --- /dev/null +++ b/plotly/validators/bar/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='bar', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_unselected.py b/plotly/validators/bar/_unselected.py new file mode 100644 index 0000000000..9acd8ecf16 --- /dev/null +++ b/plotly/validators/bar/_unselected.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='unselected', parent_name='bar', **kwargs): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.bar.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.bar.unselected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/bar/_visible.py b/plotly/validators/bar/_visible.py new file mode 100644 index 0000000000..92896ed2ea --- /dev/null +++ b/plotly/validators/bar/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='bar', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/bar/_width.py b/plotly/validators/bar/_width.py new file mode 100644 index 0000000000..4906d07eac --- /dev/null +++ b/plotly/validators/bar/_width.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='width', parent_name='bar', **kwargs): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_widthsrc.py b/plotly/validators/bar/_widthsrc.py new file mode 100644 index 0000000000..19d0bcd782 --- /dev/null +++ b/plotly/validators/bar/_widthsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='widthsrc', parent_name='bar', **kwargs): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_x.py b/plotly/validators/bar/_x.py new file mode 100644 index 0000000000..a027b458e7 --- /dev/null +++ b/plotly/validators/bar/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='bar', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_x0.py b/plotly/validators/bar/_x0.py new file mode 100644 index 0000000000..b3ecdb288a --- /dev/null +++ b/plotly/validators/bar/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='bar', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_xaxis.py b/plotly/validators/bar/_xaxis.py new file mode 100644 index 0000000000..91f468c92a --- /dev/null +++ b/plotly/validators/bar/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='bar', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_xcalendar.py b/plotly/validators/bar/_xcalendar.py new file mode 100644 index 0000000000..2afbdf96c0 --- /dev/null +++ b/plotly/validators/bar/_xcalendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xcalendar', parent_name='bar', **kwargs): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/bar/_xsrc.py b/plotly/validators/bar/_xsrc.py new file mode 100644 index 0000000000..b77e021e18 --- /dev/null +++ b/plotly/validators/bar/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='bar', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_y.py b/plotly/validators/bar/_y.py new file mode 100644 index 0000000000..182022fd65 --- /dev/null +++ b/plotly/validators/bar/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='bar', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/_y0.py b/plotly/validators/bar/_y0.py new file mode 100644 index 0000000000..6f44e088a0 --- /dev/null +++ b/plotly/validators/bar/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='bar', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_yaxis.py b/plotly/validators/bar/_yaxis.py new file mode 100644 index 0000000000..5657aa8f5d --- /dev/null +++ b/plotly/validators/bar/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='bar', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/_ycalendar.py b/plotly/validators/bar/_ycalendar.py new file mode 100644 index 0000000000..e224d6098b --- /dev/null +++ b/plotly/validators/bar/_ycalendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='ycalendar', parent_name='bar', **kwargs): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/bar/_ysrc.py b/plotly/validators/bar/_ysrc.py new file mode 100644 index 0000000000..367125fc22 --- /dev/null +++ b/plotly/validators/bar/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='bar', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/__init__.py b/plotly/validators/bar/error_x/__init__.py new file mode 100644 index 0000000000..c4605e0187 --- /dev/null +++ b/plotly/validators/bar/error_x/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_ystyle import CopyYstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/bar/error_x/_array.py b/plotly/validators/bar/error_x/_array.py new file mode 100644 index 0000000000..a979f5358b --- /dev/null +++ b/plotly/validators/bar/error_x/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='bar.error_x', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_arrayminus.py b/plotly/validators/bar/error_x/_arrayminus.py new file mode 100644 index 0000000000..b55027890b --- /dev/null +++ b/plotly/validators/bar/error_x/_arrayminus.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='arrayminus', parent_name='bar.error_x', **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_arrayminussrc.py b/plotly/validators/bar/error_x/_arrayminussrc.py new file mode 100644 index 0000000000..b3976716f1 --- /dev/null +++ b/plotly/validators/bar/error_x/_arrayminussrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arrayminussrc', parent_name='bar.error_x', **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_arraysrc.py b/plotly/validators/bar/error_x/_arraysrc.py new file mode 100644 index 0000000000..0e1e00b75c --- /dev/null +++ b/plotly/validators/bar/error_x/_arraysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arraysrc', parent_name='bar.error_x', **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_color.py b/plotly/validators/bar/error_x/_color.py new file mode 100644 index 0000000000..91b9a6de08 --- /dev/null +++ b/plotly/validators/bar/error_x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.error_x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_copy_ystyle.py b/plotly/validators/bar/error_x/_copy_ystyle.py new file mode 100644 index 0000000000..42fae2c5c2 --- /dev/null +++ b/plotly/validators/bar/error_x/_copy_ystyle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CopyYstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='copy_ystyle', parent_name='bar.error_x', **kwargs + ): + super(CopyYstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_symmetric.py b/plotly/validators/bar/error_x/_symmetric.py new file mode 100644 index 0000000000..a54eaf9d20 --- /dev/null +++ b/plotly/validators/bar/error_x/_symmetric.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='symmetric', parent_name='bar.error_x', **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_thickness.py b/plotly/validators/bar/error_x/_thickness.py new file mode 100644 index 0000000000..f5296e5591 --- /dev/null +++ b/plotly/validators/bar/error_x/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='bar.error_x', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_traceref.py b/plotly/validators/bar/error_x/_traceref.py new file mode 100644 index 0000000000..7cbf56512e --- /dev/null +++ b/plotly/validators/bar/error_x/_traceref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='traceref', parent_name='bar.error_x', **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_tracerefminus.py b/plotly/validators/bar/error_x/_tracerefminus.py new file mode 100644 index 0000000000..a642b70f72 --- /dev/null +++ b/plotly/validators/bar/error_x/_tracerefminus.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='tracerefminus', parent_name='bar.error_x', **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_type.py b/plotly/validators/bar/error_x/_type.py new file mode 100644 index 0000000000..cd6ad2be03 --- /dev/null +++ b/plotly/validators/bar/error_x/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='bar.error_x', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_value.py b/plotly/validators/bar/error_x/_value.py new file mode 100644 index 0000000000..5cc86a436c --- /dev/null +++ b/plotly/validators/bar/error_x/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='bar.error_x', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_valueminus.py b/plotly/validators/bar/error_x/_valueminus.py new file mode 100644 index 0000000000..d6f9b41304 --- /dev/null +++ b/plotly/validators/bar/error_x/_valueminus.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='valueminus', parent_name='bar.error_x', **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_visible.py b/plotly/validators/bar/error_x/_visible.py new file mode 100644 index 0000000000..76e68be178 --- /dev/null +++ b/plotly/validators/bar/error_x/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='bar.error_x', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_x/_width.py b/plotly/validators/bar/error_x/_width.py new file mode 100644 index 0000000000..04180aeceb --- /dev/null +++ b/plotly/validators/bar/error_x/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='bar.error_x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/__init__.py b/plotly/validators/bar/error_y/__init__.py new file mode 100644 index 0000000000..2fc70c4058 --- /dev/null +++ b/plotly/validators/bar/error_y/__init__.py @@ -0,0 +1,14 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/bar/error_y/_array.py b/plotly/validators/bar/error_y/_array.py new file mode 100644 index 0000000000..c6ec4c5fd1 --- /dev/null +++ b/plotly/validators/bar/error_y/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='bar.error_y', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_arrayminus.py b/plotly/validators/bar/error_y/_arrayminus.py new file mode 100644 index 0000000000..d4b0d32e99 --- /dev/null +++ b/plotly/validators/bar/error_y/_arrayminus.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='arrayminus', parent_name='bar.error_y', **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_arrayminussrc.py b/plotly/validators/bar/error_y/_arrayminussrc.py new file mode 100644 index 0000000000..99dfe22eba --- /dev/null +++ b/plotly/validators/bar/error_y/_arrayminussrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arrayminussrc', parent_name='bar.error_y', **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_arraysrc.py b/plotly/validators/bar/error_y/_arraysrc.py new file mode 100644 index 0000000000..b77dadeb68 --- /dev/null +++ b/plotly/validators/bar/error_y/_arraysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arraysrc', parent_name='bar.error_y', **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_color.py b/plotly/validators/bar/error_y/_color.py new file mode 100644 index 0000000000..86f892139b --- /dev/null +++ b/plotly/validators/bar/error_y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.error_y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_symmetric.py b/plotly/validators/bar/error_y/_symmetric.py new file mode 100644 index 0000000000..854d5fb248 --- /dev/null +++ b/plotly/validators/bar/error_y/_symmetric.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='symmetric', parent_name='bar.error_y', **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_thickness.py b/plotly/validators/bar/error_y/_thickness.py new file mode 100644 index 0000000000..14a6ca39f9 --- /dev/null +++ b/plotly/validators/bar/error_y/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='bar.error_y', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_traceref.py b/plotly/validators/bar/error_y/_traceref.py new file mode 100644 index 0000000000..2fd631d612 --- /dev/null +++ b/plotly/validators/bar/error_y/_traceref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='traceref', parent_name='bar.error_y', **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_tracerefminus.py b/plotly/validators/bar/error_y/_tracerefminus.py new file mode 100644 index 0000000000..8648eb037a --- /dev/null +++ b/plotly/validators/bar/error_y/_tracerefminus.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='tracerefminus', parent_name='bar.error_y', **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_type.py b/plotly/validators/bar/error_y/_type.py new file mode 100644 index 0000000000..a2e34f4386 --- /dev/null +++ b/plotly/validators/bar/error_y/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='bar.error_y', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_value.py b/plotly/validators/bar/error_y/_value.py new file mode 100644 index 0000000000..8a8a7c359e --- /dev/null +++ b/plotly/validators/bar/error_y/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='bar.error_y', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_valueminus.py b/plotly/validators/bar/error_y/_valueminus.py new file mode 100644 index 0000000000..af2eb769cc --- /dev/null +++ b/plotly/validators/bar/error_y/_valueminus.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='valueminus', parent_name='bar.error_y', **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_visible.py b/plotly/validators/bar/error_y/_visible.py new file mode 100644 index 0000000000..af25da4052 --- /dev/null +++ b/plotly/validators/bar/error_y/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='bar.error_y', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/error_y/_width.py b/plotly/validators/bar/error_y/_width.py new file mode 100644 index 0000000000..a3300917a7 --- /dev/null +++ b/plotly/validators/bar/error_y/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='bar.error_y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/__init__.py b/plotly/validators/bar/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/bar/hoverlabel/_bgcolor.py b/plotly/validators/bar/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..c5cce60a2a --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='bar.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_bgcolorsrc.py b/plotly/validators/bar/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..2291c02db6 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bgcolorsrc', parent_name='bar.hoverlabel', **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_bordercolor.py b/plotly/validators/bar/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..3c8a320fb8 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='bar.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_bordercolorsrc.py b/plotly/validators/bar/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..692d5cefa3 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='bar.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_font.py b/plotly/validators/bar/hoverlabel/_font.py new file mode 100644 index 0000000000..b808584e84 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='bar.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_namelength.py b/plotly/validators/bar/hoverlabel/_namelength.py new file mode 100644 index 0000000000..bdad800573 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_namelength.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='namelength', parent_name='bar.hoverlabel', **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/_namelengthsrc.py b/plotly/validators/bar/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..c87977f241 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='bar.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/__init__.py b/plotly/validators/bar/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/hoverlabel/font/_color.py b/plotly/validators/bar/hoverlabel/font/_color.py new file mode 100644 index 0000000000..3f5f0905e6 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.hoverlabel.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/_colorsrc.py b/plotly/validators/bar/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..4d8da08550 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='bar.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/_family.py b/plotly/validators/bar/hoverlabel/font/_family.py new file mode 100644 index 0000000000..f643ec55f3 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='bar.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/_familysrc.py b/plotly/validators/bar/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..d8d9e3eb82 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='bar.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/_size.py b/plotly/validators/bar/hoverlabel/font/_size.py new file mode 100644 index 0000000000..e0ba39ba83 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='bar.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/hoverlabel/font/_sizesrc.py b/plotly/validators/bar/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..dc06f22e89 --- /dev/null +++ b/plotly/validators/bar/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='bar.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/__init__.py b/plotly/validators/bar/insidetextfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/bar/insidetextfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/insidetextfont/_color.py b/plotly/validators/bar/insidetextfont/_color.py new file mode 100644 index 0000000000..d378574697 --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.insidetextfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/_colorsrc.py b/plotly/validators/bar/insidetextfont/_colorsrc.py new file mode 100644 index 0000000000..f483f9c255 --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='bar.insidetextfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/_family.py b/plotly/validators/bar/insidetextfont/_family.py new file mode 100644 index 0000000000..c158deaf65 --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='bar.insidetextfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/_familysrc.py b/plotly/validators/bar/insidetextfont/_familysrc.py new file mode 100644 index 0000000000..fc984f550f --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='bar.insidetextfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/_size.py b/plotly/validators/bar/insidetextfont/_size.py new file mode 100644 index 0000000000..d42a4095fc --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='bar.insidetextfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/insidetextfont/_sizesrc.py b/plotly/validators/bar/insidetextfont/_sizesrc.py new file mode 100644 index 0000000000..db7823751d --- /dev/null +++ b/plotly/validators/bar/insidetextfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='bar.insidetextfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/__init__.py b/plotly/validators/bar/marker/__init__.py new file mode 100644 index 0000000000..17f5ee5025 --- /dev/null +++ b/plotly/validators/bar/marker/__init__.py @@ -0,0 +1,13 @@ +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/bar/marker/_autocolorscale.py b/plotly/validators/bar/marker/_autocolorscale.py new file mode 100644 index 0000000000..d5d4a45d5a --- /dev/null +++ b/plotly/validators/bar/marker/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='bar.marker', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_cauto.py b/plotly/validators/bar/marker/_cauto.py new file mode 100644 index 0000000000..5fb092ff07 --- /dev/null +++ b/plotly/validators/bar/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='bar.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_cmax.py b/plotly/validators/bar/marker/_cmax.py new file mode 100644 index 0000000000..c457ec37f5 --- /dev/null +++ b/plotly/validators/bar/marker/_cmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmax', parent_name='bar.marker', **kwargs): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_cmin.py b/plotly/validators/bar/marker/_cmin.py new file mode 100644 index 0000000000..44d9cf34dc --- /dev/null +++ b/plotly/validators/bar/marker/_cmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmin', parent_name='bar.marker', **kwargs): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_color.py b/plotly/validators/bar/marker/_color.py new file mode 100644 index 0000000000..93e77e91e4 --- /dev/null +++ b/plotly/validators/bar/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='bar.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_colorbar.py b/plotly/validators/bar/marker/_colorbar.py new file mode 100644 index 0000000000..1171ab48ce --- /dev/null +++ b/plotly/validators/bar/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='bar.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.bar.marker.colorbar.Tickforma + tstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/bar/marker/_colorscale.py b/plotly/validators/bar/marker/_colorscale.py new file mode 100644 index 0000000000..3ac2f7f773 --- /dev/null +++ b/plotly/validators/bar/marker/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='bar.marker', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_colorsrc.py b/plotly/validators/bar/marker/_colorsrc.py new file mode 100644 index 0000000000..5b67090073 --- /dev/null +++ b/plotly/validators/bar/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='bar.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_line.py b/plotly/validators/bar/marker/_line.py new file mode 100644 index 0000000000..4df97f05bf --- /dev/null +++ b/plotly/validators/bar/marker/_line.py @@ -0,0 +1,82 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='bar.marker', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/bar/marker/_opacity.py b/plotly/validators/bar/marker/_opacity.py new file mode 100644 index 0000000000..18093c4f5a --- /dev/null +++ b/plotly/validators/bar/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='bar.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_opacitysrc.py b/plotly/validators/bar/marker/_opacitysrc.py new file mode 100644 index 0000000000..86aa04c501 --- /dev/null +++ b/plotly/validators/bar/marker/_opacitysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='opacitysrc', parent_name='bar.marker', **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_reversescale.py b/plotly/validators/bar/marker/_reversescale.py new file mode 100644 index 0000000000..cf376335e7 --- /dev/null +++ b/plotly/validators/bar/marker/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='bar.marker', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/_showscale.py b/plotly/validators/bar/marker/_showscale.py new file mode 100644 index 0000000000..a94b0ea9d1 --- /dev/null +++ b/plotly/validators/bar/marker/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='bar.marker', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/__init__.py b/plotly/validators/bar/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/bar/marker/colorbar/_bgcolor.py b/plotly/validators/bar/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..f4ce761277 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_bordercolor.py b/plotly/validators/bar/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..8747a151d2 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_borderwidth.py b/plotly/validators/bar/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..959447bd4e --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_dtick.py b/plotly/validators/bar/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..23abec8593 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='bar.marker.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_exponentformat.py b/plotly/validators/bar/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..6737870148 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_len.py b/plotly/validators/bar/marker/colorbar/_len.py new file mode 100644 index 0000000000..3ff42ad911 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='bar.marker.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_lenmode.py b/plotly/validators/bar/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..482acefb38 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_nticks.py b/plotly/validators/bar/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..c8b18a7e06 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_outlinecolor.py b/plotly/validators/bar/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..1e0f5b2f6c --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_outlinewidth.py b/plotly/validators/bar/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..5fe7b407ce --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_separatethousands.py b/plotly/validators/bar/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..c6d071ff38 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_showexponent.py b/plotly/validators/bar/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..da266205c6 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_showticklabels.py b/plotly/validators/bar/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..223ef56658 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_showtickprefix.py b/plotly/validators/bar/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..52f0e5e26d --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_showticksuffix.py b/plotly/validators/bar/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..2f652aed72 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_thickness.py b/plotly/validators/bar/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..80373b8f79 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_thicknessmode.py b/plotly/validators/bar/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..bf43dc4cff --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tick0.py b/plotly/validators/bar/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..9533f009b5 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='bar.marker.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickangle.py b/plotly/validators/bar/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..172222655b --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickcolor.py b/plotly/validators/bar/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..3cf345e29e --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickfont.py b/plotly/validators/bar/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..7cf6548376 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickformat.py b/plotly/validators/bar/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..1e83654a2b --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickformatstops.py b/plotly/validators/bar/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..52e98ea8e2 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ticklen.py b/plotly/validators/bar/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..2789de83e2 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickmode.py b/plotly/validators/bar/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..517991eaee --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickprefix.py b/plotly/validators/bar/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..48460f8f7f --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ticks.py b/plotly/validators/bar/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..cb1c0269f1 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='bar.marker.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ticksuffix.py b/plotly/validators/bar/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..6211342df5 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ticktext.py b/plotly/validators/bar/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..525d9b89e8 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ticktextsrc.py b/plotly/validators/bar/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..d014fdea23 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickvals.py b/plotly/validators/bar/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..c409829947 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickvalssrc.py b/plotly/validators/bar/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..2ae346940e --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_tickwidth.py b/plotly/validators/bar/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..23972e5c2a --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_title.py b/plotly/validators/bar/marker/colorbar/_title.py new file mode 100644 index 0000000000..5c2c2db079 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='bar.marker.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_titlefont.py b/plotly/validators/bar/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..093f3e9d91 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_titleside.py b/plotly/validators/bar/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..5c23d84d69 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_x.py b/plotly/validators/bar/marker/colorbar/_x.py new file mode 100644 index 0000000000..62387573ca --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='bar.marker.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_xanchor.py b/plotly/validators/bar/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..3aa56ad36d --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_xpad.py b/plotly/validators/bar/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..99ea6f79b3 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='bar.marker.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_y.py b/plotly/validators/bar/marker/colorbar/_y.py new file mode 100644 index 0000000000..b80524d8ef --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='bar.marker.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_yanchor.py b/plotly/validators/bar/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..4401406b5b --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='bar.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/_ypad.py b/plotly/validators/bar/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..eb088c576c --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='bar.marker.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/tickfont/__init__.py b/plotly/validators/bar/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/marker/colorbar/tickfont/_color.py b/plotly/validators/bar/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..b603db16c3 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='bar.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/tickfont/_family.py b/plotly/validators/bar/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..c3bc19d826 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='bar.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/tickfont/_size.py b/plotly/validators/bar/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..9cb9d479bc --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='bar.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/bar/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/bar/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/bar/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..b389380653 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='bar.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/tickformatstop/_value.py b/plotly/validators/bar/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..1ecb3ab6f7 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='bar.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/titlefont/__init__.py b/plotly/validators/bar/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/marker/colorbar/titlefont/_color.py b/plotly/validators/bar/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..6c2a941e17 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='bar.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/titlefont/_family.py b/plotly/validators/bar/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..c500bc81a4 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='bar.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/marker/colorbar/titlefont/_size.py b/plotly/validators/bar/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..6c026e0f44 --- /dev/null +++ b/plotly/validators/bar/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='bar.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/__init__.py b/plotly/validators/bar/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/bar/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/bar/marker/line/_autocolorscale.py b/plotly/validators/bar/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..3bd538290c --- /dev/null +++ b/plotly/validators/bar/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='bar.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_cauto.py b/plotly/validators/bar/marker/line/_cauto.py new file mode 100644 index 0000000000..e8679c85ec --- /dev/null +++ b/plotly/validators/bar/marker/line/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='bar.marker.line', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_cmax.py b/plotly/validators/bar/marker/line/_cmax.py new file mode 100644 index 0000000000..e6c7703cf3 --- /dev/null +++ b/plotly/validators/bar/marker/line/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='bar.marker.line', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_cmin.py b/plotly/validators/bar/marker/line/_cmin.py new file mode 100644 index 0000000000..fdf33d5dae --- /dev/null +++ b/plotly/validators/bar/marker/line/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='bar.marker.line', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_color.py b/plotly/validators/bar/marker/line/_color.py new file mode 100644 index 0000000000..49ae36dc8c --- /dev/null +++ b/plotly/validators/bar/marker/line/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='bar.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_colorscale.py b/plotly/validators/bar/marker/line/_colorscale.py new file mode 100644 index 0000000000..9c976e3492 --- /dev/null +++ b/plotly/validators/bar/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='bar.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_colorsrc.py b/plotly/validators/bar/marker/line/_colorsrc.py new file mode 100644 index 0000000000..63b038cb56 --- /dev/null +++ b/plotly/validators/bar/marker/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='bar.marker.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_reversescale.py b/plotly/validators/bar/marker/line/_reversescale.py new file mode 100644 index 0000000000..cd67b3f8c0 --- /dev/null +++ b/plotly/validators/bar/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='bar.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_width.py b/plotly/validators/bar/marker/line/_width.py new file mode 100644 index 0000000000..39949f7be2 --- /dev/null +++ b/plotly/validators/bar/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='bar.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/marker/line/_widthsrc.py b/plotly/validators/bar/marker/line/_widthsrc.py new file mode 100644 index 0000000000..32c1cf1628 --- /dev/null +++ b/plotly/validators/bar/marker/line/_widthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='widthsrc', parent_name='bar.marker.line', **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/__init__.py b/plotly/validators/bar/outsidetextfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/outsidetextfont/_color.py b/plotly/validators/bar/outsidetextfont/_color.py new file mode 100644 index 0000000000..8175fa91ad --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.outsidetextfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/_colorsrc.py b/plotly/validators/bar/outsidetextfont/_colorsrc.py new file mode 100644 index 0000000000..dda59a31eb --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='bar.outsidetextfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/_family.py b/plotly/validators/bar/outsidetextfont/_family.py new file mode 100644 index 0000000000..a94480f21d --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='bar.outsidetextfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/_familysrc.py b/plotly/validators/bar/outsidetextfont/_familysrc.py new file mode 100644 index 0000000000..020b77d31c --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='bar.outsidetextfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/_size.py b/plotly/validators/bar/outsidetextfont/_size.py new file mode 100644 index 0000000000..6cc8f9e332 --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='bar.outsidetextfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/outsidetextfont/_sizesrc.py b/plotly/validators/bar/outsidetextfont/_sizesrc.py new file mode 100644 index 0000000000..6d7a5f51ec --- /dev/null +++ b/plotly/validators/bar/outsidetextfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='bar.outsidetextfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/selected/__init__.py b/plotly/validators/bar/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/bar/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/bar/selected/_marker.py b/plotly/validators/bar/selected/_marker.py new file mode 100644 index 0000000000..61f2295809 --- /dev/null +++ b/plotly/validators/bar/selected/_marker.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='bar.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points.""", + **kwargs + ) diff --git a/plotly/validators/bar/selected/_textfont.py b/plotly/validators/bar/selected/_textfont.py new file mode 100644 index 0000000000..145d1a3e58 --- /dev/null +++ b/plotly/validators/bar/selected/_textfont.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='bar.selected', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/bar/selected/marker/__init__.py b/plotly/validators/bar/selected/marker/__init__.py new file mode 100644 index 0000000000..990c554a22 --- /dev/null +++ b/plotly/validators/bar/selected/marker/__init__.py @@ -0,0 +1,2 @@ +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/selected/marker/_color.py b/plotly/validators/bar/selected/marker/_color.py new file mode 100644 index 0000000000..805962e4d4 --- /dev/null +++ b/plotly/validators/bar/selected/marker/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.selected.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/selected/marker/_opacity.py b/plotly/validators/bar/selected/marker/_opacity.py new file mode 100644 index 0000000000..12bc4c1972 --- /dev/null +++ b/plotly/validators/bar/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='bar.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/selected/textfont/__init__.py b/plotly/validators/bar/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/bar/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/bar/selected/textfont/_color.py b/plotly/validators/bar/selected/textfont/_color.py new file mode 100644 index 0000000000..df58201c67 --- /dev/null +++ b/plotly/validators/bar/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='bar.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/stream/__init__.py b/plotly/validators/bar/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/bar/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/bar/stream/_maxpoints.py b/plotly/validators/bar/stream/_maxpoints.py new file mode 100644 index 0000000000..d9f29a957e --- /dev/null +++ b/plotly/validators/bar/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='bar.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/stream/_token.py b/plotly/validators/bar/stream/_token.py new file mode 100644 index 0000000000..497e8a31b3 --- /dev/null +++ b/plotly/validators/bar/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='bar.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/textfont/__init__.py b/plotly/validators/bar/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/bar/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/textfont/_color.py b/plotly/validators/bar/textfont/_color.py new file mode 100644 index 0000000000..44de3179e1 --- /dev/null +++ b/plotly/validators/bar/textfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='bar.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/textfont/_colorsrc.py b/plotly/validators/bar/textfont/_colorsrc.py new file mode 100644 index 0000000000..4e9ed3eb9f --- /dev/null +++ b/plotly/validators/bar/textfont/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='bar.textfont', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/textfont/_family.py b/plotly/validators/bar/textfont/_family.py new file mode 100644 index 0000000000..d93ee08288 --- /dev/null +++ b/plotly/validators/bar/textfont/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='bar.textfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/bar/textfont/_familysrc.py b/plotly/validators/bar/textfont/_familysrc.py new file mode 100644 index 0000000000..cbf6cc2cae --- /dev/null +++ b/plotly/validators/bar/textfont/_familysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='familysrc', parent_name='bar.textfont', **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/textfont/_size.py b/plotly/validators/bar/textfont/_size.py new file mode 100644 index 0000000000..5c061ffc99 --- /dev/null +++ b/plotly/validators/bar/textfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='bar.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/textfont/_sizesrc.py b/plotly/validators/bar/textfont/_sizesrc.py new file mode 100644 index 0000000000..2d97c4506a --- /dev/null +++ b/plotly/validators/bar/textfont/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='bar.textfont', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/bar/unselected/__init__.py b/plotly/validators/bar/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/bar/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/bar/unselected/_marker.py b/plotly/validators/bar/unselected/_marker.py new file mode 100644 index 0000000000..853558853b --- /dev/null +++ b/plotly/validators/bar/unselected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='bar.unselected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/bar/unselected/_textfont.py b/plotly/validators/bar/unselected/_textfont.py new file mode 100644 index 0000000000..f507c11d2c --- /dev/null +++ b/plotly/validators/bar/unselected/_textfont.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='bar.unselected', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/bar/unselected/marker/__init__.py b/plotly/validators/bar/unselected/marker/__init__.py new file mode 100644 index 0000000000..990c554a22 --- /dev/null +++ b/plotly/validators/bar/unselected/marker/__init__.py @@ -0,0 +1,2 @@ +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/bar/unselected/marker/_color.py b/plotly/validators/bar/unselected/marker/_color.py new file mode 100644 index 0000000000..9962e56fdf --- /dev/null +++ b/plotly/validators/bar/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='bar.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/unselected/marker/_opacity.py b/plotly/validators/bar/unselected/marker/_opacity.py new file mode 100644 index 0000000000..f1213c1aa9 --- /dev/null +++ b/plotly/validators/bar/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='bar.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/bar/unselected/textfont/__init__.py b/plotly/validators/bar/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/bar/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/bar/unselected/textfont/_color.py b/plotly/validators/bar/unselected/textfont/_color.py new file mode 100644 index 0000000000..88c9b0d76e --- /dev/null +++ b/plotly/validators/bar/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='bar.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/__init__.py b/plotly/validators/box/__init__.py new file mode 100644 index 0000000000..187afb7a57 --- /dev/null +++ b/plotly/validators/box/__init__.py @@ -0,0 +1,41 @@ +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._whiskerwidth import WhiskerwidthValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._pointpos import PointposValidator +from ._orientation import OrientationValidator +from ._opacity import OpacityValidator +from ._notchwidth import NotchwidthValidator +from ._notched import NotchedValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._jitter import JitterValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._boxpoints import BoxpointsValidator +from ._boxmean import BoxmeanValidator diff --git a/plotly/validators/box/_boxmean.py b/plotly/validators/box/_boxmean.py new file mode 100644 index 0000000000..8fce159ad5 --- /dev/null +++ b/plotly/validators/box/_boxmean.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BoxmeanValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='boxmean', parent_name='box', **kwargs): + super(BoxmeanValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + role='style', + values=[True, 'sd', False], + **kwargs + ) diff --git a/plotly/validators/box/_boxpoints.py b/plotly/validators/box/_boxpoints.py new file mode 100644 index 0000000000..efb0f9b171 --- /dev/null +++ b/plotly/validators/box/_boxpoints.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BoxpointsValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='boxpoints', parent_name='box', **kwargs): + super(BoxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + role='style', + values=['all', 'outliers', 'suspectedoutliers', False], + **kwargs + ) diff --git a/plotly/validators/box/_customdata.py b/plotly/validators/box/_customdata.py new file mode 100644 index 0000000000..9bec5359ae --- /dev/null +++ b/plotly/validators/box/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='box', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/box/_customdatasrc.py b/plotly/validators/box/_customdatasrc.py new file mode 100644 index 0000000000..ca6238e7eb --- /dev/null +++ b/plotly/validators/box/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='box', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_fillcolor.py b/plotly/validators/box/_fillcolor.py new file mode 100644 index 0000000000..e617291bff --- /dev/null +++ b/plotly/validators/box/_fillcolor.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__(self, plotly_name='fillcolor', parent_name='box', **kwargs): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_hoverinfo.py b/plotly/validators/box/_hoverinfo.py new file mode 100644 index 0000000000..2239f47f01 --- /dev/null +++ b/plotly/validators/box/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='box', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_hoverinfosrc.py b/plotly/validators/box/_hoverinfosrc.py new file mode 100644 index 0000000000..d006d9763d --- /dev/null +++ b/plotly/validators/box/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='box', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_hoverlabel.py b/plotly/validators/box/_hoverlabel.py new file mode 100644 index 0000000000..f590089e58 --- /dev/null +++ b/plotly/validators/box/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='box', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/box/_hoveron.py b/plotly/validators/box/_hoveron.py new file mode 100644 index 0000000000..b387c22d00 --- /dev/null +++ b/plotly/validators/box/_hoveron.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoveron', parent_name='box', **kwargs): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['boxes', 'points'], + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_ids.py b/plotly/validators/box/_ids.py new file mode 100644 index 0000000000..1d1d4e3993 --- /dev/null +++ b/plotly/validators/box/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='box', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/box/_idssrc.py b/plotly/validators/box/_idssrc.py new file mode 100644 index 0000000000..698cf2a19d --- /dev/null +++ b/plotly/validators/box/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='box', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_jitter.py b/plotly/validators/box/_jitter.py new file mode 100644 index 0000000000..4d3f4ef5ed --- /dev/null +++ b/plotly/validators/box/_jitter.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class JitterValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='jitter', parent_name='box', **kwargs): + super(JitterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_legendgroup.py b/plotly/validators/box/_legendgroup.py new file mode 100644 index 0000000000..0e15dc4a47 --- /dev/null +++ b/plotly/validators/box/_legendgroup.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='legendgroup', parent_name='box', **kwargs): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_line.py b/plotly/validators/box/_line.py new file mode 100644 index 0000000000..ce194c2416 --- /dev/null +++ b/plotly/validators/box/_line.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='box', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es).""", + **kwargs + ) diff --git a/plotly/validators/box/_marker.py b/plotly/validators/box/_marker.py new file mode 100644 index 0000000000..17d709e899 --- /dev/null +++ b/plotly/validators/box/_marker.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='box', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + line + plotly.graph_objs.box.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name.""", + **kwargs + ) diff --git a/plotly/validators/box/_name.py b/plotly/validators/box/_name.py new file mode 100644 index 0000000000..074d9d1ff8 --- /dev/null +++ b/plotly/validators/box/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='box', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_notched.py b/plotly/validators/box/_notched.py new file mode 100644 index 0000000000..b98f35f660 --- /dev/null +++ b/plotly/validators/box/_notched.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NotchedValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='notched', parent_name='box', **kwargs): + super(NotchedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_notchwidth.py b/plotly/validators/box/_notchwidth.py new file mode 100644 index 0000000000..00f9bf3785 --- /dev/null +++ b/plotly/validators/box/_notchwidth.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NotchwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='notchwidth', parent_name='box', **kwargs): + super(NotchwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=0.5, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_opacity.py b/plotly/validators/box/_opacity.py new file mode 100644 index 0000000000..a0746a67b6 --- /dev/null +++ b/plotly/validators/box/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='box', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_orientation.py b/plotly/validators/box/_orientation.py new file mode 100644 index 0000000000..4269f97225 --- /dev/null +++ b/plotly/validators/box/_orientation.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='orientation', parent_name='box', **kwargs): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='style', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/box/_pointpos.py b/plotly/validators/box/_pointpos.py new file mode 100644 index 0000000000..479092d43b --- /dev/null +++ b/plotly/validators/box/_pointpos.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PointposValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='pointpos', parent_name='box', **kwargs): + super(PointposValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=2, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_selected.py b/plotly/validators/box/_selected.py new file mode 100644 index 0000000000..21de3e6fc7 --- /dev/null +++ b/plotly/validators/box/_selected.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='selected', parent_name='box', **kwargs): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.box.selected.Marker instance + or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/box/_selectedpoints.py b/plotly/validators/box/_selectedpoints.py new file mode 100644 index 0000000000..6fa3fa7f95 --- /dev/null +++ b/plotly/validators/box/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='box', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_showlegend.py b/plotly/validators/box/_showlegend.py new file mode 100644 index 0000000000..f5487edf37 --- /dev/null +++ b/plotly/validators/box/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='box', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_stream.py b/plotly/validators/box/_stream.py new file mode 100644 index 0000000000..cf00a74c8a --- /dev/null +++ b/plotly/validators/box/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='box', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/box/_text.py b/plotly/validators/box/_text.py new file mode 100644 index 0000000000..88966f44ef --- /dev/null +++ b/plotly/validators/box/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='box', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_textsrc.py b/plotly/validators/box/_textsrc.py new file mode 100644 index 0000000000..49b54e29f4 --- /dev/null +++ b/plotly/validators/box/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='box', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_uid.py b/plotly/validators/box/_uid.py new file mode 100644 index 0000000000..3bed1de87c --- /dev/null +++ b/plotly/validators/box/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='box', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_unselected.py b/plotly/validators/box/_unselected.py new file mode 100644 index 0000000000..16a4b62528 --- /dev/null +++ b/plotly/validators/box/_unselected.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='unselected', parent_name='box', **kwargs): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.box.unselected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/box/_visible.py b/plotly/validators/box/_visible.py new file mode 100644 index 0000000000..5a364d908c --- /dev/null +++ b/plotly/validators/box/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='box', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/box/_whiskerwidth.py b/plotly/validators/box/_whiskerwidth.py new file mode 100644 index 0000000000..a8d4e740fd --- /dev/null +++ b/plotly/validators/box/_whiskerwidth.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WhiskerwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='whiskerwidth', parent_name='box', **kwargs + ): + super(WhiskerwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/_x.py b/plotly/validators/box/_x.py new file mode 100644 index 0000000000..62cbe0f4c2 --- /dev/null +++ b/plotly/validators/box/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='box', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/box/_x0.py b/plotly/validators/box/_x0.py new file mode 100644 index 0000000000..d5dc4bc50f --- /dev/null +++ b/plotly/validators/box/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='box', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_xaxis.py b/plotly/validators/box/_xaxis.py new file mode 100644 index 0000000000..08bdb0392b --- /dev/null +++ b/plotly/validators/box/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='box', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_xcalendar.py b/plotly/validators/box/_xcalendar.py new file mode 100644 index 0000000000..783b563d4d --- /dev/null +++ b/plotly/validators/box/_xcalendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xcalendar', parent_name='box', **kwargs): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/box/_xsrc.py b/plotly/validators/box/_xsrc.py new file mode 100644 index 0000000000..c4e80d5e43 --- /dev/null +++ b/plotly/validators/box/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='box', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_y.py b/plotly/validators/box/_y.py new file mode 100644 index 0000000000..4eb20d9dc5 --- /dev/null +++ b/plotly/validators/box/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='box', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/box/_y0.py b/plotly/validators/box/_y0.py new file mode 100644 index 0000000000..9a151bab5b --- /dev/null +++ b/plotly/validators/box/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='box', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_yaxis.py b/plotly/validators/box/_yaxis.py new file mode 100644 index 0000000000..1e7be1f02c --- /dev/null +++ b/plotly/validators/box/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='box', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/_ycalendar.py b/plotly/validators/box/_ycalendar.py new file mode 100644 index 0000000000..f5e91a2d10 --- /dev/null +++ b/plotly/validators/box/_ycalendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='ycalendar', parent_name='box', **kwargs): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/box/_ysrc.py b/plotly/validators/box/_ysrc.py new file mode 100644 index 0000000000..b09bf31f71 --- /dev/null +++ b/plotly/validators/box/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='box', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/__init__.py b/plotly/validators/box/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/box/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/box/hoverlabel/_bgcolor.py b/plotly/validators/box/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..4951f56bd4 --- /dev/null +++ b/plotly/validators/box/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='box.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_bgcolorsrc.py b/plotly/validators/box/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..24f4d1a10d --- /dev/null +++ b/plotly/validators/box/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bgcolorsrc', parent_name='box.hoverlabel', **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_bordercolor.py b/plotly/validators/box/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..af8a63edb9 --- /dev/null +++ b/plotly/validators/box/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='box.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_bordercolorsrc.py b/plotly/validators/box/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..b8f076c6fb --- /dev/null +++ b/plotly/validators/box/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='box.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_font.py b/plotly/validators/box/hoverlabel/_font.py new file mode 100644 index 0000000000..9d44016c16 --- /dev/null +++ b/plotly/validators/box/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='box.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_namelength.py b/plotly/validators/box/hoverlabel/_namelength.py new file mode 100644 index 0000000000..6936d18ac1 --- /dev/null +++ b/plotly/validators/box/hoverlabel/_namelength.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='namelength', parent_name='box.hoverlabel', **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/_namelengthsrc.py b/plotly/validators/box/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..01341dc8a5 --- /dev/null +++ b/plotly/validators/box/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='box.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/__init__.py b/plotly/validators/box/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/hoverlabel/font/_color.py b/plotly/validators/box/hoverlabel/font/_color.py new file mode 100644 index 0000000000..db25d04d84 --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='box.hoverlabel.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/_colorsrc.py b/plotly/validators/box/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..4da59ff28a --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='box.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/_family.py b/plotly/validators/box/hoverlabel/font/_family.py new file mode 100644 index 0000000000..ea9a374326 --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='box.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/_familysrc.py b/plotly/validators/box/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..87c7718339 --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='box.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/_size.py b/plotly/validators/box/hoverlabel/font/_size.py new file mode 100644 index 0000000000..c1fe0b10db --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='box.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/hoverlabel/font/_sizesrc.py b/plotly/validators/box/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..09b89d3665 --- /dev/null +++ b/plotly/validators/box/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='box.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/box/line/__init__.py b/plotly/validators/box/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/box/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/line/_color.py b/plotly/validators/box/line/_color.py new file mode 100644 index 0000000000..cec57ab1c7 --- /dev/null +++ b/plotly/validators/box/line/_color.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__(self, plotly_name='color', parent_name='box.line', **kwargs): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/line/_width.py b/plotly/validators/box/line/_width.py new file mode 100644 index 0000000000..56f39390b7 --- /dev/null +++ b/plotly/validators/box/line/_width.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='width', parent_name='box.line', **kwargs): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/__init__.py b/plotly/validators/box/marker/__init__.py new file mode 100644 index 0000000000..0bc6d87d6b --- /dev/null +++ b/plotly/validators/box/marker/__init__.py @@ -0,0 +1,6 @@ +from ._symbol import SymbolValidator +from ._size import SizeValidator +from ._outliercolor import OutliercolorValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/marker/_color.py b/plotly/validators/box/marker/_color.py new file mode 100644 index 0000000000..52479dc23d --- /dev/null +++ b/plotly/validators/box/marker/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='box.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/_line.py b/plotly/validators/box/marker/_line.py new file mode 100644 index 0000000000..ed330012ec --- /dev/null +++ b/plotly/validators/box/marker/_line.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='box.marker', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier + sample points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the + outlier sample points. + width + Sets the width (in px) of the lines bounding + the marker points.""", + **kwargs + ) diff --git a/plotly/validators/box/marker/_opacity.py b/plotly/validators/box/marker/_opacity.py new file mode 100644 index 0000000000..0670371950 --- /dev/null +++ b/plotly/validators/box/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='box.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/_outliercolor.py b/plotly/validators/box/marker/_outliercolor.py new file mode 100644 index 0000000000..a26ceeb9e9 --- /dev/null +++ b/plotly/validators/box/marker/_outliercolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OutliercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='outliercolor', parent_name='box.marker', **kwargs + ): + super(OutliercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/_size.py b/plotly/validators/box/marker/_size.py new file mode 100644 index 0000000000..062c36b178 --- /dev/null +++ b/plotly/validators/box/marker/_size.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='size', parent_name='box.marker', **kwargs): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/_symbol.py b/plotly/validators/box/marker/_symbol.py new file mode 100644 index 0000000000..287e98cc75 --- /dev/null +++ b/plotly/validators/box/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='box.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='plot', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/box/marker/line/__init__.py b/plotly/validators/box/marker/line/__init__.py new file mode 100644 index 0000000000..250468b9f8 --- /dev/null +++ b/plotly/validators/box/marker/line/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._outlierwidth import OutlierwidthValidator +from ._outliercolor import OutliercolorValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/marker/line/_color.py b/plotly/validators/box/marker/line/_color.py new file mode 100644 index 0000000000..5e9b302f5a --- /dev/null +++ b/plotly/validators/box/marker/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='box.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/line/_outliercolor.py b/plotly/validators/box/marker/line/_outliercolor.py new file mode 100644 index 0000000000..35964f9dbc --- /dev/null +++ b/plotly/validators/box/marker/line/_outliercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutliercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outliercolor', + parent_name='box.marker.line', + **kwargs + ): + super(OutliercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/line/_outlierwidth.py b/plotly/validators/box/marker/line/_outlierwidth.py new file mode 100644 index 0000000000..d4a7db702a --- /dev/null +++ b/plotly/validators/box/marker/line/_outlierwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlierwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlierwidth', + parent_name='box.marker.line', + **kwargs + ): + super(OutlierwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/marker/line/_width.py b/plotly/validators/box/marker/line/_width.py new file mode 100644 index 0000000000..4c799f606c --- /dev/null +++ b/plotly/validators/box/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='box.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/selected/__init__.py b/plotly/validators/box/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/box/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/box/selected/_marker.py b/plotly/validators/box/selected/_marker.py new file mode 100644 index 0000000000..a1987845cd --- /dev/null +++ b/plotly/validators/box/selected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='box.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/box/selected/marker/__init__.py b/plotly/validators/box/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/box/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/selected/marker/_color.py b/plotly/validators/box/selected/marker/_color.py new file mode 100644 index 0000000000..3b1688f01d --- /dev/null +++ b/plotly/validators/box/selected/marker/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='box.selected.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/selected/marker/_opacity.py b/plotly/validators/box/selected/marker/_opacity.py new file mode 100644 index 0000000000..8e9f684171 --- /dev/null +++ b/plotly/validators/box/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='box.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/selected/marker/_size.py b/plotly/validators/box/selected/marker/_size.py new file mode 100644 index 0000000000..9395117fe2 --- /dev/null +++ b/plotly/validators/box/selected/marker/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='box.selected.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/stream/__init__.py b/plotly/validators/box/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/box/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/box/stream/_maxpoints.py b/plotly/validators/box/stream/_maxpoints.py new file mode 100644 index 0000000000..fa07e9cc4b --- /dev/null +++ b/plotly/validators/box/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='box.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/box/stream/_token.py b/plotly/validators/box/stream/_token.py new file mode 100644 index 0000000000..765c476330 --- /dev/null +++ b/plotly/validators/box/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='box.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/box/unselected/__init__.py b/plotly/validators/box/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/box/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/box/unselected/_marker.py b/plotly/validators/box/unselected/_marker.py new file mode 100644 index 0000000000..2ebcaa2406 --- /dev/null +++ b/plotly/validators/box/unselected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='box.unselected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/box/unselected/marker/__init__.py b/plotly/validators/box/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/box/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/box/unselected/marker/_color.py b/plotly/validators/box/unselected/marker/_color.py new file mode 100644 index 0000000000..de0475c8c3 --- /dev/null +++ b/plotly/validators/box/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='box.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/box/unselected/marker/_opacity.py b/plotly/validators/box/unselected/marker/_opacity.py new file mode 100644 index 0000000000..daf012ecd9 --- /dev/null +++ b/plotly/validators/box/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='box.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/box/unselected/marker/_size.py b/plotly/validators/box/unselected/marker/_size.py new file mode 100644 index 0000000000..8d95d0cbf3 --- /dev/null +++ b/plotly/validators/box/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='box.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/__init__.py b/plotly/validators/candlestick/__init__.py new file mode 100644 index 0000000000..11b316b0d2 --- /dev/null +++ b/plotly/validators/candlestick/__init__.py @@ -0,0 +1,34 @@ +from ._yaxis import YAxisValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._whiskerwidth import WhiskerwidthValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._opensrc import OpensrcValidator +from ._open import OpenValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._lowsrc import LowsrcValidator +from ._low import LowValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._increasing import IncreasingValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._highsrc import HighsrcValidator +from ._high import HighValidator +from ._decreasing import DecreasingValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._closesrc import ClosesrcValidator +from ._close import CloseValidator diff --git a/plotly/validators/candlestick/_close.py b/plotly/validators/candlestick/_close.py new file mode 100644 index 0000000000..fbd1118b0b --- /dev/null +++ b/plotly/validators/candlestick/_close.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CloseValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='close', parent_name='candlestick', **kwargs + ): + super(CloseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_closesrc.py b/plotly/validators/candlestick/_closesrc.py new file mode 100644 index 0000000000..0b27f3cda5 --- /dev/null +++ b/plotly/validators/candlestick/_closesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ClosesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='closesrc', parent_name='candlestick', **kwargs + ): + super(ClosesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_customdata.py b/plotly/validators/candlestick/_customdata.py new file mode 100644 index 0000000000..ec55cb0fdb --- /dev/null +++ b/plotly/validators/candlestick/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='candlestick', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_customdatasrc.py b/plotly/validators/candlestick/_customdatasrc.py new file mode 100644 index 0000000000..1cd5f4fe0c --- /dev/null +++ b/plotly/validators/candlestick/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='candlestick', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_decreasing.py b/plotly/validators/candlestick/_decreasing.py new file mode 100644 index 0000000000..fe9c2b269e --- /dev/null +++ b/plotly/validators/candlestick/_decreasing.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class DecreasingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='decreasing', parent_name='candlestick', **kwargs + ): + super(DecreasingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Decreasing', + data_docs=""" + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + line + plotly.graph_objs.candlestick.decreasing.Line + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/candlestick/_high.py b/plotly/validators/candlestick/_high.py new file mode 100644 index 0000000000..c5c7f81d50 --- /dev/null +++ b/plotly/validators/candlestick/_high.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HighValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='high', parent_name='candlestick', **kwargs + ): + super(HighValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_highsrc.py b/plotly/validators/candlestick/_highsrc.py new file mode 100644 index 0000000000..5b8dc62cc1 --- /dev/null +++ b/plotly/validators/candlestick/_highsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HighsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='highsrc', parent_name='candlestick', **kwargs + ): + super(HighsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_hoverinfo.py b/plotly/validators/candlestick/_hoverinfo.py new file mode 100644 index 0000000000..d54b0fc84d --- /dev/null +++ b/plotly/validators/candlestick/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='candlestick', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_hoverinfosrc.py b/plotly/validators/candlestick/_hoverinfosrc.py new file mode 100644 index 0000000000..321e5064f4 --- /dev/null +++ b/plotly/validators/candlestick/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='candlestick', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_hoverlabel.py b/plotly/validators/candlestick/_hoverlabel.py new file mode 100644 index 0000000000..3c96dd8ebb --- /dev/null +++ b/plotly/validators/candlestick/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='candlestick', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/candlestick/_ids.py b/plotly/validators/candlestick/_ids.py new file mode 100644 index 0000000000..ad82d9e256 --- /dev/null +++ b/plotly/validators/candlestick/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='candlestick', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_idssrc.py b/plotly/validators/candlestick/_idssrc.py new file mode 100644 index 0000000000..dcd9400989 --- /dev/null +++ b/plotly/validators/candlestick/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='candlestick', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_increasing.py b/plotly/validators/candlestick/_increasing.py new file mode 100644 index 0000000000..4eedbaa952 --- /dev/null +++ b/plotly/validators/candlestick/_increasing.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class IncreasingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='increasing', parent_name='candlestick', **kwargs + ): + super(IncreasingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Increasing', + data_docs=""" + fillcolor + Sets the fill color. Defaults to a half- + transparent variant of the line color, marker + color, or marker line color, whichever is + available. + line + plotly.graph_objs.candlestick.increasing.Line + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/candlestick/_legendgroup.py b/plotly/validators/candlestick/_legendgroup.py new file mode 100644 index 0000000000..7932c9b96e --- /dev/null +++ b/plotly/validators/candlestick/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='candlestick', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_line.py b/plotly/validators/candlestick/_line.py new file mode 100644 index 0000000000..a69911a35f --- /dev/null +++ b/plotly/validators/candlestick/_line.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='candlestick', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + width + Sets the width (in px) of line bounding the + box(es). Note that this style setting can also + be set per direction via + `increasing.line.width` and + `decreasing.line.width`.""", + **kwargs + ) diff --git a/plotly/validators/candlestick/_low.py b/plotly/validators/candlestick/_low.py new file mode 100644 index 0000000000..4ab4c940ed --- /dev/null +++ b/plotly/validators/candlestick/_low.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LowValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='low', parent_name='candlestick', **kwargs): + super(LowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_lowsrc.py b/plotly/validators/candlestick/_lowsrc.py new file mode 100644 index 0000000000..e266959018 --- /dev/null +++ b/plotly/validators/candlestick/_lowsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LowsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='lowsrc', parent_name='candlestick', **kwargs + ): + super(LowsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_name.py b/plotly/validators/candlestick/_name.py new file mode 100644 index 0000000000..c492184aec --- /dev/null +++ b/plotly/validators/candlestick/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='candlestick', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_opacity.py b/plotly/validators/candlestick/_opacity.py new file mode 100644 index 0000000000..0ae7261ce9 --- /dev/null +++ b/plotly/validators/candlestick/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='candlestick', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/_open.py b/plotly/validators/candlestick/_open.py new file mode 100644 index 0000000000..e16fa63c36 --- /dev/null +++ b/plotly/validators/candlestick/_open.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpenValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='open', parent_name='candlestick', **kwargs + ): + super(OpenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_opensrc.py b/plotly/validators/candlestick/_opensrc.py new file mode 100644 index 0000000000..fdd520f5eb --- /dev/null +++ b/plotly/validators/candlestick/_opensrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpensrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='opensrc', parent_name='candlestick', **kwargs + ): + super(OpensrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_selectedpoints.py b/plotly/validators/candlestick/_selectedpoints.py new file mode 100644 index 0000000000..f8d44e4b76 --- /dev/null +++ b/plotly/validators/candlestick/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='candlestick', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_showlegend.py b/plotly/validators/candlestick/_showlegend.py new file mode 100644 index 0000000000..9914ea3688 --- /dev/null +++ b/plotly/validators/candlestick/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='candlestick', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_stream.py b/plotly/validators/candlestick/_stream.py new file mode 100644 index 0000000000..7895482e52 --- /dev/null +++ b/plotly/validators/candlestick/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='candlestick', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/candlestick/_text.py b/plotly/validators/candlestick/_text.py new file mode 100644 index 0000000000..9ba672bd05 --- /dev/null +++ b/plotly/validators/candlestick/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='candlestick', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_textsrc.py b/plotly/validators/candlestick/_textsrc.py new file mode 100644 index 0000000000..801e2018cf --- /dev/null +++ b/plotly/validators/candlestick/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='candlestick', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_uid.py b/plotly/validators/candlestick/_uid.py new file mode 100644 index 0000000000..9a3ede2497 --- /dev/null +++ b/plotly/validators/candlestick/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='candlestick', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_visible.py b/plotly/validators/candlestick/_visible.py new file mode 100644 index 0000000000..6ce08c48e4 --- /dev/null +++ b/plotly/validators/candlestick/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='candlestick', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/candlestick/_whiskerwidth.py b/plotly/validators/candlestick/_whiskerwidth.py new file mode 100644 index 0000000000..bdabeae712 --- /dev/null +++ b/plotly/validators/candlestick/_whiskerwidth.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WhiskerwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='whiskerwidth', parent_name='candlestick', **kwargs + ): + super(WhiskerwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/_x.py b/plotly/validators/candlestick/_x.py new file mode 100644 index 0000000000..3dba53b41a --- /dev/null +++ b/plotly/validators/candlestick/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='candlestick', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/candlestick/_xaxis.py b/plotly/validators/candlestick/_xaxis.py new file mode 100644 index 0000000000..8bcb71ce7d --- /dev/null +++ b/plotly/validators/candlestick/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='candlestick', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_xcalendar.py b/plotly/validators/candlestick/_xcalendar.py new file mode 100644 index 0000000000..e96d64f258 --- /dev/null +++ b/plotly/validators/candlestick/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='candlestick', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/candlestick/_xsrc.py b/plotly/validators/candlestick/_xsrc.py new file mode 100644 index 0000000000..ff4590c3ca --- /dev/null +++ b/plotly/validators/candlestick/_xsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='xsrc', parent_name='candlestick', **kwargs + ): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/_yaxis.py b/plotly/validators/candlestick/_yaxis.py new file mode 100644 index 0000000000..fdec0b0b1f --- /dev/null +++ b/plotly/validators/candlestick/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='candlestick', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/decreasing/__init__.py b/plotly/validators/candlestick/decreasing/__init__.py new file mode 100644 index 0000000000..20ad0eb02b --- /dev/null +++ b/plotly/validators/candlestick/decreasing/__init__.py @@ -0,0 +1,2 @@ +from ._line import LineValidator +from ._fillcolor import FillcolorValidator diff --git a/plotly/validators/candlestick/decreasing/_fillcolor.py b/plotly/validators/candlestick/decreasing/_fillcolor.py new file mode 100644 index 0000000000..d03151fbf1 --- /dev/null +++ b/plotly/validators/candlestick/decreasing/_fillcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='fillcolor', + parent_name='candlestick.decreasing', + **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/decreasing/_line.py b/plotly/validators/candlestick/decreasing/_line.py new file mode 100644 index 0000000000..1fe8f236e5 --- /dev/null +++ b/plotly/validators/candlestick/decreasing/_line.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='line', + parent_name='candlestick.decreasing', + **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es).""", + **kwargs + ) diff --git a/plotly/validators/candlestick/decreasing/line/__init__.py b/plotly/validators/candlestick/decreasing/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/candlestick/decreasing/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/candlestick/decreasing/line/_color.py b/plotly/validators/candlestick/decreasing/line/_color.py new file mode 100644 index 0000000000..bba5d37d88 --- /dev/null +++ b/plotly/validators/candlestick/decreasing/line/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='candlestick.decreasing.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/decreasing/line/_width.py b/plotly/validators/candlestick/decreasing/line/_width.py new file mode 100644 index 0000000000..911965f409 --- /dev/null +++ b/plotly/validators/candlestick/decreasing/line/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='candlestick.decreasing.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/__init__.py b/plotly/validators/candlestick/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/candlestick/hoverlabel/_bgcolor.py b/plotly/validators/candlestick/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..b2ef334d95 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_bgcolorsrc.py b/plotly/validators/candlestick/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..766487e066 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_bordercolor.py b/plotly/validators/candlestick/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..f62fcb70e0 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_bordercolorsrc.py b/plotly/validators/candlestick/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..ceb9a0d2a6 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_font.py b/plotly/validators/candlestick/hoverlabel/_font.py new file mode 100644 index 0000000000..a9f09fbeb2 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_namelength.py b/plotly/validators/candlestick/hoverlabel/_namelength.py new file mode 100644 index 0000000000..a8cf347427 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/_namelengthsrc.py b/plotly/validators/candlestick/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..3f7fe2a26e --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='candlestick.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/__init__.py b/plotly/validators/candlestick/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/candlestick/hoverlabel/font/_color.py b/plotly/validators/candlestick/hoverlabel/font/_color.py new file mode 100644 index 0000000000..86c428423c --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/_colorsrc.py b/plotly/validators/candlestick/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..34fee35aa4 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/_family.py b/plotly/validators/candlestick/hoverlabel/font/_family.py new file mode 100644 index 0000000000..44edd062dc --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/_familysrc.py b/plotly/validators/candlestick/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..ebacc9cab0 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/_size.py b/plotly/validators/candlestick/hoverlabel/font/_size.py new file mode 100644 index 0000000000..a7d33fe6a7 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/hoverlabel/font/_sizesrc.py b/plotly/validators/candlestick/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..42981595d8 --- /dev/null +++ b/plotly/validators/candlestick/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='candlestick.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/increasing/__init__.py b/plotly/validators/candlestick/increasing/__init__.py new file mode 100644 index 0000000000..20ad0eb02b --- /dev/null +++ b/plotly/validators/candlestick/increasing/__init__.py @@ -0,0 +1,2 @@ +from ._line import LineValidator +from ._fillcolor import FillcolorValidator diff --git a/plotly/validators/candlestick/increasing/_fillcolor.py b/plotly/validators/candlestick/increasing/_fillcolor.py new file mode 100644 index 0000000000..12fd250020 --- /dev/null +++ b/plotly/validators/candlestick/increasing/_fillcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='fillcolor', + parent_name='candlestick.increasing', + **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/increasing/_line.py b/plotly/validators/candlestick/increasing/_line.py new file mode 100644 index 0000000000..635468c6ec --- /dev/null +++ b/plotly/validators/candlestick/increasing/_line.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='line', + parent_name='candlestick.increasing', + **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of line bounding the box(es). + width + Sets the width (in px) of line bounding the + box(es).""", + **kwargs + ) diff --git a/plotly/validators/candlestick/increasing/line/__init__.py b/plotly/validators/candlestick/increasing/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/candlestick/increasing/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/candlestick/increasing/line/_color.py b/plotly/validators/candlestick/increasing/line/_color.py new file mode 100644 index 0000000000..47f1c346b6 --- /dev/null +++ b/plotly/validators/candlestick/increasing/line/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='candlestick.increasing.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/increasing/line/_width.py b/plotly/validators/candlestick/increasing/line/_width.py new file mode 100644 index 0000000000..d5ccb266ef --- /dev/null +++ b/plotly/validators/candlestick/increasing/line/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='candlestick.increasing.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/line/__init__.py b/plotly/validators/candlestick/line/__init__.py new file mode 100644 index 0000000000..6b3cef5b7d --- /dev/null +++ b/plotly/validators/candlestick/line/__init__.py @@ -0,0 +1 @@ +from ._width import WidthValidator diff --git a/plotly/validators/candlestick/line/_width.py b/plotly/validators/candlestick/line/_width.py new file mode 100644 index 0000000000..8bd6364df3 --- /dev/null +++ b/plotly/validators/candlestick/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='candlestick.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/candlestick/stream/__init__.py b/plotly/validators/candlestick/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/candlestick/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/candlestick/stream/_maxpoints.py b/plotly/validators/candlestick/stream/_maxpoints.py new file mode 100644 index 0000000000..55685ee246 --- /dev/null +++ b/plotly/validators/candlestick/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='candlestick.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/candlestick/stream/_token.py b/plotly/validators/candlestick/stream/_token.py new file mode 100644 index 0000000000..f0f1eae7dd --- /dev/null +++ b/plotly/validators/candlestick/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='candlestick.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/__init__.py b/plotly/validators/carpet/__init__.py new file mode 100644 index 0000000000..5dfe036361 --- /dev/null +++ b/plotly/validators/carpet/__init__.py @@ -0,0 +1,35 @@ +from ._ysrc import YsrcValidator +from ._yaxis import YAxisValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._font import FontValidator +from ._db import DbValidator +from ._da import DaValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._color import ColorValidator +from ._cheaterslope import CheaterslopeValidator +from ._carpet import CarpetValidator +from ._bsrc import BsrcValidator +from ._baxis import BaxisValidator +from ._b0 import B0Validator +from ._b import BValidator +from ._asrc import AsrcValidator +from ._aaxis import AaxisValidator +from ._a0 import A0Validator +from ._a import AValidator diff --git a/plotly/validators/carpet/_a.py b/plotly/validators/carpet/_a.py new file mode 100644 index 0000000000..62529a67b8 --- /dev/null +++ b/plotly/validators/carpet/_a.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class AValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='a', parent_name='carpet', **kwargs): + super(AValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_a0.py b/plotly/validators/carpet/_a0.py new file mode 100644 index 0000000000..963e4c19c5 --- /dev/null +++ b/plotly/validators/carpet/_a0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class A0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='a0', parent_name='carpet', **kwargs): + super(A0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_aaxis.py b/plotly/validators/carpet/_aaxis.py new file mode 100644 index 0000000000..47e48b35f5 --- /dev/null +++ b/plotly/validators/carpet/_aaxis.py @@ -0,0 +1,212 @@ +import _plotly_utils.basevalidators + + +class AaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='aaxis', parent_name='carpet', **kwargs): + super(AaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Aaxis', + data_docs=""" + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at + along the final value of this axis. If *true*, + the end line is drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major + grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether axis labels are drawn on the + low side, the high side, both, or neither side + of the axis. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at + along the starting value of this axis. If + *true*, the start line is drawn on top of the + grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.aaxis.Tickformatstop + instance or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the + title from the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question.""", + **kwargs + ) diff --git a/plotly/validators/carpet/_asrc.py b/plotly/validators/carpet/_asrc.py new file mode 100644 index 0000000000..a907120732 --- /dev/null +++ b/plotly/validators/carpet/_asrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class AsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='asrc', parent_name='carpet', **kwargs): + super(AsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_b.py b/plotly/validators/carpet/_b.py new file mode 100644 index 0000000000..38a9b8b0c8 --- /dev/null +++ b/plotly/validators/carpet/_b.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='b', parent_name='carpet', **kwargs): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_b0.py b/plotly/validators/carpet/_b0.py new file mode 100644 index 0000000000..81a4947edc --- /dev/null +++ b/plotly/validators/carpet/_b0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class B0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='b0', parent_name='carpet', **kwargs): + super(B0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_baxis.py b/plotly/validators/carpet/_baxis.py new file mode 100644 index 0000000000..2b1d12d895 --- /dev/null +++ b/plotly/validators/carpet/_baxis.py @@ -0,0 +1,212 @@ +import _plotly_utils.basevalidators + + +class BaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='baxis', parent_name='carpet', **kwargs): + super(BaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Baxis', + data_docs=""" + arraydtick + The stride between grid lines along the axis + arraytick0 + The starting index of grid lines along the axis + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + cheatertype + + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + The stride between grid lines along the axis + endline + Determines whether or not a line is drawn at + along the final value of this axis. If *true*, + the end line is drawn on top of the grid lines. + endlinecolor + Sets the line color of the end line. + endlinewidth + Sets the width (in px) of the end line. + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the axis line color. + gridwidth + Sets the width (in px) of the axis line. + labelpadding + Extra padding between label and the axis + labelprefix + Sets a axis label prefix. + labelsuffix + Sets a axis label suffix. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + minorgridcolor + Sets the color of the grid lines. + minorgridcount + Sets the number of minor grid ticks per major + grid tick + minorgridwidth + Sets the width (in px) of the grid lines. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether axis labels are drawn on the + low side, the high side, both, or neither side + of the axis. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + smoothing + + startline + Determines whether or not a line is drawn at + along the starting value of this axis. If + *true*, the start line is drawn on top of the + grid lines. + startlinecolor + Sets the line color of the start line. + startlinewidth + Sets the width (in px) of the start line. + tick0 + The starting index of grid lines along the axis + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.carpet.baxis.Tickformatstop + instance or dict with compatible properties + tickmode + + tickprefix + Sets a tick label prefix. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + titleoffset + An additional amount by which to offset the + title from the tick labels, given in pixels + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question.""", + **kwargs + ) diff --git a/plotly/validators/carpet/_bsrc.py b/plotly/validators/carpet/_bsrc.py new file mode 100644 index 0000000000..e419d8ab84 --- /dev/null +++ b/plotly/validators/carpet/_bsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class BsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='bsrc', parent_name='carpet', **kwargs): + super(BsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_carpet.py b/plotly/validators/carpet/_carpet.py new file mode 100644 index 0000000000..84c9817809 --- /dev/null +++ b/plotly/validators/carpet/_carpet.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CarpetValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='carpet', parent_name='carpet', **kwargs): + super(CarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_cheaterslope.py b/plotly/validators/carpet/_cheaterslope.py new file mode 100644 index 0000000000..83c625647e --- /dev/null +++ b/plotly/validators/carpet/_cheaterslope.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CheaterslopeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cheaterslope', parent_name='carpet', **kwargs + ): + super(CheaterslopeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_color.py b/plotly/validators/carpet/_color.py new file mode 100644 index 0000000000..9ac0de6c93 --- /dev/null +++ b/plotly/validators/carpet/_color.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__(self, plotly_name='color', parent_name='carpet', **kwargs): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/_customdata.py b/plotly/validators/carpet/_customdata.py new file mode 100644 index 0000000000..25c2552c32 --- /dev/null +++ b/plotly/validators/carpet/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='carpet', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_customdatasrc.py b/plotly/validators/carpet/_customdatasrc.py new file mode 100644 index 0000000000..ff09a043f9 --- /dev/null +++ b/plotly/validators/carpet/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='carpet', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_da.py b/plotly/validators/carpet/_da.py new file mode 100644 index 0000000000..9854ad7354 --- /dev/null +++ b/plotly/validators/carpet/_da.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DaValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='da', parent_name='carpet', **kwargs): + super(DaValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_db.py b/plotly/validators/carpet/_db.py new file mode 100644 index 0000000000..185f8084ab --- /dev/null +++ b/plotly/validators/carpet/_db.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DbValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='db', parent_name='carpet', **kwargs): + super(DbValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_font.py b/plotly/validators/carpet/_font.py new file mode 100644 index 0000000000..e3ffc9c185 --- /dev/null +++ b/plotly/validators/carpet/_font.py @@ -0,0 +1,33 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='font', parent_name='carpet', **kwargs): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/carpet/_hoverinfo.py b/plotly/validators/carpet/_hoverinfo.py new file mode 100644 index 0000000000..22a63c85be --- /dev/null +++ b/plotly/validators/carpet/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='carpet', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_hoverinfosrc.py b/plotly/validators/carpet/_hoverinfosrc.py new file mode 100644 index 0000000000..f22b789204 --- /dev/null +++ b/plotly/validators/carpet/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='carpet', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_hoverlabel.py b/plotly/validators/carpet/_hoverlabel.py new file mode 100644 index 0000000000..24b156c812 --- /dev/null +++ b/plotly/validators/carpet/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='carpet', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/carpet/_ids.py b/plotly/validators/carpet/_ids.py new file mode 100644 index 0000000000..20868e444b --- /dev/null +++ b/plotly/validators/carpet/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='carpet', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_idssrc.py b/plotly/validators/carpet/_idssrc.py new file mode 100644 index 0000000000..ad00803160 --- /dev/null +++ b/plotly/validators/carpet/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='carpet', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_legendgroup.py b/plotly/validators/carpet/_legendgroup.py new file mode 100644 index 0000000000..9326ada429 --- /dev/null +++ b/plotly/validators/carpet/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='carpet', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_name.py b/plotly/validators/carpet/_name.py new file mode 100644 index 0000000000..9224019517 --- /dev/null +++ b/plotly/validators/carpet/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='carpet', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_opacity.py b/plotly/validators/carpet/_opacity.py new file mode 100644 index 0000000000..59e9b03697 --- /dev/null +++ b/plotly/validators/carpet/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='carpet', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/_selectedpoints.py b/plotly/validators/carpet/_selectedpoints.py new file mode 100644 index 0000000000..57c496ffab --- /dev/null +++ b/plotly/validators/carpet/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='carpet', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_showlegend.py b/plotly/validators/carpet/_showlegend.py new file mode 100644 index 0000000000..00e9856771 --- /dev/null +++ b/plotly/validators/carpet/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='carpet', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_stream.py b/plotly/validators/carpet/_stream.py new file mode 100644 index 0000000000..7ee6d610e6 --- /dev/null +++ b/plotly/validators/carpet/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='carpet', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/carpet/_uid.py b/plotly/validators/carpet/_uid.py new file mode 100644 index 0000000000..14864d6e35 --- /dev/null +++ b/plotly/validators/carpet/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='carpet', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_visible.py b/plotly/validators/carpet/_visible.py new file mode 100644 index 0000000000..2f6b4181ec --- /dev/null +++ b/plotly/validators/carpet/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='carpet', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/carpet/_x.py b/plotly/validators/carpet/_x.py new file mode 100644 index 0000000000..5872cc7e05 --- /dev/null +++ b/plotly/validators/carpet/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='carpet', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_xaxis.py b/plotly/validators/carpet/_xaxis.py new file mode 100644 index 0000000000..c7220b91b2 --- /dev/null +++ b/plotly/validators/carpet/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='carpet', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_xsrc.py b/plotly/validators/carpet/_xsrc.py new file mode 100644 index 0000000000..f2c0f762a7 --- /dev/null +++ b/plotly/validators/carpet/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='carpet', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_y.py b/plotly/validators/carpet/_y.py new file mode 100644 index 0000000000..6b1791ff75 --- /dev/null +++ b/plotly/validators/carpet/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='carpet', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/_yaxis.py b/plotly/validators/carpet/_yaxis.py new file mode 100644 index 0000000000..6f8694b47d --- /dev/null +++ b/plotly/validators/carpet/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='carpet', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/_ysrc.py b/plotly/validators/carpet/_ysrc.py new file mode 100644 index 0000000000..e80d4df95b --- /dev/null +++ b/plotly/validators/carpet/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='carpet', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/__init__.py b/plotly/validators/carpet/aaxis/__init__.py new file mode 100644 index 0000000000..40cab15907 --- /dev/null +++ b/plotly/validators/carpet/aaxis/__init__.py @@ -0,0 +1,54 @@ +from ._type import TypeValidator +from ._titleoffset import TitleoffsetValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._startlinewidth import StartlinewidthValidator +from ._startlinecolor import StartlinecolorValidator +from ._startline import StartlineValidator +from ._smoothing import SmoothingValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._minorgridwidth import MinorgridwidthValidator +from ._minorgridcount import MinorgridcountValidator +from ._minorgridcolor import MinorgridcolorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._labelsuffix import LabelsuffixValidator +from ._labelprefix import LabelprefixValidator +from ._labelpadding import LabelpaddingValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._fixedrange import FixedrangeValidator +from ._exponentformat import ExponentformatValidator +from ._endlinewidth import EndlinewidthValidator +from ._endlinecolor import EndlinecolorValidator +from ._endline import EndlineValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._cheatertype import CheatertypeValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._autorange import AutorangeValidator +from ._arraytick0 import Arraytick0Validator +from ._arraydtick import ArraydtickValidator diff --git a/plotly/validators/carpet/aaxis/_arraydtick.py b/plotly/validators/carpet/aaxis/_arraydtick.py new file mode 100644 index 0000000000..61d8d68560 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_arraydtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ArraydtickValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='arraydtick', parent_name='carpet.aaxis', **kwargs + ): + super(ArraydtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_arraytick0.py b/plotly/validators/carpet/aaxis/_arraytick0.py new file mode 100644 index 0000000000..6609e19a86 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_arraytick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Arraytick0Validator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='arraytick0', parent_name='carpet.aaxis', **kwargs + ): + super(Arraytick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_autorange.py b/plotly/validators/carpet/aaxis/_autorange.py new file mode 100644 index 0000000000..722b29b271 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_autorange.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='autorange', parent_name='carpet.aaxis', **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_categoryarray.py b/plotly/validators/carpet/aaxis/_categoryarray.py new file mode 100644 index 0000000000..f4edd3764a --- /dev/null +++ b/plotly/validators/carpet/aaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='carpet.aaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_categoryarraysrc.py b/plotly/validators/carpet/aaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..141ff215b2 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='carpet.aaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_categoryorder.py b/plotly/validators/carpet/aaxis/_categoryorder.py new file mode 100644 index 0000000000..f30c4d8d8a --- /dev/null +++ b/plotly/validators/carpet/aaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='carpet.aaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_cheatertype.py b/plotly/validators/carpet/aaxis/_cheatertype.py new file mode 100644 index 0000000000..f834b3252d --- /dev/null +++ b/plotly/validators/carpet/aaxis/_cheatertype.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CheatertypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='cheatertype', parent_name='carpet.aaxis', **kwargs + ): + super(CheatertypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['index', 'value'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_color.py b/plotly/validators/carpet/aaxis/_color.py new file mode 100644 index 0000000000..0cd4e08b0c --- /dev/null +++ b/plotly/validators/carpet/aaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='carpet.aaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_dtick.py b/plotly/validators/carpet/aaxis/_dtick.py new file mode 100644 index 0000000000..4e20a58b96 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='dtick', parent_name='carpet.aaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_endline.py b/plotly/validators/carpet/aaxis/_endline.py new file mode 100644 index 0000000000..9a11a5a320 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_endline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='endline', parent_name='carpet.aaxis', **kwargs + ): + super(EndlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_endlinecolor.py b/plotly/validators/carpet/aaxis/_endlinecolor.py new file mode 100644 index 0000000000..d11fae4f3d --- /dev/null +++ b/plotly/validators/carpet/aaxis/_endlinecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='endlinecolor', parent_name='carpet.aaxis', **kwargs + ): + super(EndlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_endlinewidth.py b/plotly/validators/carpet/aaxis/_endlinewidth.py new file mode 100644 index 0000000000..d7475a8ed0 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_endlinewidth.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='endlinewidth', parent_name='carpet.aaxis', **kwargs + ): + super(EndlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_exponentformat.py b/plotly/validators/carpet/aaxis/_exponentformat.py new file mode 100644 index 0000000000..062a6d9eee --- /dev/null +++ b/plotly/validators/carpet/aaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='carpet.aaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_fixedrange.py b/plotly/validators/carpet/aaxis/_fixedrange.py new file mode 100644 index 0000000000..4eda608338 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_fixedrange.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FixedrangeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='fixedrange', parent_name='carpet.aaxis', **kwargs + ): + super(FixedrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_gridcolor.py b/plotly/validators/carpet/aaxis/_gridcolor.py new file mode 100644 index 0000000000..43340808b7 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_gridcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='gridcolor', parent_name='carpet.aaxis', **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_gridwidth.py b/plotly/validators/carpet/aaxis/_gridwidth.py new file mode 100644 index 0000000000..692d8edab4 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_gridwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='gridwidth', parent_name='carpet.aaxis', **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_labelpadding.py b/plotly/validators/carpet/aaxis/_labelpadding.py new file mode 100644 index 0000000000..a14997fbe1 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_labelpadding.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelpaddingValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='labelpadding', parent_name='carpet.aaxis', **kwargs + ): + super(LabelpaddingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_labelprefix.py b/plotly/validators/carpet/aaxis/_labelprefix.py new file mode 100644 index 0000000000..1de9524a98 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_labelprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='labelprefix', parent_name='carpet.aaxis', **kwargs + ): + super(LabelprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_labelsuffix.py b/plotly/validators/carpet/aaxis/_labelsuffix.py new file mode 100644 index 0000000000..0a916d4b92 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_labelsuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelsuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='labelsuffix', parent_name='carpet.aaxis', **kwargs + ): + super(LabelsuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_linecolor.py b/plotly/validators/carpet/aaxis/_linecolor.py new file mode 100644 index 0000000000..7ef9907aef --- /dev/null +++ b/plotly/validators/carpet/aaxis/_linecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='linecolor', parent_name='carpet.aaxis', **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_linewidth.py b/plotly/validators/carpet/aaxis/_linewidth.py new file mode 100644 index 0000000000..d62f654f45 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_linewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='linewidth', parent_name='carpet.aaxis', **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_minorgridcolor.py b/plotly/validators/carpet/aaxis/_minorgridcolor.py new file mode 100644 index 0000000000..d4f1f06b8f --- /dev/null +++ b/plotly/validators/carpet/aaxis/_minorgridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class MinorgridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='minorgridcolor', + parent_name='carpet.aaxis', + **kwargs + ): + super(MinorgridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_minorgridcount.py b/plotly/validators/carpet/aaxis/_minorgridcount.py new file mode 100644 index 0000000000..6be0ffe7d3 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_minorgridcount.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MinorgridcountValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='minorgridcount', + parent_name='carpet.aaxis', + **kwargs + ): + super(MinorgridcountValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_minorgridwidth.py b/plotly/validators/carpet/aaxis/_minorgridwidth.py new file mode 100644 index 0000000000..cddff88a00 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_minorgridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MinorgridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='minorgridwidth', + parent_name='carpet.aaxis', + **kwargs + ): + super(MinorgridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_nticks.py b/plotly/validators/carpet/aaxis/_nticks.py new file mode 100644 index 0000000000..9b6efbf94c --- /dev/null +++ b/plotly/validators/carpet/aaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='carpet.aaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_range.py b/plotly/validators/carpet/aaxis/_range.py new file mode 100644 index 0000000000..f821015716 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='carpet.aaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_rangemode.py b/plotly/validators/carpet/aaxis/_rangemode.py new file mode 100644 index 0000000000..623a08d31a --- /dev/null +++ b/plotly/validators/carpet/aaxis/_rangemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='rangemode', parent_name='carpet.aaxis', **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_separatethousands.py b/plotly/validators/carpet/aaxis/_separatethousands.py new file mode 100644 index 0000000000..550a39ac1f --- /dev/null +++ b/plotly/validators/carpet/aaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='carpet.aaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showexponent.py b/plotly/validators/carpet/aaxis/_showexponent.py new file mode 100644 index 0000000000..efebcaf843 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showexponent.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='showexponent', parent_name='carpet.aaxis', **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showgrid.py b/plotly/validators/carpet/aaxis/_showgrid.py new file mode 100644 index 0000000000..a51db46204 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showgrid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showgrid', parent_name='carpet.aaxis', **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showline.py b/plotly/validators/carpet/aaxis/_showline.py new file mode 100644 index 0000000000..12dd523d6d --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showline', parent_name='carpet.aaxis', **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showticklabels.py b/plotly/validators/carpet/aaxis/_showticklabels.py new file mode 100644 index 0000000000..bfd990b028 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showticklabels.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='carpet.aaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['start', 'end', 'both', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showtickprefix.py b/plotly/validators/carpet/aaxis/_showtickprefix.py new file mode 100644 index 0000000000..673c7dbb7a --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='carpet.aaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_showticksuffix.py b/plotly/validators/carpet/aaxis/_showticksuffix.py new file mode 100644 index 0000000000..6d6eadaee6 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='carpet.aaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_smoothing.py b/plotly/validators/carpet/aaxis/_smoothing.py new file mode 100644 index 0000000000..70ea99728e --- /dev/null +++ b/plotly/validators/carpet/aaxis/_smoothing.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='smoothing', parent_name='carpet.aaxis', **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1.3, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_startline.py b/plotly/validators/carpet/aaxis/_startline.py new file mode 100644 index 0000000000..8ce64d9371 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_startline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class StartlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='startline', parent_name='carpet.aaxis', **kwargs + ): + super(StartlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_startlinecolor.py b/plotly/validators/carpet/aaxis/_startlinecolor.py new file mode 100644 index 0000000000..fb46bf1ff7 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_startlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class StartlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='startlinecolor', + parent_name='carpet.aaxis', + **kwargs + ): + super(StartlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_startlinewidth.py b/plotly/validators/carpet/aaxis/_startlinewidth.py new file mode 100644 index 0000000000..c1fc7498bc --- /dev/null +++ b/plotly/validators/carpet/aaxis/_startlinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class StartlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startlinewidth', + parent_name='carpet.aaxis', + **kwargs + ): + super(StartlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tick0.py b/plotly/validators/carpet/aaxis/_tick0.py new file mode 100644 index 0000000000..9fb01110d2 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tick0', parent_name='carpet.aaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickangle.py b/plotly/validators/carpet/aaxis/_tickangle.py new file mode 100644 index 0000000000..ecb1e3a7b7 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='carpet.aaxis', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickfont.py b/plotly/validators/carpet/aaxis/_tickfont.py new file mode 100644 index 0000000000..cce9aa3974 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='carpet.aaxis', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickformat.py b/plotly/validators/carpet/aaxis/_tickformat.py new file mode 100644 index 0000000000..ae04ebaea9 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickformat', parent_name='carpet.aaxis', **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickformatstops.py b/plotly/validators/carpet/aaxis/_tickformatstops.py new file mode 100644 index 0000000000..0c35cfcc8e --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='carpet.aaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickmode.py b/plotly/validators/carpet/aaxis/_tickmode.py new file mode 100644 index 0000000000..3b6e84652b --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='carpet.aaxis', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickprefix.py b/plotly/validators/carpet/aaxis/_tickprefix.py new file mode 100644 index 0000000000..193f0f7e26 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickprefix', parent_name='carpet.aaxis', **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_ticksuffix.py b/plotly/validators/carpet/aaxis/_ticksuffix.py new file mode 100644 index 0000000000..706f255f3c --- /dev/null +++ b/plotly/validators/carpet/aaxis/_ticksuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='ticksuffix', parent_name='carpet.aaxis', **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_ticktext.py b/plotly/validators/carpet/aaxis/_ticktext.py new file mode 100644 index 0000000000..15a6266db2 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='carpet.aaxis', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_ticktextsrc.py b/plotly/validators/carpet/aaxis/_ticktextsrc.py new file mode 100644 index 0000000000..a631bc4e80 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_ticktextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ticktextsrc', parent_name='carpet.aaxis', **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickvals.py b/plotly/validators/carpet/aaxis/_tickvals.py new file mode 100644 index 0000000000..d662833232 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='carpet.aaxis', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_tickvalssrc.py b/plotly/validators/carpet/aaxis/_tickvalssrc.py new file mode 100644 index 0000000000..5341c82a1b --- /dev/null +++ b/plotly/validators/carpet/aaxis/_tickvalssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='tickvalssrc', parent_name='carpet.aaxis', **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_title.py b/plotly/validators/carpet/aaxis/_title.py new file mode 100644 index 0000000000..ce625fb6b5 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='carpet.aaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_titlefont.py b/plotly/validators/carpet/aaxis/_titlefont.py new file mode 100644 index 0000000000..9e80b0aa3a --- /dev/null +++ b/plotly/validators/carpet/aaxis/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='carpet.aaxis', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_titleoffset.py b/plotly/validators/carpet/aaxis/_titleoffset.py new file mode 100644 index 0000000000..07a336edd9 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_titleoffset.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleoffsetValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='titleoffset', parent_name='carpet.aaxis', **kwargs + ): + super(TitleoffsetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/_type.py b/plotly/validators/carpet/aaxis/_type.py new file mode 100644 index 0000000000..6cbfa90237 --- /dev/null +++ b/plotly/validators/carpet/aaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='carpet.aaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/tickfont/__init__.py b/plotly/validators/carpet/aaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/aaxis/tickfont/_color.py b/plotly/validators/carpet/aaxis/tickfont/_color.py new file mode 100644 index 0000000000..97ba9e96b4 --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='carpet.aaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/tickfont/_family.py b/plotly/validators/carpet/aaxis/tickfont/_family.py new file mode 100644 index 0000000000..9eaed0fdf3 --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='carpet.aaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/tickfont/_size.py b/plotly/validators/carpet/aaxis/tickfont/_size.py new file mode 100644 index 0000000000..7ca5fac8c9 --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='carpet.aaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/tickformatstop/__init__.py b/plotly/validators/carpet/aaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/carpet/aaxis/tickformatstop/_dtickrange.py b/plotly/validators/carpet/aaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..9b945447b4 --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='carpet.aaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/tickformatstop/_value.py b/plotly/validators/carpet/aaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..a0fbe693f3 --- /dev/null +++ b/plotly/validators/carpet/aaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='carpet.aaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/titlefont/__init__.py b/plotly/validators/carpet/aaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/carpet/aaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/aaxis/titlefont/_color.py b/plotly/validators/carpet/aaxis/titlefont/_color.py new file mode 100644 index 0000000000..2ce38debc0 --- /dev/null +++ b/plotly/validators/carpet/aaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='carpet.aaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/titlefont/_family.py b/plotly/validators/carpet/aaxis/titlefont/_family.py new file mode 100644 index 0000000000..94a8259773 --- /dev/null +++ b/plotly/validators/carpet/aaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='carpet.aaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/aaxis/titlefont/_size.py b/plotly/validators/carpet/aaxis/titlefont/_size.py new file mode 100644 index 0000000000..86e5381a6a --- /dev/null +++ b/plotly/validators/carpet/aaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='carpet.aaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/__init__.py b/plotly/validators/carpet/baxis/__init__.py new file mode 100644 index 0000000000..40cab15907 --- /dev/null +++ b/plotly/validators/carpet/baxis/__init__.py @@ -0,0 +1,54 @@ +from ._type import TypeValidator +from ._titleoffset import TitleoffsetValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._startlinewidth import StartlinewidthValidator +from ._startlinecolor import StartlinecolorValidator +from ._startline import StartlineValidator +from ._smoothing import SmoothingValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._minorgridwidth import MinorgridwidthValidator +from ._minorgridcount import MinorgridcountValidator +from ._minorgridcolor import MinorgridcolorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._labelsuffix import LabelsuffixValidator +from ._labelprefix import LabelprefixValidator +from ._labelpadding import LabelpaddingValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._fixedrange import FixedrangeValidator +from ._exponentformat import ExponentformatValidator +from ._endlinewidth import EndlinewidthValidator +from ._endlinecolor import EndlinecolorValidator +from ._endline import EndlineValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._cheatertype import CheatertypeValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._autorange import AutorangeValidator +from ._arraytick0 import Arraytick0Validator +from ._arraydtick import ArraydtickValidator diff --git a/plotly/validators/carpet/baxis/_arraydtick.py b/plotly/validators/carpet/baxis/_arraydtick.py new file mode 100644 index 0000000000..21f1077431 --- /dev/null +++ b/plotly/validators/carpet/baxis/_arraydtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ArraydtickValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='arraydtick', parent_name='carpet.baxis', **kwargs + ): + super(ArraydtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_arraytick0.py b/plotly/validators/carpet/baxis/_arraytick0.py new file mode 100644 index 0000000000..16126a3aed --- /dev/null +++ b/plotly/validators/carpet/baxis/_arraytick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Arraytick0Validator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='arraytick0', parent_name='carpet.baxis', **kwargs + ): + super(Arraytick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_autorange.py b/plotly/validators/carpet/baxis/_autorange.py new file mode 100644 index 0000000000..b9aeefa9a5 --- /dev/null +++ b/plotly/validators/carpet/baxis/_autorange.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='autorange', parent_name='carpet.baxis', **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_categoryarray.py b/plotly/validators/carpet/baxis/_categoryarray.py new file mode 100644 index 0000000000..07f504c9b9 --- /dev/null +++ b/plotly/validators/carpet/baxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='carpet.baxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_categoryarraysrc.py b/plotly/validators/carpet/baxis/_categoryarraysrc.py new file mode 100644 index 0000000000..e482d43a6b --- /dev/null +++ b/plotly/validators/carpet/baxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='carpet.baxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_categoryorder.py b/plotly/validators/carpet/baxis/_categoryorder.py new file mode 100644 index 0000000000..164fb966a3 --- /dev/null +++ b/plotly/validators/carpet/baxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='carpet.baxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_cheatertype.py b/plotly/validators/carpet/baxis/_cheatertype.py new file mode 100644 index 0000000000..171924e715 --- /dev/null +++ b/plotly/validators/carpet/baxis/_cheatertype.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CheatertypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='cheatertype', parent_name='carpet.baxis', **kwargs + ): + super(CheatertypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['index', 'value'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_color.py b/plotly/validators/carpet/baxis/_color.py new file mode 100644 index 0000000000..7f3c41d85b --- /dev/null +++ b/plotly/validators/carpet/baxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='carpet.baxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_dtick.py b/plotly/validators/carpet/baxis/_dtick.py new file mode 100644 index 0000000000..0ab39050d8 --- /dev/null +++ b/plotly/validators/carpet/baxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='dtick', parent_name='carpet.baxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_endline.py b/plotly/validators/carpet/baxis/_endline.py new file mode 100644 index 0000000000..3578140059 --- /dev/null +++ b/plotly/validators/carpet/baxis/_endline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='endline', parent_name='carpet.baxis', **kwargs + ): + super(EndlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_endlinecolor.py b/plotly/validators/carpet/baxis/_endlinecolor.py new file mode 100644 index 0000000000..50c66787dd --- /dev/null +++ b/plotly/validators/carpet/baxis/_endlinecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='endlinecolor', parent_name='carpet.baxis', **kwargs + ): + super(EndlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_endlinewidth.py b/plotly/validators/carpet/baxis/_endlinewidth.py new file mode 100644 index 0000000000..5c52d15b52 --- /dev/null +++ b/plotly/validators/carpet/baxis/_endlinewidth.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class EndlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='endlinewidth', parent_name='carpet.baxis', **kwargs + ): + super(EndlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_exponentformat.py b/plotly/validators/carpet/baxis/_exponentformat.py new file mode 100644 index 0000000000..ed687f0bea --- /dev/null +++ b/plotly/validators/carpet/baxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='carpet.baxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_fixedrange.py b/plotly/validators/carpet/baxis/_fixedrange.py new file mode 100644 index 0000000000..371c19dc38 --- /dev/null +++ b/plotly/validators/carpet/baxis/_fixedrange.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FixedrangeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='fixedrange', parent_name='carpet.baxis', **kwargs + ): + super(FixedrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_gridcolor.py b/plotly/validators/carpet/baxis/_gridcolor.py new file mode 100644 index 0000000000..9b0a1b7511 --- /dev/null +++ b/plotly/validators/carpet/baxis/_gridcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='gridcolor', parent_name='carpet.baxis', **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_gridwidth.py b/plotly/validators/carpet/baxis/_gridwidth.py new file mode 100644 index 0000000000..1aecddaaa9 --- /dev/null +++ b/plotly/validators/carpet/baxis/_gridwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='gridwidth', parent_name='carpet.baxis', **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_labelpadding.py b/plotly/validators/carpet/baxis/_labelpadding.py new file mode 100644 index 0000000000..552202dd4d --- /dev/null +++ b/plotly/validators/carpet/baxis/_labelpadding.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelpaddingValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='labelpadding', parent_name='carpet.baxis', **kwargs + ): + super(LabelpaddingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_labelprefix.py b/plotly/validators/carpet/baxis/_labelprefix.py new file mode 100644 index 0000000000..7ff62cfa66 --- /dev/null +++ b/plotly/validators/carpet/baxis/_labelprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='labelprefix', parent_name='carpet.baxis', **kwargs + ): + super(LabelprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_labelsuffix.py b/plotly/validators/carpet/baxis/_labelsuffix.py new file mode 100644 index 0000000000..2df118641c --- /dev/null +++ b/plotly/validators/carpet/baxis/_labelsuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelsuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='labelsuffix', parent_name='carpet.baxis', **kwargs + ): + super(LabelsuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_linecolor.py b/plotly/validators/carpet/baxis/_linecolor.py new file mode 100644 index 0000000000..a51b9ddcac --- /dev/null +++ b/plotly/validators/carpet/baxis/_linecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='linecolor', parent_name='carpet.baxis', **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_linewidth.py b/plotly/validators/carpet/baxis/_linewidth.py new file mode 100644 index 0000000000..f4549108d4 --- /dev/null +++ b/plotly/validators/carpet/baxis/_linewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='linewidth', parent_name='carpet.baxis', **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_minorgridcolor.py b/plotly/validators/carpet/baxis/_minorgridcolor.py new file mode 100644 index 0000000000..4edf69f10c --- /dev/null +++ b/plotly/validators/carpet/baxis/_minorgridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class MinorgridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='minorgridcolor', + parent_name='carpet.baxis', + **kwargs + ): + super(MinorgridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_minorgridcount.py b/plotly/validators/carpet/baxis/_minorgridcount.py new file mode 100644 index 0000000000..509f7129c0 --- /dev/null +++ b/plotly/validators/carpet/baxis/_minorgridcount.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MinorgridcountValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='minorgridcount', + parent_name='carpet.baxis', + **kwargs + ): + super(MinorgridcountValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_minorgridwidth.py b/plotly/validators/carpet/baxis/_minorgridwidth.py new file mode 100644 index 0000000000..42aed71bb2 --- /dev/null +++ b/plotly/validators/carpet/baxis/_minorgridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MinorgridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='minorgridwidth', + parent_name='carpet.baxis', + **kwargs + ): + super(MinorgridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_nticks.py b/plotly/validators/carpet/baxis/_nticks.py new file mode 100644 index 0000000000..83c4672860 --- /dev/null +++ b/plotly/validators/carpet/baxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='carpet.baxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_range.py b/plotly/validators/carpet/baxis/_range.py new file mode 100644 index 0000000000..fc78c187a2 --- /dev/null +++ b/plotly/validators/carpet/baxis/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='carpet.baxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_rangemode.py b/plotly/validators/carpet/baxis/_rangemode.py new file mode 100644 index 0000000000..2485768ea7 --- /dev/null +++ b/plotly/validators/carpet/baxis/_rangemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='rangemode', parent_name='carpet.baxis', **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_separatethousands.py b/plotly/validators/carpet/baxis/_separatethousands.py new file mode 100644 index 0000000000..af7025eb02 --- /dev/null +++ b/plotly/validators/carpet/baxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='carpet.baxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showexponent.py b/plotly/validators/carpet/baxis/_showexponent.py new file mode 100644 index 0000000000..9adc6a42ef --- /dev/null +++ b/plotly/validators/carpet/baxis/_showexponent.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='showexponent', parent_name='carpet.baxis', **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showgrid.py b/plotly/validators/carpet/baxis/_showgrid.py new file mode 100644 index 0000000000..79aa7213ce --- /dev/null +++ b/plotly/validators/carpet/baxis/_showgrid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showgrid', parent_name='carpet.baxis', **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showline.py b/plotly/validators/carpet/baxis/_showline.py new file mode 100644 index 0000000000..6a533978c3 --- /dev/null +++ b/plotly/validators/carpet/baxis/_showline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showline', parent_name='carpet.baxis', **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showticklabels.py b/plotly/validators/carpet/baxis/_showticklabels.py new file mode 100644 index 0000000000..c57a1aee8c --- /dev/null +++ b/plotly/validators/carpet/baxis/_showticklabels.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='carpet.baxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['start', 'end', 'both', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showtickprefix.py b/plotly/validators/carpet/baxis/_showtickprefix.py new file mode 100644 index 0000000000..d122f31a5e --- /dev/null +++ b/plotly/validators/carpet/baxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='carpet.baxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_showticksuffix.py b/plotly/validators/carpet/baxis/_showticksuffix.py new file mode 100644 index 0000000000..74240a0ad8 --- /dev/null +++ b/plotly/validators/carpet/baxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='carpet.baxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_smoothing.py b/plotly/validators/carpet/baxis/_smoothing.py new file mode 100644 index 0000000000..e95975b02d --- /dev/null +++ b/plotly/validators/carpet/baxis/_smoothing.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='smoothing', parent_name='carpet.baxis', **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1.3, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_startline.py b/plotly/validators/carpet/baxis/_startline.py new file mode 100644 index 0000000000..cc560eec1a --- /dev/null +++ b/plotly/validators/carpet/baxis/_startline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class StartlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='startline', parent_name='carpet.baxis', **kwargs + ): + super(StartlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_startlinecolor.py b/plotly/validators/carpet/baxis/_startlinecolor.py new file mode 100644 index 0000000000..514d73baa1 --- /dev/null +++ b/plotly/validators/carpet/baxis/_startlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class StartlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='startlinecolor', + parent_name='carpet.baxis', + **kwargs + ): + super(StartlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_startlinewidth.py b/plotly/validators/carpet/baxis/_startlinewidth.py new file mode 100644 index 0000000000..13f950cd13 --- /dev/null +++ b/plotly/validators/carpet/baxis/_startlinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class StartlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startlinewidth', + parent_name='carpet.baxis', + **kwargs + ): + super(StartlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tick0.py b/plotly/validators/carpet/baxis/_tick0.py new file mode 100644 index 0000000000..5534a3ee48 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tick0', parent_name='carpet.baxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickangle.py b/plotly/validators/carpet/baxis/_tickangle.py new file mode 100644 index 0000000000..f5ae877336 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='carpet.baxis', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickfont.py b/plotly/validators/carpet/baxis/_tickfont.py new file mode 100644 index 0000000000..246c60a5a2 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='carpet.baxis', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickformat.py b/plotly/validators/carpet/baxis/_tickformat.py new file mode 100644 index 0000000000..f9f0067cb3 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickformat', parent_name='carpet.baxis', **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickformatstops.py b/plotly/validators/carpet/baxis/_tickformatstops.py new file mode 100644 index 0000000000..126de9b49d --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='carpet.baxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickmode.py b/plotly/validators/carpet/baxis/_tickmode.py new file mode 100644 index 0000000000..0f7361b1e3 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='carpet.baxis', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickprefix.py b/plotly/validators/carpet/baxis/_tickprefix.py new file mode 100644 index 0000000000..9257d0bed2 --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickprefix', parent_name='carpet.baxis', **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_ticksuffix.py b/plotly/validators/carpet/baxis/_ticksuffix.py new file mode 100644 index 0000000000..5414004f22 --- /dev/null +++ b/plotly/validators/carpet/baxis/_ticksuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='ticksuffix', parent_name='carpet.baxis', **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_ticktext.py b/plotly/validators/carpet/baxis/_ticktext.py new file mode 100644 index 0000000000..2eb2fda0ca --- /dev/null +++ b/plotly/validators/carpet/baxis/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='carpet.baxis', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_ticktextsrc.py b/plotly/validators/carpet/baxis/_ticktextsrc.py new file mode 100644 index 0000000000..b2cf8e1719 --- /dev/null +++ b/plotly/validators/carpet/baxis/_ticktextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ticktextsrc', parent_name='carpet.baxis', **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickvals.py b/plotly/validators/carpet/baxis/_tickvals.py new file mode 100644 index 0000000000..3acf73af9c --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='carpet.baxis', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_tickvalssrc.py b/plotly/validators/carpet/baxis/_tickvalssrc.py new file mode 100644 index 0000000000..4535ea900b --- /dev/null +++ b/plotly/validators/carpet/baxis/_tickvalssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='tickvalssrc', parent_name='carpet.baxis', **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_title.py b/plotly/validators/carpet/baxis/_title.py new file mode 100644 index 0000000000..eb67934c25 --- /dev/null +++ b/plotly/validators/carpet/baxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='carpet.baxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_titlefont.py b/plotly/validators/carpet/baxis/_titlefont.py new file mode 100644 index 0000000000..5aa72c1b5f --- /dev/null +++ b/plotly/validators/carpet/baxis/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='carpet.baxis', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_titleoffset.py b/plotly/validators/carpet/baxis/_titleoffset.py new file mode 100644 index 0000000000..c0e316070b --- /dev/null +++ b/plotly/validators/carpet/baxis/_titleoffset.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleoffsetValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='titleoffset', parent_name='carpet.baxis', **kwargs + ): + super(TitleoffsetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/_type.py b/plotly/validators/carpet/baxis/_type.py new file mode 100644 index 0000000000..260b81c0a2 --- /dev/null +++ b/plotly/validators/carpet/baxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='carpet.baxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/tickfont/__init__.py b/plotly/validators/carpet/baxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/carpet/baxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/baxis/tickfont/_color.py b/plotly/validators/carpet/baxis/tickfont/_color.py new file mode 100644 index 0000000000..f5e497777e --- /dev/null +++ b/plotly/validators/carpet/baxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='carpet.baxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/tickfont/_family.py b/plotly/validators/carpet/baxis/tickfont/_family.py new file mode 100644 index 0000000000..7f465a113d --- /dev/null +++ b/plotly/validators/carpet/baxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='carpet.baxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/tickfont/_size.py b/plotly/validators/carpet/baxis/tickfont/_size.py new file mode 100644 index 0000000000..6c49558be2 --- /dev/null +++ b/plotly/validators/carpet/baxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='carpet.baxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/tickformatstop/__init__.py b/plotly/validators/carpet/baxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/carpet/baxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/carpet/baxis/tickformatstop/_dtickrange.py b/plotly/validators/carpet/baxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..4273fd456e --- /dev/null +++ b/plotly/validators/carpet/baxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='carpet.baxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/tickformatstop/_value.py b/plotly/validators/carpet/baxis/tickformatstop/_value.py new file mode 100644 index 0000000000..a0615bd105 --- /dev/null +++ b/plotly/validators/carpet/baxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='carpet.baxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/titlefont/__init__.py b/plotly/validators/carpet/baxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/carpet/baxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/baxis/titlefont/_color.py b/plotly/validators/carpet/baxis/titlefont/_color.py new file mode 100644 index 0000000000..3c2a77991d --- /dev/null +++ b/plotly/validators/carpet/baxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='carpet.baxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/titlefont/_family.py b/plotly/validators/carpet/baxis/titlefont/_family.py new file mode 100644 index 0000000000..e781d1e8db --- /dev/null +++ b/plotly/validators/carpet/baxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='carpet.baxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/baxis/titlefont/_size.py b/plotly/validators/carpet/baxis/titlefont/_size.py new file mode 100644 index 0000000000..c94c1b8542 --- /dev/null +++ b/plotly/validators/carpet/baxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='carpet.baxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/font/__init__.py b/plotly/validators/carpet/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/carpet/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/font/_color.py b/plotly/validators/carpet/font/_color.py new file mode 100644 index 0000000000..318fc059ab --- /dev/null +++ b/plotly/validators/carpet/font/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='carpet.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/font/_family.py b/plotly/validators/carpet/font/_family.py new file mode 100644 index 0000000000..6e5d620721 --- /dev/null +++ b/plotly/validators/carpet/font/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='carpet.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/font/_size.py b/plotly/validators/carpet/font/_size.py new file mode 100644 index 0000000000..28caefec20 --- /dev/null +++ b/plotly/validators/carpet/font/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='carpet.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/__init__.py b/plotly/validators/carpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/carpet/hoverlabel/_bgcolor.py b/plotly/validators/carpet/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..029ea64eda --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='carpet.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_bgcolorsrc.py b/plotly/validators/carpet/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..5ecf3bc60a --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='carpet.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_bordercolor.py b/plotly/validators/carpet/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..b54c3c64d2 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='carpet.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_bordercolorsrc.py b/plotly/validators/carpet/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..2f99321589 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='carpet.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_font.py b/plotly/validators/carpet/hoverlabel/_font.py new file mode 100644 index 0000000000..d4ab4ed1d7 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='carpet.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_namelength.py b/plotly/validators/carpet/hoverlabel/_namelength.py new file mode 100644 index 0000000000..5454b5800d --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='carpet.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/_namelengthsrc.py b/plotly/validators/carpet/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..382a3449c9 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='carpet.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/__init__.py b/plotly/validators/carpet/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/carpet/hoverlabel/font/_color.py b/plotly/validators/carpet/hoverlabel/font/_color.py new file mode 100644 index 0000000000..ac93108a6e --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/_colorsrc.py b/plotly/validators/carpet/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..32b55093f4 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/_family.py b/plotly/validators/carpet/hoverlabel/font/_family.py new file mode 100644 index 0000000000..1fc93e98ba --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/_familysrc.py b/plotly/validators/carpet/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..a510cd2dc9 --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/_size.py b/plotly/validators/carpet/hoverlabel/font/_size.py new file mode 100644 index 0000000000..a2e01ae07f --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/carpet/hoverlabel/font/_sizesrc.py b/plotly/validators/carpet/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..9d10f1b56c --- /dev/null +++ b/plotly/validators/carpet/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='carpet.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/stream/__init__.py b/plotly/validators/carpet/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/carpet/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/carpet/stream/_maxpoints.py b/plotly/validators/carpet/stream/_maxpoints.py new file mode 100644 index 0000000000..8373e11071 --- /dev/null +++ b/plotly/validators/carpet/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='carpet.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/carpet/stream/_token.py b/plotly/validators/carpet/stream/_token.py new file mode 100644 index 0000000000..b7ee73d06a --- /dev/null +++ b/plotly/validators/carpet/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='carpet.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/choropleth/__init__.py b/plotly/validators/choropleth/__init__.py new file mode 100644 index 0000000000..80b99a8aba --- /dev/null +++ b/plotly/validators/choropleth/__init__.py @@ -0,0 +1,34 @@ +from ._zsrc import ZsrcValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._locationssrc import LocationssrcValidator +from ._locations import LocationsValidator +from ._locationmode import LocationmodeValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._geo import GeoValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/choropleth/_autocolorscale.py b/plotly/validators/choropleth/_autocolorscale.py new file mode 100644 index 0000000000..4d489312f6 --- /dev/null +++ b/plotly/validators/choropleth/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='choropleth', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/_colorbar.py b/plotly/validators/choropleth/_colorbar.py new file mode 100644 index 0000000000..9a72cdb988 --- /dev/null +++ b/plotly/validators/choropleth/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='choropleth', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.choropleth.colorbar.Tickforma + tstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_colorscale.py b/plotly/validators/choropleth/_colorscale.py new file mode 100644 index 0000000000..98ce138aea --- /dev/null +++ b/plotly/validators/choropleth/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='choropleth', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/_customdata.py b/plotly/validators/choropleth/_customdata.py new file mode 100644 index 0000000000..60bb0c3d4b --- /dev/null +++ b/plotly/validators/choropleth/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='choropleth', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/_customdatasrc.py b/plotly/validators/choropleth/_customdatasrc.py new file mode 100644 index 0000000000..20f6df094e --- /dev/null +++ b/plotly/validators/choropleth/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='choropleth', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_geo.py b/plotly/validators/choropleth/_geo.py new file mode 100644 index 0000000000..6c8dbb3b1d --- /dev/null +++ b/plotly/validators/choropleth/_geo.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class GeoValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='geo', parent_name='choropleth', **kwargs): + super(GeoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='geo', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_hoverinfo.py b/plotly/validators/choropleth/_hoverinfo.py new file mode 100644 index 0000000000..68d79e6cfe --- /dev/null +++ b/plotly/validators/choropleth/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='choropleth', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['location', 'z', 'text', 'name', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_hoverinfosrc.py b/plotly/validators/choropleth/_hoverinfosrc.py new file mode 100644 index 0000000000..9c8558ae86 --- /dev/null +++ b/plotly/validators/choropleth/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='choropleth', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_hoverlabel.py b/plotly/validators/choropleth/_hoverlabel.py new file mode 100644 index 0000000000..4ccf091d15 --- /dev/null +++ b/plotly/validators/choropleth/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='choropleth', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_ids.py b/plotly/validators/choropleth/_ids.py new file mode 100644 index 0000000000..fdef90c974 --- /dev/null +++ b/plotly/validators/choropleth/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='choropleth', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/_idssrc.py b/plotly/validators/choropleth/_idssrc.py new file mode 100644 index 0000000000..ca66cd858b --- /dev/null +++ b/plotly/validators/choropleth/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='choropleth', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_legendgroup.py b/plotly/validators/choropleth/_legendgroup.py new file mode 100644 index 0000000000..fab333d203 --- /dev/null +++ b/plotly/validators/choropleth/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='choropleth', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_locationmode.py b/plotly/validators/choropleth/_locationmode.py new file mode 100644 index 0000000000..140b9b0b97 --- /dev/null +++ b/plotly/validators/choropleth/_locationmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LocationmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='locationmode', parent_name='choropleth', **kwargs + ): + super(LocationmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['ISO-3', 'USA-states', 'country names'], + **kwargs + ) diff --git a/plotly/validators/choropleth/_locations.py b/plotly/validators/choropleth/_locations.py new file mode 100644 index 0000000000..8ace990858 --- /dev/null +++ b/plotly/validators/choropleth/_locations.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LocationsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='locations', parent_name='choropleth', **kwargs + ): + super(LocationsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/_locationssrc.py b/plotly/validators/choropleth/_locationssrc.py new file mode 100644 index 0000000000..0e18aadfdb --- /dev/null +++ b/plotly/validators/choropleth/_locationssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LocationssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='locationssrc', parent_name='choropleth', **kwargs + ): + super(LocationssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_marker.py b/plotly/validators/choropleth/_marker.py new file mode 100644 index 0000000000..290a177618 --- /dev/null +++ b/plotly/validators/choropleth/_marker.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='choropleth', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + line + plotly.graph_objs.choropleth.marker.Line + instance or dict with compatible properties + opacity + Sets the opacity of the locations. + opacitysrc + Sets the source reference on plot.ly for + opacity .""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_name.py b/plotly/validators/choropleth/_name.py new file mode 100644 index 0000000000..19da61e59e --- /dev/null +++ b/plotly/validators/choropleth/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='choropleth', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_opacity.py b/plotly/validators/choropleth/_opacity.py new file mode 100644 index 0000000000..f0b1532099 --- /dev/null +++ b/plotly/validators/choropleth/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='choropleth', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/_reversescale.py b/plotly/validators/choropleth/_reversescale.py new file mode 100644 index 0000000000..8af580fb67 --- /dev/null +++ b/plotly/validators/choropleth/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='choropleth', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/_selected.py b/plotly/validators/choropleth/_selected.py new file mode 100644 index 0000000000..b38d14e98f --- /dev/null +++ b/plotly/validators/choropleth/_selected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='choropleth', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.choropleth.selected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_selectedpoints.py b/plotly/validators/choropleth/_selectedpoints.py new file mode 100644 index 0000000000..9fd8b8284c --- /dev/null +++ b/plotly/validators/choropleth/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='choropleth', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_showlegend.py b/plotly/validators/choropleth/_showlegend.py new file mode 100644 index 0000000000..28f8fcaec0 --- /dev/null +++ b/plotly/validators/choropleth/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='choropleth', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_showscale.py b/plotly/validators/choropleth/_showscale.py new file mode 100644 index 0000000000..ed85961f7d --- /dev/null +++ b/plotly/validators/choropleth/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='choropleth', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_stream.py b/plotly/validators/choropleth/_stream.py new file mode 100644 index 0000000000..697af69ddf --- /dev/null +++ b/plotly/validators/choropleth/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='choropleth', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_text.py b/plotly/validators/choropleth/_text.py new file mode 100644 index 0000000000..ecf206f89b --- /dev/null +++ b/plotly/validators/choropleth/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='choropleth', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_textsrc.py b/plotly/validators/choropleth/_textsrc.py new file mode 100644 index 0000000000..c2925c4c4c --- /dev/null +++ b/plotly/validators/choropleth/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='choropleth', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_uid.py b/plotly/validators/choropleth/_uid.py new file mode 100644 index 0000000000..4f4bf6b52f --- /dev/null +++ b/plotly/validators/choropleth/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='choropleth', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_unselected.py b/plotly/validators/choropleth/_unselected.py new file mode 100644 index 0000000000..e3eefeeea6 --- /dev/null +++ b/plotly/validators/choropleth/_unselected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='choropleth', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.choropleth.unselected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/choropleth/_visible.py b/plotly/validators/choropleth/_visible.py new file mode 100644 index 0000000000..236452626e --- /dev/null +++ b/plotly/validators/choropleth/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='choropleth', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/choropleth/_z.py b/plotly/validators/choropleth/_z.py new file mode 100644 index 0000000000..4b8515679c --- /dev/null +++ b/plotly/validators/choropleth/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='choropleth', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/_zauto.py b/plotly/validators/choropleth/_zauto.py new file mode 100644 index 0000000000..63b423a9da --- /dev/null +++ b/plotly/validators/choropleth/_zauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zauto', parent_name='choropleth', **kwargs + ): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_zmax.py b/plotly/validators/choropleth/_zmax.py new file mode 100644 index 0000000000..4062aa9795 --- /dev/null +++ b/plotly/validators/choropleth/_zmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmax', parent_name='choropleth', **kwargs): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_zmin.py b/plotly/validators/choropleth/_zmin.py new file mode 100644 index 0000000000..b48e16c2e0 --- /dev/null +++ b/plotly/validators/choropleth/_zmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmin', parent_name='choropleth', **kwargs): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/_zsrc.py b/plotly/validators/choropleth/_zsrc.py new file mode 100644 index 0000000000..013f1e73a4 --- /dev/null +++ b/plotly/validators/choropleth/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='choropleth', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/__init__.py b/plotly/validators/choropleth/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/choropleth/colorbar/_bgcolor.py b/plotly/validators/choropleth/colorbar/_bgcolor.py new file mode 100644 index 0000000000..aa5410ac39 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_bordercolor.py b/plotly/validators/choropleth/colorbar/_bordercolor.py new file mode 100644 index 0000000000..d757731af2 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_borderwidth.py b/plotly/validators/choropleth/colorbar/_borderwidth.py new file mode 100644 index 0000000000..77d413c51a --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='choropleth.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_dtick.py b/plotly/validators/choropleth/colorbar/_dtick.py new file mode 100644 index 0000000000..1d91d33918 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='choropleth.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_exponentformat.py b/plotly/validators/choropleth/colorbar/_exponentformat.py new file mode 100644 index 0000000000..c4e0635908 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_len.py b/plotly/validators/choropleth/colorbar/_len.py new file mode 100644 index 0000000000..f9f9ef9cfe --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='choropleth.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_lenmode.py b/plotly/validators/choropleth/colorbar/_lenmode.py new file mode 100644 index 0000000000..b9199d37e5 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='choropleth.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_nticks.py b/plotly/validators/choropleth/colorbar/_nticks.py new file mode 100644 index 0000000000..378f79a5a2 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='choropleth.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_outlinecolor.py b/plotly/validators/choropleth/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..4b525db692 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_outlinewidth.py b/plotly/validators/choropleth/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..bd66fc3fdb --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='choropleth.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_separatethousands.py b/plotly/validators/choropleth/colorbar/_separatethousands.py new file mode 100644 index 0000000000..5b0102f882 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='choropleth.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_showexponent.py b/plotly/validators/choropleth/colorbar/_showexponent.py new file mode 100644 index 0000000000..23d6f98dbb --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_showticklabels.py b/plotly/validators/choropleth/colorbar/_showticklabels.py new file mode 100644 index 0000000000..ed0e8b11a7 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_showtickprefix.py b/plotly/validators/choropleth/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..389d8773eb --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_showticksuffix.py b/plotly/validators/choropleth/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..60d2723540 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_thickness.py b/plotly/validators/choropleth/colorbar/_thickness.py new file mode 100644 index 0000000000..2cb01d4775 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_thicknessmode.py b/plotly/validators/choropleth/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..ffa53175d2 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='choropleth.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tick0.py b/plotly/validators/choropleth/colorbar/_tick0.py new file mode 100644 index 0000000000..ff96deef0a --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='choropleth.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickangle.py b/plotly/validators/choropleth/colorbar/_tickangle.py new file mode 100644 index 0000000000..5a0ecae684 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickcolor.py b/plotly/validators/choropleth/colorbar/_tickcolor.py new file mode 100644 index 0000000000..cf23df6a5c --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickfont.py b/plotly/validators/choropleth/colorbar/_tickfont.py new file mode 100644 index 0000000000..5fffd02df4 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickformat.py b/plotly/validators/choropleth/colorbar/_tickformat.py new file mode 100644 index 0000000000..64b0c19fb8 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickformatstops.py b/plotly/validators/choropleth/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..e46982b404 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ticklen.py b/plotly/validators/choropleth/colorbar/_ticklen.py new file mode 100644 index 0000000000..ef08838684 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickmode.py b/plotly/validators/choropleth/colorbar/_tickmode.py new file mode 100644 index 0000000000..5522c036a8 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickprefix.py b/plotly/validators/choropleth/colorbar/_tickprefix.py new file mode 100644 index 0000000000..f41222f0fc --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ticks.py b/plotly/validators/choropleth/colorbar/_ticks.py new file mode 100644 index 0000000000..3c01b0eb8f --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='choropleth.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ticksuffix.py b/plotly/validators/choropleth/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..bb39f622da --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ticktext.py b/plotly/validators/choropleth/colorbar/_ticktext.py new file mode 100644 index 0000000000..52598aae5d --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ticktextsrc.py b/plotly/validators/choropleth/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..50c156abb5 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickvals.py b/plotly/validators/choropleth/colorbar/_tickvals.py new file mode 100644 index 0000000000..33b542e475 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickvalssrc.py b/plotly/validators/choropleth/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..391c53ee52 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_tickwidth.py b/plotly/validators/choropleth/colorbar/_tickwidth.py new file mode 100644 index 0000000000..877359e875 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_title.py b/plotly/validators/choropleth/colorbar/_title.py new file mode 100644 index 0000000000..89ad5b044d --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='choropleth.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_titlefont.py b/plotly/validators/choropleth/colorbar/_titlefont.py new file mode 100644 index 0000000000..b01c59ab6d --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_titleside.py b/plotly/validators/choropleth/colorbar/_titleside.py new file mode 100644 index 0000000000..3de81a3fa5 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='choropleth.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_x.py b/plotly/validators/choropleth/colorbar/_x.py new file mode 100644 index 0000000000..e4e9e21ed8 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='choropleth.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_xanchor.py b/plotly/validators/choropleth/colorbar/_xanchor.py new file mode 100644 index 0000000000..75bf9c16b1 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_xpad.py b/plotly/validators/choropleth/colorbar/_xpad.py new file mode 100644 index 0000000000..180282c01f --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='choropleth.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_y.py b/plotly/validators/choropleth/colorbar/_y.py new file mode 100644 index 0000000000..89d1809a66 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='choropleth.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_yanchor.py b/plotly/validators/choropleth/colorbar/_yanchor.py new file mode 100644 index 0000000000..f980f59f48 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='choropleth.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/_ypad.py b/plotly/validators/choropleth/colorbar/_ypad.py new file mode 100644 index 0000000000..aaafc236f7 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='choropleth.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/tickfont/__init__.py b/plotly/validators/choropleth/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/choropleth/colorbar/tickfont/_color.py b/plotly/validators/choropleth/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..bb5086664a --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='choropleth.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/tickfont/_family.py b/plotly/validators/choropleth/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..841d80969e --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='choropleth.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/tickfont/_size.py b/plotly/validators/choropleth/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..e0ae24535c --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='choropleth.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/tickformatstop/__init__.py b/plotly/validators/choropleth/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/choropleth/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/choropleth/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..a563745d5f --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='choropleth.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/tickformatstop/_value.py b/plotly/validators/choropleth/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..b4e92318fc --- /dev/null +++ b/plotly/validators/choropleth/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='choropleth.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/titlefont/__init__.py b/plotly/validators/choropleth/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/choropleth/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/choropleth/colorbar/titlefont/_color.py b/plotly/validators/choropleth/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..bd9dc13452 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='choropleth.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/titlefont/_family.py b/plotly/validators/choropleth/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..1a772a370b --- /dev/null +++ b/plotly/validators/choropleth/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='choropleth.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/choropleth/colorbar/titlefont/_size.py b/plotly/validators/choropleth/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..8417a6af04 --- /dev/null +++ b/plotly/validators/choropleth/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='choropleth.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/__init__.py b/plotly/validators/choropleth/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/choropleth/hoverlabel/_bgcolor.py b/plotly/validators/choropleth/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..8799039208 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_bgcolorsrc.py b/plotly/validators/choropleth/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..61e6d6dbed --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_bordercolor.py b/plotly/validators/choropleth/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..c929a1b883 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_bordercolorsrc.py b/plotly/validators/choropleth/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..15f61462c9 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_font.py b/plotly/validators/choropleth/hoverlabel/_font.py new file mode 100644 index 0000000000..527554d4c7 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_namelength.py b/plotly/validators/choropleth/hoverlabel/_namelength.py new file mode 100644 index 0000000000..ae0a9fd40d --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/_namelengthsrc.py b/plotly/validators/choropleth/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..35d150c7db --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='choropleth.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/__init__.py b/plotly/validators/choropleth/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/choropleth/hoverlabel/font/_color.py b/plotly/validators/choropleth/hoverlabel/font/_color.py new file mode 100644 index 0000000000..44c8a2172a --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/_colorsrc.py b/plotly/validators/choropleth/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..a19419e398 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/_family.py b/plotly/validators/choropleth/hoverlabel/font/_family.py new file mode 100644 index 0000000000..af4d4b9fb4 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/_familysrc.py b/plotly/validators/choropleth/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..7734a404fd --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/_size.py b/plotly/validators/choropleth/hoverlabel/font/_size.py new file mode 100644 index 0000000000..80513079aa --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/hoverlabel/font/_sizesrc.py b/plotly/validators/choropleth/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..bc0e3adf17 --- /dev/null +++ b/plotly/validators/choropleth/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='choropleth.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/__init__.py b/plotly/validators/choropleth/marker/__init__.py new file mode 100644 index 0000000000..0cd59cc062 --- /dev/null +++ b/plotly/validators/choropleth/marker/__init__.py @@ -0,0 +1,3 @@ +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator diff --git a/plotly/validators/choropleth/marker/_line.py b/plotly/validators/choropleth/marker/_line.py new file mode 100644 index 0000000000..919cbf0620 --- /dev/null +++ b/plotly/validators/choropleth/marker/_line.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='choropleth.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/_opacity.py b/plotly/validators/choropleth/marker/_opacity.py new file mode 100644 index 0000000000..743daa9c4e --- /dev/null +++ b/plotly/validators/choropleth/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='choropleth.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/_opacitysrc.py b/plotly/validators/choropleth/marker/_opacitysrc.py new file mode 100644 index 0000000000..4a9af9131b --- /dev/null +++ b/plotly/validators/choropleth/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='choropleth.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/line/__init__.py b/plotly/validators/choropleth/marker/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/choropleth/marker/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/choropleth/marker/line/_color.py b/plotly/validators/choropleth/marker/line/_color.py new file mode 100644 index 0000000000..217b43f5a6 --- /dev/null +++ b/plotly/validators/choropleth/marker/line/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='choropleth.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/line/_colorsrc.py b/plotly/validators/choropleth/marker/line/_colorsrc.py new file mode 100644 index 0000000000..da224abace --- /dev/null +++ b/plotly/validators/choropleth/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='choropleth.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/line/_width.py b/plotly/validators/choropleth/marker/line/_width.py new file mode 100644 index 0000000000..6cb601bf5e --- /dev/null +++ b/plotly/validators/choropleth/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='choropleth.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/marker/line/_widthsrc.py b/plotly/validators/choropleth/marker/line/_widthsrc.py new file mode 100644 index 0000000000..2024cad349 --- /dev/null +++ b/plotly/validators/choropleth/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='choropleth.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/selected/__init__.py b/plotly/validators/choropleth/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/choropleth/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/choropleth/selected/_marker.py b/plotly/validators/choropleth/selected/_marker.py new file mode 100644 index 0000000000..fb39cf5321 --- /dev/null +++ b/plotly/validators/choropleth/selected/_marker.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='choropleth.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + opacity + Sets the marker opacity of selected points.""", + **kwargs + ) diff --git a/plotly/validators/choropleth/selected/marker/__init__.py b/plotly/validators/choropleth/selected/marker/__init__.py new file mode 100644 index 0000000000..c5fa1abc97 --- /dev/null +++ b/plotly/validators/choropleth/selected/marker/__init__.py @@ -0,0 +1 @@ +from ._opacity import OpacityValidator diff --git a/plotly/validators/choropleth/selected/marker/_opacity.py b/plotly/validators/choropleth/selected/marker/_opacity.py new file mode 100644 index 0000000000..a33cf6e0a6 --- /dev/null +++ b/plotly/validators/choropleth/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='choropleth.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/choropleth/stream/__init__.py b/plotly/validators/choropleth/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/choropleth/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/choropleth/stream/_maxpoints.py b/plotly/validators/choropleth/stream/_maxpoints.py new file mode 100644 index 0000000000..1c9339741e --- /dev/null +++ b/plotly/validators/choropleth/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='choropleth.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/choropleth/stream/_token.py b/plotly/validators/choropleth/stream/_token.py new file mode 100644 index 0000000000..14ab42b62b --- /dev/null +++ b/plotly/validators/choropleth/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='choropleth.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/choropleth/unselected/__init__.py b/plotly/validators/choropleth/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/choropleth/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/choropleth/unselected/_marker.py b/plotly/validators/choropleth/unselected/_marker.py new file mode 100644 index 0000000000..0a6c0c347f --- /dev/null +++ b/plotly/validators/choropleth/unselected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='choropleth.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/choropleth/unselected/marker/__init__.py b/plotly/validators/choropleth/unselected/marker/__init__.py new file mode 100644 index 0000000000..c5fa1abc97 --- /dev/null +++ b/plotly/validators/choropleth/unselected/marker/__init__.py @@ -0,0 +1 @@ +from ._opacity import OpacityValidator diff --git a/plotly/validators/choropleth/unselected/marker/_opacity.py b/plotly/validators/choropleth/unselected/marker/_opacity.py new file mode 100644 index 0000000000..9ca5866759 --- /dev/null +++ b/plotly/validators/choropleth/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='choropleth.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/__init__.py b/plotly/validators/cone/__init__.py new file mode 100644 index 0000000000..138e781f80 --- /dev/null +++ b/plotly/validators/cone/__init__.py @@ -0,0 +1,43 @@ +from ._zsrc import ZsrcValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._x import XValidator +from ._wsrc import WsrcValidator +from ._w import WValidator +from ._vsrc import VsrcValidator +from ._visible import VisibleValidator +from ._v import VValidator +from ._usrc import UsrcValidator +from ._uid import UidValidator +from ._u import UValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._scene import SceneValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._lightposition import LightpositionValidator +from ._lighting import LightingValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator +from ._anchor import AnchorValidator diff --git a/plotly/validators/cone/_anchor.py b/plotly/validators/cone/_anchor.py new file mode 100644 index 0000000000..c49abe44ee --- /dev/null +++ b/plotly/validators/cone/_anchor.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class AnchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='anchor', parent_name='cone', **kwargs): + super(AnchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['tip', 'tail', 'cm', 'center'], + **kwargs + ) diff --git a/plotly/validators/cone/_autocolorscale.py b/plotly/validators/cone/_autocolorscale.py new file mode 100644 index 0000000000..ecde99205c --- /dev/null +++ b/plotly/validators/cone/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='cone', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/_cauto.py b/plotly/validators/cone/_cauto.py new file mode 100644 index 0000000000..10519be419 --- /dev/null +++ b/plotly/validators/cone/_cauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='cauto', parent_name='cone', **kwargs): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_cmax.py b/plotly/validators/cone/_cmax.py new file mode 100644 index 0000000000..b7643c8045 --- /dev/null +++ b/plotly/validators/cone/_cmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmax', parent_name='cone', **kwargs): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_cmin.py b/plotly/validators/cone/_cmin.py new file mode 100644 index 0000000000..d886c70607 --- /dev/null +++ b/plotly/validators/cone/_cmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmin', parent_name='cone', **kwargs): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_colorbar.py b/plotly/validators/cone/_colorbar.py new file mode 100644 index 0000000000..4dc7a1280b --- /dev/null +++ b/plotly/validators/cone/_colorbar.py @@ -0,0 +1,207 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='colorbar', parent_name='cone', **kwargs): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.cone.colorbar.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/cone/_colorscale.py b/plotly/validators/cone/_colorscale.py new file mode 100644 index 0000000000..cf57b9babc --- /dev/null +++ b/plotly/validators/cone/_colorscale.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__(self, plotly_name='colorscale', parent_name='cone', **kwargs): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/_customdata.py b/plotly/validators/cone/_customdata.py new file mode 100644 index 0000000000..4c14750e41 --- /dev/null +++ b/plotly/validators/cone/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='cone', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_customdatasrc.py b/plotly/validators/cone/_customdatasrc.py new file mode 100644 index 0000000000..c96fbad290 --- /dev/null +++ b/plotly/validators/cone/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='cone', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_hoverinfo.py b/plotly/validators/cone/_hoverinfo.py new file mode 100644 index 0000000000..fbd5cfc2d1 --- /dev/null +++ b/plotly/validators/cone/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='cone', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'u', 'v', 'w', 'norm', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_hoverinfosrc.py b/plotly/validators/cone/_hoverinfosrc.py new file mode 100644 index 0000000000..f7a120281e --- /dev/null +++ b/plotly/validators/cone/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='cone', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_hoverlabel.py b/plotly/validators/cone/_hoverlabel.py new file mode 100644 index 0000000000..d1dd26c1ad --- /dev/null +++ b/plotly/validators/cone/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='cone', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/cone/_ids.py b/plotly/validators/cone/_ids.py new file mode 100644 index 0000000000..3b8e466384 --- /dev/null +++ b/plotly/validators/cone/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='cone', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_idssrc.py b/plotly/validators/cone/_idssrc.py new file mode 100644 index 0000000000..e5917de037 --- /dev/null +++ b/plotly/validators/cone/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='cone', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_legendgroup.py b/plotly/validators/cone/_legendgroup.py new file mode 100644 index 0000000000..27f35534ef --- /dev/null +++ b/plotly/validators/cone/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='cone', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_lighting.py b/plotly/validators/cone/_lighting.py new file mode 100644 index 0000000000..fb58937fb5 --- /dev/null +++ b/plotly/validators/cone/_lighting.py @@ -0,0 +1,37 @@ +import _plotly_utils.basevalidators + + +class LightingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='lighting', parent_name='cone', **kwargs): + super(LightingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lighting', + data_docs=""" + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids + math issues arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids + math issues arising from degenerate geometry.""", + **kwargs + ) diff --git a/plotly/validators/cone/_lightposition.py b/plotly/validators/cone/_lightposition.py new file mode 100644 index 0000000000..68d73bcc88 --- /dev/null +++ b/plotly/validators/cone/_lightposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LightpositionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lightposition', parent_name='cone', **kwargs + ): + super(LightpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lightposition', + data_docs=""" + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex.""", + **kwargs + ) diff --git a/plotly/validators/cone/_name.py b/plotly/validators/cone/_name.py new file mode 100644 index 0000000000..f828d334f6 --- /dev/null +++ b/plotly/validators/cone/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='cone', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_opacity.py b/plotly/validators/cone/_opacity.py new file mode 100644 index 0000000000..78303e7cd1 --- /dev/null +++ b/plotly/validators/cone/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='cone', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/_reversescale.py b/plotly/validators/cone/_reversescale.py new file mode 100644 index 0000000000..307ce6f6ff --- /dev/null +++ b/plotly/validators/cone/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='cone', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/_scene.py b/plotly/validators/cone/_scene.py new file mode 100644 index 0000000000..10ee2dcc9f --- /dev/null +++ b/plotly/validators/cone/_scene.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SceneValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='scene', parent_name='cone', **kwargs): + super(SceneValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='scene', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_selectedpoints.py b/plotly/validators/cone/_selectedpoints.py new file mode 100644 index 0000000000..cc84b9f5b6 --- /dev/null +++ b/plotly/validators/cone/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='cone', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_showlegend.py b/plotly/validators/cone/_showlegend.py new file mode 100644 index 0000000000..f8b3c960a9 --- /dev/null +++ b/plotly/validators/cone/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='cone', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_showscale.py b/plotly/validators/cone/_showscale.py new file mode 100644 index 0000000000..c4a941ac59 --- /dev/null +++ b/plotly/validators/cone/_showscale.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showscale', parent_name='cone', **kwargs): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_sizemode.py b/plotly/validators/cone/_sizemode.py new file mode 100644 index 0000000000..01fb2b3e51 --- /dev/null +++ b/plotly/validators/cone/_sizemode.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='sizemode', parent_name='cone', **kwargs): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['scaled', 'absolute'], + **kwargs + ) diff --git a/plotly/validators/cone/_sizeref.py b/plotly/validators/cone/_sizeref.py new file mode 100644 index 0000000000..54fe57a5ad --- /dev/null +++ b/plotly/validators/cone/_sizeref.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='sizeref', parent_name='cone', **kwargs): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_stream.py b/plotly/validators/cone/_stream.py new file mode 100644 index 0000000000..279bfba7f5 --- /dev/null +++ b/plotly/validators/cone/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='cone', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/cone/_text.py b/plotly/validators/cone/_text.py new file mode 100644 index 0000000000..aede439b48 --- /dev/null +++ b/plotly/validators/cone/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='cone', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_textsrc.py b/plotly/validators/cone/_textsrc.py new file mode 100644 index 0000000000..bf3a55e60d --- /dev/null +++ b/plotly/validators/cone/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='cone', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_u.py b/plotly/validators/cone/_u.py new file mode 100644 index 0000000000..190f1217c9 --- /dev/null +++ b/plotly/validators/cone/_u.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='u', parent_name='cone', **kwargs): + super(UValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_uid.py b/plotly/validators/cone/_uid.py new file mode 100644 index 0000000000..5ae71ec39a --- /dev/null +++ b/plotly/validators/cone/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='cone', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_usrc.py b/plotly/validators/cone/_usrc.py new file mode 100644 index 0000000000..3e1855c4ac --- /dev/null +++ b/plotly/validators/cone/_usrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='usrc', parent_name='cone', **kwargs): + super(UsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_v.py b/plotly/validators/cone/_v.py new file mode 100644 index 0000000000..dc855fa710 --- /dev/null +++ b/plotly/validators/cone/_v.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class VValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='v', parent_name='cone', **kwargs): + super(VValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_visible.py b/plotly/validators/cone/_visible.py new file mode 100644 index 0000000000..c5d09fdb33 --- /dev/null +++ b/plotly/validators/cone/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='cone', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/cone/_vsrc.py b/plotly/validators/cone/_vsrc.py new file mode 100644 index 0000000000..0cbc59ea6d --- /dev/null +++ b/plotly/validators/cone/_vsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class VsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='vsrc', parent_name='cone', **kwargs): + super(VsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_w.py b/plotly/validators/cone/_w.py new file mode 100644 index 0000000000..8162412b36 --- /dev/null +++ b/plotly/validators/cone/_w.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class WValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='w', parent_name='cone', **kwargs): + super(WValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_wsrc.py b/plotly/validators/cone/_wsrc.py new file mode 100644 index 0000000000..6e4442dd71 --- /dev/null +++ b/plotly/validators/cone/_wsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class WsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='wsrc', parent_name='cone', **kwargs): + super(WsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_x.py b/plotly/validators/cone/_x.py new file mode 100644 index 0000000000..f664796b71 --- /dev/null +++ b/plotly/validators/cone/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='cone', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_xsrc.py b/plotly/validators/cone/_xsrc.py new file mode 100644 index 0000000000..5a88304594 --- /dev/null +++ b/plotly/validators/cone/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='cone', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_y.py b/plotly/validators/cone/_y.py new file mode 100644 index 0000000000..48589f55e2 --- /dev/null +++ b/plotly/validators/cone/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='cone', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_ysrc.py b/plotly/validators/cone/_ysrc.py new file mode 100644 index 0000000000..00e7aa39f6 --- /dev/null +++ b/plotly/validators/cone/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='cone', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/_z.py b/plotly/validators/cone/_z.py new file mode 100644 index 0000000000..63a090f44b --- /dev/null +++ b/plotly/validators/cone/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='cone', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/_zsrc.py b/plotly/validators/cone/_zsrc.py new file mode 100644 index 0000000000..364d01c5c8 --- /dev/null +++ b/plotly/validators/cone/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='cone', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/__init__.py b/plotly/validators/cone/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/cone/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/cone/colorbar/_bgcolor.py b/plotly/validators/cone/colorbar/_bgcolor.py new file mode 100644 index 0000000000..9596b64e34 --- /dev/null +++ b/plotly/validators/cone/colorbar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='cone.colorbar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_bordercolor.py b/plotly/validators/cone/colorbar/_bordercolor.py new file mode 100644 index 0000000000..9f525f6ba9 --- /dev/null +++ b/plotly/validators/cone/colorbar/_bordercolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bordercolor', parent_name='cone.colorbar', **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_borderwidth.py b/plotly/validators/cone/colorbar/_borderwidth.py new file mode 100644 index 0000000000..b0ea0cb4d1 --- /dev/null +++ b/plotly/validators/cone/colorbar/_borderwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='borderwidth', parent_name='cone.colorbar', **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_dtick.py b/plotly/validators/cone/colorbar/_dtick.py new file mode 100644 index 0000000000..343dab6c0f --- /dev/null +++ b/plotly/validators/cone/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='cone.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_exponentformat.py b/plotly/validators/cone/colorbar/_exponentformat.py new file mode 100644 index 0000000000..389d825724 --- /dev/null +++ b/plotly/validators/cone/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='cone.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_len.py b/plotly/validators/cone/colorbar/_len.py new file mode 100644 index 0000000000..e1cf504f2e --- /dev/null +++ b/plotly/validators/cone/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='cone.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_lenmode.py b/plotly/validators/cone/colorbar/_lenmode.py new file mode 100644 index 0000000000..b4d96489e5 --- /dev/null +++ b/plotly/validators/cone/colorbar/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='cone.colorbar', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_nticks.py b/plotly/validators/cone/colorbar/_nticks.py new file mode 100644 index 0000000000..f237a5b316 --- /dev/null +++ b/plotly/validators/cone/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='cone.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_outlinecolor.py b/plotly/validators/cone/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..db08b2f034 --- /dev/null +++ b/plotly/validators/cone/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='cone.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_outlinewidth.py b/plotly/validators/cone/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..4549e5e7b7 --- /dev/null +++ b/plotly/validators/cone/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='cone.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_separatethousands.py b/plotly/validators/cone/colorbar/_separatethousands.py new file mode 100644 index 0000000000..91abcc6504 --- /dev/null +++ b/plotly/validators/cone/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='cone.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_showexponent.py b/plotly/validators/cone/colorbar/_showexponent.py new file mode 100644 index 0000000000..357398d1eb --- /dev/null +++ b/plotly/validators/cone/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='cone.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_showticklabels.py b/plotly/validators/cone/colorbar/_showticklabels.py new file mode 100644 index 0000000000..4cf171f027 --- /dev/null +++ b/plotly/validators/cone/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='cone.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_showtickprefix.py b/plotly/validators/cone/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..520593846f --- /dev/null +++ b/plotly/validators/cone/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='cone.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_showticksuffix.py b/plotly/validators/cone/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..206c6d163f --- /dev/null +++ b/plotly/validators/cone/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='cone.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_thickness.py b/plotly/validators/cone/colorbar/_thickness.py new file mode 100644 index 0000000000..eabc0a3482 --- /dev/null +++ b/plotly/validators/cone/colorbar/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='cone.colorbar', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_thicknessmode.py b/plotly/validators/cone/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..567e13d0cb --- /dev/null +++ b/plotly/validators/cone/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='cone.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tick0.py b/plotly/validators/cone/colorbar/_tick0.py new file mode 100644 index 0000000000..6e1b0920b3 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='cone.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickangle.py b/plotly/validators/cone/colorbar/_tickangle.py new file mode 100644 index 0000000000..47ccbb7bd1 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='cone.colorbar', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickcolor.py b/plotly/validators/cone/colorbar/_tickcolor.py new file mode 100644 index 0000000000..6ed8cde164 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='tickcolor', parent_name='cone.colorbar', **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickfont.py b/plotly/validators/cone/colorbar/_tickfont.py new file mode 100644 index 0000000000..e4abd2a6e5 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='cone.colorbar', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickformat.py b/plotly/validators/cone/colorbar/_tickformat.py new file mode 100644 index 0000000000..2cfa8dbb58 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickformat', parent_name='cone.colorbar', **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickformatstops.py b/plotly/validators/cone/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..6ee76c1fb1 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='cone.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ticklen.py b/plotly/validators/cone/colorbar/_ticklen.py new file mode 100644 index 0000000000..0331e40880 --- /dev/null +++ b/plotly/validators/cone/colorbar/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='cone.colorbar', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickmode.py b/plotly/validators/cone/colorbar/_tickmode.py new file mode 100644 index 0000000000..745700afcc --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='cone.colorbar', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickprefix.py b/plotly/validators/cone/colorbar/_tickprefix.py new file mode 100644 index 0000000000..145b08f23d --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickprefix', parent_name='cone.colorbar', **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ticks.py b/plotly/validators/cone/colorbar/_ticks.py new file mode 100644 index 0000000000..da2f3255bb --- /dev/null +++ b/plotly/validators/cone/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='cone.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ticksuffix.py b/plotly/validators/cone/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..d1302877e7 --- /dev/null +++ b/plotly/validators/cone/colorbar/_ticksuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='ticksuffix', parent_name='cone.colorbar', **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ticktext.py b/plotly/validators/cone/colorbar/_ticktext.py new file mode 100644 index 0000000000..6b63ad6cc8 --- /dev/null +++ b/plotly/validators/cone/colorbar/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='cone.colorbar', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ticktextsrc.py b/plotly/validators/cone/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..6f64a10f25 --- /dev/null +++ b/plotly/validators/cone/colorbar/_ticktextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ticktextsrc', parent_name='cone.colorbar', **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickvals.py b/plotly/validators/cone/colorbar/_tickvals.py new file mode 100644 index 0000000000..b7fbdd523b --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='cone.colorbar', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickvalssrc.py b/plotly/validators/cone/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..d4721454c5 --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickvalssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='tickvalssrc', parent_name='cone.colorbar', **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_tickwidth.py b/plotly/validators/cone/colorbar/_tickwidth.py new file mode 100644 index 0000000000..9b039a6f8a --- /dev/null +++ b/plotly/validators/cone/colorbar/_tickwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tickwidth', parent_name='cone.colorbar', **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_title.py b/plotly/validators/cone/colorbar/_title.py new file mode 100644 index 0000000000..904301ea8c --- /dev/null +++ b/plotly/validators/cone/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='cone.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_titlefont.py b/plotly/validators/cone/colorbar/_titlefont.py new file mode 100644 index 0000000000..ddbe18a0ad --- /dev/null +++ b/plotly/validators/cone/colorbar/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='cone.colorbar', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_titleside.py b/plotly/validators/cone/colorbar/_titleside.py new file mode 100644 index 0000000000..9db0a0ac7e --- /dev/null +++ b/plotly/validators/cone/colorbar/_titleside.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='titleside', parent_name='cone.colorbar', **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_x.py b/plotly/validators/cone/colorbar/_x.py new file mode 100644 index 0000000000..2af7b8cf16 --- /dev/null +++ b/plotly/validators/cone/colorbar/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='x', parent_name='cone.colorbar', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_xanchor.py b/plotly/validators/cone/colorbar/_xanchor.py new file mode 100644 index 0000000000..8666aa0b22 --- /dev/null +++ b/plotly/validators/cone/colorbar/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='cone.colorbar', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_xpad.py b/plotly/validators/cone/colorbar/_xpad.py new file mode 100644 index 0000000000..130e8c7b52 --- /dev/null +++ b/plotly/validators/cone/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='cone.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_y.py b/plotly/validators/cone/colorbar/_y.py new file mode 100644 index 0000000000..7ce4ef3bcc --- /dev/null +++ b/plotly/validators/cone/colorbar/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='y', parent_name='cone.colorbar', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_yanchor.py b/plotly/validators/cone/colorbar/_yanchor.py new file mode 100644 index 0000000000..b59eae4203 --- /dev/null +++ b/plotly/validators/cone/colorbar/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='cone.colorbar', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/_ypad.py b/plotly/validators/cone/colorbar/_ypad.py new file mode 100644 index 0000000000..bfb780ac84 --- /dev/null +++ b/plotly/validators/cone/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='cone.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/tickfont/__init__.py b/plotly/validators/cone/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/cone/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/cone/colorbar/tickfont/_color.py b/plotly/validators/cone/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..9d15a159ec --- /dev/null +++ b/plotly/validators/cone/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='cone.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/tickfont/_family.py b/plotly/validators/cone/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..76d8f6549c --- /dev/null +++ b/plotly/validators/cone/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='cone.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/tickfont/_size.py b/plotly/validators/cone/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..3643ecf6ca --- /dev/null +++ b/plotly/validators/cone/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='cone.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/tickformatstop/__init__.py b/plotly/validators/cone/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/cone/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/cone/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/cone/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..0d4bb43682 --- /dev/null +++ b/plotly/validators/cone/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='cone.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/tickformatstop/_value.py b/plotly/validators/cone/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..4edb5cde18 --- /dev/null +++ b/plotly/validators/cone/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='cone.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/titlefont/__init__.py b/plotly/validators/cone/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/cone/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/cone/colorbar/titlefont/_color.py b/plotly/validators/cone/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..7db851d0b5 --- /dev/null +++ b/plotly/validators/cone/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='cone.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/titlefont/_family.py b/plotly/validators/cone/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..cf1b396978 --- /dev/null +++ b/plotly/validators/cone/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='cone.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/cone/colorbar/titlefont/_size.py b/plotly/validators/cone/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..ab18ad8026 --- /dev/null +++ b/plotly/validators/cone/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='cone.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/__init__.py b/plotly/validators/cone/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/cone/hoverlabel/_bgcolor.py b/plotly/validators/cone/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..53cc4e5d74 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='cone.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_bgcolorsrc.py b/plotly/validators/cone/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..73608e4917 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='cone.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_bordercolor.py b/plotly/validators/cone/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..fdc6109af0 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='cone.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_bordercolorsrc.py b/plotly/validators/cone/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..749e4d52bd --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='cone.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_font.py b/plotly/validators/cone/hoverlabel/_font.py new file mode 100644 index 0000000000..38821a4f3a --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='cone.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_namelength.py b/plotly/validators/cone/hoverlabel/_namelength.py new file mode 100644 index 0000000000..ea3bd1ee48 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='cone.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/_namelengthsrc.py b/plotly/validators/cone/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..98534e4ded --- /dev/null +++ b/plotly/validators/cone/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='cone.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/__init__.py b/plotly/validators/cone/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/cone/hoverlabel/font/_color.py b/plotly/validators/cone/hoverlabel/font/_color.py new file mode 100644 index 0000000000..246afae6c3 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='cone.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/_colorsrc.py b/plotly/validators/cone/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..67467b4190 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='cone.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/_family.py b/plotly/validators/cone/hoverlabel/font/_family.py new file mode 100644 index 0000000000..e43d5a3ddc --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='cone.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/_familysrc.py b/plotly/validators/cone/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..ee31906c8d --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='cone.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/_size.py b/plotly/validators/cone/hoverlabel/font/_size.py new file mode 100644 index 0000000000..e07c6dba27 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='cone.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/hoverlabel/font/_sizesrc.py b/plotly/validators/cone/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..ad8b441f00 --- /dev/null +++ b/plotly/validators/cone/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='cone.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/__init__.py b/plotly/validators/cone/lighting/__init__.py new file mode 100644 index 0000000000..6abe696b0d --- /dev/null +++ b/plotly/validators/cone/lighting/__init__.py @@ -0,0 +1,7 @@ +from ._vertexnormalsepsilon import VertexnormalsepsilonValidator +from ._specular import SpecularValidator +from ._roughness import RoughnessValidator +from ._fresnel import FresnelValidator +from ._facenormalsepsilon import FacenormalsepsilonValidator +from ._diffuse import DiffuseValidator +from ._ambient import AmbientValidator diff --git a/plotly/validators/cone/lighting/_ambient.py b/plotly/validators/cone/lighting/_ambient.py new file mode 100644 index 0000000000..ee50f3cf38 --- /dev/null +++ b/plotly/validators/cone/lighting/_ambient.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AmbientValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ambient', parent_name='cone.lighting', **kwargs + ): + super(AmbientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_diffuse.py b/plotly/validators/cone/lighting/_diffuse.py new file mode 100644 index 0000000000..8af55aebfc --- /dev/null +++ b/plotly/validators/cone/lighting/_diffuse.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class DiffuseValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='diffuse', parent_name='cone.lighting', **kwargs + ): + super(DiffuseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_facenormalsepsilon.py b/plotly/validators/cone/lighting/_facenormalsepsilon.py new file mode 100644 index 0000000000..e39f6e4789 --- /dev/null +++ b/plotly/validators/cone/lighting/_facenormalsepsilon.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class FacenormalsepsilonValidator( + _plotly_utils.basevalidators.NumberValidator +): + + def __init__( + self, + plotly_name='facenormalsepsilon', + parent_name='cone.lighting', + **kwargs + ): + super(FacenormalsepsilonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_fresnel.py b/plotly/validators/cone/lighting/_fresnel.py new file mode 100644 index 0000000000..fe3d354342 --- /dev/null +++ b/plotly/validators/cone/lighting/_fresnel.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FresnelValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='fresnel', parent_name='cone.lighting', **kwargs + ): + super(FresnelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=5, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_roughness.py b/plotly/validators/cone/lighting/_roughness.py new file mode 100644 index 0000000000..3a984db10b --- /dev/null +++ b/plotly/validators/cone/lighting/_roughness.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class RoughnessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='roughness', parent_name='cone.lighting', **kwargs + ): + super(RoughnessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_specular.py b/plotly/validators/cone/lighting/_specular.py new file mode 100644 index 0000000000..21c5cc2697 --- /dev/null +++ b/plotly/validators/cone/lighting/_specular.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SpecularValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='specular', parent_name='cone.lighting', **kwargs + ): + super(SpecularValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=2, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lighting/_vertexnormalsepsilon.py b/plotly/validators/cone/lighting/_vertexnormalsepsilon.py new file mode 100644 index 0000000000..73632ab042 --- /dev/null +++ b/plotly/validators/cone/lighting/_vertexnormalsepsilon.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class VertexnormalsepsilonValidator( + _plotly_utils.basevalidators.NumberValidator +): + + def __init__( + self, + plotly_name='vertexnormalsepsilon', + parent_name='cone.lighting', + **kwargs + ): + super(VertexnormalsepsilonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lightposition/__init__.py b/plotly/validators/cone/lightposition/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/cone/lightposition/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/cone/lightposition/_x.py b/plotly/validators/cone/lightposition/_x.py new file mode 100644 index 0000000000..afdf3356c3 --- /dev/null +++ b/plotly/validators/cone/lightposition/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='cone.lightposition', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lightposition/_y.py b/plotly/validators/cone/lightposition/_y.py new file mode 100644 index 0000000000..a1432fcace --- /dev/null +++ b/plotly/validators/cone/lightposition/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='cone.lightposition', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/lightposition/_z.py b/plotly/validators/cone/lightposition/_z.py new file mode 100644 index 0000000000..6c0ffe776c --- /dev/null +++ b/plotly/validators/cone/lightposition/_z.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='z', parent_name='cone.lightposition', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/cone/stream/__init__.py b/plotly/validators/cone/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/cone/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/cone/stream/_maxpoints.py b/plotly/validators/cone/stream/_maxpoints.py new file mode 100644 index 0000000000..081b573bf1 --- /dev/null +++ b/plotly/validators/cone/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='cone.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/cone/stream/_token.py b/plotly/validators/cone/stream/_token.py new file mode 100644 index 0000000000..ca57635488 --- /dev/null +++ b/plotly/validators/cone/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='cone.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contour/__init__.py b/plotly/validators/contour/__init__.py new file mode 100644 index 0000000000..4b2956e184 --- /dev/null +++ b/plotly/validators/contour/__init__.py @@ -0,0 +1,49 @@ +from ._zsrc import ZsrcValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zhoverformat import ZhoverformatValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._ytype import YtypeValidator +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xtype import XtypeValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._transpose import TransposeValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._ncontours import NcontoursValidator +from ._name import NameValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._contours import ContoursValidator +from ._connectgaps import ConnectgapsValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocontour import AutocontourValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/contour/_autocolorscale.py b/plotly/validators/contour/_autocolorscale.py new file mode 100644 index 0000000000..db2616ecfc --- /dev/null +++ b/plotly/validators/contour/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='contour', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_autocontour.py b/plotly/validators/contour/_autocontour.py new file mode 100644 index 0000000000..a99907f49d --- /dev/null +++ b/plotly/validators/contour/_autocontour.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocontourValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocontour', parent_name='contour', **kwargs + ): + super(AutocontourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_colorbar.py b/plotly/validators/contour/_colorbar.py new file mode 100644 index 0000000000..eacf34755f --- /dev/null +++ b/plotly/validators/contour/_colorbar.py @@ -0,0 +1,209 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='contour', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.contour.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/contour/_colorscale.py b/plotly/validators/contour/_colorscale.py new file mode 100644 index 0000000000..b5d1c157b3 --- /dev/null +++ b/plotly/validators/contour/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='contour', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_connectgaps.py b/plotly/validators/contour/_connectgaps.py new file mode 100644 index 0000000000..843a1b23b4 --- /dev/null +++ b/plotly/validators/contour/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='contour', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_contours.py b/plotly/validators/contour/_contours.py new file mode 100644 index 0000000000..5f5769f4e6 --- /dev/null +++ b/plotly/validators/contour/_contours.py @@ -0,0 +1,77 @@ +import _plotly_utils.basevalidators + + +class ContoursValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='contours', parent_name='contour', **kwargs + ): + super(ContoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contours', + data_docs=""" + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *heatmap*, + a heatmap gradient coloring is applied between + each contour level. If *lines*, coloring is + done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound.""", + **kwargs + ) diff --git a/plotly/validators/contour/_customdata.py b/plotly/validators/contour/_customdata.py new file mode 100644 index 0000000000..1d0079fdf0 --- /dev/null +++ b/plotly/validators/contour/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='contour', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_customdatasrc.py b/plotly/validators/contour/_customdatasrc.py new file mode 100644 index 0000000000..a8bb4f4aba --- /dev/null +++ b/plotly/validators/contour/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='contour', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_dx.py b/plotly/validators/contour/_dx.py new file mode 100644 index 0000000000..8fd201ba3c --- /dev/null +++ b/plotly/validators/contour/_dx.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='contour', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_dy.py b/plotly/validators/contour/_dy.py new file mode 100644 index 0000000000..2ed5482768 --- /dev/null +++ b/plotly/validators/contour/_dy.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='contour', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_fillcolor.py b/plotly/validators/contour/_fillcolor.py new file mode 100644 index 0000000000..37ebd2a7d9 --- /dev/null +++ b/plotly/validators/contour/_fillcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='contour', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + colorscale_path='contour.colorscale', + **kwargs + ) diff --git a/plotly/validators/contour/_hoverinfo.py b/plotly/validators/contour/_hoverinfo.py new file mode 100644 index 0000000000..dccdd19964 --- /dev/null +++ b/plotly/validators/contour/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='contour', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_hoverinfosrc.py b/plotly/validators/contour/_hoverinfosrc.py new file mode 100644 index 0000000000..fa22563bc6 --- /dev/null +++ b/plotly/validators/contour/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='contour', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_hoverlabel.py b/plotly/validators/contour/_hoverlabel.py new file mode 100644 index 0000000000..0df0ed1db0 --- /dev/null +++ b/plotly/validators/contour/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='contour', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/contour/_ids.py b/plotly/validators/contour/_ids.py new file mode 100644 index 0000000000..59dbdbeaa3 --- /dev/null +++ b/plotly/validators/contour/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='contour', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_idssrc.py b/plotly/validators/contour/_idssrc.py new file mode 100644 index 0000000000..50a9c0c0e3 --- /dev/null +++ b/plotly/validators/contour/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='contour', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_legendgroup.py b/plotly/validators/contour/_legendgroup.py new file mode 100644 index 0000000000..0becbfbf19 --- /dev/null +++ b/plotly/validators/contour/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='contour', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_line.py b/plotly/validators/contour/_line.py new file mode 100644 index 0000000000..cb8ce4d723 --- /dev/null +++ b/plotly/validators/contour/_line.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='contour', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the contour level. Has no + effect if `contours.coloring` is set to + *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/contour/_name.py b/plotly/validators/contour/_name.py new file mode 100644 index 0000000000..a0aeed16bd --- /dev/null +++ b/plotly/validators/contour/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='contour', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_ncontours.py b/plotly/validators/contour/_ncontours.py new file mode 100644 index 0000000000..1c4527ebc8 --- /dev/null +++ b/plotly/validators/contour/_ncontours.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NcontoursValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='ncontours', parent_name='contour', **kwargs + ): + super(NcontoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_opacity.py b/plotly/validators/contour/_opacity.py new file mode 100644 index 0000000000..a1f45c2d52 --- /dev/null +++ b/plotly/validators/contour/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='contour', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_reversescale.py b/plotly/validators/contour/_reversescale.py new file mode 100644 index 0000000000..5ea24c712f --- /dev/null +++ b/plotly/validators/contour/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='contour', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_selectedpoints.py b/plotly/validators/contour/_selectedpoints.py new file mode 100644 index 0000000000..0c87a70b6b --- /dev/null +++ b/plotly/validators/contour/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='contour', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_showlegend.py b/plotly/validators/contour/_showlegend.py new file mode 100644 index 0000000000..ee8ecb60a0 --- /dev/null +++ b/plotly/validators/contour/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='contour', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_showscale.py b/plotly/validators/contour/_showscale.py new file mode 100644 index 0000000000..ba57e58c3e --- /dev/null +++ b/plotly/validators/contour/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='contour', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_stream.py b/plotly/validators/contour/_stream.py new file mode 100644 index 0000000000..4998d15e83 --- /dev/null +++ b/plotly/validators/contour/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='contour', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/contour/_text.py b/plotly/validators/contour/_text.py new file mode 100644 index 0000000000..a4e66790ae --- /dev/null +++ b/plotly/validators/contour/_text.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='text', parent_name='contour', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_textsrc.py b/plotly/validators/contour/_textsrc.py new file mode 100644 index 0000000000..7c1af6c594 --- /dev/null +++ b/plotly/validators/contour/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='contour', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_transpose.py b/plotly/validators/contour/_transpose.py new file mode 100644 index 0000000000..f0b237e7ce --- /dev/null +++ b/plotly/validators/contour/_transpose.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TransposeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='transpose', parent_name='contour', **kwargs + ): + super(TransposeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_uid.py b/plotly/validators/contour/_uid.py new file mode 100644 index 0000000000..4af159506a --- /dev/null +++ b/plotly/validators/contour/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='contour', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_visible.py b/plotly/validators/contour/_visible.py new file mode 100644 index 0000000000..89a674f524 --- /dev/null +++ b/plotly/validators/contour/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='contour', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/contour/_x.py b/plotly/validators/contour/_x.py new file mode 100644 index 0000000000..9519764b64 --- /dev/null +++ b/plotly/validators/contour/_x.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='contour', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_x0.py b/plotly/validators/contour/_x0.py new file mode 100644 index 0000000000..ecb54274ec --- /dev/null +++ b/plotly/validators/contour/_x0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='contour', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_xaxis.py b/plotly/validators/contour/_xaxis.py new file mode 100644 index 0000000000..52f3a9eefb --- /dev/null +++ b/plotly/validators/contour/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='contour', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_xcalendar.py b/plotly/validators/contour/_xcalendar.py new file mode 100644 index 0000000000..70337b7635 --- /dev/null +++ b/plotly/validators/contour/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='contour', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/contour/_xsrc.py b/plotly/validators/contour/_xsrc.py new file mode 100644 index 0000000000..285b25821b --- /dev/null +++ b/plotly/validators/contour/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='contour', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_xtype.py b/plotly/validators/contour/_xtype.py new file mode 100644 index 0000000000..c3bb66bb58 --- /dev/null +++ b/plotly/validators/contour/_xtype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xtype', parent_name='contour', **kwargs): + super(XtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/contour/_y.py b/plotly/validators/contour/_y.py new file mode 100644 index 0000000000..38093afd00 --- /dev/null +++ b/plotly/validators/contour/_y.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='contour', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_y0.py b/plotly/validators/contour/_y0.py new file mode 100644 index 0000000000..cbfddc51ea --- /dev/null +++ b/plotly/validators/contour/_y0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='contour', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_yaxis.py b/plotly/validators/contour/_yaxis.py new file mode 100644 index 0000000000..d794892e27 --- /dev/null +++ b/plotly/validators/contour/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='contour', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_ycalendar.py b/plotly/validators/contour/_ycalendar.py new file mode 100644 index 0000000000..6b9a8a75cd --- /dev/null +++ b/plotly/validators/contour/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='contour', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/contour/_ysrc.py b/plotly/validators/contour/_ysrc.py new file mode 100644 index 0000000000..6a6064a988 --- /dev/null +++ b/plotly/validators/contour/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='contour', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_ytype.py b/plotly/validators/contour/_ytype.py new file mode 100644 index 0000000000..b0b8ba0eee --- /dev/null +++ b/plotly/validators/contour/_ytype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='ytype', parent_name='contour', **kwargs): + super(YtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/contour/_z.py b/plotly/validators/contour/_z.py new file mode 100644 index 0000000000..3cb17c5e79 --- /dev/null +++ b/plotly/validators/contour/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='contour', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/_zauto.py b/plotly/validators/contour/_zauto.py new file mode 100644 index 0000000000..84e8bc385c --- /dev/null +++ b/plotly/validators/contour/_zauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='zauto', parent_name='contour', **kwargs): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_zhoverformat.py b/plotly/validators/contour/_zhoverformat.py new file mode 100644 index 0000000000..9901b4eed4 --- /dev/null +++ b/plotly/validators/contour/_zhoverformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZhoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='zhoverformat', parent_name='contour', **kwargs + ): + super(ZhoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/_zmax.py b/plotly/validators/contour/_zmax.py new file mode 100644 index 0000000000..3fef06aedf --- /dev/null +++ b/plotly/validators/contour/_zmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmax', parent_name='contour', **kwargs): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_zmin.py b/plotly/validators/contour/_zmin.py new file mode 100644 index 0000000000..8c19babf19 --- /dev/null +++ b/plotly/validators/contour/_zmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmin', parent_name='contour', **kwargs): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/_zsrc.py b/plotly/validators/contour/_zsrc.py new file mode 100644 index 0000000000..5fcb1d82eb --- /dev/null +++ b/plotly/validators/contour/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='contour', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/__init__.py b/plotly/validators/contour/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/contour/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/contour/colorbar/_bgcolor.py b/plotly/validators/contour/colorbar/_bgcolor.py new file mode 100644 index 0000000000..298de58ce1 --- /dev/null +++ b/plotly/validators/contour/colorbar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='contour.colorbar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_bordercolor.py b/plotly/validators/contour/colorbar/_bordercolor.py new file mode 100644 index 0000000000..151ac16481 --- /dev/null +++ b/plotly/validators/contour/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='contour.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_borderwidth.py b/plotly/validators/contour/colorbar/_borderwidth.py new file mode 100644 index 0000000000..b1cfd4cabe --- /dev/null +++ b/plotly/validators/contour/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='contour.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_dtick.py b/plotly/validators/contour/colorbar/_dtick.py new file mode 100644 index 0000000000..8fc3f61c7a --- /dev/null +++ b/plotly/validators/contour/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='contour.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_exponentformat.py b/plotly/validators/contour/colorbar/_exponentformat.py new file mode 100644 index 0000000000..d8602a3876 --- /dev/null +++ b/plotly/validators/contour/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='contour.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_len.py b/plotly/validators/contour/colorbar/_len.py new file mode 100644 index 0000000000..caa27314eb --- /dev/null +++ b/plotly/validators/contour/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='contour.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_lenmode.py b/plotly/validators/contour/colorbar/_lenmode.py new file mode 100644 index 0000000000..fce61607c7 --- /dev/null +++ b/plotly/validators/contour/colorbar/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='contour.colorbar', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_nticks.py b/plotly/validators/contour/colorbar/_nticks.py new file mode 100644 index 0000000000..18456a92e3 --- /dev/null +++ b/plotly/validators/contour/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='contour.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_outlinecolor.py b/plotly/validators/contour/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..9922b4ae5c --- /dev/null +++ b/plotly/validators/contour/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='contour.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_outlinewidth.py b/plotly/validators/contour/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..950e9de5d5 --- /dev/null +++ b/plotly/validators/contour/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='contour.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_separatethousands.py b/plotly/validators/contour/colorbar/_separatethousands.py new file mode 100644 index 0000000000..cebe89c0c7 --- /dev/null +++ b/plotly/validators/contour/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='contour.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_showexponent.py b/plotly/validators/contour/colorbar/_showexponent.py new file mode 100644 index 0000000000..af2427ff17 --- /dev/null +++ b/plotly/validators/contour/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='contour.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_showticklabels.py b/plotly/validators/contour/colorbar/_showticklabels.py new file mode 100644 index 0000000000..1b89d1e967 --- /dev/null +++ b/plotly/validators/contour/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='contour.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_showtickprefix.py b/plotly/validators/contour/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..acc85f4eaf --- /dev/null +++ b/plotly/validators/contour/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='contour.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_showticksuffix.py b/plotly/validators/contour/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..b48ea8946e --- /dev/null +++ b/plotly/validators/contour/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='contour.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_thickness.py b/plotly/validators/contour/colorbar/_thickness.py new file mode 100644 index 0000000000..2aebf6b44f --- /dev/null +++ b/plotly/validators/contour/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='contour.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_thicknessmode.py b/plotly/validators/contour/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..9d24037680 --- /dev/null +++ b/plotly/validators/contour/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='contour.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tick0.py b/plotly/validators/contour/colorbar/_tick0.py new file mode 100644 index 0000000000..3fa179face --- /dev/null +++ b/plotly/validators/contour/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='contour.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickangle.py b/plotly/validators/contour/colorbar/_tickangle.py new file mode 100644 index 0000000000..c1e482cff2 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='contour.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickcolor.py b/plotly/validators/contour/colorbar/_tickcolor.py new file mode 100644 index 0000000000..24651b91c8 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='contour.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickfont.py b/plotly/validators/contour/colorbar/_tickfont.py new file mode 100644 index 0000000000..f72acf6685 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='contour.colorbar', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickformat.py b/plotly/validators/contour/colorbar/_tickformat.py new file mode 100644 index 0000000000..8b45634acd --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='contour.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickformatstops.py b/plotly/validators/contour/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..f01b0c5be1 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='contour.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ticklen.py b/plotly/validators/contour/colorbar/_ticklen.py new file mode 100644 index 0000000000..5472dfdb04 --- /dev/null +++ b/plotly/validators/contour/colorbar/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='contour.colorbar', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickmode.py b/plotly/validators/contour/colorbar/_tickmode.py new file mode 100644 index 0000000000..afcea5f4d1 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='contour.colorbar', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickprefix.py b/plotly/validators/contour/colorbar/_tickprefix.py new file mode 100644 index 0000000000..91b30bc7cc --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='contour.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ticks.py b/plotly/validators/contour/colorbar/_ticks.py new file mode 100644 index 0000000000..5972f8a268 --- /dev/null +++ b/plotly/validators/contour/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='contour.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ticksuffix.py b/plotly/validators/contour/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..07c22c8e81 --- /dev/null +++ b/plotly/validators/contour/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='contour.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ticktext.py b/plotly/validators/contour/colorbar/_ticktext.py new file mode 100644 index 0000000000..81a3e2b6ff --- /dev/null +++ b/plotly/validators/contour/colorbar/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='contour.colorbar', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ticktextsrc.py b/plotly/validators/contour/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..91f22bad25 --- /dev/null +++ b/plotly/validators/contour/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='contour.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickvals.py b/plotly/validators/contour/colorbar/_tickvals.py new file mode 100644 index 0000000000..4525ee6177 --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='contour.colorbar', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickvalssrc.py b/plotly/validators/contour/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..cda3518ffd --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='contour.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_tickwidth.py b/plotly/validators/contour/colorbar/_tickwidth.py new file mode 100644 index 0000000000..a96fca1e6e --- /dev/null +++ b/plotly/validators/contour/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='contour.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_title.py b/plotly/validators/contour/colorbar/_title.py new file mode 100644 index 0000000000..5bf4814cc5 --- /dev/null +++ b/plotly/validators/contour/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='contour.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_titlefont.py b/plotly/validators/contour/colorbar/_titlefont.py new file mode 100644 index 0000000000..aa75e96ad6 --- /dev/null +++ b/plotly/validators/contour/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='contour.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_titleside.py b/plotly/validators/contour/colorbar/_titleside.py new file mode 100644 index 0000000000..bba18a5d05 --- /dev/null +++ b/plotly/validators/contour/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='contour.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_x.py b/plotly/validators/contour/colorbar/_x.py new file mode 100644 index 0000000000..34175d9ae2 --- /dev/null +++ b/plotly/validators/contour/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='contour.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_xanchor.py b/plotly/validators/contour/colorbar/_xanchor.py new file mode 100644 index 0000000000..067d68a9ad --- /dev/null +++ b/plotly/validators/contour/colorbar/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='contour.colorbar', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_xpad.py b/plotly/validators/contour/colorbar/_xpad.py new file mode 100644 index 0000000000..6ee29fb94a --- /dev/null +++ b/plotly/validators/contour/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='contour.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_y.py b/plotly/validators/contour/colorbar/_y.py new file mode 100644 index 0000000000..48e29e3ac8 --- /dev/null +++ b/plotly/validators/contour/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='contour.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_yanchor.py b/plotly/validators/contour/colorbar/_yanchor.py new file mode 100644 index 0000000000..d8eef22845 --- /dev/null +++ b/plotly/validators/contour/colorbar/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='contour.colorbar', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/_ypad.py b/plotly/validators/contour/colorbar/_ypad.py new file mode 100644 index 0000000000..96c61b68d3 --- /dev/null +++ b/plotly/validators/contour/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='contour.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/tickfont/__init__.py b/plotly/validators/contour/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contour/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contour/colorbar/tickfont/_color.py b/plotly/validators/contour/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..6d3214029a --- /dev/null +++ b/plotly/validators/contour/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contour.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/tickfont/_family.py b/plotly/validators/contour/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..9fe61bcac3 --- /dev/null +++ b/plotly/validators/contour/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contour.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/tickfont/_size.py b/plotly/validators/contour/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..cbe0c8263d --- /dev/null +++ b/plotly/validators/contour/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contour.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/tickformatstop/__init__.py b/plotly/validators/contour/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/contour/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/contour/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/contour/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..9b4be1acd5 --- /dev/null +++ b/plotly/validators/contour/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='contour.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/tickformatstop/_value.py b/plotly/validators/contour/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..0e64f38f5e --- /dev/null +++ b/plotly/validators/contour/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='contour.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/titlefont/__init__.py b/plotly/validators/contour/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contour/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contour/colorbar/titlefont/_color.py b/plotly/validators/contour/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..7110d7b40b --- /dev/null +++ b/plotly/validators/contour/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contour.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/titlefont/_family.py b/plotly/validators/contour/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..018b7224c1 --- /dev/null +++ b/plotly/validators/contour/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contour.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contour/colorbar/titlefont/_size.py b/plotly/validators/contour/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..ebce9a1cc2 --- /dev/null +++ b/plotly/validators/contour/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contour.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/__init__.py b/plotly/validators/contour/contours/__init__.py new file mode 100644 index 0000000000..2ff9693386 --- /dev/null +++ b/plotly/validators/contour/contours/__init__.py @@ -0,0 +1,11 @@ +from ._value import ValueValidator +from ._type import TypeValidator +from ._start import StartValidator +from ._size import SizeValidator +from ._showlines import ShowlinesValidator +from ._showlabels import ShowlabelsValidator +from ._operation import OperationValidator +from ._labelformat import LabelformatValidator +from ._labelfont import LabelfontValidator +from ._end import EndValidator +from ._coloring import ColoringValidator diff --git a/plotly/validators/contour/contours/_coloring.py b/plotly/validators/contour/contours/_coloring.py new file mode 100644 index 0000000000..d8c089a85e --- /dev/null +++ b/plotly/validators/contour/contours/_coloring.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColoringValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='coloring', parent_name='contour.contours', **kwargs + ): + super(ColoringValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fill', 'heatmap', 'lines', 'none'], + **kwargs + ) diff --git a/plotly/validators/contour/contours/_end.py b/plotly/validators/contour/contours/_end.py new file mode 100644 index 0000000000..16aa755053 --- /dev/null +++ b/plotly/validators/contour/contours/_end.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='end', parent_name='contour.contours', **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_labelfont.py b/plotly/validators/contour/contours/_labelfont.py new file mode 100644 index 0000000000..66226f4905 --- /dev/null +++ b/plotly/validators/contour/contours/_labelfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class LabelfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='labelfont', + parent_name='contour.contours', + **kwargs + ): + super(LabelfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Labelfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contour/contours/_labelformat.py b/plotly/validators/contour/contours/_labelformat.py new file mode 100644 index 0000000000..defdbfc946 --- /dev/null +++ b/plotly/validators/contour/contours/_labelformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LabelformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='labelformat', + parent_name='contour.contours', + **kwargs + ): + super(LabelformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_operation.py b/plotly/validators/contour/contours/_operation.py new file mode 100644 index 0000000000..0c5e004169 --- /dev/null +++ b/plotly/validators/contour/contours/_operation.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class OperationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='operation', + parent_name='contour.contours', + **kwargs + ): + super(OperationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + '=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', ')(', + '](', ')[' + ], + **kwargs + ) diff --git a/plotly/validators/contour/contours/_showlabels.py b/plotly/validators/contour/contours/_showlabels.py new file mode 100644 index 0000000000..0b8697d298 --- /dev/null +++ b/plotly/validators/contour/contours/_showlabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlabels', + parent_name='contour.contours', + **kwargs + ): + super(ShowlabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_showlines.py b/plotly/validators/contour/contours/_showlines.py new file mode 100644 index 0000000000..989856161f --- /dev/null +++ b/plotly/validators/contour/contours/_showlines.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlinesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlines', + parent_name='contour.contours', + **kwargs + ): + super(ShowlinesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_size.py b/plotly/validators/contour/contours/_size.py new file mode 100644 index 0000000000..fa933361ea --- /dev/null +++ b/plotly/validators/contour/contours/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='contour.contours', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_start.py b/plotly/validators/contour/contours/_start.py new file mode 100644 index 0000000000..c488afdd3c --- /dev/null +++ b/plotly/validators/contour/contours/_start.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='start', parent_name='contour.contours', **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/_type.py b/plotly/validators/contour/contours/_type.py new file mode 100644 index 0000000000..9f6042a534 --- /dev/null +++ b/plotly/validators/contour/contours/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='contour.contours', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['levels', 'constraint'], + **kwargs + ) diff --git a/plotly/validators/contour/contours/_value.py b/plotly/validators/contour/contours/_value.py new file mode 100644 index 0000000000..3114780828 --- /dev/null +++ b/plotly/validators/contour/contours/_value.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='value', parent_name='contour.contours', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/contours/labelfont/__init__.py b/plotly/validators/contour/contours/labelfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contour/contours/labelfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contour/contours/labelfont/_color.py b/plotly/validators/contour/contours/labelfont/_color.py new file mode 100644 index 0000000000..b2af3b1b7c --- /dev/null +++ b/plotly/validators/contour/contours/labelfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contour.contours.labelfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/contours/labelfont/_family.py b/plotly/validators/contour/contours/labelfont/_family.py new file mode 100644 index 0000000000..8b91c486c9 --- /dev/null +++ b/plotly/validators/contour/contours/labelfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contour.contours.labelfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contour/contours/labelfont/_size.py b/plotly/validators/contour/contours/labelfont/_size.py new file mode 100644 index 0000000000..d6b7afef3b --- /dev/null +++ b/plotly/validators/contour/contours/labelfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contour.contours.labelfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/__init__.py b/plotly/validators/contour/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/contour/hoverlabel/_bgcolor.py b/plotly/validators/contour/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..e37b7067f0 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='contour.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_bgcolorsrc.py b/plotly/validators/contour/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..424509b6c0 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='contour.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_bordercolor.py b/plotly/validators/contour/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..59f4fd7442 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='contour.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_bordercolorsrc.py b/plotly/validators/contour/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..ddfdb36b02 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='contour.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_font.py b/plotly/validators/contour/hoverlabel/_font.py new file mode 100644 index 0000000000..283d54faab --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='contour.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_namelength.py b/plotly/validators/contour/hoverlabel/_namelength.py new file mode 100644 index 0000000000..1712b6c2da --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='contour.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/_namelengthsrc.py b/plotly/validators/contour/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..4aa71bafca --- /dev/null +++ b/plotly/validators/contour/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='contour.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/__init__.py b/plotly/validators/contour/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/contour/hoverlabel/font/_color.py b/plotly/validators/contour/hoverlabel/font/_color.py new file mode 100644 index 0000000000..2d3dbe2c0b --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/_colorsrc.py b/plotly/validators/contour/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..c51c90834c --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/_family.py b/plotly/validators/contour/hoverlabel/font/_family.py new file mode 100644 index 0000000000..e77ce77ebf --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/_familysrc.py b/plotly/validators/contour/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..598436f555 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/_size.py b/plotly/validators/contour/hoverlabel/font/_size.py new file mode 100644 index 0000000000..b791ccb174 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/hoverlabel/font/_sizesrc.py b/plotly/validators/contour/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..3811686aa5 --- /dev/null +++ b/plotly/validators/contour/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='contour.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/line/__init__.py b/plotly/validators/contour/line/__init__.py new file mode 100644 index 0000000000..185c3b5d84 --- /dev/null +++ b/plotly/validators/contour/line/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/contour/line/_color.py b/plotly/validators/contour/line/_color.py new file mode 100644 index 0000000000..55d6c92caf --- /dev/null +++ b/plotly/validators/contour/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='contour.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style+colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/line/_dash.py b/plotly/validators/contour/line/_dash.py new file mode 100644 index 0000000000..c2dbd033f5 --- /dev/null +++ b/plotly/validators/contour/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='contour.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/contour/line/_smoothing.py b/plotly/validators/contour/line/_smoothing.py new file mode 100644 index 0000000000..8036524089 --- /dev/null +++ b/plotly/validators/contour/line/_smoothing.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='smoothing', parent_name='contour.line', **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/line/_width.py b/plotly/validators/contour/line/_width.py new file mode 100644 index 0000000000..3474c1f652 --- /dev/null +++ b/plotly/validators/contour/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='contour.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style+colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contour/stream/__init__.py b/plotly/validators/contour/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/contour/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/contour/stream/_maxpoints.py b/plotly/validators/contour/stream/_maxpoints.py new file mode 100644 index 0000000000..c1137fd218 --- /dev/null +++ b/plotly/validators/contour/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='contour.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/contour/stream/_token.py b/plotly/validators/contour/stream/_token.py new file mode 100644 index 0000000000..c0883bfd1b --- /dev/null +++ b/plotly/validators/contour/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='contour.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contourcarpet/__init__.py b/plotly/validators/contourcarpet/__init__.py new file mode 100644 index 0000000000..866e2f18ef --- /dev/null +++ b/plotly/validators/contourcarpet/__init__.py @@ -0,0 +1,46 @@ +from ._zsrc import ZsrcValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._yaxis import YAxisValidator +from ._xaxis import XAxisValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._transpose import TransposeValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._ncontours import NcontoursValidator +from ._name import NameValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._db import DbValidator +from ._da import DaValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._contours import ContoursValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._carpet import CarpetValidator +from ._btype import BtypeValidator +from ._bsrc import BsrcValidator +from ._b0 import B0Validator +from ._b import BValidator +from ._autocontour import AutocontourValidator +from ._autocolorscale import AutocolorscaleValidator +from ._atype import AtypeValidator +from ._asrc import AsrcValidator +from ._a0 import A0Validator +from ._a import AValidator diff --git a/plotly/validators/contourcarpet/_a.py b/plotly/validators/contourcarpet/_a.py new file mode 100644 index 0000000000..fdfc88feef --- /dev/null +++ b/plotly/validators/contourcarpet/_a.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class AValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='a', parent_name='contourcarpet', **kwargs): + super(AValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_a0.py b/plotly/validators/contourcarpet/_a0.py new file mode 100644 index 0000000000..056d4d4bb6 --- /dev/null +++ b/plotly/validators/contourcarpet/_a0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class A0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='a0', parent_name='contourcarpet', **kwargs + ): + super(A0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_asrc.py b/plotly/validators/contourcarpet/_asrc.py new file mode 100644 index 0000000000..e83ec35860 --- /dev/null +++ b/plotly/validators/contourcarpet/_asrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='asrc', parent_name='contourcarpet', **kwargs + ): + super(AsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_atype.py b/plotly/validators/contourcarpet/_atype.py new file mode 100644 index 0000000000..fda6b55e86 --- /dev/null +++ b/plotly/validators/contourcarpet/_atype.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='atype', parent_name='contourcarpet', **kwargs + ): + super(AtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_autocolorscale.py b/plotly/validators/contourcarpet/_autocolorscale.py new file mode 100644 index 0000000000..0a51996648 --- /dev/null +++ b/plotly/validators/contourcarpet/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='contourcarpet', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_autocontour.py b/plotly/validators/contourcarpet/_autocontour.py new file mode 100644 index 0000000000..ca7b2ff14b --- /dev/null +++ b/plotly/validators/contourcarpet/_autocontour.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocontourValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocontour', parent_name='contourcarpet', **kwargs + ): + super(AutocontourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_b.py b/plotly/validators/contourcarpet/_b.py new file mode 100644 index 0000000000..b83c9695a6 --- /dev/null +++ b/plotly/validators/contourcarpet/_b.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='b', parent_name='contourcarpet', **kwargs): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_b0.py b/plotly/validators/contourcarpet/_b0.py new file mode 100644 index 0000000000..7425625da9 --- /dev/null +++ b/plotly/validators/contourcarpet/_b0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class B0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='b0', parent_name='contourcarpet', **kwargs + ): + super(B0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_bsrc.py b/plotly/validators/contourcarpet/_bsrc.py new file mode 100644 index 0000000000..94abb71d17 --- /dev/null +++ b/plotly/validators/contourcarpet/_bsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bsrc', parent_name='contourcarpet', **kwargs + ): + super(BsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_btype.py b/plotly/validators/contourcarpet/_btype.py new file mode 100644 index 0000000000..1270861eb2 --- /dev/null +++ b/plotly/validators/contourcarpet/_btype.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='btype', parent_name='contourcarpet', **kwargs + ): + super(BtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_carpet.py b/plotly/validators/contourcarpet/_carpet.py new file mode 100644 index 0000000000..621568628e --- /dev/null +++ b/plotly/validators/contourcarpet/_carpet.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CarpetValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='carpet', parent_name='contourcarpet', **kwargs + ): + super(CarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_colorbar.py b/plotly/validators/contourcarpet/_colorbar.py new file mode 100644 index 0000000000..252d8b7c4a --- /dev/null +++ b/plotly/validators/contourcarpet/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='contourcarpet', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.contourcarpet.colorbar.Tickfo + rmatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_colorscale.py b/plotly/validators/contourcarpet/_colorscale.py new file mode 100644 index 0000000000..6d794c87b8 --- /dev/null +++ b/plotly/validators/contourcarpet/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='contourcarpet', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_contours.py b/plotly/validators/contourcarpet/_contours.py new file mode 100644 index 0000000000..01e15e7318 --- /dev/null +++ b/plotly/validators/contourcarpet/_contours.py @@ -0,0 +1,75 @@ +import _plotly_utils.basevalidators + + +class ContoursValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='contours', parent_name='contourcarpet', **kwargs + ): + super(ContoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contours', + data_docs=""" + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *lines*, + coloring is done on the contour lines. If + *none*, no coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound.""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_customdata.py b/plotly/validators/contourcarpet/_customdata.py new file mode 100644 index 0000000000..33cca3d3c0 --- /dev/null +++ b/plotly/validators/contourcarpet/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='contourcarpet', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_customdatasrc.py b/plotly/validators/contourcarpet/_customdatasrc.py new file mode 100644 index 0000000000..500a6654c1 --- /dev/null +++ b/plotly/validators/contourcarpet/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='contourcarpet', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_da.py b/plotly/validators/contourcarpet/_da.py new file mode 100644 index 0000000000..7be3c1b3a3 --- /dev/null +++ b/plotly/validators/contourcarpet/_da.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DaValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='da', parent_name='contourcarpet', **kwargs + ): + super(DaValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_db.py b/plotly/validators/contourcarpet/_db.py new file mode 100644 index 0000000000..9ea1eb6723 --- /dev/null +++ b/plotly/validators/contourcarpet/_db.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DbValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='db', parent_name='contourcarpet', **kwargs + ): + super(DbValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_fillcolor.py b/plotly/validators/contourcarpet/_fillcolor.py new file mode 100644 index 0000000000..7c50fb4268 --- /dev/null +++ b/plotly/validators/contourcarpet/_fillcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='contourcarpet', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + colorscale_path='contourcarpet.colorscale', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_hoverinfo.py b/plotly/validators/contourcarpet/_hoverinfo.py new file mode 100644 index 0000000000..245146f2f3 --- /dev/null +++ b/plotly/validators/contourcarpet/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='contourcarpet', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_hoverinfosrc.py b/plotly/validators/contourcarpet/_hoverinfosrc.py new file mode 100644 index 0000000000..5d3c0df1c0 --- /dev/null +++ b/plotly/validators/contourcarpet/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='contourcarpet', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_hoverlabel.py b/plotly/validators/contourcarpet/_hoverlabel.py new file mode 100644 index 0000000000..60c667298a --- /dev/null +++ b/plotly/validators/contourcarpet/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='contourcarpet', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_ids.py b/plotly/validators/contourcarpet/_ids.py new file mode 100644 index 0000000000..0576214979 --- /dev/null +++ b/plotly/validators/contourcarpet/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='contourcarpet', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_idssrc.py b/plotly/validators/contourcarpet/_idssrc.py new file mode 100644 index 0000000000..0b2342d166 --- /dev/null +++ b/plotly/validators/contourcarpet/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='contourcarpet', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_legendgroup.py b/plotly/validators/contourcarpet/_legendgroup.py new file mode 100644 index 0000000000..fbd31fb635 --- /dev/null +++ b/plotly/validators/contourcarpet/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='contourcarpet', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_line.py b/plotly/validators/contourcarpet/_line.py new file mode 100644 index 0000000000..4b99f316d6 --- /dev/null +++ b/plotly/validators/contourcarpet/_line.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='contourcarpet', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the contour level. Has no if + `contours.coloring` is set to *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_name.py b/plotly/validators/contourcarpet/_name.py new file mode 100644 index 0000000000..f6ea80c2c2 --- /dev/null +++ b/plotly/validators/contourcarpet/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='contourcarpet', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_ncontours.py b/plotly/validators/contourcarpet/_ncontours.py new file mode 100644 index 0000000000..0a59293cab --- /dev/null +++ b/plotly/validators/contourcarpet/_ncontours.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NcontoursValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='ncontours', parent_name='contourcarpet', **kwargs + ): + super(NcontoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_opacity.py b/plotly/validators/contourcarpet/_opacity.py new file mode 100644 index 0000000000..d638d62182 --- /dev/null +++ b/plotly/validators/contourcarpet/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='contourcarpet', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_reversescale.py b/plotly/validators/contourcarpet/_reversescale.py new file mode 100644 index 0000000000..4271ff3a25 --- /dev/null +++ b/plotly/validators/contourcarpet/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='contourcarpet', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_selectedpoints.py b/plotly/validators/contourcarpet/_selectedpoints.py new file mode 100644 index 0000000000..30adda32d8 --- /dev/null +++ b/plotly/validators/contourcarpet/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='contourcarpet', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_showlegend.py b/plotly/validators/contourcarpet/_showlegend.py new file mode 100644 index 0000000000..ef39d78a5b --- /dev/null +++ b/plotly/validators/contourcarpet/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='contourcarpet', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_showscale.py b/plotly/validators/contourcarpet/_showscale.py new file mode 100644 index 0000000000..487e798fff --- /dev/null +++ b/plotly/validators/contourcarpet/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='contourcarpet', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_stream.py b/plotly/validators/contourcarpet/_stream.py new file mode 100644 index 0000000000..00d9bbf8db --- /dev/null +++ b/plotly/validators/contourcarpet/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='contourcarpet', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_text.py b/plotly/validators/contourcarpet/_text.py new file mode 100644 index 0000000000..8cb25381bb --- /dev/null +++ b/plotly/validators/contourcarpet/_text.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='text', parent_name='contourcarpet', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_textsrc.py b/plotly/validators/contourcarpet/_textsrc.py new file mode 100644 index 0000000000..649dd3c006 --- /dev/null +++ b/plotly/validators/contourcarpet/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='contourcarpet', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_transpose.py b/plotly/validators/contourcarpet/_transpose.py new file mode 100644 index 0000000000..1a172b55a9 --- /dev/null +++ b/plotly/validators/contourcarpet/_transpose.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TransposeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='transpose', parent_name='contourcarpet', **kwargs + ): + super(TransposeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_uid.py b/plotly/validators/contourcarpet/_uid.py new file mode 100644 index 0000000000..3813129fd3 --- /dev/null +++ b/plotly/validators/contourcarpet/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='contourcarpet', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_visible.py b/plotly/validators/contourcarpet/_visible.py new file mode 100644 index 0000000000..67be9dac9b --- /dev/null +++ b/plotly/validators/contourcarpet/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='contourcarpet', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_xaxis.py b/plotly/validators/contourcarpet/_xaxis.py new file mode 100644 index 0000000000..a20fa6c3d6 --- /dev/null +++ b/plotly/validators/contourcarpet/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='contourcarpet', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_yaxis.py b/plotly/validators/contourcarpet/_yaxis.py new file mode 100644 index 0000000000..6da0141d0c --- /dev/null +++ b/plotly/validators/contourcarpet/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='contourcarpet', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_z.py b/plotly/validators/contourcarpet/_z.py new file mode 100644 index 0000000000..70072fb789 --- /dev/null +++ b/plotly/validators/contourcarpet/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='contourcarpet', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_zauto.py b/plotly/validators/contourcarpet/_zauto.py new file mode 100644 index 0000000000..d279efb96e --- /dev/null +++ b/plotly/validators/contourcarpet/_zauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zauto', parent_name='contourcarpet', **kwargs + ): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_zmax.py b/plotly/validators/contourcarpet/_zmax.py new file mode 100644 index 0000000000..e2ff09b113 --- /dev/null +++ b/plotly/validators/contourcarpet/_zmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmax', parent_name='contourcarpet', **kwargs + ): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_zmin.py b/plotly/validators/contourcarpet/_zmin.py new file mode 100644 index 0000000000..464297b44b --- /dev/null +++ b/plotly/validators/contourcarpet/_zmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmin', parent_name='contourcarpet', **kwargs + ): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/_zsrc.py b/plotly/validators/contourcarpet/_zsrc.py new file mode 100644 index 0000000000..69a7a3b699 --- /dev/null +++ b/plotly/validators/contourcarpet/_zsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='zsrc', parent_name='contourcarpet', **kwargs + ): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/__init__.py b/plotly/validators/contourcarpet/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/contourcarpet/colorbar/_bgcolor.py b/plotly/validators/contourcarpet/colorbar/_bgcolor.py new file mode 100644 index 0000000000..dfe1e94381 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_bordercolor.py b/plotly/validators/contourcarpet/colorbar/_bordercolor.py new file mode 100644 index 0000000000..380b571da2 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_borderwidth.py b/plotly/validators/contourcarpet/colorbar/_borderwidth.py new file mode 100644 index 0000000000..4951725596 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_dtick.py b/plotly/validators/contourcarpet/colorbar/_dtick.py new file mode 100644 index 0000000000..81a0241b06 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_exponentformat.py b/plotly/validators/contourcarpet/colorbar/_exponentformat.py new file mode 100644 index 0000000000..99ef4e5227 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_len.py b/plotly/validators/contourcarpet/colorbar/_len.py new file mode 100644 index 0000000000..adbd00c365 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_lenmode.py b/plotly/validators/contourcarpet/colorbar/_lenmode.py new file mode 100644 index 0000000000..aef6a10ece --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_nticks.py b/plotly/validators/contourcarpet/colorbar/_nticks.py new file mode 100644 index 0000000000..13b461cb49 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_outlinecolor.py b/plotly/validators/contourcarpet/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..a92f2d4cf6 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_outlinewidth.py b/plotly/validators/contourcarpet/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..f6ca409667 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_separatethousands.py b/plotly/validators/contourcarpet/colorbar/_separatethousands.py new file mode 100644 index 0000000000..e084180c6d --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_showexponent.py b/plotly/validators/contourcarpet/colorbar/_showexponent.py new file mode 100644 index 0000000000..0369bc325b --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_showticklabels.py b/plotly/validators/contourcarpet/colorbar/_showticklabels.py new file mode 100644 index 0000000000..d53bddc4ac --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_showtickprefix.py b/plotly/validators/contourcarpet/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..f91e8a499b --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_showticksuffix.py b/plotly/validators/contourcarpet/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..f6fd7142ed --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_thickness.py b/plotly/validators/contourcarpet/colorbar/_thickness.py new file mode 100644 index 0000000000..3d907c11c0 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_thicknessmode.py b/plotly/validators/contourcarpet/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..b6b7d612ad --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tick0.py b/plotly/validators/contourcarpet/colorbar/_tick0.py new file mode 100644 index 0000000000..84fcea8d05 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickangle.py b/plotly/validators/contourcarpet/colorbar/_tickangle.py new file mode 100644 index 0000000000..fd8375dee4 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickcolor.py b/plotly/validators/contourcarpet/colorbar/_tickcolor.py new file mode 100644 index 0000000000..d91c6f79af --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickfont.py b/plotly/validators/contourcarpet/colorbar/_tickfont.py new file mode 100644 index 0000000000..eed959f389 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickformat.py b/plotly/validators/contourcarpet/colorbar/_tickformat.py new file mode 100644 index 0000000000..91101d9e84 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickformatstops.py b/plotly/validators/contourcarpet/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..571bd141f9 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ticklen.py b/plotly/validators/contourcarpet/colorbar/_ticklen.py new file mode 100644 index 0000000000..fe42e77c6e --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickmode.py b/plotly/validators/contourcarpet/colorbar/_tickmode.py new file mode 100644 index 0000000000..26eed2babb --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickprefix.py b/plotly/validators/contourcarpet/colorbar/_tickprefix.py new file mode 100644 index 0000000000..dbff7fbe48 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ticks.py b/plotly/validators/contourcarpet/colorbar/_ticks.py new file mode 100644 index 0000000000..f0b999aeb1 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ticksuffix.py b/plotly/validators/contourcarpet/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..38ef64acb9 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ticktext.py b/plotly/validators/contourcarpet/colorbar/_ticktext.py new file mode 100644 index 0000000000..41eb08f89c --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ticktextsrc.py b/plotly/validators/contourcarpet/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..2f9a2cd294 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickvals.py b/plotly/validators/contourcarpet/colorbar/_tickvals.py new file mode 100644 index 0000000000..d23628bd3a --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickvalssrc.py b/plotly/validators/contourcarpet/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..d11e8039ee --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_tickwidth.py b/plotly/validators/contourcarpet/colorbar/_tickwidth.py new file mode 100644 index 0000000000..e2555ff832 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_title.py b/plotly/validators/contourcarpet/colorbar/_title.py new file mode 100644 index 0000000000..26cf4275ad --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_titlefont.py b/plotly/validators/contourcarpet/colorbar/_titlefont.py new file mode 100644 index 0000000000..2e3eeb93d5 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_titleside.py b/plotly/validators/contourcarpet/colorbar/_titleside.py new file mode 100644 index 0000000000..08320e3927 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_x.py b/plotly/validators/contourcarpet/colorbar/_x.py new file mode 100644 index 0000000000..4e888de839 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='contourcarpet.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_xanchor.py b/plotly/validators/contourcarpet/colorbar/_xanchor.py new file mode 100644 index 0000000000..b2e6eae805 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_xpad.py b/plotly/validators/contourcarpet/colorbar/_xpad.py new file mode 100644 index 0000000000..e021029e9a --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_y.py b/plotly/validators/contourcarpet/colorbar/_y.py new file mode 100644 index 0000000000..fc6b2c9100 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='contourcarpet.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_yanchor.py b/plotly/validators/contourcarpet/colorbar/_yanchor.py new file mode 100644 index 0000000000..c250f30ff4 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/_ypad.py b/plotly/validators/contourcarpet/colorbar/_ypad.py new file mode 100644 index 0000000000..6460906a20 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='contourcarpet.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/tickfont/__init__.py b/plotly/validators/contourcarpet/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contourcarpet/colorbar/tickfont/_color.py b/plotly/validators/contourcarpet/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..fbf4457b2a --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contourcarpet.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/tickfont/_family.py b/plotly/validators/contourcarpet/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..15aef26e53 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contourcarpet.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/tickfont/_size.py b/plotly/validators/contourcarpet/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..96500cf457 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contourcarpet.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/tickformatstop/__init__.py b/plotly/validators/contourcarpet/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/contourcarpet/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/contourcarpet/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..2ff2830b55 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='contourcarpet.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/tickformatstop/_value.py b/plotly/validators/contourcarpet/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..89ed827398 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='contourcarpet.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/titlefont/__init__.py b/plotly/validators/contourcarpet/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contourcarpet/colorbar/titlefont/_color.py b/plotly/validators/contourcarpet/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..3cad2367b2 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contourcarpet.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/titlefont/_family.py b/plotly/validators/contourcarpet/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..03366d4c49 --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contourcarpet.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contourcarpet/colorbar/titlefont/_size.py b/plotly/validators/contourcarpet/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..60040b582d --- /dev/null +++ b/plotly/validators/contourcarpet/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contourcarpet.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/__init__.py b/plotly/validators/contourcarpet/contours/__init__.py new file mode 100644 index 0000000000..2ff9693386 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/__init__.py @@ -0,0 +1,11 @@ +from ._value import ValueValidator +from ._type import TypeValidator +from ._start import StartValidator +from ._size import SizeValidator +from ._showlines import ShowlinesValidator +from ._showlabels import ShowlabelsValidator +from ._operation import OperationValidator +from ._labelformat import LabelformatValidator +from ._labelfont import LabelfontValidator +from ._end import EndValidator +from ._coloring import ColoringValidator diff --git a/plotly/validators/contourcarpet/contours/_coloring.py b/plotly/validators/contourcarpet/contours/_coloring.py new file mode 100644 index 0000000000..71063cadb9 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_coloring.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColoringValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='coloring', + parent_name='contourcarpet.contours', + **kwargs + ): + super(ColoringValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fill', 'lines', 'none'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_end.py b/plotly/validators/contourcarpet/contours/_end.py new file mode 100644 index 0000000000..eb90f641ef --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_end.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='end', + parent_name='contourcarpet.contours', + **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_labelfont.py b/plotly/validators/contourcarpet/contours/_labelfont.py new file mode 100644 index 0000000000..763c5ed281 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_labelfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class LabelfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='labelfont', + parent_name='contourcarpet.contours', + **kwargs + ): + super(LabelfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Labelfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_labelformat.py b/plotly/validators/contourcarpet/contours/_labelformat.py new file mode 100644 index 0000000000..e1b4ca45b5 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_labelformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LabelformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='labelformat', + parent_name='contourcarpet.contours', + **kwargs + ): + super(LabelformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_operation.py b/plotly/validators/contourcarpet/contours/_operation.py new file mode 100644 index 0000000000..d26cbe08e2 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_operation.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class OperationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='operation', + parent_name='contourcarpet.contours', + **kwargs + ): + super(OperationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + '=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', ')(', + '](', ')[' + ], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_showlabels.py b/plotly/validators/contourcarpet/contours/_showlabels.py new file mode 100644 index 0000000000..d01ab2896b --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_showlabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlabels', + parent_name='contourcarpet.contours', + **kwargs + ): + super(ShowlabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_showlines.py b/plotly/validators/contourcarpet/contours/_showlines.py new file mode 100644 index 0000000000..b7bb1f6a96 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_showlines.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlinesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlines', + parent_name='contourcarpet.contours', + **kwargs + ): + super(ShowlinesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_size.py b/plotly/validators/contourcarpet/contours/_size.py new file mode 100644 index 0000000000..a83d0079dc --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contourcarpet.contours', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_start.py b/plotly/validators/contourcarpet/contours/_start.py new file mode 100644 index 0000000000..878ba5c8ea --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_start.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='start', + parent_name='contourcarpet.contours', + **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_type.py b/plotly/validators/contourcarpet/contours/_type.py new file mode 100644 index 0000000000..92a9e032f1 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_type.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='contourcarpet.contours', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['levels', 'constraint'], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/_value.py b/plotly/validators/contourcarpet/contours/_value.py new file mode 100644 index 0000000000..20079fe9e0 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='value', + parent_name='contourcarpet.contours', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/labelfont/__init__.py b/plotly/validators/contourcarpet/contours/labelfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/contourcarpet/contours/labelfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/contourcarpet/contours/labelfont/_color.py b/plotly/validators/contourcarpet/contours/labelfont/_color.py new file mode 100644 index 0000000000..71dcef5aeb --- /dev/null +++ b/plotly/validators/contourcarpet/contours/labelfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contourcarpet.contours.labelfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/labelfont/_family.py b/plotly/validators/contourcarpet/contours/labelfont/_family.py new file mode 100644 index 0000000000..c72927f131 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/labelfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contourcarpet.contours.labelfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contourcarpet/contours/labelfont/_size.py b/plotly/validators/contourcarpet/contours/labelfont/_size.py new file mode 100644 index 0000000000..6203f56078 --- /dev/null +++ b/plotly/validators/contourcarpet/contours/labelfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contourcarpet.contours.labelfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/__init__.py b/plotly/validators/contourcarpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/contourcarpet/hoverlabel/_bgcolor.py b/plotly/validators/contourcarpet/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..9663d07186 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_bgcolorsrc.py b/plotly/validators/contourcarpet/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..4eb8ed653e --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_bordercolor.py b/plotly/validators/contourcarpet/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..c6c72059cc --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_bordercolorsrc.py b/plotly/validators/contourcarpet/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..e974502dee --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_font.py b/plotly/validators/contourcarpet/hoverlabel/_font.py new file mode 100644 index 0000000000..67d9a3124f --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_namelength.py b/plotly/validators/contourcarpet/hoverlabel/_namelength.py new file mode 100644 index 0000000000..ed002bacdb --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/_namelengthsrc.py b/plotly/validators/contourcarpet/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..fbe431757c --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='contourcarpet.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/__init__.py b/plotly/validators/contourcarpet/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_color.py b/plotly/validators/contourcarpet/hoverlabel/font/_color.py new file mode 100644 index 0000000000..498ca9f8dd --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_colorsrc.py b/plotly/validators/contourcarpet/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..5f587f8859 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_family.py b/plotly/validators/contourcarpet/hoverlabel/font/_family.py new file mode 100644 index 0000000000..d1d70e5725 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_familysrc.py b/plotly/validators/contourcarpet/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..b18739d194 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_size.py b/plotly/validators/contourcarpet/hoverlabel/font/_size.py new file mode 100644 index 0000000000..fa08c08fbd --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/hoverlabel/font/_sizesrc.py b/plotly/validators/contourcarpet/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..b65fc45538 --- /dev/null +++ b/plotly/validators/contourcarpet/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='contourcarpet.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/line/__init__.py b/plotly/validators/contourcarpet/line/__init__.py new file mode 100644 index 0000000000..185c3b5d84 --- /dev/null +++ b/plotly/validators/contourcarpet/line/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/contourcarpet/line/_color.py b/plotly/validators/contourcarpet/line/_color.py new file mode 100644 index 0000000000..a6db96dade --- /dev/null +++ b/plotly/validators/contourcarpet/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='contourcarpet.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/line/_dash.py b/plotly/validators/contourcarpet/line/_dash.py new file mode 100644 index 0000000000..c7b0dd2306 --- /dev/null +++ b/plotly/validators/contourcarpet/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='contourcarpet.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/contourcarpet/line/_smoothing.py b/plotly/validators/contourcarpet/line/_smoothing.py new file mode 100644 index 0000000000..86b11e797f --- /dev/null +++ b/plotly/validators/contourcarpet/line/_smoothing.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='smoothing', + parent_name='contourcarpet.line', + **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/line/_width.py b/plotly/validators/contourcarpet/line/_width.py new file mode 100644 index 0000000000..7b6c5b2d8b --- /dev/null +++ b/plotly/validators/contourcarpet/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='contourcarpet.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/stream/__init__.py b/plotly/validators/contourcarpet/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/contourcarpet/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/contourcarpet/stream/_maxpoints.py b/plotly/validators/contourcarpet/stream/_maxpoints.py new file mode 100644 index 0000000000..ca4e78a5f1 --- /dev/null +++ b/plotly/validators/contourcarpet/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='contourcarpet.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/contourcarpet/stream/_token.py b/plotly/validators/contourcarpet/stream/_token.py new file mode 100644 index 0000000000..3f83206d61 --- /dev/null +++ b/plotly/validators/contourcarpet/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='contourcarpet.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/frame/__init__.py b/plotly/validators/frame/__init__.py new file mode 100644 index 0000000000..3568b63191 --- /dev/null +++ b/plotly/validators/frame/__init__.py @@ -0,0 +1,6 @@ +from ._traces import TracesValidator +from ._name import NameValidator +from ._layout import LayoutValidator +from ._group import GroupValidator +from ._data import DataValidator +from ._baseframe import BaseframeValidator diff --git a/plotly/validators/frame/_baseframe.py b/plotly/validators/frame/_baseframe.py new file mode 100644 index 0000000000..568d8f553a --- /dev/null +++ b/plotly/validators/frame/_baseframe.py @@ -0,0 +1,12 @@ +import _plotly_utils.basevalidators + + +class BaseframeValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='baseframe', parent_name='frame', **kwargs): + super(BaseframeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='info', + **kwargs + ) diff --git a/plotly/validators/frame/_data.py b/plotly/validators/frame/_data.py new file mode 100644 index 0000000000..b7df87c2a0 --- /dev/null +++ b/plotly/validators/frame/_data.py @@ -0,0 +1,12 @@ +import plotly.validators + + +class DataValidator(plotly.validators.DataValidator): + + def __init__(self, plotly_name='data', parent_name='frame', **kwargs): + super(DataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='object', + **kwargs + ) diff --git a/plotly/validators/frame/_group.py b/plotly/validators/frame/_group.py new file mode 100644 index 0000000000..d6cde6b843 --- /dev/null +++ b/plotly/validators/frame/_group.py @@ -0,0 +1,12 @@ +import _plotly_utils.basevalidators + + +class GroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='group', parent_name='frame', **kwargs): + super(GroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='info', + **kwargs + ) diff --git a/plotly/validators/frame/_layout.py b/plotly/validators/frame/_layout.py new file mode 100644 index 0000000000..114362e048 --- /dev/null +++ b/plotly/validators/frame/_layout.py @@ -0,0 +1,12 @@ +import plotly.validators + + +class LayoutValidator(plotly.validators.LayoutValidator): + + def __init__(self, plotly_name='layout', parent_name='frame', **kwargs): + super(LayoutValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='object', + **kwargs + ) diff --git a/plotly/validators/frame/_name.py b/plotly/validators/frame/_name.py new file mode 100644 index 0000000000..3a6ea8f0d4 --- /dev/null +++ b/plotly/validators/frame/_name.py @@ -0,0 +1,12 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='frame', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='info', + **kwargs + ) diff --git a/plotly/validators/frame/_traces.py b/plotly/validators/frame/_traces.py new file mode 100644 index 0000000000..c6bb37bbdf --- /dev/null +++ b/plotly/validators/frame/_traces.py @@ -0,0 +1,12 @@ +import _plotly_utils.basevalidators + + +class TracesValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='traces', parent_name='frame', **kwargs): + super(TracesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/__init__.py b/plotly/validators/heatmap/__init__.py new file mode 100644 index 0000000000..35c8190059 --- /dev/null +++ b/plotly/validators/heatmap/__init__.py @@ -0,0 +1,47 @@ +from ._zsrc import ZsrcValidator +from ._zsmooth import ZsmoothValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zhoverformat import ZhoverformatValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._ytype import YtypeValidator +from ._ysrc import YsrcValidator +from ._ygap import YgapValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xtype import XtypeValidator +from ._xsrc import XsrcValidator +from ._xgap import XgapValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._transpose import TransposeValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/heatmap/_autocolorscale.py b/plotly/validators/heatmap/_autocolorscale.py new file mode 100644 index 0000000000..eeb8525f5f --- /dev/null +++ b/plotly/validators/heatmap/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='heatmap', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_colorbar.py b/plotly/validators/heatmap/_colorbar.py new file mode 100644 index 0000000000..6e2e19b254 --- /dev/null +++ b/plotly/validators/heatmap/_colorbar.py @@ -0,0 +1,209 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='heatmap', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmap.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/heatmap/_colorscale.py b/plotly/validators/heatmap/_colorscale.py new file mode 100644 index 0000000000..3a5698c7c2 --- /dev/null +++ b/plotly/validators/heatmap/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='heatmap', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_connectgaps.py b/plotly/validators/heatmap/_connectgaps.py new file mode 100644 index 0000000000..b20317cc23 --- /dev/null +++ b/plotly/validators/heatmap/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='heatmap', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_customdata.py b/plotly/validators/heatmap/_customdata.py new file mode 100644 index 0000000000..d2d73d1461 --- /dev/null +++ b/plotly/validators/heatmap/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='heatmap', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_customdatasrc.py b/plotly/validators/heatmap/_customdatasrc.py new file mode 100644 index 0000000000..9d96d44bd0 --- /dev/null +++ b/plotly/validators/heatmap/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='heatmap', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_dx.py b/plotly/validators/heatmap/_dx.py new file mode 100644 index 0000000000..aa61fe2809 --- /dev/null +++ b/plotly/validators/heatmap/_dx.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='heatmap', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_dy.py b/plotly/validators/heatmap/_dy.py new file mode 100644 index 0000000000..cbb9456c12 --- /dev/null +++ b/plotly/validators/heatmap/_dy.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='heatmap', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_hoverinfo.py b/plotly/validators/heatmap/_hoverinfo.py new file mode 100644 index 0000000000..48ee17a591 --- /dev/null +++ b/plotly/validators/heatmap/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='heatmap', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_hoverinfosrc.py b/plotly/validators/heatmap/_hoverinfosrc.py new file mode 100644 index 0000000000..ec2926538d --- /dev/null +++ b/plotly/validators/heatmap/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='heatmap', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_hoverlabel.py b/plotly/validators/heatmap/_hoverlabel.py new file mode 100644 index 0000000000..3f5e895f40 --- /dev/null +++ b/plotly/validators/heatmap/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='heatmap', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/heatmap/_ids.py b/plotly/validators/heatmap/_ids.py new file mode 100644 index 0000000000..5a7ad01eeb --- /dev/null +++ b/plotly/validators/heatmap/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='heatmap', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_idssrc.py b/plotly/validators/heatmap/_idssrc.py new file mode 100644 index 0000000000..0679807d9e --- /dev/null +++ b/plotly/validators/heatmap/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='heatmap', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_legendgroup.py b/plotly/validators/heatmap/_legendgroup.py new file mode 100644 index 0000000000..bf20c90dd1 --- /dev/null +++ b/plotly/validators/heatmap/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='heatmap', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_name.py b/plotly/validators/heatmap/_name.py new file mode 100644 index 0000000000..9fe464959f --- /dev/null +++ b/plotly/validators/heatmap/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='heatmap', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_opacity.py b/plotly/validators/heatmap/_opacity.py new file mode 100644 index 0000000000..19cbed91d3 --- /dev/null +++ b/plotly/validators/heatmap/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='heatmap', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_reversescale.py b/plotly/validators/heatmap/_reversescale.py new file mode 100644 index 0000000000..6bb521c6dd --- /dev/null +++ b/plotly/validators/heatmap/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='heatmap', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_selectedpoints.py b/plotly/validators/heatmap/_selectedpoints.py new file mode 100644 index 0000000000..868567bb71 --- /dev/null +++ b/plotly/validators/heatmap/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='heatmap', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_showlegend.py b/plotly/validators/heatmap/_showlegend.py new file mode 100644 index 0000000000..c17c6040d2 --- /dev/null +++ b/plotly/validators/heatmap/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='heatmap', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_showscale.py b/plotly/validators/heatmap/_showscale.py new file mode 100644 index 0000000000..6231428718 --- /dev/null +++ b/plotly/validators/heatmap/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='heatmap', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_stream.py b/plotly/validators/heatmap/_stream.py new file mode 100644 index 0000000000..9d0f497f63 --- /dev/null +++ b/plotly/validators/heatmap/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='heatmap', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/heatmap/_text.py b/plotly/validators/heatmap/_text.py new file mode 100644 index 0000000000..5d3df6b42d --- /dev/null +++ b/plotly/validators/heatmap/_text.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='text', parent_name='heatmap', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_textsrc.py b/plotly/validators/heatmap/_textsrc.py new file mode 100644 index 0000000000..a8714262b0 --- /dev/null +++ b/plotly/validators/heatmap/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='heatmap', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_transpose.py b/plotly/validators/heatmap/_transpose.py new file mode 100644 index 0000000000..d32d8aa7b7 --- /dev/null +++ b/plotly/validators/heatmap/_transpose.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TransposeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='transpose', parent_name='heatmap', **kwargs + ): + super(TransposeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_uid.py b/plotly/validators/heatmap/_uid.py new file mode 100644 index 0000000000..3ccd54d7d3 --- /dev/null +++ b/plotly/validators/heatmap/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='heatmap', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_visible.py b/plotly/validators/heatmap/_visible.py new file mode 100644 index 0000000000..f0b0d22e79 --- /dev/null +++ b/plotly/validators/heatmap/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='heatmap', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/heatmap/_x.py b/plotly/validators/heatmap/_x.py new file mode 100644 index 0000000000..afb147e317 --- /dev/null +++ b/plotly/validators/heatmap/_x.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='heatmap', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_x0.py b/plotly/validators/heatmap/_x0.py new file mode 100644 index 0000000000..7a98e47e8d --- /dev/null +++ b/plotly/validators/heatmap/_x0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='heatmap', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_xaxis.py b/plotly/validators/heatmap/_xaxis.py new file mode 100644 index 0000000000..9c85fe945b --- /dev/null +++ b/plotly/validators/heatmap/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='heatmap', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_xcalendar.py b/plotly/validators/heatmap/_xcalendar.py new file mode 100644 index 0000000000..47a0136874 --- /dev/null +++ b/plotly/validators/heatmap/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='heatmap', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/heatmap/_xgap.py b/plotly/validators/heatmap/_xgap.py new file mode 100644 index 0000000000..b739043827 --- /dev/null +++ b/plotly/validators/heatmap/_xgap.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='xgap', parent_name='heatmap', **kwargs): + super(XgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_xsrc.py b/plotly/validators/heatmap/_xsrc.py new file mode 100644 index 0000000000..b7d5ca6953 --- /dev/null +++ b/plotly/validators/heatmap/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='heatmap', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_xtype.py b/plotly/validators/heatmap/_xtype.py new file mode 100644 index 0000000000..8a308e9e79 --- /dev/null +++ b/plotly/validators/heatmap/_xtype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xtype', parent_name='heatmap', **kwargs): + super(XtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/heatmap/_y.py b/plotly/validators/heatmap/_y.py new file mode 100644 index 0000000000..0e84e0a699 --- /dev/null +++ b/plotly/validators/heatmap/_y.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='heatmap', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_y0.py b/plotly/validators/heatmap/_y0.py new file mode 100644 index 0000000000..8bae24f085 --- /dev/null +++ b/plotly/validators/heatmap/_y0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='heatmap', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_yaxis.py b/plotly/validators/heatmap/_yaxis.py new file mode 100644 index 0000000000..66d2111433 --- /dev/null +++ b/plotly/validators/heatmap/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='heatmap', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_ycalendar.py b/plotly/validators/heatmap/_ycalendar.py new file mode 100644 index 0000000000..f0d31f0c97 --- /dev/null +++ b/plotly/validators/heatmap/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='heatmap', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/heatmap/_ygap.py b/plotly/validators/heatmap/_ygap.py new file mode 100644 index 0000000000..69a615b205 --- /dev/null +++ b/plotly/validators/heatmap/_ygap.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='ygap', parent_name='heatmap', **kwargs): + super(YgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_ysrc.py b/plotly/validators/heatmap/_ysrc.py new file mode 100644 index 0000000000..c4708d2c6f --- /dev/null +++ b/plotly/validators/heatmap/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='heatmap', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_ytype.py b/plotly/validators/heatmap/_ytype.py new file mode 100644 index 0000000000..8bbfc64707 --- /dev/null +++ b/plotly/validators/heatmap/_ytype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='ytype', parent_name='heatmap', **kwargs): + super(YtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/heatmap/_z.py b/plotly/validators/heatmap/_z.py new file mode 100644 index 0000000000..e8cfdb06cb --- /dev/null +++ b/plotly/validators/heatmap/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='heatmap', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/_zauto.py b/plotly/validators/heatmap/_zauto.py new file mode 100644 index 0000000000..7af1e2b9dd --- /dev/null +++ b/plotly/validators/heatmap/_zauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='zauto', parent_name='heatmap', **kwargs): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_zhoverformat.py b/plotly/validators/heatmap/_zhoverformat.py new file mode 100644 index 0000000000..d515b7c86b --- /dev/null +++ b/plotly/validators/heatmap/_zhoverformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZhoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='zhoverformat', parent_name='heatmap', **kwargs + ): + super(ZhoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/_zmax.py b/plotly/validators/heatmap/_zmax.py new file mode 100644 index 0000000000..80f1f43973 --- /dev/null +++ b/plotly/validators/heatmap/_zmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmax', parent_name='heatmap', **kwargs): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_zmin.py b/plotly/validators/heatmap/_zmin.py new file mode 100644 index 0000000000..4e539c6d37 --- /dev/null +++ b/plotly/validators/heatmap/_zmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmin', parent_name='heatmap', **kwargs): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/_zsmooth.py b/plotly/validators/heatmap/_zsmooth.py new file mode 100644 index 0000000000..16258a459a --- /dev/null +++ b/plotly/validators/heatmap/_zsmooth.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZsmoothValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='zsmooth', parent_name='heatmap', **kwargs): + super(ZsmoothValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fast', 'best', False], + **kwargs + ) diff --git a/plotly/validators/heatmap/_zsrc.py b/plotly/validators/heatmap/_zsrc.py new file mode 100644 index 0000000000..7e4dfe8bf1 --- /dev/null +++ b/plotly/validators/heatmap/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='heatmap', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/__init__.py b/plotly/validators/heatmap/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/heatmap/colorbar/_bgcolor.py b/plotly/validators/heatmap/colorbar/_bgcolor.py new file mode 100644 index 0000000000..7e7e04ca1d --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='heatmap.colorbar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_bordercolor.py b/plotly/validators/heatmap/colorbar/_bordercolor.py new file mode 100644 index 0000000000..218ec70578 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='heatmap.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_borderwidth.py b/plotly/validators/heatmap/colorbar/_borderwidth.py new file mode 100644 index 0000000000..a0fd49d425 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='heatmap.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_dtick.py b/plotly/validators/heatmap/colorbar/_dtick.py new file mode 100644 index 0000000000..46f346e25d --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='heatmap.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_exponentformat.py b/plotly/validators/heatmap/colorbar/_exponentformat.py new file mode 100644 index 0000000000..d0e1534bc7 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_len.py b/plotly/validators/heatmap/colorbar/_len.py new file mode 100644 index 0000000000..750e67324e --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='heatmap.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_lenmode.py b/plotly/validators/heatmap/colorbar/_lenmode.py new file mode 100644 index 0000000000..e49e9eba88 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='heatmap.colorbar', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_nticks.py b/plotly/validators/heatmap/colorbar/_nticks.py new file mode 100644 index 0000000000..526cc0a333 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='heatmap.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_outlinecolor.py b/plotly/validators/heatmap/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..e6eb3a185a --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='heatmap.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_outlinewidth.py b/plotly/validators/heatmap/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..68771503bf --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='heatmap.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_separatethousands.py b/plotly/validators/heatmap/colorbar/_separatethousands.py new file mode 100644 index 0000000000..a00edad756 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='heatmap.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_showexponent.py b/plotly/validators/heatmap/colorbar/_showexponent.py new file mode 100644 index 0000000000..7f46e4361f --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_showticklabels.py b/plotly/validators/heatmap/colorbar/_showticklabels.py new file mode 100644 index 0000000000..b978be9103 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_showtickprefix.py b/plotly/validators/heatmap/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..90d0b44529 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_showticksuffix.py b/plotly/validators/heatmap/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..65daca0470 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_thickness.py b/plotly/validators/heatmap/colorbar/_thickness.py new file mode 100644 index 0000000000..af54f9fa96 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_thicknessmode.py b/plotly/validators/heatmap/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..e52b29bd31 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='heatmap.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tick0.py b/plotly/validators/heatmap/colorbar/_tick0.py new file mode 100644 index 0000000000..a6737076c5 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='heatmap.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickangle.py b/plotly/validators/heatmap/colorbar/_tickangle.py new file mode 100644 index 0000000000..8575acb85f --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickcolor.py b/plotly/validators/heatmap/colorbar/_tickcolor.py new file mode 100644 index 0000000000..5df1535c35 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickfont.py b/plotly/validators/heatmap/colorbar/_tickfont.py new file mode 100644 index 0000000000..cc07b55496 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='heatmap.colorbar', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickformat.py b/plotly/validators/heatmap/colorbar/_tickformat.py new file mode 100644 index 0000000000..606819a5a1 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickformatstops.py b/plotly/validators/heatmap/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..4a4db9bce0 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ticklen.py b/plotly/validators/heatmap/colorbar/_ticklen.py new file mode 100644 index 0000000000..5e620c3b4d --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='heatmap.colorbar', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickmode.py b/plotly/validators/heatmap/colorbar/_tickmode.py new file mode 100644 index 0000000000..33b6813735 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='heatmap.colorbar', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickprefix.py b/plotly/validators/heatmap/colorbar/_tickprefix.py new file mode 100644 index 0000000000..8f58811994 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ticks.py b/plotly/validators/heatmap/colorbar/_ticks.py new file mode 100644 index 0000000000..9b07e7903f --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='heatmap.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ticksuffix.py b/plotly/validators/heatmap/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..5cd29ae7c3 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ticktext.py b/plotly/validators/heatmap/colorbar/_ticktext.py new file mode 100644 index 0000000000..88f1eb4fe0 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='heatmap.colorbar', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ticktextsrc.py b/plotly/validators/heatmap/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..e37e072233 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickvals.py b/plotly/validators/heatmap/colorbar/_tickvals.py new file mode 100644 index 0000000000..593861a512 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='heatmap.colorbar', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickvalssrc.py b/plotly/validators/heatmap/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..3840bd9ab8 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_tickwidth.py b/plotly/validators/heatmap/colorbar/_tickwidth.py new file mode 100644 index 0000000000..c927441d14 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_title.py b/plotly/validators/heatmap/colorbar/_title.py new file mode 100644 index 0000000000..b770fbeeb2 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='heatmap.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_titlefont.py b/plotly/validators/heatmap/colorbar/_titlefont.py new file mode 100644 index 0000000000..ea7b81af54 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_titleside.py b/plotly/validators/heatmap/colorbar/_titleside.py new file mode 100644 index 0000000000..94e3fbf49a --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='heatmap.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_x.py b/plotly/validators/heatmap/colorbar/_x.py new file mode 100644 index 0000000000..c9232049f0 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='heatmap.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_xanchor.py b/plotly/validators/heatmap/colorbar/_xanchor.py new file mode 100644 index 0000000000..a69f6fe1eb --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='heatmap.colorbar', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_xpad.py b/plotly/validators/heatmap/colorbar/_xpad.py new file mode 100644 index 0000000000..ff614c51d9 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='heatmap.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_y.py b/plotly/validators/heatmap/colorbar/_y.py new file mode 100644 index 0000000000..c512c70729 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='heatmap.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_yanchor.py b/plotly/validators/heatmap/colorbar/_yanchor.py new file mode 100644 index 0000000000..1046bce982 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='heatmap.colorbar', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/_ypad.py b/plotly/validators/heatmap/colorbar/_ypad.py new file mode 100644 index 0000000000..8bc38e7918 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='heatmap.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/tickfont/__init__.py b/plotly/validators/heatmap/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmap/colorbar/tickfont/_color.py b/plotly/validators/heatmap/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..766b89edf9 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmap.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/tickfont/_family.py b/plotly/validators/heatmap/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..e250589c90 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmap.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/tickfont/_size.py b/plotly/validators/heatmap/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..4181dd849e --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmap.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/tickformatstop/__init__.py b/plotly/validators/heatmap/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/heatmap/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/heatmap/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..8e9668e21c --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='heatmap.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/tickformatstop/_value.py b/plotly/validators/heatmap/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..4830a6be58 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='heatmap.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/titlefont/__init__.py b/plotly/validators/heatmap/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/heatmap/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmap/colorbar/titlefont/_color.py b/plotly/validators/heatmap/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..926d921697 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmap.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/titlefont/_family.py b/plotly/validators/heatmap/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..b061248b31 --- /dev/null +++ b/plotly/validators/heatmap/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmap.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmap/colorbar/titlefont/_size.py b/plotly/validators/heatmap/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..5ee5311acd --- /dev/null +++ b/plotly/validators/heatmap/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmap.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/__init__.py b/plotly/validators/heatmap/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/heatmap/hoverlabel/_bgcolor.py b/plotly/validators/heatmap/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..d90596b6f9 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_bgcolorsrc.py b/plotly/validators/heatmap/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..318eeff63e --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_bordercolor.py b/plotly/validators/heatmap/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..81c4a4cb18 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_bordercolorsrc.py b/plotly/validators/heatmap/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..6b48d5dfe0 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_font.py b/plotly/validators/heatmap/hoverlabel/_font.py new file mode 100644 index 0000000000..697d14b5a2 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='heatmap.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_namelength.py b/plotly/validators/heatmap/hoverlabel/_namelength.py new file mode 100644 index 0000000000..5bdb8b785c --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/_namelengthsrc.py b/plotly/validators/heatmap/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..9ae670f890 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='heatmap.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/__init__.py b/plotly/validators/heatmap/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmap/hoverlabel/font/_color.py b/plotly/validators/heatmap/hoverlabel/font/_color.py new file mode 100644 index 0000000000..756c9d6452 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/_colorsrc.py b/plotly/validators/heatmap/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..61e4df785c --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/_family.py b/plotly/validators/heatmap/hoverlabel/font/_family.py new file mode 100644 index 0000000000..7c23bb8a77 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/_familysrc.py b/plotly/validators/heatmap/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..a750a08eb4 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/_size.py b/plotly/validators/heatmap/hoverlabel/font/_size.py new file mode 100644 index 0000000000..9efab6e2b8 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmap/hoverlabel/font/_sizesrc.py b/plotly/validators/heatmap/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..602b465738 --- /dev/null +++ b/plotly/validators/heatmap/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='heatmap.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/stream/__init__.py b/plotly/validators/heatmap/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/heatmap/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/heatmap/stream/_maxpoints.py b/plotly/validators/heatmap/stream/_maxpoints.py new file mode 100644 index 0000000000..b180c104aa --- /dev/null +++ b/plotly/validators/heatmap/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='heatmap.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmap/stream/_token.py b/plotly/validators/heatmap/stream/_token.py new file mode 100644 index 0000000000..a991133b55 --- /dev/null +++ b/plotly/validators/heatmap/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='heatmap.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmapgl/__init__.py b/plotly/validators/heatmapgl/__init__.py new file mode 100644 index 0000000000..5afb19f13e --- /dev/null +++ b/plotly/validators/heatmapgl/__init__.py @@ -0,0 +1,40 @@ +from ._zsrc import ZsrcValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._ytype import YtypeValidator +from ._ysrc import YsrcValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xtype import XtypeValidator +from ._xsrc import XsrcValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._transpose import TransposeValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/heatmapgl/_autocolorscale.py b/plotly/validators/heatmapgl/_autocolorscale.py new file mode 100644 index 0000000000..cf8c611e1b --- /dev/null +++ b/plotly/validators/heatmapgl/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='heatmapgl', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_colorbar.py b/plotly/validators/heatmapgl/_colorbar.py new file mode 100644 index 0000000000..2760e906bc --- /dev/null +++ b/plotly/validators/heatmapgl/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='heatmapgl', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.heatmapgl.colorbar.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_colorscale.py b/plotly/validators/heatmapgl/_colorscale.py new file mode 100644 index 0000000000..5f22d4d011 --- /dev/null +++ b/plotly/validators/heatmapgl/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='heatmapgl', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_customdata.py b/plotly/validators/heatmapgl/_customdata.py new file mode 100644 index 0000000000..0ec94590a8 --- /dev/null +++ b/plotly/validators/heatmapgl/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='heatmapgl', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_customdatasrc.py b/plotly/validators/heatmapgl/_customdatasrc.py new file mode 100644 index 0000000000..530e5eaff8 --- /dev/null +++ b/plotly/validators/heatmapgl/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='heatmapgl', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_dx.py b/plotly/validators/heatmapgl/_dx.py new file mode 100644 index 0000000000..4dc3a79ade --- /dev/null +++ b/plotly/validators/heatmapgl/_dx.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='heatmapgl', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_dy.py b/plotly/validators/heatmapgl/_dy.py new file mode 100644 index 0000000000..b7fb189ce1 --- /dev/null +++ b/plotly/validators/heatmapgl/_dy.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='heatmapgl', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_hoverinfo.py b/plotly/validators/heatmapgl/_hoverinfo.py new file mode 100644 index 0000000000..9bfbc06ad9 --- /dev/null +++ b/plotly/validators/heatmapgl/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='heatmapgl', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_hoverinfosrc.py b/plotly/validators/heatmapgl/_hoverinfosrc.py new file mode 100644 index 0000000000..b1a241795b --- /dev/null +++ b/plotly/validators/heatmapgl/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='heatmapgl', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_hoverlabel.py b/plotly/validators/heatmapgl/_hoverlabel.py new file mode 100644 index 0000000000..7971433afa --- /dev/null +++ b/plotly/validators/heatmapgl/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='heatmapgl', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_ids.py b/plotly/validators/heatmapgl/_ids.py new file mode 100644 index 0000000000..7c77cac148 --- /dev/null +++ b/plotly/validators/heatmapgl/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='heatmapgl', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_idssrc.py b/plotly/validators/heatmapgl/_idssrc.py new file mode 100644 index 0000000000..150b61facd --- /dev/null +++ b/plotly/validators/heatmapgl/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='heatmapgl', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_legendgroup.py b/plotly/validators/heatmapgl/_legendgroup.py new file mode 100644 index 0000000000..38359cf4aa --- /dev/null +++ b/plotly/validators/heatmapgl/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='heatmapgl', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_name.py b/plotly/validators/heatmapgl/_name.py new file mode 100644 index 0000000000..22f5628792 --- /dev/null +++ b/plotly/validators/heatmapgl/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='heatmapgl', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_opacity.py b/plotly/validators/heatmapgl/_opacity.py new file mode 100644 index 0000000000..5ba844fc45 --- /dev/null +++ b/plotly/validators/heatmapgl/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='heatmapgl', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_reversescale.py b/plotly/validators/heatmapgl/_reversescale.py new file mode 100644 index 0000000000..7ba5b88867 --- /dev/null +++ b/plotly/validators/heatmapgl/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='heatmapgl', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_selectedpoints.py b/plotly/validators/heatmapgl/_selectedpoints.py new file mode 100644 index 0000000000..2b825c9a1c --- /dev/null +++ b/plotly/validators/heatmapgl/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='heatmapgl', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_showlegend.py b/plotly/validators/heatmapgl/_showlegend.py new file mode 100644 index 0000000000..5cedd6f406 --- /dev/null +++ b/plotly/validators/heatmapgl/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='heatmapgl', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_showscale.py b/plotly/validators/heatmapgl/_showscale.py new file mode 100644 index 0000000000..38aca07b45 --- /dev/null +++ b/plotly/validators/heatmapgl/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='heatmapgl', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_stream.py b/plotly/validators/heatmapgl/_stream.py new file mode 100644 index 0000000000..ffb26e2302 --- /dev/null +++ b/plotly/validators/heatmapgl/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='heatmapgl', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_text.py b/plotly/validators/heatmapgl/_text.py new file mode 100644 index 0000000000..9a2da2ced4 --- /dev/null +++ b/plotly/validators/heatmapgl/_text.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='text', parent_name='heatmapgl', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_textsrc.py b/plotly/validators/heatmapgl/_textsrc.py new file mode 100644 index 0000000000..8f4bd36509 --- /dev/null +++ b/plotly/validators/heatmapgl/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='heatmapgl', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_transpose.py b/plotly/validators/heatmapgl/_transpose.py new file mode 100644 index 0000000000..10e3559eb8 --- /dev/null +++ b/plotly/validators/heatmapgl/_transpose.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TransposeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='transpose', parent_name='heatmapgl', **kwargs + ): + super(TransposeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_uid.py b/plotly/validators/heatmapgl/_uid.py new file mode 100644 index 0000000000..b1bad8d18d --- /dev/null +++ b/plotly/validators/heatmapgl/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='heatmapgl', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_visible.py b/plotly/validators/heatmapgl/_visible.py new file mode 100644 index 0000000000..f060fec1d3 --- /dev/null +++ b/plotly/validators/heatmapgl/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='heatmapgl', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_x.py b/plotly/validators/heatmapgl/_x.py new file mode 100644 index 0000000000..37233b6f0c --- /dev/null +++ b/plotly/validators/heatmapgl/_x.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='heatmapgl', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_x0.py b/plotly/validators/heatmapgl/_x0.py new file mode 100644 index 0000000000..1781eb56c0 --- /dev/null +++ b/plotly/validators/heatmapgl/_x0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='heatmapgl', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'xtype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_xaxis.py b/plotly/validators/heatmapgl/_xaxis.py new file mode 100644 index 0000000000..b9d28d0660 --- /dev/null +++ b/plotly/validators/heatmapgl/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='heatmapgl', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_xsrc.py b/plotly/validators/heatmapgl/_xsrc.py new file mode 100644 index 0000000000..601903910b --- /dev/null +++ b/plotly/validators/heatmapgl/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='heatmapgl', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_xtype.py b/plotly/validators/heatmapgl/_xtype.py new file mode 100644 index 0000000000..8c2698dd0d --- /dev/null +++ b/plotly/validators/heatmapgl/_xtype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xtype', parent_name='heatmapgl', **kwargs): + super(XtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_y.py b/plotly/validators/heatmapgl/_y.py new file mode 100644 index 0000000000..6a48bed545 --- /dev/null +++ b/plotly/validators/heatmapgl/_y.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='heatmapgl', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'array'}, + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_y0.py b/plotly/validators/heatmapgl/_y0.py new file mode 100644 index 0000000000..4d3aa1040f --- /dev/null +++ b/plotly/validators/heatmapgl/_y0.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='heatmapgl', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'ytype': 'scaled'}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_yaxis.py b/plotly/validators/heatmapgl/_yaxis.py new file mode 100644 index 0000000000..e6a8760669 --- /dev/null +++ b/plotly/validators/heatmapgl/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='heatmapgl', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_ysrc.py b/plotly/validators/heatmapgl/_ysrc.py new file mode 100644 index 0000000000..922fa703c0 --- /dev/null +++ b/plotly/validators/heatmapgl/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='heatmapgl', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_ytype.py b/plotly/validators/heatmapgl/_ytype.py new file mode 100644 index 0000000000..2f10a0cb26 --- /dev/null +++ b/plotly/validators/heatmapgl/_ytype.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YtypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='ytype', parent_name='heatmapgl', **kwargs): + super(YtypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['array', 'scaled'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_z.py b/plotly/validators/heatmapgl/_z.py new file mode 100644 index 0000000000..f93963fb7e --- /dev/null +++ b/plotly/validators/heatmapgl/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='heatmapgl', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_zauto.py b/plotly/validators/heatmapgl/_zauto.py new file mode 100644 index 0000000000..0214989941 --- /dev/null +++ b/plotly/validators/heatmapgl/_zauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='zauto', parent_name='heatmapgl', **kwargs): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_zmax.py b/plotly/validators/heatmapgl/_zmax.py new file mode 100644 index 0000000000..954481a1c1 --- /dev/null +++ b/plotly/validators/heatmapgl/_zmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmax', parent_name='heatmapgl', **kwargs): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_zmin.py b/plotly/validators/heatmapgl/_zmin.py new file mode 100644 index 0000000000..eefdbad3e6 --- /dev/null +++ b/plotly/validators/heatmapgl/_zmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='zmin', parent_name='heatmapgl', **kwargs): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/_zsrc.py b/plotly/validators/heatmapgl/_zsrc.py new file mode 100644 index 0000000000..ccddf17762 --- /dev/null +++ b/plotly/validators/heatmapgl/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='heatmapgl', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/__init__.py b/plotly/validators/heatmapgl/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/heatmapgl/colorbar/_bgcolor.py b/plotly/validators/heatmapgl/colorbar/_bgcolor.py new file mode 100644 index 0000000000..96737cd0bb --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_bordercolor.py b/plotly/validators/heatmapgl/colorbar/_bordercolor.py new file mode 100644 index 0000000000..62692a3bf4 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_borderwidth.py b/plotly/validators/heatmapgl/colorbar/_borderwidth.py new file mode 100644 index 0000000000..840708eae9 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_dtick.py b/plotly/validators/heatmapgl/colorbar/_dtick.py new file mode 100644 index 0000000000..97172ff717 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='heatmapgl.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_exponentformat.py b/plotly/validators/heatmapgl/colorbar/_exponentformat.py new file mode 100644 index 0000000000..52ac3bb05a --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_len.py b/plotly/validators/heatmapgl/colorbar/_len.py new file mode 100644 index 0000000000..5283198083 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='heatmapgl.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_lenmode.py b/plotly/validators/heatmapgl/colorbar/_lenmode.py new file mode 100644 index 0000000000..aa1a5bdd92 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_nticks.py b/plotly/validators/heatmapgl/colorbar/_nticks.py new file mode 100644 index 0000000000..381e625da6 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='heatmapgl.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_outlinecolor.py b/plotly/validators/heatmapgl/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..ef5341223b --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_outlinewidth.py b/plotly/validators/heatmapgl/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..9d5406a9e9 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_separatethousands.py b/plotly/validators/heatmapgl/colorbar/_separatethousands.py new file mode 100644 index 0000000000..cf0dcf8ff9 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_showexponent.py b/plotly/validators/heatmapgl/colorbar/_showexponent.py new file mode 100644 index 0000000000..c53716a67f --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_showticklabels.py b/plotly/validators/heatmapgl/colorbar/_showticklabels.py new file mode 100644 index 0000000000..6707f75036 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_showtickprefix.py b/plotly/validators/heatmapgl/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..55d20b61a4 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_showticksuffix.py b/plotly/validators/heatmapgl/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..a29d718473 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_thickness.py b/plotly/validators/heatmapgl/colorbar/_thickness.py new file mode 100644 index 0000000000..7e8ecabc06 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_thicknessmode.py b/plotly/validators/heatmapgl/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..b2839ae79f --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tick0.py b/plotly/validators/heatmapgl/colorbar/_tick0.py new file mode 100644 index 0000000000..44d55ecd1e --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='heatmapgl.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickangle.py b/plotly/validators/heatmapgl/colorbar/_tickangle.py new file mode 100644 index 0000000000..7aea76ddd0 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickcolor.py b/plotly/validators/heatmapgl/colorbar/_tickcolor.py new file mode 100644 index 0000000000..e9fa4d8ddc --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickfont.py b/plotly/validators/heatmapgl/colorbar/_tickfont.py new file mode 100644 index 0000000000..074b034f11 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickformat.py b/plotly/validators/heatmapgl/colorbar/_tickformat.py new file mode 100644 index 0000000000..6183f33fa5 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickformatstops.py b/plotly/validators/heatmapgl/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..19a350d055 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ticklen.py b/plotly/validators/heatmapgl/colorbar/_ticklen.py new file mode 100644 index 0000000000..e91df806db --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickmode.py b/plotly/validators/heatmapgl/colorbar/_tickmode.py new file mode 100644 index 0000000000..340680c39a --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickprefix.py b/plotly/validators/heatmapgl/colorbar/_tickprefix.py new file mode 100644 index 0000000000..24d2069320 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ticks.py b/plotly/validators/heatmapgl/colorbar/_ticks.py new file mode 100644 index 0000000000..5031ccfedf --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='heatmapgl.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ticksuffix.py b/plotly/validators/heatmapgl/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..155237ffbe --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ticktext.py b/plotly/validators/heatmapgl/colorbar/_ticktext.py new file mode 100644 index 0000000000..06b1018e2a --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ticktextsrc.py b/plotly/validators/heatmapgl/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..0d5ef37a2d --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickvals.py b/plotly/validators/heatmapgl/colorbar/_tickvals.py new file mode 100644 index 0000000000..c3f245faae --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickvalssrc.py b/plotly/validators/heatmapgl/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..1bb4db0861 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_tickwidth.py b/plotly/validators/heatmapgl/colorbar/_tickwidth.py new file mode 100644 index 0000000000..28593a50d5 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_title.py b/plotly/validators/heatmapgl/colorbar/_title.py new file mode 100644 index 0000000000..32444cc983 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='heatmapgl.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_titlefont.py b/plotly/validators/heatmapgl/colorbar/_titlefont.py new file mode 100644 index 0000000000..83654a818c --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_titleside.py b/plotly/validators/heatmapgl/colorbar/_titleside.py new file mode 100644 index 0000000000..02219ec411 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_x.py b/plotly/validators/heatmapgl/colorbar/_x.py new file mode 100644 index 0000000000..292cb1d257 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='heatmapgl.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_xanchor.py b/plotly/validators/heatmapgl/colorbar/_xanchor.py new file mode 100644 index 0000000000..c0cd2f0280 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_xpad.py b/plotly/validators/heatmapgl/colorbar/_xpad.py new file mode 100644 index 0000000000..f6b8dbd537 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='heatmapgl.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_y.py b/plotly/validators/heatmapgl/colorbar/_y.py new file mode 100644 index 0000000000..bdcc2192a4 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='heatmapgl.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_yanchor.py b/plotly/validators/heatmapgl/colorbar/_yanchor.py new file mode 100644 index 0000000000..427feb9cad --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='heatmapgl.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/_ypad.py b/plotly/validators/heatmapgl/colorbar/_ypad.py new file mode 100644 index 0000000000..3c3fad021f --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='heatmapgl.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/tickfont/__init__.py b/plotly/validators/heatmapgl/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmapgl/colorbar/tickfont/_color.py b/plotly/validators/heatmapgl/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..4e2bd16e70 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmapgl.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/tickfont/_family.py b/plotly/validators/heatmapgl/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..ff3c0681f0 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmapgl.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/tickfont/_size.py b/plotly/validators/heatmapgl/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..1286afc65f --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmapgl.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/tickformatstop/__init__.py b/plotly/validators/heatmapgl/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/heatmapgl/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/heatmapgl/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..ebea0fb626 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='heatmapgl.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/tickformatstop/_value.py b/plotly/validators/heatmapgl/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..5005d6f7f3 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='heatmapgl.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/titlefont/__init__.py b/plotly/validators/heatmapgl/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmapgl/colorbar/titlefont/_color.py b/plotly/validators/heatmapgl/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..4bd65828d4 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmapgl.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/titlefont/_family.py b/plotly/validators/heatmapgl/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..8b2c483aa8 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmapgl.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmapgl/colorbar/titlefont/_size.py b/plotly/validators/heatmapgl/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..4121f5cd63 --- /dev/null +++ b/plotly/validators/heatmapgl/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmapgl.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/__init__.py b/plotly/validators/heatmapgl/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/heatmapgl/hoverlabel/_bgcolor.py b/plotly/validators/heatmapgl/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..17b45015fc --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_bgcolorsrc.py b/plotly/validators/heatmapgl/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..87183fa5f0 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_bordercolor.py b/plotly/validators/heatmapgl/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..8b23a3d65d --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_bordercolorsrc.py b/plotly/validators/heatmapgl/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..ddb13d91fc --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_font.py b/plotly/validators/heatmapgl/hoverlabel/_font.py new file mode 100644 index 0000000000..39bc5ba770 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='heatmapgl.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_namelength.py b/plotly/validators/heatmapgl/hoverlabel/_namelength.py new file mode 100644 index 0000000000..5432e33436 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/_namelengthsrc.py b/plotly/validators/heatmapgl/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..ccc9ced44c --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='heatmapgl.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/__init__.py b/plotly/validators/heatmapgl/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_color.py b/plotly/validators/heatmapgl/hoverlabel/font/_color.py new file mode 100644 index 0000000000..84f4f6d670 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_colorsrc.py b/plotly/validators/heatmapgl/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..ae8a3d648c --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_family.py b/plotly/validators/heatmapgl/hoverlabel/font/_family.py new file mode 100644 index 0000000000..04878cf799 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_familysrc.py b/plotly/validators/heatmapgl/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..a721f3e6f4 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_size.py b/plotly/validators/heatmapgl/hoverlabel/font/_size.py new file mode 100644 index 0000000000..75db2ae275 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/hoverlabel/font/_sizesrc.py b/plotly/validators/heatmapgl/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..28fb945d68 --- /dev/null +++ b/plotly/validators/heatmapgl/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='heatmapgl.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/stream/__init__.py b/plotly/validators/heatmapgl/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/heatmapgl/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/heatmapgl/stream/_maxpoints.py b/plotly/validators/heatmapgl/stream/_maxpoints.py new file mode 100644 index 0000000000..42c666184b --- /dev/null +++ b/plotly/validators/heatmapgl/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='heatmapgl.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/heatmapgl/stream/_token.py b/plotly/validators/heatmapgl/stream/_token.py new file mode 100644 index 0000000000..025f6c666c --- /dev/null +++ b/plotly/validators/heatmapgl/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='heatmapgl.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram/__init__.py b/plotly/validators/histogram/__init__.py new file mode 100644 index 0000000000..1d94f5adef --- /dev/null +++ b/plotly/validators/histogram/__init__.py @@ -0,0 +1,40 @@ +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._ybins import YBinsValidator +from ._yaxis import YAxisValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xbins import XBinsValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._orientation import OrientationValidator +from ._opacity import OpacityValidator +from ._nbinsy import NbinsyValidator +from ._nbinsx import NbinsxValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._histnorm import HistnormValidator +from ._histfunc import HistfuncValidator +from ._error_y import ErrorYValidator +from ._error_x import ErrorXValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._cumulative import CumulativeValidator +from ._autobiny import AutobinyValidator +from ._autobinx import AutobinxValidator diff --git a/plotly/validators/histogram/_autobinx.py b/plotly/validators/histogram/_autobinx.py new file mode 100644 index 0000000000..c4c6552daf --- /dev/null +++ b/plotly/validators/histogram/_autobinx.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutobinxValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autobinx', parent_name='histogram', **kwargs + ): + super(AutobinxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/_autobiny.py b/plotly/validators/histogram/_autobiny.py new file mode 100644 index 0000000000..415f81cfe9 --- /dev/null +++ b/plotly/validators/histogram/_autobiny.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutobinyValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autobiny', parent_name='histogram', **kwargs + ): + super(AutobinyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/_cumulative.py b/plotly/validators/histogram/_cumulative.py new file mode 100644 index 0000000000..58c5f4ce7a --- /dev/null +++ b/plotly/validators/histogram/_cumulative.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class CumulativeValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='cumulative', parent_name='histogram', **kwargs + ): + super(CumulativeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Cumulative', + data_docs=""" + currentbin + Only applies if cumulative is enabled. Sets + whether the current bin is included, excluded, + or has half of its value included in the + current cumulative value. *include* is the + default for compatibility with various other + tools, however it introduces a half-bin bias to + the results. *exclude* makes the opposite half- + bin bias, and *half* removes it. + direction + Only applies if cumulative is enabled. If + *increasing* (default) we sum all prior bins, + so the result increases from left to right. If + *decreasing* we sum later bins so the result + decreases from left to right. + enabled + If true, display the cumulative distribution by + summing the binned values. Use the `direction` + and `centralbin` attributes to tune the + accumulation method. Note: in this mode, the + *density* `histnorm` settings behave the same + as their equivalents without *density*: ** and + *density* both rise to the number of data + points, and *probability* and *probability + density* both rise to the number of sample + points.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_customdata.py b/plotly/validators/histogram/_customdata.py new file mode 100644 index 0000000000..b4da088400 --- /dev/null +++ b/plotly/validators/histogram/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='histogram', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/_customdatasrc.py b/plotly/validators/histogram/_customdatasrc.py new file mode 100644 index 0000000000..7da6f8e491 --- /dev/null +++ b/plotly/validators/histogram/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='histogram', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_error_x.py b/plotly/validators/histogram/_error_x.py new file mode 100644 index 0000000000..012b75cd8e --- /dev/null +++ b/plotly/validators/histogram/_error_x.py @@ -0,0 +1,72 @@ +import _plotly_utils.basevalidators + + +class ErrorXValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_x', parent_name='histogram', **kwargs + ): + super(ErrorXValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorX', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_error_y.py b/plotly/validators/histogram/_error_y.py new file mode 100644 index 0000000000..f3d3a175c8 --- /dev/null +++ b/plotly/validators/histogram/_error_y.py @@ -0,0 +1,70 @@ +import _plotly_utils.basevalidators + + +class ErrorYValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_y', parent_name='histogram', **kwargs + ): + super(ErrorYValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorY', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_histfunc.py b/plotly/validators/histogram/_histfunc.py new file mode 100644 index 0000000000..88edebaa7c --- /dev/null +++ b/plotly/validators/histogram/_histfunc.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HistfuncValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='histfunc', parent_name='histogram', **kwargs + ): + super(HistfuncValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['count', 'sum', 'avg', 'min', 'max'], + **kwargs + ) diff --git a/plotly/validators/histogram/_histnorm.py b/plotly/validators/histogram/_histnorm.py new file mode 100644 index 0000000000..ab3f2999dc --- /dev/null +++ b/plotly/validators/histogram/_histnorm.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HistnormValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='histnorm', parent_name='histogram', **kwargs + ): + super(HistnormValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + '', 'percent', 'probability', 'density', 'probability density' + ], + **kwargs + ) diff --git a/plotly/validators/histogram/_hoverinfo.py b/plotly/validators/histogram/_hoverinfo.py new file mode 100644 index 0000000000..eb0b3adfd2 --- /dev/null +++ b/plotly/validators/histogram/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='histogram', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_hoverinfosrc.py b/plotly/validators/histogram/_hoverinfosrc.py new file mode 100644 index 0000000000..2fd8be468f --- /dev/null +++ b/plotly/validators/histogram/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='histogram', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_hoverlabel.py b/plotly/validators/histogram/_hoverlabel.py new file mode 100644 index 0000000000..fec6e3c280 --- /dev/null +++ b/plotly/validators/histogram/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='histogram', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/histogram/_ids.py b/plotly/validators/histogram/_ids.py new file mode 100644 index 0000000000..09745b32c6 --- /dev/null +++ b/plotly/validators/histogram/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='histogram', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/_idssrc.py b/plotly/validators/histogram/_idssrc.py new file mode 100644 index 0000000000..dc75f9af72 --- /dev/null +++ b/plotly/validators/histogram/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='histogram', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_legendgroup.py b/plotly/validators/histogram/_legendgroup.py new file mode 100644 index 0000000000..031f934de5 --- /dev/null +++ b/plotly/validators/histogram/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='histogram', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_marker.py b/plotly/validators/histogram/_marker.py new file mode 100644 index 0000000000..7e14e26e5c --- /dev/null +++ b/plotly/validators/histogram/_marker.py @@ -0,0 +1,92 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='histogram', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.histogram.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.histogram.marker.Line + instance or dict with compatible properties + opacity + Sets the opacity of the bars. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_name.py b/plotly/validators/histogram/_name.py new file mode 100644 index 0000000000..84288f9e2f --- /dev/null +++ b/plotly/validators/histogram/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='histogram', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_nbinsx.py b/plotly/validators/histogram/_nbinsx.py new file mode 100644 index 0000000000..0750b2ad21 --- /dev/null +++ b/plotly/validators/histogram/_nbinsx.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsxValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsx', parent_name='histogram', **kwargs + ): + super(NbinsxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/_nbinsy.py b/plotly/validators/histogram/_nbinsy.py new file mode 100644 index 0000000000..0ea60df31c --- /dev/null +++ b/plotly/validators/histogram/_nbinsy.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsyValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsy', parent_name='histogram', **kwargs + ): + super(NbinsyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/_opacity.py b/plotly/validators/histogram/_opacity.py new file mode 100644 index 0000000000..eea056aef6 --- /dev/null +++ b/plotly/validators/histogram/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='histogram', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/_orientation.py b/plotly/validators/histogram/_orientation.py new file mode 100644 index 0000000000..f2d9f6fd12 --- /dev/null +++ b/plotly/validators/histogram/_orientation.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='orientation', parent_name='histogram', **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/histogram/_selected.py b/plotly/validators/histogram/_selected.py new file mode 100644 index 0000000000..fb41afafc4 --- /dev/null +++ b/plotly/validators/histogram/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='histogram', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.histogram.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.histogram.selected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/histogram/_selectedpoints.py b/plotly/validators/histogram/_selectedpoints.py new file mode 100644 index 0000000000..b9ef78f4da --- /dev/null +++ b/plotly/validators/histogram/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='histogram', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_showlegend.py b/plotly/validators/histogram/_showlegend.py new file mode 100644 index 0000000000..b46b52c860 --- /dev/null +++ b/plotly/validators/histogram/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='histogram', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_stream.py b/plotly/validators/histogram/_stream.py new file mode 100644 index 0000000000..91e5cc443e --- /dev/null +++ b/plotly/validators/histogram/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='histogram', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_text.py b/plotly/validators/histogram/_text.py new file mode 100644 index 0000000000..aac667f5fe --- /dev/null +++ b/plotly/validators/histogram/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='histogram', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_textsrc.py b/plotly/validators/histogram/_textsrc.py new file mode 100644 index 0000000000..b8dac50f1a --- /dev/null +++ b/plotly/validators/histogram/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='histogram', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_uid.py b/plotly/validators/histogram/_uid.py new file mode 100644 index 0000000000..74449d563a --- /dev/null +++ b/plotly/validators/histogram/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='histogram', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_unselected.py b/plotly/validators/histogram/_unselected.py new file mode 100644 index 0000000000..5a190f6e73 --- /dev/null +++ b/plotly/validators/histogram/_unselected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='histogram', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.histogram.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.histogram.unselected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/histogram/_visible.py b/plotly/validators/histogram/_visible.py new file mode 100644 index 0000000000..2b18480256 --- /dev/null +++ b/plotly/validators/histogram/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='histogram', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/histogram/_x.py b/plotly/validators/histogram/_x.py new file mode 100644 index 0000000000..226c9f2979 --- /dev/null +++ b/plotly/validators/histogram/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='histogram', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/_xaxis.py b/plotly/validators/histogram/_xaxis.py new file mode 100644 index 0000000000..e2228e6927 --- /dev/null +++ b/plotly/validators/histogram/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='histogram', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_xbins.py b/plotly/validators/histogram/_xbins.py new file mode 100644 index 0000000000..c4a71a88f4 --- /dev/null +++ b/plotly/validators/histogram/_xbins.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='xbins', parent_name='histogram', **kwargs): + super(XBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='XBins', + data_docs=""" + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_xcalendar.py b/plotly/validators/histogram/_xcalendar.py new file mode 100644 index 0000000000..51c2e2bfc6 --- /dev/null +++ b/plotly/validators/histogram/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='histogram', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram/_xsrc.py b/plotly/validators/histogram/_xsrc.py new file mode 100644 index 0000000000..96b9b03ff7 --- /dev/null +++ b/plotly/validators/histogram/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='histogram', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_y.py b/plotly/validators/histogram/_y.py new file mode 100644 index 0000000000..5289dba6b0 --- /dev/null +++ b/plotly/validators/histogram/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='histogram', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/_yaxis.py b/plotly/validators/histogram/_yaxis.py new file mode 100644 index 0000000000..23d116fbca --- /dev/null +++ b/plotly/validators/histogram/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='histogram', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/_ybins.py b/plotly/validators/histogram/_ybins.py new file mode 100644 index 0000000000..6ecd461cf2 --- /dev/null +++ b/plotly/validators/histogram/_ybins.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='ybins', parent_name='histogram', **kwargs): + super(YBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YBins', + data_docs=""" + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram/_ycalendar.py b/plotly/validators/histogram/_ycalendar.py new file mode 100644 index 0000000000..2a8456a93b --- /dev/null +++ b/plotly/validators/histogram/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='histogram', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram/_ysrc.py b/plotly/validators/histogram/_ysrc.py new file mode 100644 index 0000000000..2cdd4d40ce --- /dev/null +++ b/plotly/validators/histogram/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='histogram', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/cumulative/__init__.py b/plotly/validators/histogram/cumulative/__init__.py new file mode 100644 index 0000000000..d3426ed067 --- /dev/null +++ b/plotly/validators/histogram/cumulative/__init__.py @@ -0,0 +1,3 @@ +from ._enabled import EnabledValidator +from ._direction import DirectionValidator +from ._currentbin import CurrentbinValidator diff --git a/plotly/validators/histogram/cumulative/_currentbin.py b/plotly/validators/histogram/cumulative/_currentbin.py new file mode 100644 index 0000000000..81591599a5 --- /dev/null +++ b/plotly/validators/histogram/cumulative/_currentbin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CurrentbinValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='currentbin', + parent_name='histogram.cumulative', + **kwargs + ): + super(CurrentbinValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['include', 'exclude', 'half'], + **kwargs + ) diff --git a/plotly/validators/histogram/cumulative/_direction.py b/plotly/validators/histogram/cumulative/_direction.py new file mode 100644 index 0000000000..75fc9e7dd8 --- /dev/null +++ b/plotly/validators/histogram/cumulative/_direction.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DirectionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='direction', + parent_name='histogram.cumulative', + **kwargs + ): + super(DirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['increasing', 'decreasing'], + **kwargs + ) diff --git a/plotly/validators/histogram/cumulative/_enabled.py b/plotly/validators/histogram/cumulative/_enabled.py new file mode 100644 index 0000000000..5f7eebec6a --- /dev/null +++ b/plotly/validators/histogram/cumulative/_enabled.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class EnabledValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='enabled', + parent_name='histogram.cumulative', + **kwargs + ): + super(EnabledValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/__init__.py b/plotly/validators/histogram/error_x/__init__.py new file mode 100644 index 0000000000..c4605e0187 --- /dev/null +++ b/plotly/validators/histogram/error_x/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_ystyle import CopyYstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/histogram/error_x/_array.py b/plotly/validators/histogram/error_x/_array.py new file mode 100644 index 0000000000..d8b3eb7609 --- /dev/null +++ b/plotly/validators/histogram/error_x/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='histogram.error_x', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_arrayminus.py b/plotly/validators/histogram/error_x/_arrayminus.py new file mode 100644 index 0000000000..68163bdd58 --- /dev/null +++ b/plotly/validators/histogram/error_x/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='histogram.error_x', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_arrayminussrc.py b/plotly/validators/histogram/error_x/_arrayminussrc.py new file mode 100644 index 0000000000..25cd755d8c --- /dev/null +++ b/plotly/validators/histogram/error_x/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='histogram.error_x', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_arraysrc.py b/plotly/validators/histogram/error_x/_arraysrc.py new file mode 100644 index 0000000000..0ce339e9f7 --- /dev/null +++ b/plotly/validators/histogram/error_x/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='histogram.error_x', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_color.py b/plotly/validators/histogram/error_x/_color.py new file mode 100644 index 0000000000..64472ad3a7 --- /dev/null +++ b/plotly/validators/histogram/error_x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='histogram.error_x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_copy_ystyle.py b/plotly/validators/histogram/error_x/_copy_ystyle.py new file mode 100644 index 0000000000..36f85973b5 --- /dev/null +++ b/plotly/validators/histogram/error_x/_copy_ystyle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CopyYstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='copy_ystyle', + parent_name='histogram.error_x', + **kwargs + ): + super(CopyYstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_symmetric.py b/plotly/validators/histogram/error_x/_symmetric.py new file mode 100644 index 0000000000..858dc9d75d --- /dev/null +++ b/plotly/validators/histogram/error_x/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='histogram.error_x', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_thickness.py b/plotly/validators/histogram/error_x/_thickness.py new file mode 100644 index 0000000000..4b5e8ab0c5 --- /dev/null +++ b/plotly/validators/histogram/error_x/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='histogram.error_x', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_traceref.py b/plotly/validators/histogram/error_x/_traceref.py new file mode 100644 index 0000000000..8def211d4d --- /dev/null +++ b/plotly/validators/histogram/error_x/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='histogram.error_x', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_tracerefminus.py b/plotly/validators/histogram/error_x/_tracerefminus.py new file mode 100644 index 0000000000..52210ea958 --- /dev/null +++ b/plotly/validators/histogram/error_x/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='histogram.error_x', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_type.py b/plotly/validators/histogram/error_x/_type.py new file mode 100644 index 0000000000..4e226d98f1 --- /dev/null +++ b/plotly/validators/histogram/error_x/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='histogram.error_x', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_value.py b/plotly/validators/histogram/error_x/_value.py new file mode 100644 index 0000000000..2ee094b86f --- /dev/null +++ b/plotly/validators/histogram/error_x/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='histogram.error_x', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_valueminus.py b/plotly/validators/histogram/error_x/_valueminus.py new file mode 100644 index 0000000000..1d554c198f --- /dev/null +++ b/plotly/validators/histogram/error_x/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='histogram.error_x', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_visible.py b/plotly/validators/histogram/error_x/_visible.py new file mode 100644 index 0000000000..599142e4cb --- /dev/null +++ b/plotly/validators/histogram/error_x/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='histogram.error_x', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_x/_width.py b/plotly/validators/histogram/error_x/_width.py new file mode 100644 index 0000000000..b55dd4f71b --- /dev/null +++ b/plotly/validators/histogram/error_x/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='histogram.error_x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/__init__.py b/plotly/validators/histogram/error_y/__init__.py new file mode 100644 index 0000000000..2fc70c4058 --- /dev/null +++ b/plotly/validators/histogram/error_y/__init__.py @@ -0,0 +1,14 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/histogram/error_y/_array.py b/plotly/validators/histogram/error_y/_array.py new file mode 100644 index 0000000000..fb6f234c82 --- /dev/null +++ b/plotly/validators/histogram/error_y/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='histogram.error_y', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_arrayminus.py b/plotly/validators/histogram/error_y/_arrayminus.py new file mode 100644 index 0000000000..54500abe06 --- /dev/null +++ b/plotly/validators/histogram/error_y/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='histogram.error_y', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_arrayminussrc.py b/plotly/validators/histogram/error_y/_arrayminussrc.py new file mode 100644 index 0000000000..32ff845fd2 --- /dev/null +++ b/plotly/validators/histogram/error_y/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='histogram.error_y', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_arraysrc.py b/plotly/validators/histogram/error_y/_arraysrc.py new file mode 100644 index 0000000000..09e6b9dc9b --- /dev/null +++ b/plotly/validators/histogram/error_y/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='histogram.error_y', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_color.py b/plotly/validators/histogram/error_y/_color.py new file mode 100644 index 0000000000..40ed1f3ae2 --- /dev/null +++ b/plotly/validators/histogram/error_y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='histogram.error_y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_symmetric.py b/plotly/validators/histogram/error_y/_symmetric.py new file mode 100644 index 0000000000..994c7eb622 --- /dev/null +++ b/plotly/validators/histogram/error_y/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='histogram.error_y', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_thickness.py b/plotly/validators/histogram/error_y/_thickness.py new file mode 100644 index 0000000000..dd3e6762db --- /dev/null +++ b/plotly/validators/histogram/error_y/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='histogram.error_y', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_traceref.py b/plotly/validators/histogram/error_y/_traceref.py new file mode 100644 index 0000000000..793b02b717 --- /dev/null +++ b/plotly/validators/histogram/error_y/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='histogram.error_y', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_tracerefminus.py b/plotly/validators/histogram/error_y/_tracerefminus.py new file mode 100644 index 0000000000..9b634f2ae6 --- /dev/null +++ b/plotly/validators/histogram/error_y/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='histogram.error_y', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_type.py b/plotly/validators/histogram/error_y/_type.py new file mode 100644 index 0000000000..1ce37429c9 --- /dev/null +++ b/plotly/validators/histogram/error_y/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='histogram.error_y', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_value.py b/plotly/validators/histogram/error_y/_value.py new file mode 100644 index 0000000000..7baa2c9c1b --- /dev/null +++ b/plotly/validators/histogram/error_y/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='histogram.error_y', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_valueminus.py b/plotly/validators/histogram/error_y/_valueminus.py new file mode 100644 index 0000000000..0505ea564a --- /dev/null +++ b/plotly/validators/histogram/error_y/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='histogram.error_y', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_visible.py b/plotly/validators/histogram/error_y/_visible.py new file mode 100644 index 0000000000..d3d16b157d --- /dev/null +++ b/plotly/validators/histogram/error_y/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='histogram.error_y', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/error_y/_width.py b/plotly/validators/histogram/error_y/_width.py new file mode 100644 index 0000000000..5afbe4f6bf --- /dev/null +++ b/plotly/validators/histogram/error_y/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='histogram.error_y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/__init__.py b/plotly/validators/histogram/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram/hoverlabel/_bgcolor.py b/plotly/validators/histogram/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..0491418a0d --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_bgcolorsrc.py b/plotly/validators/histogram/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..2e6fcda507 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_bordercolor.py b/plotly/validators/histogram/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..ef21130c20 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_bordercolorsrc.py b/plotly/validators/histogram/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..43da4cf536 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_font.py b/plotly/validators/histogram/hoverlabel/_font.py new file mode 100644 index 0000000000..daaa412416 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='histogram.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_namelength.py b/plotly/validators/histogram/hoverlabel/_namelength.py new file mode 100644 index 0000000000..0932e23c9f --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/_namelengthsrc.py b/plotly/validators/histogram/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..87410ad0aa --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='histogram.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/__init__.py b/plotly/validators/histogram/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram/hoverlabel/font/_color.py b/plotly/validators/histogram/hoverlabel/font/_color.py new file mode 100644 index 0000000000..75ff34cf1b --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/_colorsrc.py b/plotly/validators/histogram/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..1857e71305 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/_family.py b/plotly/validators/histogram/hoverlabel/font/_family.py new file mode 100644 index 0000000000..60cd99895b --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/_familysrc.py b/plotly/validators/histogram/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..e65fd13d0d --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/_size.py b/plotly/validators/histogram/hoverlabel/font/_size.py new file mode 100644 index 0000000000..d27dc23eeb --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/hoverlabel/font/_sizesrc.py b/plotly/validators/histogram/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..fcd6cf9fc9 --- /dev/null +++ b/plotly/validators/histogram/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='histogram.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/__init__.py b/plotly/validators/histogram/marker/__init__.py new file mode 100644 index 0000000000..17f5ee5025 --- /dev/null +++ b/plotly/validators/histogram/marker/__init__.py @@ -0,0 +1,13 @@ +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/histogram/marker/_autocolorscale.py b/plotly/validators/histogram/marker/_autocolorscale.py new file mode 100644 index 0000000000..36840a947f --- /dev/null +++ b/plotly/validators/histogram/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='histogram.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_cauto.py b/plotly/validators/histogram/marker/_cauto.py new file mode 100644 index 0000000000..5d449984b5 --- /dev/null +++ b/plotly/validators/histogram/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='histogram.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_cmax.py b/plotly/validators/histogram/marker/_cmax.py new file mode 100644 index 0000000000..69e10ad048 --- /dev/null +++ b/plotly/validators/histogram/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='histogram.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_cmin.py b/plotly/validators/histogram/marker/_cmin.py new file mode 100644 index 0000000000..7e84c4ba70 --- /dev/null +++ b/plotly/validators/histogram/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='histogram.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_color.py b/plotly/validators/histogram/marker/_color.py new file mode 100644 index 0000000000..c507c0b9fc --- /dev/null +++ b/plotly/validators/histogram/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='histogram.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='histogram.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_colorbar.py b/plotly/validators/histogram/marker/_colorbar.py new file mode 100644 index 0000000000..9469d50f3d --- /dev/null +++ b/plotly/validators/histogram/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='histogram.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_colorscale.py b/plotly/validators/histogram/marker/_colorscale.py new file mode 100644 index 0000000000..bd3e865968 --- /dev/null +++ b/plotly/validators/histogram/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='histogram.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_colorsrc.py b/plotly/validators/histogram/marker/_colorsrc.py new file mode 100644 index 0000000000..fcac564af6 --- /dev/null +++ b/plotly/validators/histogram/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='histogram.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_line.py b/plotly/validators/histogram/marker/_line.py new file mode 100644 index 0000000000..192adbdf05 --- /dev/null +++ b/plotly/validators/histogram/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='histogram.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_opacity.py b/plotly/validators/histogram/marker/_opacity.py new file mode 100644 index 0000000000..2edd995f91 --- /dev/null +++ b/plotly/validators/histogram/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='histogram.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_opacitysrc.py b/plotly/validators/histogram/marker/_opacitysrc.py new file mode 100644 index 0000000000..31938b1d10 --- /dev/null +++ b/plotly/validators/histogram/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='histogram.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_reversescale.py b/plotly/validators/histogram/marker/_reversescale.py new file mode 100644 index 0000000000..50514f488b --- /dev/null +++ b/plotly/validators/histogram/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='histogram.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/_showscale.py b/plotly/validators/histogram/marker/_showscale.py new file mode 100644 index 0000000000..9ae878dd8c --- /dev/null +++ b/plotly/validators/histogram/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='histogram.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/__init__.py b/plotly/validators/histogram/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram/marker/colorbar/_bgcolor.py b/plotly/validators/histogram/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..26702047dc --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_bordercolor.py b/plotly/validators/histogram/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..3ecf1ebd6a --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_borderwidth.py b/plotly/validators/histogram/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..e36cc653cf --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_dtick.py b/plotly/validators/histogram/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..c27079a175 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_exponentformat.py b/plotly/validators/histogram/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..bd81d6d339 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_len.py b/plotly/validators/histogram/marker/colorbar/_len.py new file mode 100644 index 0000000000..399f785242 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_lenmode.py b/plotly/validators/histogram/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..2d7dd716f7 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_nticks.py b/plotly/validators/histogram/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..401f66fb83 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_outlinecolor.py b/plotly/validators/histogram/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..90c9a0cdb7 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_outlinewidth.py b/plotly/validators/histogram/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..1c13b9bb39 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_separatethousands.py b/plotly/validators/histogram/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..c9be80584a --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_showexponent.py b/plotly/validators/histogram/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..cb26225b8b --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_showticklabels.py b/plotly/validators/histogram/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..f4b70af9f0 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_showtickprefix.py b/plotly/validators/histogram/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..b6ea6df43a --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_showticksuffix.py b/plotly/validators/histogram/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..6e21638aa0 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_thickness.py b/plotly/validators/histogram/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..8640683d99 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_thicknessmode.py b/plotly/validators/histogram/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..1b966a8b4d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tick0.py b/plotly/validators/histogram/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..cc71595b8b --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickangle.py b/plotly/validators/histogram/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..b607cd0c6d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickcolor.py b/plotly/validators/histogram/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..f87c1ad81d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickfont.py b/plotly/validators/histogram/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..efadccc78f --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickformat.py b/plotly/validators/histogram/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..ac05b98b91 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickformatstops.py b/plotly/validators/histogram/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..165e57ad22 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ticklen.py b/plotly/validators/histogram/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..529bfa8f3d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickmode.py b/plotly/validators/histogram/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..f48ef1157d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickprefix.py b/plotly/validators/histogram/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..d4b6db8330 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ticks.py b/plotly/validators/histogram/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..1d911a57bf --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ticksuffix.py b/plotly/validators/histogram/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..8c892c69d4 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ticktext.py b/plotly/validators/histogram/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..5bf9c824eb --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ticktextsrc.py b/plotly/validators/histogram/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..59b95e038d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickvals.py b/plotly/validators/histogram/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..db85112d4d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickvalssrc.py b/plotly/validators/histogram/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..1e98668408 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_tickwidth.py b/plotly/validators/histogram/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..b55fec77fc --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_title.py b/plotly/validators/histogram/marker/colorbar/_title.py new file mode 100644 index 0000000000..9857616a3d --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_titlefont.py b/plotly/validators/histogram/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..5405631a26 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_titleside.py b/plotly/validators/histogram/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..dba795a46a --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_x.py b/plotly/validators/histogram/marker/colorbar/_x.py new file mode 100644 index 0000000000..ead88a60fc --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_xanchor.py b/plotly/validators/histogram/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..67babdc1d5 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_xpad.py b/plotly/validators/histogram/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..83c8f22d17 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_y.py b/plotly/validators/histogram/marker/colorbar/_y.py new file mode 100644 index 0000000000..5f676bec71 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_yanchor.py b/plotly/validators/histogram/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..c4695f7141 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/_ypad.py b/plotly/validators/histogram/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..a1116a8f1c --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='histogram.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/tickfont/__init__.py b/plotly/validators/histogram/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram/marker/colorbar/tickfont/_color.py b/plotly/validators/histogram/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..6fa0aeb7b3 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/tickfont/_family.py b/plotly/validators/histogram/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..26ad0da9cc --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/tickfont/_size.py b/plotly/validators/histogram/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..6bc0ed5afd --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/histogram/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/histogram/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/histogram/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..6577f0f61e --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='histogram.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/tickformatstop/_value.py b/plotly/validators/histogram/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..5a0266e7e7 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='histogram.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/titlefont/__init__.py b/plotly/validators/histogram/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram/marker/colorbar/titlefont/_color.py b/plotly/validators/histogram/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..e861364307 --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/titlefont/_family.py b/plotly/validators/histogram/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..f912cf964b --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram/marker/colorbar/titlefont/_size.py b/plotly/validators/histogram/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..f96b5d698b --- /dev/null +++ b/plotly/validators/histogram/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/__init__.py b/plotly/validators/histogram/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/histogram/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/histogram/marker/line/_autocolorscale.py b/plotly/validators/histogram/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..4f1ebe63b8 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='histogram.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_cauto.py b/plotly/validators/histogram/marker/line/_cauto.py new file mode 100644 index 0000000000..a8a6da584b --- /dev/null +++ b/plotly/validators/histogram/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='histogram.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_cmax.py b/plotly/validators/histogram/marker/line/_cmax.py new file mode 100644 index 0000000000..8ce1d18352 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='histogram.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_cmin.py b/plotly/validators/histogram/marker/line/_cmin.py new file mode 100644 index 0000000000..77e0aaac06 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='histogram.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_color.py b/plotly/validators/histogram/marker/line/_color.py new file mode 100644 index 0000000000..c37336cfe6 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='histogram.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_colorscale.py b/plotly/validators/histogram/marker/line/_colorscale.py new file mode 100644 index 0000000000..c9fd6b1bc9 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='histogram.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_colorsrc.py b/plotly/validators/histogram/marker/line/_colorsrc.py new file mode 100644 index 0000000000..0983015b84 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_reversescale.py b/plotly/validators/histogram/marker/line/_reversescale.py new file mode 100644 index 0000000000..632463033a --- /dev/null +++ b/plotly/validators/histogram/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='histogram.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_width.py b/plotly/validators/histogram/marker/line/_width.py new file mode 100644 index 0000000000..607384b256 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='histogram.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/marker/line/_widthsrc.py b/plotly/validators/histogram/marker/line/_widthsrc.py new file mode 100644 index 0000000000..061871e824 --- /dev/null +++ b/plotly/validators/histogram/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='histogram.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/selected/__init__.py b/plotly/validators/histogram/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/histogram/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/histogram/selected/_marker.py b/plotly/validators/histogram/selected/_marker.py new file mode 100644 index 0000000000..aebcfc27a9 --- /dev/null +++ b/plotly/validators/histogram/selected/_marker.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='histogram.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points.""", + **kwargs + ) diff --git a/plotly/validators/histogram/selected/_textfont.py b/plotly/validators/histogram/selected/_textfont.py new file mode 100644 index 0000000000..c02f63ef20 --- /dev/null +++ b/plotly/validators/histogram/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='histogram.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/histogram/selected/marker/__init__.py b/plotly/validators/histogram/selected/marker/__init__.py new file mode 100644 index 0000000000..990c554a22 --- /dev/null +++ b/plotly/validators/histogram/selected/marker/__init__.py @@ -0,0 +1,2 @@ +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram/selected/marker/_color.py b/plotly/validators/histogram/selected/marker/_color.py new file mode 100644 index 0000000000..4afd3cbe0c --- /dev/null +++ b/plotly/validators/histogram/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/selected/marker/_opacity.py b/plotly/validators/histogram/selected/marker/_opacity.py new file mode 100644 index 0000000000..cea766b223 --- /dev/null +++ b/plotly/validators/histogram/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='histogram.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/selected/textfont/__init__.py b/plotly/validators/histogram/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/histogram/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/histogram/selected/textfont/_color.py b/plotly/validators/histogram/selected/textfont/_color.py new file mode 100644 index 0000000000..d0457135c5 --- /dev/null +++ b/plotly/validators/histogram/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/stream/__init__.py b/plotly/validators/histogram/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/histogram/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/histogram/stream/_maxpoints.py b/plotly/validators/histogram/stream/_maxpoints.py new file mode 100644 index 0000000000..e93f2257e7 --- /dev/null +++ b/plotly/validators/histogram/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='histogram.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram/stream/_token.py b/plotly/validators/histogram/stream/_token.py new file mode 100644 index 0000000000..7174073f99 --- /dev/null +++ b/plotly/validators/histogram/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='histogram.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram/unselected/__init__.py b/plotly/validators/histogram/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/histogram/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/histogram/unselected/_marker.py b/plotly/validators/histogram/unselected/_marker.py new file mode 100644 index 0000000000..0613994699 --- /dev/null +++ b/plotly/validators/histogram/unselected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='histogram.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/histogram/unselected/_textfont.py b/plotly/validators/histogram/unselected/_textfont.py new file mode 100644 index 0000000000..cef038f25c --- /dev/null +++ b/plotly/validators/histogram/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='histogram.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/histogram/unselected/marker/__init__.py b/plotly/validators/histogram/unselected/marker/__init__.py new file mode 100644 index 0000000000..990c554a22 --- /dev/null +++ b/plotly/validators/histogram/unselected/marker/__init__.py @@ -0,0 +1,2 @@ +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram/unselected/marker/_color.py b/plotly/validators/histogram/unselected/marker/_color.py new file mode 100644 index 0000000000..dc7e3e8bbd --- /dev/null +++ b/plotly/validators/histogram/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/unselected/marker/_opacity.py b/plotly/validators/histogram/unselected/marker/_opacity.py new file mode 100644 index 0000000000..9d783ca9fb --- /dev/null +++ b/plotly/validators/histogram/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='histogram.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/unselected/textfont/__init__.py b/plotly/validators/histogram/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/histogram/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/histogram/unselected/textfont/_color.py b/plotly/validators/histogram/unselected/textfont/_color.py new file mode 100644 index 0000000000..e1cf33e81f --- /dev/null +++ b/plotly/validators/histogram/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/xbins/__init__.py b/plotly/validators/histogram/xbins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram/xbins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram/xbins/_end.py b/plotly/validators/histogram/xbins/_end.py new file mode 100644 index 0000000000..03af230627 --- /dev/null +++ b/plotly/validators/histogram/xbins/_end.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='end', parent_name='histogram.xbins', **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/xbins/_size.py b/plotly/validators/histogram/xbins/_size.py new file mode 100644 index 0000000000..a1196edb28 --- /dev/null +++ b/plotly/validators/histogram/xbins/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='size', parent_name='histogram.xbins', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/xbins/_start.py b/plotly/validators/histogram/xbins/_start.py new file mode 100644 index 0000000000..c00341c7e1 --- /dev/null +++ b/plotly/validators/histogram/xbins/_start.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='start', parent_name='histogram.xbins', **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/ybins/__init__.py b/plotly/validators/histogram/ybins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram/ybins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram/ybins/_end.py b/plotly/validators/histogram/ybins/_end.py new file mode 100644 index 0000000000..c53d7f62e0 --- /dev/null +++ b/plotly/validators/histogram/ybins/_end.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='end', parent_name='histogram.ybins', **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/ybins/_size.py b/plotly/validators/histogram/ybins/_size.py new file mode 100644 index 0000000000..ae24077200 --- /dev/null +++ b/plotly/validators/histogram/ybins/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='size', parent_name='histogram.ybins', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram/ybins/_start.py b/plotly/validators/histogram/ybins/_start.py new file mode 100644 index 0000000000..518a03bc3f --- /dev/null +++ b/plotly/validators/histogram/ybins/_start.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='start', parent_name='histogram.ybins', **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/__init__.py b/plotly/validators/histogram2d/__init__.py new file mode 100644 index 0000000000..307139f9a6 --- /dev/null +++ b/plotly/validators/histogram2d/__init__.py @@ -0,0 +1,46 @@ +from ._zsrc import ZsrcValidator +from ._zsmooth import ZsmoothValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zhoverformat import ZhoverformatValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._ygap import YgapValidator +from ._ycalendar import YcalendarValidator +from ._ybins import YBinsValidator +from ._yaxis import YAxisValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xgap import XgapValidator +from ._xcalendar import XcalendarValidator +from ._xbins import XBinsValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._nbinsy import NbinsyValidator +from ._nbinsx import NbinsxValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._histnorm import HistnormValidator +from ._histfunc import HistfuncValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocolorscale import AutocolorscaleValidator +from ._autobiny import AutobinyValidator +from ._autobinx import AutobinxValidator diff --git a/plotly/validators/histogram2d/_autobinx.py b/plotly/validators/histogram2d/_autobinx.py new file mode 100644 index 0000000000..9d06f6a514 --- /dev/null +++ b/plotly/validators/histogram2d/_autobinx.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutobinxValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autobinx', parent_name='histogram2d', **kwargs + ): + super(AutobinxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_autobiny.py b/plotly/validators/histogram2d/_autobiny.py new file mode 100644 index 0000000000..fd63422523 --- /dev/null +++ b/plotly/validators/histogram2d/_autobiny.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutobinyValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autobiny', parent_name='histogram2d', **kwargs + ): + super(AutobinyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_autocolorscale.py b/plotly/validators/histogram2d/_autocolorscale.py new file mode 100644 index 0000000000..d1e0e84e6f --- /dev/null +++ b/plotly/validators/histogram2d/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='histogram2d', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_colorbar.py b/plotly/validators/histogram2d/_colorbar.py new file mode 100644 index 0000000000..213c8ef93e --- /dev/null +++ b/plotly/validators/histogram2d/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='histogram2d', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2d.colorbar.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_colorscale.py b/plotly/validators/histogram2d/_colorscale.py new file mode 100644 index 0000000000..16d4c75d9e --- /dev/null +++ b/plotly/validators/histogram2d/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='histogram2d', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_customdata.py b/plotly/validators/histogram2d/_customdata.py new file mode 100644 index 0000000000..c2570ffe73 --- /dev/null +++ b/plotly/validators/histogram2d/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='histogram2d', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_customdatasrc.py b/plotly/validators/histogram2d/_customdatasrc.py new file mode 100644 index 0000000000..d6daa61db9 --- /dev/null +++ b/plotly/validators/histogram2d/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='histogram2d', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_histfunc.py b/plotly/validators/histogram2d/_histfunc.py new file mode 100644 index 0000000000..13bc7a88cf --- /dev/null +++ b/plotly/validators/histogram2d/_histfunc.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HistfuncValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='histfunc', parent_name='histogram2d', **kwargs + ): + super(HistfuncValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['count', 'sum', 'avg', 'min', 'max'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_histnorm.py b/plotly/validators/histogram2d/_histnorm.py new file mode 100644 index 0000000000..297ffde797 --- /dev/null +++ b/plotly/validators/histogram2d/_histnorm.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HistnormValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='histnorm', parent_name='histogram2d', **kwargs + ): + super(HistnormValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + '', 'percent', 'probability', 'density', 'probability density' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_hoverinfo.py b/plotly/validators/histogram2d/_hoverinfo.py new file mode 100644 index 0000000000..b39d6c85ae --- /dev/null +++ b/plotly/validators/histogram2d/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='histogram2d', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_hoverinfosrc.py b/plotly/validators/histogram2d/_hoverinfosrc.py new file mode 100644 index 0000000000..33e8f2bb8a --- /dev/null +++ b/plotly/validators/histogram2d/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='histogram2d', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_hoverlabel.py b/plotly/validators/histogram2d/_hoverlabel.py new file mode 100644 index 0000000000..9cf03de1c3 --- /dev/null +++ b/plotly/validators/histogram2d/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='histogram2d', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_ids.py b/plotly/validators/histogram2d/_ids.py new file mode 100644 index 0000000000..0386bb96c9 --- /dev/null +++ b/plotly/validators/histogram2d/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='histogram2d', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_idssrc.py b/plotly/validators/histogram2d/_idssrc.py new file mode 100644 index 0000000000..403f0c7fb1 --- /dev/null +++ b/plotly/validators/histogram2d/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='histogram2d', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_legendgroup.py b/plotly/validators/histogram2d/_legendgroup.py new file mode 100644 index 0000000000..32aa310202 --- /dev/null +++ b/plotly/validators/histogram2d/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='histogram2d', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_marker.py b/plotly/validators/histogram2d/_marker.py new file mode 100644 index 0000000000..2ff17d2b15 --- /dev/null +++ b/plotly/validators/histogram2d/_marker.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='histogram2d', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color + .""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_name.py b/plotly/validators/histogram2d/_name.py new file mode 100644 index 0000000000..af80197286 --- /dev/null +++ b/plotly/validators/histogram2d/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='histogram2d', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_nbinsx.py b/plotly/validators/histogram2d/_nbinsx.py new file mode 100644 index 0000000000..35f21b636a --- /dev/null +++ b/plotly/validators/histogram2d/_nbinsx.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsxValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsx', parent_name='histogram2d', **kwargs + ): + super(NbinsxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_nbinsy.py b/plotly/validators/histogram2d/_nbinsy.py new file mode 100644 index 0000000000..2efa6ed024 --- /dev/null +++ b/plotly/validators/histogram2d/_nbinsy.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsyValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsy', parent_name='histogram2d', **kwargs + ): + super(NbinsyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_opacity.py b/plotly/validators/histogram2d/_opacity.py new file mode 100644 index 0000000000..4f4dc5fa8f --- /dev/null +++ b/plotly/validators/histogram2d/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='histogram2d', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_reversescale.py b/plotly/validators/histogram2d/_reversescale.py new file mode 100644 index 0000000000..27d63b0829 --- /dev/null +++ b/plotly/validators/histogram2d/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='histogram2d', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_selectedpoints.py b/plotly/validators/histogram2d/_selectedpoints.py new file mode 100644 index 0000000000..9bde81298c --- /dev/null +++ b/plotly/validators/histogram2d/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='histogram2d', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_showlegend.py b/plotly/validators/histogram2d/_showlegend.py new file mode 100644 index 0000000000..67f498970e --- /dev/null +++ b/plotly/validators/histogram2d/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='histogram2d', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_showscale.py b/plotly/validators/histogram2d/_showscale.py new file mode 100644 index 0000000000..f2f5b938ba --- /dev/null +++ b/plotly/validators/histogram2d/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='histogram2d', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_stream.py b/plotly/validators/histogram2d/_stream.py new file mode 100644 index 0000000000..06b858f285 --- /dev/null +++ b/plotly/validators/histogram2d/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='histogram2d', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_uid.py b/plotly/validators/histogram2d/_uid.py new file mode 100644 index 0000000000..4f8d6db5c7 --- /dev/null +++ b/plotly/validators/histogram2d/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='histogram2d', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_visible.py b/plotly/validators/histogram2d/_visible.py new file mode 100644 index 0000000000..a435046ba0 --- /dev/null +++ b/plotly/validators/histogram2d/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='histogram2d', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_x.py b/plotly/validators/histogram2d/_x.py new file mode 100644 index 0000000000..faf8fcb4c4 --- /dev/null +++ b/plotly/validators/histogram2d/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='histogram2d', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_xaxis.py b/plotly/validators/histogram2d/_xaxis.py new file mode 100644 index 0000000000..458fef97fe --- /dev/null +++ b/plotly/validators/histogram2d/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='histogram2d', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_xbins.py b/plotly/validators/histogram2d/_xbins.py new file mode 100644 index 0000000000..d444e41751 --- /dev/null +++ b/plotly/validators/histogram2d/_xbins.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class XBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='xbins', parent_name='histogram2d', **kwargs + ): + super(XBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='XBins', + data_docs=""" + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_xcalendar.py b/plotly/validators/histogram2d/_xcalendar.py new file mode 100644 index 0000000000..d935d9d491 --- /dev/null +++ b/plotly/validators/histogram2d/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='histogram2d', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_xgap.py b/plotly/validators/histogram2d/_xgap.py new file mode 100644 index 0000000000..e082b64db5 --- /dev/null +++ b/plotly/validators/histogram2d/_xgap.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xgap', parent_name='histogram2d', **kwargs + ): + super(XgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_xsrc.py b/plotly/validators/histogram2d/_xsrc.py new file mode 100644 index 0000000000..14c767948c --- /dev/null +++ b/plotly/validators/histogram2d/_xsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='xsrc', parent_name='histogram2d', **kwargs + ): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_y.py b/plotly/validators/histogram2d/_y.py new file mode 100644 index 0000000000..e7d997d788 --- /dev/null +++ b/plotly/validators/histogram2d/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='histogram2d', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_yaxis.py b/plotly/validators/histogram2d/_yaxis.py new file mode 100644 index 0000000000..708ec8b87a --- /dev/null +++ b/plotly/validators/histogram2d/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='histogram2d', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_ybins.py b/plotly/validators/histogram2d/_ybins.py new file mode 100644 index 0000000000..be72a207f3 --- /dev/null +++ b/plotly/validators/histogram2d/_ybins.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class YBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='ybins', parent_name='histogram2d', **kwargs + ): + super(YBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YBins', + data_docs=""" + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/_ycalendar.py b/plotly/validators/histogram2d/_ycalendar.py new file mode 100644 index 0000000000..145c338f38 --- /dev/null +++ b/plotly/validators/histogram2d/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='histogram2d', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_ygap.py b/plotly/validators/histogram2d/_ygap.py new file mode 100644 index 0000000000..90b9721df6 --- /dev/null +++ b/plotly/validators/histogram2d/_ygap.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ygap', parent_name='histogram2d', **kwargs + ): + super(YgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_ysrc.py b/plotly/validators/histogram2d/_ysrc.py new file mode 100644 index 0000000000..05e1390124 --- /dev/null +++ b/plotly/validators/histogram2d/_ysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ysrc', parent_name='histogram2d', **kwargs + ): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_z.py b/plotly/validators/histogram2d/_z.py new file mode 100644 index 0000000000..5bb20f4c31 --- /dev/null +++ b/plotly/validators/histogram2d/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='histogram2d', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zauto.py b/plotly/validators/histogram2d/_zauto.py new file mode 100644 index 0000000000..ce1eb2c9ca --- /dev/null +++ b/plotly/validators/histogram2d/_zauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zauto', parent_name='histogram2d', **kwargs + ): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zhoverformat.py b/plotly/validators/histogram2d/_zhoverformat.py new file mode 100644 index 0000000000..b241241a4c --- /dev/null +++ b/plotly/validators/histogram2d/_zhoverformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZhoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='zhoverformat', parent_name='histogram2d', **kwargs + ): + super(ZhoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zmax.py b/plotly/validators/histogram2d/_zmax.py new file mode 100644 index 0000000000..8b2e5899b7 --- /dev/null +++ b/plotly/validators/histogram2d/_zmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmax', parent_name='histogram2d', **kwargs + ): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zmin.py b/plotly/validators/histogram2d/_zmin.py new file mode 100644 index 0000000000..1f6c56cba1 --- /dev/null +++ b/plotly/validators/histogram2d/_zmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmin', parent_name='histogram2d', **kwargs + ): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zsmooth.py b/plotly/validators/histogram2d/_zsmooth.py new file mode 100644 index 0000000000..a1ebb26328 --- /dev/null +++ b/plotly/validators/histogram2d/_zsmooth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZsmoothValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='zsmooth', parent_name='histogram2d', **kwargs + ): + super(ZsmoothValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fast', 'best', False], + **kwargs + ) diff --git a/plotly/validators/histogram2d/_zsrc.py b/plotly/validators/histogram2d/_zsrc.py new file mode 100644 index 0000000000..0b000eaa66 --- /dev/null +++ b/plotly/validators/histogram2d/_zsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='zsrc', parent_name='histogram2d', **kwargs + ): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/__init__.py b/plotly/validators/histogram2d/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram2d/colorbar/_bgcolor.py b/plotly/validators/histogram2d/colorbar/_bgcolor.py new file mode 100644 index 0000000000..4bfc44f51f --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_bordercolor.py b/plotly/validators/histogram2d/colorbar/_bordercolor.py new file mode 100644 index 0000000000..ca57d6ff7a --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_borderwidth.py b/plotly/validators/histogram2d/colorbar/_borderwidth.py new file mode 100644 index 0000000000..bebec1f565 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_dtick.py b/plotly/validators/histogram2d/colorbar/_dtick.py new file mode 100644 index 0000000000..cf5c336959 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_exponentformat.py b/plotly/validators/histogram2d/colorbar/_exponentformat.py new file mode 100644 index 0000000000..f96a163c0c --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_len.py b/plotly/validators/histogram2d/colorbar/_len.py new file mode 100644 index 0000000000..55eb60375a --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='histogram2d.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_lenmode.py b/plotly/validators/histogram2d/colorbar/_lenmode.py new file mode 100644 index 0000000000..503747a705 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_nticks.py b/plotly/validators/histogram2d/colorbar/_nticks.py new file mode 100644 index 0000000000..326ac3027b --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_outlinecolor.py b/plotly/validators/histogram2d/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..661519e8ee --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_outlinewidth.py b/plotly/validators/histogram2d/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..13475753b7 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_separatethousands.py b/plotly/validators/histogram2d/colorbar/_separatethousands.py new file mode 100644 index 0000000000..a434b89fee --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_showexponent.py b/plotly/validators/histogram2d/colorbar/_showexponent.py new file mode 100644 index 0000000000..9f89fc5e16 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_showticklabels.py b/plotly/validators/histogram2d/colorbar/_showticklabels.py new file mode 100644 index 0000000000..f0ee437f89 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_showtickprefix.py b/plotly/validators/histogram2d/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..6c72536556 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_showticksuffix.py b/plotly/validators/histogram2d/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..cc5bace594 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_thickness.py b/plotly/validators/histogram2d/colorbar/_thickness.py new file mode 100644 index 0000000000..ede919d39d --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_thicknessmode.py b/plotly/validators/histogram2d/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..7dcef6fe20 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tick0.py b/plotly/validators/histogram2d/colorbar/_tick0.py new file mode 100644 index 0000000000..80c5cf27d8 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickangle.py b/plotly/validators/histogram2d/colorbar/_tickangle.py new file mode 100644 index 0000000000..e58533ee50 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickcolor.py b/plotly/validators/histogram2d/colorbar/_tickcolor.py new file mode 100644 index 0000000000..8ae3b05aa7 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickfont.py b/plotly/validators/histogram2d/colorbar/_tickfont.py new file mode 100644 index 0000000000..2438db796a --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickformat.py b/plotly/validators/histogram2d/colorbar/_tickformat.py new file mode 100644 index 0000000000..2ee892db7a --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickformatstops.py b/plotly/validators/histogram2d/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..095d029c9a --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ticklen.py b/plotly/validators/histogram2d/colorbar/_ticklen.py new file mode 100644 index 0000000000..6bf0ba81de --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickmode.py b/plotly/validators/histogram2d/colorbar/_tickmode.py new file mode 100644 index 0000000000..6659c7c5f6 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickprefix.py b/plotly/validators/histogram2d/colorbar/_tickprefix.py new file mode 100644 index 0000000000..758c198489 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ticks.py b/plotly/validators/histogram2d/colorbar/_ticks.py new file mode 100644 index 0000000000..7790d1f42c --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ticksuffix.py b/plotly/validators/histogram2d/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..3f91722749 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ticktext.py b/plotly/validators/histogram2d/colorbar/_ticktext.py new file mode 100644 index 0000000000..5b828b8eaf --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ticktextsrc.py b/plotly/validators/histogram2d/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..db560e737b --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickvals.py b/plotly/validators/histogram2d/colorbar/_tickvals.py new file mode 100644 index 0000000000..a98e0cbf4c --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickvalssrc.py b/plotly/validators/histogram2d/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..3138d446b3 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_tickwidth.py b/plotly/validators/histogram2d/colorbar/_tickwidth.py new file mode 100644 index 0000000000..cdd8c56c7e --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_title.py b/plotly/validators/histogram2d/colorbar/_title.py new file mode 100644 index 0000000000..88007b8be8 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_titlefont.py b/plotly/validators/histogram2d/colorbar/_titlefont.py new file mode 100644 index 0000000000..7788a9b4e1 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_titleside.py b/plotly/validators/histogram2d/colorbar/_titleside.py new file mode 100644 index 0000000000..2552cd7f07 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_x.py b/plotly/validators/histogram2d/colorbar/_x.py new file mode 100644 index 0000000000..7462302bb4 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='histogram2d.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_xanchor.py b/plotly/validators/histogram2d/colorbar/_xanchor.py new file mode 100644 index 0000000000..5047298b9b --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_xpad.py b/plotly/validators/histogram2d/colorbar/_xpad.py new file mode 100644 index 0000000000..9b6b8a0465 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='histogram2d.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_y.py b/plotly/validators/histogram2d/colorbar/_y.py new file mode 100644 index 0000000000..c7feccd7e1 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='histogram2d.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_yanchor.py b/plotly/validators/histogram2d/colorbar/_yanchor.py new file mode 100644 index 0000000000..b513727c2e --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='histogram2d.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/_ypad.py b/plotly/validators/histogram2d/colorbar/_ypad.py new file mode 100644 index 0000000000..f039d0f705 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='histogram2d.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/tickfont/__init__.py b/plotly/validators/histogram2d/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2d/colorbar/tickfont/_color.py b/plotly/validators/histogram2d/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..d17106f709 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2d.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/tickfont/_family.py b/plotly/validators/histogram2d/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..4a779b6ee4 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2d.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/tickfont/_size.py b/plotly/validators/histogram2d/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..33da029f50 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2d.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/tickformatstop/__init__.py b/plotly/validators/histogram2d/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/histogram2d/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/histogram2d/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..ba080b21e9 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='histogram2d.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/tickformatstop/_value.py b/plotly/validators/histogram2d/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..1c5b58433f --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='histogram2d.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/titlefont/__init__.py b/plotly/validators/histogram2d/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2d/colorbar/titlefont/_color.py b/plotly/validators/histogram2d/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..ff98af5fcf --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2d.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/titlefont/_family.py b/plotly/validators/histogram2d/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..1855e85f93 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2d.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2d/colorbar/titlefont/_size.py b/plotly/validators/histogram2d/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..4311c5d7d1 --- /dev/null +++ b/plotly/validators/histogram2d/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2d.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/__init__.py b/plotly/validators/histogram2d/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram2d/hoverlabel/_bgcolor.py b/plotly/validators/histogram2d/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..a72ced7914 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_bgcolorsrc.py b/plotly/validators/histogram2d/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..1015f328d7 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_bordercolor.py b/plotly/validators/histogram2d/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..1c7728344c --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_bordercolorsrc.py b/plotly/validators/histogram2d/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..978d1ad600 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_font.py b/plotly/validators/histogram2d/hoverlabel/_font.py new file mode 100644 index 0000000000..2d85c4f509 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_namelength.py b/plotly/validators/histogram2d/hoverlabel/_namelength.py new file mode 100644 index 0000000000..bfef696330 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/_namelengthsrc.py b/plotly/validators/histogram2d/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..58d2522be4 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='histogram2d.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/__init__.py b/plotly/validators/histogram2d/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2d/hoverlabel/font/_color.py b/plotly/validators/histogram2d/hoverlabel/font/_color.py new file mode 100644 index 0000000000..df13a5160b --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/_colorsrc.py b/plotly/validators/histogram2d/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..4a1c00e8fd --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/_family.py b/plotly/validators/histogram2d/hoverlabel/font/_family.py new file mode 100644 index 0000000000..5b55e4cf45 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/_familysrc.py b/plotly/validators/histogram2d/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..0917cf48ed --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/_size.py b/plotly/validators/histogram2d/hoverlabel/font/_size.py new file mode 100644 index 0000000000..168fb42d15 --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/hoverlabel/font/_sizesrc.py b/plotly/validators/histogram2d/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..614ab024ed --- /dev/null +++ b/plotly/validators/histogram2d/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='histogram2d.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/marker/__init__.py b/plotly/validators/histogram2d/marker/__init__.py new file mode 100644 index 0000000000..e60d2b4c8d --- /dev/null +++ b/plotly/validators/histogram2d/marker/__init__.py @@ -0,0 +1,2 @@ +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2d/marker/_color.py b/plotly/validators/histogram2d/marker/_color.py new file mode 100644 index 0000000000..90adf8abaa --- /dev/null +++ b/plotly/validators/histogram2d/marker/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='color', parent_name='histogram2d.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2d/marker/_colorsrc.py b/plotly/validators/histogram2d/marker/_colorsrc.py new file mode 100644 index 0000000000..47f5e856a7 --- /dev/null +++ b/plotly/validators/histogram2d/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram2d.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/stream/__init__.py b/plotly/validators/histogram2d/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/histogram2d/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/histogram2d/stream/_maxpoints.py b/plotly/validators/histogram2d/stream/_maxpoints.py new file mode 100644 index 0000000000..a2984b9eb1 --- /dev/null +++ b/plotly/validators/histogram2d/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='histogram2d.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2d/stream/_token.py b/plotly/validators/histogram2d/stream/_token.py new file mode 100644 index 0000000000..45171601a2 --- /dev/null +++ b/plotly/validators/histogram2d/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='histogram2d.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2d/xbins/__init__.py b/plotly/validators/histogram2d/xbins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram2d/xbins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram2d/xbins/_end.py b/plotly/validators/histogram2d/xbins/_end.py new file mode 100644 index 0000000000..6bd1972c75 --- /dev/null +++ b/plotly/validators/histogram2d/xbins/_end.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='end', parent_name='histogram2d.xbins', **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/xbins/_size.py b/plotly/validators/histogram2d/xbins/_size.py new file mode 100644 index 0000000000..2d9ed038a8 --- /dev/null +++ b/plotly/validators/histogram2d/xbins/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='size', parent_name='histogram2d.xbins', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/xbins/_start.py b/plotly/validators/histogram2d/xbins/_start.py new file mode 100644 index 0000000000..c5ec949a32 --- /dev/null +++ b/plotly/validators/histogram2d/xbins/_start.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='start', parent_name='histogram2d.xbins', **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/ybins/__init__.py b/plotly/validators/histogram2d/ybins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram2d/ybins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram2d/ybins/_end.py b/plotly/validators/histogram2d/ybins/_end.py new file mode 100644 index 0000000000..73893ff086 --- /dev/null +++ b/plotly/validators/histogram2d/ybins/_end.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='end', parent_name='histogram2d.ybins', **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/ybins/_size.py b/plotly/validators/histogram2d/ybins/_size.py new file mode 100644 index 0000000000..54f8b36301 --- /dev/null +++ b/plotly/validators/histogram2d/ybins/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='size', parent_name='histogram2d.ybins', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2d/ybins/_start.py b/plotly/validators/histogram2d/ybins/_start.py new file mode 100644 index 0000000000..0622fe29d4 --- /dev/null +++ b/plotly/validators/histogram2d/ybins/_start.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='start', parent_name='histogram2d.ybins', **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/__init__.py b/plotly/validators/histogram2dcontour/__init__.py new file mode 100644 index 0000000000..0cca92ce3e --- /dev/null +++ b/plotly/validators/histogram2dcontour/__init__.py @@ -0,0 +1,47 @@ +from ._zsrc import ZsrcValidator +from ._zmin import ZminValidator +from ._zmax import ZmaxValidator +from ._zhoverformat import ZhoverformatValidator +from ._zauto import ZautoValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._ybins import YBinsValidator +from ._yaxis import YAxisValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xbins import XBinsValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._ncontours import NcontoursValidator +from ._nbinsy import NbinsyValidator +from ._nbinsx import NbinsxValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._histnorm import HistnormValidator +from ._histfunc import HistfuncValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._contours import ContoursValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._autocontour import AutocontourValidator +from ._autocolorscale import AutocolorscaleValidator +from ._autobiny import AutobinyValidator +from ._autobinx import AutobinxValidator diff --git a/plotly/validators/histogram2dcontour/_autobinx.py b/plotly/validators/histogram2dcontour/_autobinx.py new file mode 100644 index 0000000000..3e3bbbf5b7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_autobinx.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutobinxValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autobinx', + parent_name='histogram2dcontour', + **kwargs + ): + super(AutobinxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_autobiny.py b/plotly/validators/histogram2dcontour/_autobiny.py new file mode 100644 index 0000000000..93bc5980fb --- /dev/null +++ b/plotly/validators/histogram2dcontour/_autobiny.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutobinyValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autobiny', + parent_name='histogram2dcontour', + **kwargs + ): + super(AutobinyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_autocolorscale.py b/plotly/validators/histogram2dcontour/_autocolorscale.py new file mode 100644 index 0000000000..7ba33b5849 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='histogram2dcontour', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_autocontour.py b/plotly/validators/histogram2dcontour/_autocontour.py new file mode 100644 index 0000000000..f6c585d0c6 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_autocontour.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocontourValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocontour', + parent_name='histogram2dcontour', + **kwargs + ): + super(AutocontourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_colorbar.py b/plotly/validators/histogram2dcontour/_colorbar.py new file mode 100644 index 0000000000..6c0688a4fb --- /dev/null +++ b/plotly/validators/histogram2dcontour/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='histogram2dcontour', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.histogram2dcontour.colorbar.T + ickformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_colorscale.py b/plotly/validators/histogram2dcontour/_colorscale.py new file mode 100644 index 0000000000..cefbe0ba98 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='histogram2dcontour', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_contours.py b/plotly/validators/histogram2dcontour/_contours.py new file mode 100644 index 0000000000..98690b500f --- /dev/null +++ b/plotly/validators/histogram2dcontour/_contours.py @@ -0,0 +1,80 @@ +import _plotly_utils.basevalidators + + +class ContoursValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='contours', + parent_name='histogram2dcontour', + **kwargs + ): + super(ContoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contours', + data_docs=""" + coloring + Determines the coloring method showing the + contour values. If *fill*, coloring is done + evenly between each contour level If *heatmap*, + a heatmap gradient coloring is applied between + each contour level. If *lines*, coloring is + done on the contour lines. If *none*, no + coloring is applied on this trace. + end + Sets the end contour level value. Must be more + than `contours.start` + labelfont + Sets the font used for labeling the contour + levels. The default color comes from the lines, + if shown. The default family and size come from + `layout.font`. + labelformat + Sets the contour label formatting rule using d3 + formatting mini-language which is very similar + to Python, see: https://github.com/d3/d3-format + /blob/master/README.md#locale_format. + operation + Sets the constraint operation. *=* keeps + regions equal to `value` *<* and *<=* keep + regions less than `value` *>* and *>=* keep + regions greater than `value` *[]*, *()*, *[)*, + and *(]* keep regions inside `value[0]` to + `value[1]` *][*, *)(*, *](*, *)[* keep regions + outside `value[0]` to value[1]` Open vs. closed + intervals make no difference to constraint + display, but all versions are allowed for + consistency with filter transforms. + showlabels + Determines whether to label the contour lines + with their values. + showlines + Determines whether or not the contour lines are + drawn. Has an effect only if + `contours.coloring` is set to *fill*. + size + Sets the step between each contour level. Must + be positive. + start + Sets the starting contour level value. Must be + less than `contours.end` + type + If `levels`, the data is represented as a + contour plot with multiple levels displayed. If + `constraint`, the data is represented as + constraints with the invalid region shaded as + specified by the `operation` and `value` + parameters. + value + Sets the value or values of the constraint + boundary. When `operation` is set to one of the + comparison values (=,<,>=,>,<=) *value* is + expected to be a number. When `operation` is + set to one of the interval values + ([],(),[),(],][,)(,](,)[) *value* is expected + to be an array of two numbers where the first + is the lower bound and the second is the upper + bound.""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_customdata.py b/plotly/validators/histogram2dcontour/_customdata.py new file mode 100644 index 0000000000..091017f0ac --- /dev/null +++ b/plotly/validators/histogram2dcontour/_customdata.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='customdata', + parent_name='histogram2dcontour', + **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_customdatasrc.py b/plotly/validators/histogram2dcontour/_customdatasrc.py new file mode 100644 index 0000000000..c9014fef7a --- /dev/null +++ b/plotly/validators/histogram2dcontour/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='histogram2dcontour', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_histfunc.py b/plotly/validators/histogram2dcontour/_histfunc.py new file mode 100644 index 0000000000..4e1f6c7f99 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_histfunc.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class HistfuncValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='histfunc', + parent_name='histogram2dcontour', + **kwargs + ): + super(HistfuncValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['count', 'sum', 'avg', 'min', 'max'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_histnorm.py b/plotly/validators/histogram2dcontour/_histnorm.py new file mode 100644 index 0000000000..6dbecd2098 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_histnorm.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class HistnormValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='histnorm', + parent_name='histogram2dcontour', + **kwargs + ): + super(HistnormValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + '', 'percent', 'probability', 'density', 'probability density' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_hoverinfo.py b/plotly/validators/histogram2dcontour/_hoverinfo.py new file mode 100644 index 0000000000..d1543acfe7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_hoverinfo.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, + plotly_name='hoverinfo', + parent_name='histogram2dcontour', + **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_hoverinfosrc.py b/plotly/validators/histogram2dcontour/_hoverinfosrc.py new file mode 100644 index 0000000000..78a1ba7d74 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='histogram2dcontour', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_hoverlabel.py b/plotly/validators/histogram2dcontour/_hoverlabel.py new file mode 100644 index 0000000000..b3f7276db0 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_hoverlabel.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='hoverlabel', + parent_name='histogram2dcontour', + **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_ids.py b/plotly/validators/histogram2dcontour/_ids.py new file mode 100644 index 0000000000..255ea286b0 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='histogram2dcontour', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_idssrc.py b/plotly/validators/histogram2dcontour/_idssrc.py new file mode 100644 index 0000000000..e722a8a691 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='histogram2dcontour', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_legendgroup.py b/plotly/validators/histogram2dcontour/_legendgroup.py new file mode 100644 index 0000000000..80829cd6b0 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_legendgroup.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='legendgroup', + parent_name='histogram2dcontour', + **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_line.py b/plotly/validators/histogram2dcontour/_line.py new file mode 100644 index 0000000000..600838663d --- /dev/null +++ b/plotly/validators/histogram2dcontour/_line.py @@ -0,0 +1,29 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='histogram2dcontour', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the contour level. Has no + effect if `contours.coloring` is set to + *lines*. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + smoothing + Sets the amount of smoothing for the contour + lines, where *0* corresponds to no smoothing. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_marker.py b/plotly/validators/histogram2dcontour/_marker.py new file mode 100644 index 0000000000..e67560049c --- /dev/null +++ b/plotly/validators/histogram2dcontour/_marker.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='histogram2dcontour', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the aggregation data. + colorsrc + Sets the source reference on plot.ly for color + .""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_name.py b/plotly/validators/histogram2dcontour/_name.py new file mode 100644 index 0000000000..f9fa970b42 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='histogram2dcontour', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_nbinsx.py b/plotly/validators/histogram2dcontour/_nbinsx.py new file mode 100644 index 0000000000..308ea23758 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_nbinsx.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsxValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsx', parent_name='histogram2dcontour', **kwargs + ): + super(NbinsxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_nbinsy.py b/plotly/validators/histogram2dcontour/_nbinsy.py new file mode 100644 index 0000000000..60eaf53939 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_nbinsy.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NbinsyValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nbinsy', parent_name='histogram2dcontour', **kwargs + ): + super(NbinsyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_ncontours.py b/plotly/validators/histogram2dcontour/_ncontours.py new file mode 100644 index 0000000000..f373cee63c --- /dev/null +++ b/plotly/validators/histogram2dcontour/_ncontours.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NcontoursValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='ncontours', + parent_name='histogram2dcontour', + **kwargs + ): + super(NcontoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_opacity.py b/plotly/validators/histogram2dcontour/_opacity.py new file mode 100644 index 0000000000..cf68d2d742 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='histogram2dcontour', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_reversescale.py b/plotly/validators/histogram2dcontour/_reversescale.py new file mode 100644 index 0000000000..f2b040c1e6 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='histogram2dcontour', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_selectedpoints.py b/plotly/validators/histogram2dcontour/_selectedpoints.py new file mode 100644 index 0000000000..54ab8dd340 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='histogram2dcontour', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_showlegend.py b/plotly/validators/histogram2dcontour/_showlegend.py new file mode 100644 index 0000000000..67a60d6dab --- /dev/null +++ b/plotly/validators/histogram2dcontour/_showlegend.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlegend', + parent_name='histogram2dcontour', + **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_showscale.py b/plotly/validators/histogram2dcontour/_showscale.py new file mode 100644 index 0000000000..000610fc39 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='histogram2dcontour', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_stream.py b/plotly/validators/histogram2dcontour/_stream.py new file mode 100644 index 0000000000..1fd236754e --- /dev/null +++ b/plotly/validators/histogram2dcontour/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='histogram2dcontour', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_uid.py b/plotly/validators/histogram2dcontour/_uid.py new file mode 100644 index 0000000000..4a80d6d971 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='histogram2dcontour', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_visible.py b/plotly/validators/histogram2dcontour/_visible.py new file mode 100644 index 0000000000..5908674778 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_visible.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='histogram2dcontour', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_x.py b/plotly/validators/histogram2dcontour/_x.py new file mode 100644 index 0000000000..e9bb8e0275 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='histogram2dcontour', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_xaxis.py b/plotly/validators/histogram2dcontour/_xaxis.py new file mode 100644 index 0000000000..4da448468e --- /dev/null +++ b/plotly/validators/histogram2dcontour/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='histogram2dcontour', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_xbins.py b/plotly/validators/histogram2dcontour/_xbins.py new file mode 100644 index 0000000000..113a3bee86 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_xbins.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class XBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='xbins', parent_name='histogram2dcontour', **kwargs + ): + super(XBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='XBins', + data_docs=""" + end + Sets the end value for the x axis bins. + size + Sets the step in-between value each x axis bin. + start + Sets the starting value for the x axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_xcalendar.py b/plotly/validators/histogram2dcontour/_xcalendar.py new file mode 100644 index 0000000000..22f7547140 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_xcalendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xcalendar', + parent_name='histogram2dcontour', + **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_xsrc.py b/plotly/validators/histogram2dcontour/_xsrc.py new file mode 100644 index 0000000000..65d7416164 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_xsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='xsrc', parent_name='histogram2dcontour', **kwargs + ): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_y.py b/plotly/validators/histogram2dcontour/_y.py new file mode 100644 index 0000000000..841b1a5da6 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='histogram2dcontour', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_yaxis.py b/plotly/validators/histogram2dcontour/_yaxis.py new file mode 100644 index 0000000000..1ec392eda8 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='histogram2dcontour', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_ybins.py b/plotly/validators/histogram2dcontour/_ybins.py new file mode 100644 index 0000000000..85c0b53665 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_ybins.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class YBinsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='ybins', parent_name='histogram2dcontour', **kwargs + ): + super(YBinsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YBins', + data_docs=""" + end + Sets the end value for the y axis bins. + size + Sets the step in-between value each y axis bin. + start + Sets the starting value for the y axis bins.""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_ycalendar.py b/plotly/validators/histogram2dcontour/_ycalendar.py new file mode 100644 index 0000000000..344c7e2739 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_ycalendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ycalendar', + parent_name='histogram2dcontour', + **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_ysrc.py b/plotly/validators/histogram2dcontour/_ysrc.py new file mode 100644 index 0000000000..a9fd432e96 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_ysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ysrc', parent_name='histogram2dcontour', **kwargs + ): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_z.py b/plotly/validators/histogram2dcontour/_z.py new file mode 100644 index 0000000000..940401b3b3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_z.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='z', parent_name='histogram2dcontour', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_zauto.py b/plotly/validators/histogram2dcontour/_zauto.py new file mode 100644 index 0000000000..b8f455653e --- /dev/null +++ b/plotly/validators/histogram2dcontour/_zauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zauto', parent_name='histogram2dcontour', **kwargs + ): + super(ZautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_zhoverformat.py b/plotly/validators/histogram2dcontour/_zhoverformat.py new file mode 100644 index 0000000000..ec39773e8b --- /dev/null +++ b/plotly/validators/histogram2dcontour/_zhoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZhoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='zhoverformat', + parent_name='histogram2dcontour', + **kwargs + ): + super(ZhoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_zmax.py b/plotly/validators/histogram2dcontour/_zmax.py new file mode 100644 index 0000000000..cdf7499e66 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_zmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmax', parent_name='histogram2dcontour', **kwargs + ): + super(ZmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_zmin.py b/plotly/validators/histogram2dcontour/_zmin.py new file mode 100644 index 0000000000..a70c9a1131 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_zmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ZminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zmin', parent_name='histogram2dcontour', **kwargs + ): + super(ZminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/_zsrc.py b/plotly/validators/histogram2dcontour/_zsrc.py new file mode 100644 index 0000000000..ebef35f456 --- /dev/null +++ b/plotly/validators/histogram2dcontour/_zsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='zsrc', parent_name='histogram2dcontour', **kwargs + ): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/__init__.py b/plotly/validators/histogram2dcontour/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram2dcontour/colorbar/_bgcolor.py b/plotly/validators/histogram2dcontour/colorbar/_bgcolor.py new file mode 100644 index 0000000000..861156ce6d --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_bordercolor.py b/plotly/validators/histogram2dcontour/colorbar/_bordercolor.py new file mode 100644 index 0000000000..aba8ab9c3d --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_borderwidth.py b/plotly/validators/histogram2dcontour/colorbar/_borderwidth.py new file mode 100644 index 0000000000..3d61ea8532 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_dtick.py b/plotly/validators/histogram2dcontour/colorbar/_dtick.py new file mode 100644 index 0000000000..e2cfff1227 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_exponentformat.py b/plotly/validators/histogram2dcontour/colorbar/_exponentformat.py new file mode 100644 index 0000000000..dbad2c08f6 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_len.py b/plotly/validators/histogram2dcontour/colorbar/_len.py new file mode 100644 index 0000000000..5c2f8b1538 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_lenmode.py b/plotly/validators/histogram2dcontour/colorbar/_lenmode.py new file mode 100644 index 0000000000..ee98382b58 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_nticks.py b/plotly/validators/histogram2dcontour/colorbar/_nticks.py new file mode 100644 index 0000000000..03a002e5db --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_outlinecolor.py b/plotly/validators/histogram2dcontour/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..b5e229675f --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_outlinewidth.py b/plotly/validators/histogram2dcontour/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..583a6adbcc --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_separatethousands.py b/plotly/validators/histogram2dcontour/colorbar/_separatethousands.py new file mode 100644 index 0000000000..89c47e288c --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_showexponent.py b/plotly/validators/histogram2dcontour/colorbar/_showexponent.py new file mode 100644 index 0000000000..bdf67928f1 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_showticklabels.py b/plotly/validators/histogram2dcontour/colorbar/_showticklabels.py new file mode 100644 index 0000000000..b0f65eb7cb --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_showtickprefix.py b/plotly/validators/histogram2dcontour/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..714bb88fa3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_showticksuffix.py b/plotly/validators/histogram2dcontour/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..78473a6521 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_thickness.py b/plotly/validators/histogram2dcontour/colorbar/_thickness.py new file mode 100644 index 0000000000..79fae518dc --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_thicknessmode.py b/plotly/validators/histogram2dcontour/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..ad4e65ab56 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tick0.py b/plotly/validators/histogram2dcontour/colorbar/_tick0.py new file mode 100644 index 0000000000..f26e4dab28 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickangle.py b/plotly/validators/histogram2dcontour/colorbar/_tickangle.py new file mode 100644 index 0000000000..147f1e635f --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickcolor.py b/plotly/validators/histogram2dcontour/colorbar/_tickcolor.py new file mode 100644 index 0000000000..e6afbc2f31 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickfont.py b/plotly/validators/histogram2dcontour/colorbar/_tickfont.py new file mode 100644 index 0000000000..312f550ace --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickformat.py b/plotly/validators/histogram2dcontour/colorbar/_tickformat.py new file mode 100644 index 0000000000..94de8c6f4b --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickformatstops.py b/plotly/validators/histogram2dcontour/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..55dec863e5 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ticklen.py b/plotly/validators/histogram2dcontour/colorbar/_ticklen.py new file mode 100644 index 0000000000..3ff873efe0 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickmode.py b/plotly/validators/histogram2dcontour/colorbar/_tickmode.py new file mode 100644 index 0000000000..e2393f5a9d --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickprefix.py b/plotly/validators/histogram2dcontour/colorbar/_tickprefix.py new file mode 100644 index 0000000000..ecff399e55 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ticks.py b/plotly/validators/histogram2dcontour/colorbar/_ticks.py new file mode 100644 index 0000000000..317038b1da --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ticksuffix.py b/plotly/validators/histogram2dcontour/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..8b9d6d71e7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ticktext.py b/plotly/validators/histogram2dcontour/colorbar/_ticktext.py new file mode 100644 index 0000000000..c949339640 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ticktextsrc.py b/plotly/validators/histogram2dcontour/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..e43182a88b --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickvals.py b/plotly/validators/histogram2dcontour/colorbar/_tickvals.py new file mode 100644 index 0000000000..227f68e67a --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickvalssrc.py b/plotly/validators/histogram2dcontour/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..4f9bb24e09 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_tickwidth.py b/plotly/validators/histogram2dcontour/colorbar/_tickwidth.py new file mode 100644 index 0000000000..8f5ec20a5e --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_title.py b/plotly/validators/histogram2dcontour/colorbar/_title.py new file mode 100644 index 0000000000..7a8fcf95da --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_titlefont.py b/plotly/validators/histogram2dcontour/colorbar/_titlefont.py new file mode 100644 index 0000000000..1a6542a412 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_titleside.py b/plotly/validators/histogram2dcontour/colorbar/_titleside.py new file mode 100644 index 0000000000..6187e34b1a --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_x.py b/plotly/validators/histogram2dcontour/colorbar/_x.py new file mode 100644 index 0000000000..96cbb00cae --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_xanchor.py b/plotly/validators/histogram2dcontour/colorbar/_xanchor.py new file mode 100644 index 0000000000..34516d9cf9 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_xpad.py b/plotly/validators/histogram2dcontour/colorbar/_xpad.py new file mode 100644 index 0000000000..33a075d966 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_y.py b/plotly/validators/histogram2dcontour/colorbar/_y.py new file mode 100644 index 0000000000..66fcad8019 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_yanchor.py b/plotly/validators/histogram2dcontour/colorbar/_yanchor.py new file mode 100644 index 0000000000..63b2149fbc --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/_ypad.py b/plotly/validators/histogram2dcontour/colorbar/_ypad.py new file mode 100644 index 0000000000..fb6e262ef8 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='histogram2dcontour.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/tickfont/__init__.py b/plotly/validators/histogram2dcontour/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/colorbar/tickfont/_color.py b/plotly/validators/histogram2dcontour/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..5bdbfd9f11 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/tickfont/_family.py b/plotly/validators/histogram2dcontour/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..fae7031be1 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2dcontour.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/tickfont/_size.py b/plotly/validators/histogram2dcontour/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..49973f95f7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/tickformatstop/__init__.py b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..ad8283d0e5 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='histogram2dcontour.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_value.py b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..957e579cd9 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='histogram2dcontour.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/titlefont/__init__.py b/plotly/validators/histogram2dcontour/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/colorbar/titlefont/_color.py b/plotly/validators/histogram2dcontour/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..9f9de6283e --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/titlefont/_family.py b/plotly/validators/histogram2dcontour/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..fb076096c7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2dcontour.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/colorbar/titlefont/_size.py b/plotly/validators/histogram2dcontour/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..360c551501 --- /dev/null +++ b/plotly/validators/histogram2dcontour/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/__init__.py b/plotly/validators/histogram2dcontour/contours/__init__.py new file mode 100644 index 0000000000..2ff9693386 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/__init__.py @@ -0,0 +1,11 @@ +from ._value import ValueValidator +from ._type import TypeValidator +from ._start import StartValidator +from ._size import SizeValidator +from ._showlines import ShowlinesValidator +from ._showlabels import ShowlabelsValidator +from ._operation import OperationValidator +from ._labelformat import LabelformatValidator +from ._labelfont import LabelfontValidator +from ._end import EndValidator +from ._coloring import ColoringValidator diff --git a/plotly/validators/histogram2dcontour/contours/_coloring.py b/plotly/validators/histogram2dcontour/contours/_coloring.py new file mode 100644 index 0000000000..f2e25de088 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_coloring.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColoringValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='coloring', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(ColoringValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fill', 'heatmap', 'lines', 'none'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_end.py b/plotly/validators/histogram2dcontour/contours/_end.py new file mode 100644 index 0000000000..464d8940d3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_end.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='end', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_labelfont.py b/plotly/validators/histogram2dcontour/contours/_labelfont.py new file mode 100644 index 0000000000..3c30c5e1aa --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_labelfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class LabelfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='labelfont', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(LabelfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Labelfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_labelformat.py b/plotly/validators/histogram2dcontour/contours/_labelformat.py new file mode 100644 index 0000000000..a5d5e0dfb0 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_labelformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LabelformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='labelformat', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(LabelformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_operation.py b/plotly/validators/histogram2dcontour/contours/_operation.py new file mode 100644 index 0000000000..376f11518a --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_operation.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class OperationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='operation', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(OperationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + '=', '<', '>=', '>', '<=', '[]', '()', '[)', '(]', '][', ')(', + '](', ')[' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_showlabels.py b/plotly/validators/histogram2dcontour/contours/_showlabels.py new file mode 100644 index 0000000000..196356c81c --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_showlabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlabels', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(ShowlabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_showlines.py b/plotly/validators/histogram2dcontour/contours/_showlines.py new file mode 100644 index 0000000000..74ed551150 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_showlines.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlinesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showlines', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(ShowlinesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_size.py b/plotly/validators/histogram2dcontour/contours/_size.py new file mode 100644 index 0000000000..03e7a7949d --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_start.py b/plotly/validators/histogram2dcontour/contours/_start.py new file mode 100644 index 0000000000..b83162f52a --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_start.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='start', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^autocontour': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_type.py b/plotly/validators/histogram2dcontour/contours/_type.py new file mode 100644 index 0000000000..5845401258 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_type.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['levels', 'constraint'], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/_value.py b/plotly/validators/histogram2dcontour/contours/_value.py new file mode 100644 index 0000000000..6992260807 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='value', + parent_name='histogram2dcontour.contours', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/labelfont/__init__.py b/plotly/validators/histogram2dcontour/contours/labelfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/labelfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/contours/labelfont/_color.py b/plotly/validators/histogram2dcontour/contours/labelfont/_color.py new file mode 100644 index 0000000000..a6aabf644d --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/labelfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.contours.labelfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/labelfont/_family.py b/plotly/validators/histogram2dcontour/contours/labelfont/_family.py new file mode 100644 index 0000000000..672c3c6a4b --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/labelfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2dcontour.contours.labelfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/contours/labelfont/_size.py b/plotly/validators/histogram2dcontour/contours/labelfont/_size.py new file mode 100644 index 0000000000..1904a33375 --- /dev/null +++ b/plotly/validators/histogram2dcontour/contours/labelfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.contours.labelfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/__init__.py b/plotly/validators/histogram2dcontour/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_bgcolor.py b/plotly/validators/histogram2dcontour/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..fba6b89101 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_bgcolorsrc.py b/plotly/validators/histogram2dcontour/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..1e6f8815d7 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_bordercolor.py b/plotly/validators/histogram2dcontour/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..daa1c9b251 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_bordercolorsrc.py b/plotly/validators/histogram2dcontour/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..134bfae906 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_font.py b/plotly/validators/histogram2dcontour/hoverlabel/_font.py new file mode 100644 index 0000000000..d3ae6bdab4 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_namelength.py b/plotly/validators/histogram2dcontour/hoverlabel/_namelength.py new file mode 100644 index 0000000000..ed1350ebc4 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/_namelengthsrc.py b/plotly/validators/histogram2dcontour/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..08bcf85902 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='histogram2dcontour.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/__init__.py b/plotly/validators/histogram2dcontour/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_color.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_color.py new file mode 100644 index 0000000000..775d588c05 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_colorsrc.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..c6a3252ce2 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_family.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_family.py new file mode 100644 index 0000000000..1bd8276fcc --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_familysrc.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..99617a1ffe --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_size.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_size.py new file mode 100644 index 0000000000..c843fd64d3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/hoverlabel/font/_sizesrc.py b/plotly/validators/histogram2dcontour/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..61326e41cb --- /dev/null +++ b/plotly/validators/histogram2dcontour/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='histogram2dcontour.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/line/__init__.py b/plotly/validators/histogram2dcontour/line/__init__.py new file mode 100644 index 0000000000..185c3b5d84 --- /dev/null +++ b/plotly/validators/histogram2dcontour/line/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/line/_color.py b/plotly/validators/histogram2dcontour/line/_color.py new file mode 100644 index 0000000000..4cc8c83975 --- /dev/null +++ b/plotly/validators/histogram2dcontour/line/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style+colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/line/_dash.py b/plotly/validators/histogram2dcontour/line/_dash.py new file mode 100644 index 0000000000..34111ebbf5 --- /dev/null +++ b/plotly/validators/histogram2dcontour/line/_dash.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='dash', + parent_name='histogram2dcontour.line', + **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/line/_smoothing.py b/plotly/validators/histogram2dcontour/line/_smoothing.py new file mode 100644 index 0000000000..a9b2b25abe --- /dev/null +++ b/plotly/validators/histogram2dcontour/line/_smoothing.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='smoothing', + parent_name='histogram2dcontour.line', + **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/line/_width.py b/plotly/validators/histogram2dcontour/line/_width.py new file mode 100644 index 0000000000..b9fa7839c3 --- /dev/null +++ b/plotly/validators/histogram2dcontour/line/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='histogram2dcontour.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style+colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/marker/__init__.py b/plotly/validators/histogram2dcontour/marker/__init__.py new file mode 100644 index 0000000000..e60d2b4c8d --- /dev/null +++ b/plotly/validators/histogram2dcontour/marker/__init__.py @@ -0,0 +1,2 @@ +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/histogram2dcontour/marker/_color.py b/plotly/validators/histogram2dcontour/marker/_color.py new file mode 100644 index 0000000000..f534569e33 --- /dev/null +++ b/plotly/validators/histogram2dcontour/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='color', + parent_name='histogram2dcontour.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/marker/_colorsrc.py b/plotly/validators/histogram2dcontour/marker/_colorsrc.py new file mode 100644 index 0000000000..8c53f1f340 --- /dev/null +++ b/plotly/validators/histogram2dcontour/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='histogram2dcontour.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/stream/__init__.py b/plotly/validators/histogram2dcontour/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/histogram2dcontour/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/histogram2dcontour/stream/_maxpoints.py b/plotly/validators/histogram2dcontour/stream/_maxpoints.py new file mode 100644 index 0000000000..ff6b0aca06 --- /dev/null +++ b/plotly/validators/histogram2dcontour/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='histogram2dcontour.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/stream/_token.py b/plotly/validators/histogram2dcontour/stream/_token.py new file mode 100644 index 0000000000..00695b11ea --- /dev/null +++ b/plotly/validators/histogram2dcontour/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='histogram2dcontour.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/xbins/__init__.py b/plotly/validators/histogram2dcontour/xbins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram2dcontour/xbins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram2dcontour/xbins/_end.py b/plotly/validators/histogram2dcontour/xbins/_end.py new file mode 100644 index 0000000000..6bd4441c10 --- /dev/null +++ b/plotly/validators/histogram2dcontour/xbins/_end.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='end', + parent_name='histogram2dcontour.xbins', + **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/xbins/_size.py b/plotly/validators/histogram2dcontour/xbins/_size.py new file mode 100644 index 0000000000..b9ad6e7179 --- /dev/null +++ b/plotly/validators/histogram2dcontour/xbins/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.xbins', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/xbins/_start.py b/plotly/validators/histogram2dcontour/xbins/_start.py new file mode 100644 index 0000000000..13c459782a --- /dev/null +++ b/plotly/validators/histogram2dcontour/xbins/_start.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='start', + parent_name='histogram2dcontour.xbins', + **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobinx': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/ybins/__init__.py b/plotly/validators/histogram2dcontour/ybins/__init__.py new file mode 100644 index 0000000000..06f4b8ab6a --- /dev/null +++ b/plotly/validators/histogram2dcontour/ybins/__init__.py @@ -0,0 +1,3 @@ +from ._start import StartValidator +from ._size import SizeValidator +from ._end import EndValidator diff --git a/plotly/validators/histogram2dcontour/ybins/_end.py b/plotly/validators/histogram2dcontour/ybins/_end.py new file mode 100644 index 0000000000..1bea8ec6d1 --- /dev/null +++ b/plotly/validators/histogram2dcontour/ybins/_end.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class EndValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='end', + parent_name='histogram2dcontour.ybins', + **kwargs + ): + super(EndValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/ybins/_size.py b/plotly/validators/histogram2dcontour/ybins/_size.py new file mode 100644 index 0000000000..2e5439650b --- /dev/null +++ b/plotly/validators/histogram2dcontour/ybins/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='size', + parent_name='histogram2dcontour.ybins', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/histogram2dcontour/ybins/_start.py b/plotly/validators/histogram2dcontour/ybins/_start.py new file mode 100644 index 0000000000..433ad74282 --- /dev/null +++ b/plotly/validators/histogram2dcontour/ybins/_start.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='start', + parent_name='histogram2dcontour.ybins', + **kwargs + ): + super(StartValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'^autobiny': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/__init__.py b/plotly/validators/layout/__init__.py new file mode 100644 index 0000000000..1e7b7badf4 --- /dev/null +++ b/plotly/validators/layout/__init__.py @@ -0,0 +1,51 @@ +from ._yaxis import YAxisValidator +from ._xaxis import XAxisValidator +from ._width import WidthValidator +from ._violinmode import ViolinmodeValidator +from ._violingroupgap import ViolingroupgapValidator +from ._violingap import ViolingapValidator +from ._updatemenus import UpdatemenusValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._ternary import TernaryValidator +from ._spikedistance import SpikedistanceValidator +from ._sliders import SlidersValidator +from ._showlegend import ShowlegendValidator +from ._shapes import ShapesValidator +from ._separators import SeparatorsValidator +from ._selectdirection import SelectdirectionValidator +from ._scene import SceneValidator +from ._radialaxis import RadialAxisValidator +from ._polar import PolarValidator +from ._plot_bgcolor import PlotBgcolorValidator +from ._paper_bgcolor import PaperBgcolorValidator +from ._orientation import OrientationValidator +from ._margin import MarginValidator +from ._mapbox import MapboxValidator +from ._legend import LegendValidator +from ._images import ImagesValidator +from ._hovermode import HovermodeValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverdistance import HoverdistanceValidator +from ._hidesources import HidesourcesValidator +from ._hiddenlabelssrc import HiddenlabelssrcValidator +from ._hiddenlabels import HiddenlabelsValidator +from ._height import HeightValidator +from ._grid import GridValidator +from ._geo import GeoValidator +from ._font import FontValidator +from ._dragmode import DragmodeValidator +from ._direction import DirectionValidator +from ._datarevision import DatarevisionValidator +from ._colorway import ColorwayValidator +from ._calendar import CalendarValidator +from ._boxmode import BoxmodeValidator +from ._boxgroupgap import BoxgroupgapValidator +from ._boxgap import BoxgapValidator +from ._barnorm import BarnormValidator +from ._barmode import BarmodeValidator +from ._bargroupgap import BargroupgapValidator +from ._bargap import BargapValidator +from ._autosize import AutosizeValidator +from ._annotations import AnnotationsValidator +from ._angularaxis import AngularAxisValidator diff --git a/plotly/validators/layout/_angularaxis.py b/plotly/validators/layout/_angularaxis.py new file mode 100644 index 0000000000..cbe5f875e9 --- /dev/null +++ b/plotly/validators/layout/_angularaxis.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class AngularAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='angularaxis', parent_name='layout', **kwargs + ): + super(AngularAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='AngularAxis', + data_docs=""" + domain + Polar chart subplots are not supported yet. + This key has currently no effect. + endpadding + + range + Defines the start and end point of this angular + axis. + showline + Determines whether or not the line bounding + this angular axis will be shown on the figure. + showticklabels + Determines whether or not the angular axis + ticks will feature tick labels. + tickcolor + Sets the color of the tick lines on this + angular axis. + ticklen + Sets the length of the tick lines on this + angular axis. + tickorientation + Sets the orientation (from the paper + perspective) of the angular axis tick labels. + ticksuffix + Sets the length of the tick lines on this + angular axis. + visible + Determines whether or not this axis will be + visible.""", + **kwargs + ) diff --git a/plotly/validators/layout/_annotations.py b/plotly/validators/layout/_annotations.py new file mode 100644 index 0000000000..8af6dcb99e --- /dev/null +++ b/plotly/validators/layout/_annotations.py @@ -0,0 +1,257 @@ +import _plotly_utils.basevalidators + + +class AnnotationsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, plotly_name='annotations', parent_name='layout', **kwargs + ): + super(AnnotationsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Annotation', + data_docs=""" + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + arrowwidth + Sets the width (in px) of annotation arrow + line. + ax + Sets the x component of the arrow tail about + the arrow head. If `axref` is `pixel`, a + positive (negative) component corresponds to + an arrow pointing from right to left (left to + right). If `axref` is an axis, this is an + absolute value on that axis, like `x`, NOT a + relative value. + axref + Indicates in what terms the tail of the + annotation (ax,ay) is specified. If `pixel`, + `ax` is a relative offset in pixels from `x`. + If set to an x axis id (e.g. *x* or *x2*), `ax` + is specified in the same terms as that axis. + This is useful for trendline annotations which + should continue to indicate the correct trend + when zoomed. + ay + Sets the y component of the arrow tail about + the arrow head. If `ayref` is `pixel`, a + positive (negative) component corresponds to + an arrow pointing from bottom to top (top to + bottom). If `ayref` is an axis, this is an + absolute value on that axis, like `y`, NOT a + relative value. + ayref + Indicates in what terms the tail of the + annotation (ax,ay) is specified. If `pixel`, + `ay` is a relative offset in pixels from `y`. + If set to a y axis id (e.g. *y* or *y2*), `ay` + is specified in the same terms as that axis. + This is useful for trendline annotations which + should continue to indicate the correct trend + when zoomed. + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the + annotation `text`. + borderpad + Sets the padding (in px) between the `text` and + the enclosing border. + borderwidth + Sets the width (in px) of the border enclosing + the annotation `text`. + captureevents + Determines whether the annotation text box + captures mouse move and click events, or allows + those events to pass through to data points in + the plot that may be behind the annotation. By + default `captureevents` is *false* unless + `hovertext` is provided. If you use the event + `plotly_clickannotation` without `hovertext` + you must explicitly enable `captureevents`. + clicktoshow + Makes this annotation respond to clicks on the + plot. If you click a data point that exactly + matches the `x` and `y` values of this + annotation, and it is hidden (visible: false), + it will appear. In *onoff* mode, you must click + the same point again to make it disappear, so + if you click multiple points, you can show + multiple annotations. In *onout* mode, a click + anywhere else in the plot (on another data + point or not) will hide this annotation. If you + need to show/hide this annotation in response + to different `x` or `y` values, you can set + `xclick` and/or `yclick`. This is useful for + example to label the side of a bar. To label + markers though, `standoff` is preferred over + `xclick` and `yclick`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. + Taller text will be clipped. + hoverlabel + plotly.graph_objs.layout.annotation.Hoverlabel + instance or dict with compatible properties + hovertext + Sets text to appear when hovering over this + annotation. If omitted or blank, no hover label + will appear. + opacity + Sets the opacity of the annotation (text + + arrow). + showarrow + Determines whether or not the annotation is + drawn with an arrow. If *true*, `text` is + placed near the arrow's tail. If *false*, + `text` lines up with the `x` and `y` provided. + standoff + Sets a distance, in pixels, to move the end + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow + head, relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + startstandoff + Sets a distance, in pixels, to move the start + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. + Plotly uses a subset of HTML tags to do things + like newline (
), bold (), italics + (), hyperlinks (). + Tags , , are also + supported. + textangle + Sets the angle at which the `text` is drawn + with respect to the horizontal. + valign + Sets the vertical alignment of the `text` + within the box. Has an effect only if an + explicit height is set to override the text + height. + visible + Determines whether or not this annotation is + visible. + width + Sets an explicit width for the text box. null + (default) lets the text set the box width. + Wider text will be clipped. There is no + automatic wrapping; use
to start a new + line. + x + Sets the annotation's x position. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + xanchor + Sets the text box's horizontal position anchor + This anchor binds the `x` position to the + *left*, *center* or *right* of the annotation. + For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the + right-most portion of the annotation lines up + with the right-most edge of the plotting area. + If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + xclick + Toggle this annotation when clicking a data + point whose `x` value is `xclick` rather than + the annotation's `x` value. + xref + Sets the annotation's x coordinate axis. If set + to an x axis id (e.g. *x* or *x2*), the `x` + position refers to an x coordinate If set to + *paper*, the `x` position refers to the + distance from the left side of the plotting + area in normalized coordinates where 0 (1) + corresponds to the left (right) side. + xshift + Shifts the position of the whole annotation and + arrow to the right (positive) or left + (negative) by this many pixels. + y + Sets the annotation's y position. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + yanchor + Sets the text box's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the annotation. + For example, if `y` is set to 1, `yref` to + *paper* and `yanchor` to *top* then the top- + most portion of the annotation lines up with + the top-most edge of the plotting area. If + *auto*, the anchor is equivalent to *middle* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + yclick + Toggle this annotation when clicking a data + point whose `y` value is `yclick` rather than + the annotation's `y` value. + yref + Sets the annotation's y coordinate axis. If set + to an y axis id (e.g. *y* or *y2*), the `y` + position refers to an y coordinate If set to + *paper*, the `y` position refers to the + distance from the bottom of the plotting area + in normalized coordinates where 0 (1) + corresponds to the bottom (top). + yshift + Shifts the position of the whole annotation and + arrow up (positive) or down (negative) by this + many pixels.""", + **kwargs + ) diff --git a/plotly/validators/layout/_autosize.py b/plotly/validators/layout/_autosize.py new file mode 100644 index 0000000000..ca43694fd6 --- /dev/null +++ b/plotly/validators/layout/_autosize.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class AutosizeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='autosize', parent_name='layout', **kwargs): + super(AutosizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_bargap.py b/plotly/validators/layout/_bargap.py new file mode 100644 index 0000000000..e5a0147cdf --- /dev/null +++ b/plotly/validators/layout/_bargap.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BargapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='bargap', parent_name='layout', **kwargs): + super(BargapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_bargroupgap.py b/plotly/validators/layout/_bargroupgap.py new file mode 100644 index 0000000000..35866cdbc5 --- /dev/null +++ b/plotly/validators/layout/_bargroupgap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class BargroupgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='bargroupgap', parent_name='layout', **kwargs + ): + super(BargroupgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_barmode.py b/plotly/validators/layout/_barmode.py new file mode 100644 index 0000000000..219d3bee75 --- /dev/null +++ b/plotly/validators/layout/_barmode.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BarmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='barmode', parent_name='layout', **kwargs): + super(BarmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['stack', 'group', 'overlay', 'relative'], + **kwargs + ) diff --git a/plotly/validators/layout/_barnorm.py b/plotly/validators/layout/_barnorm.py new file mode 100644 index 0000000000..dcfe90a230 --- /dev/null +++ b/plotly/validators/layout/_barnorm.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BarnormValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='barnorm', parent_name='layout', **kwargs): + super(BarnormValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['', 'fraction', 'percent'], + **kwargs + ) diff --git a/plotly/validators/layout/_boxgap.py b/plotly/validators/layout/_boxgap.py new file mode 100644 index 0000000000..34612556c0 --- /dev/null +++ b/plotly/validators/layout/_boxgap.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BoxgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='boxgap', parent_name='layout', **kwargs): + super(BoxgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_boxgroupgap.py b/plotly/validators/layout/_boxgroupgap.py new file mode 100644 index 0000000000..db40da8872 --- /dev/null +++ b/plotly/validators/layout/_boxgroupgap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class BoxgroupgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='boxgroupgap', parent_name='layout', **kwargs + ): + super(BoxgroupgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_boxmode.py b/plotly/validators/layout/_boxmode.py new file mode 100644 index 0000000000..9cdf71ee35 --- /dev/null +++ b/plotly/validators/layout/_boxmode.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BoxmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='boxmode', parent_name='layout', **kwargs): + super(BoxmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['group', 'overlay'], + **kwargs + ) diff --git a/plotly/validators/layout/_calendar.py b/plotly/validators/layout/_calendar.py new file mode 100644 index 0000000000..f8b6e6f8cc --- /dev/null +++ b/plotly/validators/layout/_calendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='calendar', parent_name='layout', **kwargs): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/_colorway.py b/plotly/validators/layout/_colorway.py new file mode 100644 index 0000000000..2a7a7800eb --- /dev/null +++ b/plotly/validators/layout/_colorway.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ColorwayValidator(_plotly_utils.basevalidators.ColorlistValidator): + + def __init__(self, plotly_name='colorway', parent_name='layout', **kwargs): + super(ColorwayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_datarevision.py b/plotly/validators/layout/_datarevision.py new file mode 100644 index 0000000000..7f4a6586bd --- /dev/null +++ b/plotly/validators/layout/_datarevision.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class DatarevisionValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='datarevision', parent_name='layout', **kwargs + ): + super(DatarevisionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_direction.py b/plotly/validators/layout/_direction.py new file mode 100644 index 0000000000..a78dc22170 --- /dev/null +++ b/plotly/validators/layout/_direction.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DirectionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='direction', parent_name='layout', **kwargs + ): + super(DirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['clockwise', 'counterclockwise'], + **kwargs + ) diff --git a/plotly/validators/layout/_dragmode.py b/plotly/validators/layout/_dragmode.py new file mode 100644 index 0000000000..e2554ee931 --- /dev/null +++ b/plotly/validators/layout/_dragmode.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DragmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='dragmode', parent_name='layout', **kwargs): + super(DragmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='modebar', + role='info', + values=['zoom', 'pan', 'select', 'lasso', 'orbit', 'turntable'], + **kwargs + ) diff --git a/plotly/validators/layout/_font.py b/plotly/validators/layout/_font.py new file mode 100644 index 0000000000..c3ffe8e3a8 --- /dev/null +++ b/plotly/validators/layout/_font.py @@ -0,0 +1,33 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='font', parent_name='layout', **kwargs): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/_geo.py b/plotly/validators/layout/_geo.py new file mode 100644 index 0000000000..67f2a66f42 --- /dev/null +++ b/plotly/validators/layout/_geo.py @@ -0,0 +1,85 @@ +import _plotly_utils.basevalidators + + +class GeoValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='geo', parent_name='layout', **kwargs): + super(GeoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Geo', + data_docs=""" + bgcolor + Set the background color of the map + center + plotly.graph_objs.layout.geo.Center instance or + dict with compatible properties + coastlinecolor + Sets the coastline color. + coastlinewidth + Sets the coastline stroke width (in px). + countrycolor + Sets line color of the country boundaries. + countrywidth + Sets line width (in px) of the country + boundaries. + domain + plotly.graph_objs.layout.geo.Domain instance or + dict with compatible properties + framecolor + Sets the color the frame. + framewidth + Sets the stroke width (in px) of the frame. + lakecolor + Sets the color of the lakes. + landcolor + Sets the land mass color. + lataxis + plotly.graph_objs.layout.geo.Lataxis instance + or dict with compatible properties + lonaxis + plotly.graph_objs.layout.geo.Lonaxis instance + or dict with compatible properties + oceancolor + Sets the ocean color + projection + plotly.graph_objs.layout.geo.Projection + instance or dict with compatible properties + resolution + Sets the resolution of the base layers. The + values have units of km/mm e.g. 110 corresponds + to a scale ratio of 1:110,000,000. + rivercolor + Sets color of the rivers. + riverwidth + Sets the stroke width (in px) of the rivers. + scope + Set the scope of the map. + showcoastlines + Sets whether or not the coastlines are drawn. + showcountries + Sets whether or not country boundaries are + drawn. + showframe + Sets whether or not a frame is drawn around the + map. + showlakes + Sets whether or not lakes are drawn. + showland + Sets whether or not land masses are filled in + color. + showocean + Sets whether or not oceans are filled in color. + showrivers + Sets whether or not rivers are drawn. + showsubunits + Sets whether or not boundaries of subunits + within countries (e.g. states, provinces) are + drawn. + subunitcolor + Sets the color of the subunits boundaries. + subunitwidth + Sets the stroke width (in px) of the subunits + boundaries.""", + **kwargs + ) diff --git a/plotly/validators/layout/_grid.py b/plotly/validators/layout/_grid.py new file mode 100644 index 0000000000..4f5ef8bb99 --- /dev/null +++ b/plotly/validators/layout/_grid.py @@ -0,0 +1,92 @@ +import _plotly_utils.basevalidators + + +class GridValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='grid', parent_name='layout', **kwargs): + super(GridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Grid', + data_docs=""" + columns + The number of columns in the grid. If you + provide a 2D `subplots` array, the length of + its longest row is used as the default. If you + give an `xaxes` array, its length is used as + the default. But it's also possible to have a + different length, if you want to leave a row at + the end for non-cartesian subplots. + domain + plotly.graph_objs.layout.grid.Domain instance + or dict with compatible properties + pattern + If no `subplots`, `xaxes`, or `yaxes` are given + but we do have `rows` and `columns`, we can + generate defaults using consecutive axis IDs, + in two ways: *coupled* gives one x axis per + column and one y axis per row. *independent* + uses a new xy pair for each cell, left-to-right + across each row then iterating rows according + to `roworder`. + roworder + Is the first row the top or the bottom? Note + that columns are always enumerated from left to + right. + rows + The number of rows in the grid. If you provide + a 2D `subplots` array or a `yaxes` array, its + length is used as the default. But it's also + possible to have a different length, if you + want to leave a row at the end for non- + cartesian subplots. + subplots + Used for freeform grids, where some axes may be + shared across subplots but others are not. Each + entry should be a cartesian subplot id, like + *xy* or *x3y2*, or ** to leave that cell empty. + You may reuse x axes within the same column, + and y axes within the same row. Non-cartesian + subplots and traces that support `domain` can + place themselves in this grid separately using + the `gridcell` attribute. + xaxes + Used with `yaxes` when the x and y axes are + shared across columns and rows. Each entry + should be an x axis id like *x*, *x2*, etc., or + ** to not put an x axis in that column. Entries + other than ** must be unique. Ignored if + `subplots` is present. If missing but `yaxes` + is present, will generate consecutive IDs. + xgap + Horizontal space between grid cells, expressed + as a fraction of the total width available to + one cell. Defaults to 0.1 for coupled-axes + grids and 0.2 for independent grids. + xside + Sets where the x axis labels and titles go. + *bottom* means the very bottom of the grid. + *bottom plot* is the lowest plot that each x + axis is used in. *top* and *top plot* are + similar. + yaxes + Used with `yaxes` when the x and y axes are + shared across columns and rows. Each entry + should be an y axis id like *y*, *y2*, etc., or + ** to not put a y axis in that row. Entries + other than ** must be unique. Ignored if + `subplots` is present. If missing but `xaxes` + is present, will generate consecutive IDs. + ygap + Vertical space between grid cells, expressed as + a fraction of the total height available to one + cell. Defaults to 0.1 for coupled-axes grids + and 0.3 for independent grids. + yside + Sets where the y axis labels and titles go. + *left* means the very left edge of the grid. + *left plot* is the leftmost plot that each y + axis is used in. *right* and *right plot* are + similar.""", + **kwargs + ) diff --git a/plotly/validators/layout/_height.py b/plotly/validators/layout/_height.py new file mode 100644 index 0000000000..a2a9dcd18c --- /dev/null +++ b/plotly/validators/layout/_height.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class HeightValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='height', parent_name='layout', **kwargs): + super(HeightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=10, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_hiddenlabels.py b/plotly/validators/layout/_hiddenlabels.py new file mode 100644 index 0000000000..586b79e2f1 --- /dev/null +++ b/plotly/validators/layout/_hiddenlabels.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HiddenlabelsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='hiddenlabels', parent_name='layout', **kwargs + ): + super(HiddenlabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/_hiddenlabelssrc.py b/plotly/validators/layout/_hiddenlabelssrc.py new file mode 100644 index 0000000000..6b3dcedc24 --- /dev/null +++ b/plotly/validators/layout/_hiddenlabelssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HiddenlabelssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hiddenlabelssrc', parent_name='layout', **kwargs + ): + super(HiddenlabelssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_hidesources.py b/plotly/validators/layout/_hidesources.py new file mode 100644 index 0000000000..310da7c29e --- /dev/null +++ b/plotly/validators/layout/_hidesources.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HidesourcesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='hidesources', parent_name='layout', **kwargs + ): + super(HidesourcesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_hoverdistance.py b/plotly/validators/layout/_hoverdistance.py new file mode 100644 index 0000000000..feb973fc02 --- /dev/null +++ b/plotly/validators/layout/_hoverdistance.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverdistanceValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='hoverdistance', parent_name='layout', **kwargs + ): + super(HoverdistanceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + min=-1, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_hoverlabel.py b/plotly/validators/layout/_hoverlabel.py new file mode 100644 index 0000000000..5cd8c15418 --- /dev/null +++ b/plotly/validators/layout/_hoverlabel.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='layout', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of all hover labels + on graph + bordercolor + Sets the border color of all hover labels on + graph. + font + Sets the default hover label font used by all + traces on the graph. + namelength + Sets the default length (in number of + characters) of the trace name in the hover + labels for all traces. -1 shows the whole name + regardless of length. 0-3 shows the first 0-3 + characters, and an integer >3 will show the + whole name if it is less than that many + characters, but if it is longer, will truncate + to `namelength - 3` characters and add an + ellipsis.""", + **kwargs + ) diff --git a/plotly/validators/layout/_hovermode.py b/plotly/validators/layout/_hovermode.py new file mode 100644 index 0000000000..a3ba20b7ec --- /dev/null +++ b/plotly/validators/layout/_hovermode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovermodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='hovermode', parent_name='layout', **kwargs + ): + super(HovermodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='modebar', + role='info', + values=['x', 'y', 'closest', False], + **kwargs + ) diff --git a/plotly/validators/layout/_images.py b/plotly/validators/layout/_images.py new file mode 100644 index 0000000000..1b1baf4c18 --- /dev/null +++ b/plotly/validators/layout/_images.py @@ -0,0 +1,69 @@ +import _plotly_utils.basevalidators + + +class ImagesValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__(self, plotly_name='images', parent_name='layout', **kwargs): + super(ImagesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Image', + data_docs=""" + layer + Specifies whether images are drawn below or + above traces. When `xref` and `yref` are both + set to `paper`, image is drawn below the entire + plot area. + opacity + Sets the opacity of the image. + sizex + Sets the image container size horizontally. The + image will be sized based on the `position` + value. When `xref` is set to `paper`, units are + sized relative to the plot width. + sizey + Sets the image container size vertically. The + image will be sized based on the `position` + value. When `yref` is set to `paper`, units are + sized relative to the plot height. + sizing + Specifies which dimension of the image to + constrain. + source + Specifies the URL of the image to be used. The + URL must be accessible from the domain where + the plot code is run, and can be either + relative or absolute. + visible + Determines whether or not this image is + visible. + x + Sets the image's x position. When `xref` is set + to `paper`, units are sized relative to the + plot height. See `xref` for more info + xanchor + Sets the anchor for the x position + xref + Sets the images's x coordinate axis. If set to + a x axis id (e.g. *x* or *x2*), the `x` + position refers to an x data coordinate If set + to *paper*, the `x` position refers to the + distance from the left of plot in normalized + coordinates where *0* (*1*) corresponds to the + left (right). + y + Sets the image's y position. When `yref` is set + to `paper`, units are sized relative to the + plot height. See `yref` for more info + yanchor + Sets the anchor for the y position. + yref + Sets the images's y coordinate axis. If set to + a y axis id (e.g. *y* or *y2*), the `y` + position refers to a y data coordinate. If set + to *paper*, the `y` position refers to the + distance from the bottom of the plot in + normalized coordinates where *0* (*1*) + corresponds to the bottom (top).""", + **kwargs + ) diff --git a/plotly/validators/layout/_legend.py b/plotly/validators/layout/_legend.py new file mode 100644 index 0000000000..451ddec5ef --- /dev/null +++ b/plotly/validators/layout/_legend.py @@ -0,0 +1,52 @@ +import _plotly_utils.basevalidators + + +class LegendValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='legend', parent_name='layout', **kwargs): + super(LegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Legend', + data_docs=""" + bgcolor + Sets the legend background color. + bordercolor + Sets the color of the border enclosing the + legend. + borderwidth + Sets the width (in px) of the border enclosing + the legend. + font + Sets the font used to text the legend items. + orientation + Sets the orientation of the legend. + tracegroupgap + Sets the amount of vertical space (in px) + between legend groups. + traceorder + Determines the order at which the legend items + are displayed. If *normal*, the items are + displayed top-to-bottom in the same order as + the input data. If *reversed*, the items are + displayed in the opposite order as *normal*. If + *grouped*, the items are displayed in groups + (when a trace `legendgroup` is provided). if + *grouped+reversed*, the items are displayed in + the opposite order as *grouped*. + x + Sets the x position (in normalized coordinates) + of the legend. + xanchor + Sets the legend's horizontal position anchor. + This anchor binds the `x` position to the + *left*, *center* or *right* of the legend. + y + Sets the y position (in normalized coordinates) + of the legend. + yanchor + Sets the legend's vertical position anchor This + anchor binds the `y` position to the *top*, + *middle* or *bottom* of the legend.""", + **kwargs + ) diff --git a/plotly/validators/layout/_mapbox.py b/plotly/validators/layout/_mapbox.py new file mode 100644 index 0000000000..45bb95be3e --- /dev/null +++ b/plotly/validators/layout/_mapbox.py @@ -0,0 +1,40 @@ +import _plotly_utils.basevalidators + + +class MapboxValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='mapbox', parent_name='layout', **kwargs): + super(MapboxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Mapbox', + data_docs=""" + accesstoken + Sets the mapbox access token to be used for + this mapbox map. Alternatively, the mapbox + access token can be set in the configuration + options under `mapboxAccessToken`. + bearing + Sets the bearing angle of the map (in degrees + counter-clockwise from North). + center + plotly.graph_objs.layout.mapbox.Center instance + or dict with compatible properties + domain + plotly.graph_objs.layout.mapbox.Domain instance + or dict with compatible properties + layers + plotly.graph_objs.layout.mapbox.Layer instance + or dict with compatible properties + pitch + Sets the pitch angle of the map (in degrees, + where *0* means perpendicular to the surface of + the map). + style + Sets the Mapbox map style. Either input one of + the default Mapbox style names or the URL to a + custom style or a valid Mapbox style JSON. + zoom + Sets the zoom level of the map.""", + **kwargs + ) diff --git a/plotly/validators/layout/_margin.py b/plotly/validators/layout/_margin.py new file mode 100644 index 0000000000..5ebdbce81d --- /dev/null +++ b/plotly/validators/layout/_margin.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class MarginValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='margin', parent_name='layout', **kwargs): + super(MarginValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Margin', + data_docs=""" + autoexpand + + b + Sets the bottom margin (in px). + l + Sets the left margin (in px). + pad + Sets the amount of padding (in px) between the + plotting area and the axis lines + r + Sets the right margin (in px). + t + Sets the top margin (in px).""", + **kwargs + ) diff --git a/plotly/validators/layout/_orientation.py b/plotly/validators/layout/_orientation.py new file mode 100644 index 0000000000..ee48717552 --- /dev/null +++ b/plotly/validators/layout/_orientation.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='orientation', parent_name='layout', **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_paper_bgcolor.py b/plotly/validators/layout/_paper_bgcolor.py new file mode 100644 index 0000000000..09ed5f0cf9 --- /dev/null +++ b/plotly/validators/layout/_paper_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PaperBgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='paper_bgcolor', parent_name='layout', **kwargs + ): + super(PaperBgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_plot_bgcolor.py b/plotly/validators/layout/_plot_bgcolor.py new file mode 100644 index 0000000000..846339f358 --- /dev/null +++ b/plotly/validators/layout/_plot_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PlotBgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='plot_bgcolor', parent_name='layout', **kwargs + ): + super(PlotBgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_polar.py b/plotly/validators/layout/_polar.py new file mode 100644 index 0000000000..21265ae1d3 --- /dev/null +++ b/plotly/validators/layout/_polar.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class PolarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='polar', parent_name='layout', **kwargs): + super(PolarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Polar', + data_docs=""" + angularaxis + plotly.graph_objs.layout.polar.AngularAxis + instance or dict with compatible properties + bgcolor + Set the background color of the subplot + domain + plotly.graph_objs.layout.polar.Domain instance + or dict with compatible properties + radialaxis + plotly.graph_objs.layout.polar.RadialAxis + instance or dict with compatible properties + sector + Sets angular span of this polar subplot with + two angles (in degrees). Sector are assumed to + be spanned in the counterclockwise direction + with *0* corresponding to rightmost limit of + the polar subplot.""", + **kwargs + ) diff --git a/plotly/validators/layout/_radialaxis.py b/plotly/validators/layout/_radialaxis.py new file mode 100644 index 0000000000..09f2b98fd6 --- /dev/null +++ b/plotly/validators/layout/_radialaxis.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class RadialAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='radialaxis', parent_name='layout', **kwargs + ): + super(RadialAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='RadialAxis', + data_docs=""" + domain + Polar chart subplots are not supported yet. + This key has currently no effect. + endpadding + + orientation + Sets the orientation (an angle with respect to + the origin) of the radial axis. + range + Defines the start and end point of this radial + axis. + showline + Determines whether or not the line bounding + this radial axis will be shown on the figure. + showticklabels + Determines whether or not the radial axis ticks + will feature tick labels. + tickcolor + Sets the color of the tick lines on this radial + axis. + ticklen + Sets the length of the tick lines on this + radial axis. + tickorientation + Sets the orientation (from the paper + perspective) of the radial axis tick labels. + ticksuffix + Sets the length of the tick lines on this + radial axis. + visible + Determines whether or not this axis will be + visible.""", + **kwargs + ) diff --git a/plotly/validators/layout/_scene.py b/plotly/validators/layout/_scene.py new file mode 100644 index 0000000000..4b9dea01bc --- /dev/null +++ b/plotly/validators/layout/_scene.py @@ -0,0 +1,54 @@ +import _plotly_utils.basevalidators + + +class SceneValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='scene', parent_name='layout', **kwargs): + super(SceneValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Scene', + data_docs=""" + annotations + plotly.graph_objs.layout.scene.Annotation + instance or dict with compatible properties + aspectmode + If *cube*, this scene's axes are drawn as a + cube, regardless of the axes' ranges. If + *data*, this scene's axes are drawn in + proportion with the axes' ranges. If *manual*, + this scene's axes are drawn in proportion with + the input of *aspectratio* (the default + behavior if *aspectratio* is provided). If + *auto*, this scene's axes are drawn using the + results of *data* except when one axis is more + than four times the size of the two others, + where in that case the results of *cube* are + used. + aspectratio + Sets this scene's axis aspectratio. + bgcolor + + camera + plotly.graph_objs.layout.scene.Camera instance + or dict with compatible properties + domain + plotly.graph_objs.layout.scene.Domain instance + or dict with compatible properties + dragmode + Determines the mode of drag interactions for + this scene. + hovermode + Determines the mode of hover interactions for + this scene. + xaxis + plotly.graph_objs.layout.scene.XAxis instance + or dict with compatible properties + yaxis + plotly.graph_objs.layout.scene.YAxis instance + or dict with compatible properties + zaxis + plotly.graph_objs.layout.scene.ZAxis instance + or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/layout/_selectdirection.py b/plotly/validators/layout/_selectdirection.py new file mode 100644 index 0000000000..a069adcf9e --- /dev/null +++ b/plotly/validators/layout/_selectdirection.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectdirectionValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, plotly_name='selectdirection', parent_name='layout', **kwargs + ): + super(SelectdirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + values=['h', 'v', 'd', 'any'], + **kwargs + ) diff --git a/plotly/validators/layout/_separators.py b/plotly/validators/layout/_separators.py new file mode 100644 index 0000000000..25103da31a --- /dev/null +++ b/plotly/validators/layout/_separators.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SeparatorsValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='separators', parent_name='layout', **kwargs + ): + super(SeparatorsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_shapes.py b/plotly/validators/layout/_shapes.py new file mode 100644 index 0000000000..0ac6e3637e --- /dev/null +++ b/plotly/validators/layout/_shapes.py @@ -0,0 +1,138 @@ +import _plotly_utils.basevalidators + + +class ShapesValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__(self, plotly_name='shapes', parent_name='layout', **kwargs): + super(ShapesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Shape', + data_docs=""" + fillcolor + Sets the color filling the shape's interior. + layer + Specifies whether shapes are drawn below or + above traces. + line + plotly.graph_objs.layout.shape.Line instance or + dict with compatible properties + opacity + Sets the opacity of the shape. + path + For `type` *path* - a valid SVG path with the + pixel values replaced by data values in + `xsizemode`/`ysizemode` being *scaled* and + taken unmodified as pixels relative to + `xanchor` and `yanchor` in case of *pixel* size + mode. There are a few restrictions / quirks + only absolute instructions, not relative. So + the allowed segments are: M, L, H, V, Q, C, T, + S, and Z arcs (A) are not allowed because + radius rx and ry are relative. In the future we + could consider supporting relative commands, + but we would have to decide on how to handle + date and log axes. Note that even as is, Q and + C Bezier paths that are smooth on linear axes + may not be smooth on log, and vice versa. no + chained "polybezier" commands - specify the + segment type for each one. On category axes, + values are numbers scaled to the serial numbers + of categories because using the categories + themselves there would be no way to describe + fractional positions On data axes: because + space and T are both normal components of path + strings, we can't use either to separate date + from time parts. Therefore we'll use underscore + for this purpose: 2015-02-21_13:45:56.789 + type + Specifies the shape type to be drawn. If + *line*, a line is drawn from (`x0`,`y0`) to + (`x1`,`y1`) with respect to the axes' sizing + mode. If *circle*, a circle is drawn from + ((`x0`+`x1`)/2, (`y0`+`y1`)/2)) with radius + (|(`x0`+`x1`)/2 - `x0`|, |(`y0`+`y1`)/2 + -`y0`)|) with respect to the axes' sizing mode. + If *rect*, a rectangle is drawn linking + (`x0`,`y0`), (`x1`,`y0`), (`x1`,`y1`), + (`x0`,`y1`), (`x0`,`y0`) with respect to the + axes' sizing mode. If *path*, draw a custom SVG + path using `path`. with respect to the axes' + sizing mode. + visible + Determines whether or not this shape is + visible. + x0 + Sets the shape's starting x position. See + `type` and `xsizemode` for more info. + x1 + Sets the shape's end x position. See `type` and + `xsizemode` for more info. + xanchor + Only relevant in conjunction with `xsizemode` + set to *pixel*. Specifies the anchor point on + the x axis to which `x0`, `x1` and x + coordinates within `path` are relative to. E.g. + useful to attach a pixel sized shape to a + certain data value. No effect when `xsizemode` + not set to *pixel*. + xref + Sets the shape's x coordinate axis. If set to + an x axis id (e.g. *x* or *x2*), the `x` + position refers to an x coordinate. If set to + *paper*, the `x` position refers to the + distance from the left side of the plotting + area in normalized coordinates where *0* (*1*) + corresponds to the left (right) side. If the + axis `type` is *log*, then you must take the + log of your desired range. If the axis `type` + is *date*, then you must convert the date to + unix time in milliseconds. + xsizemode + Sets the shapes's sizing mode along the x axis. + If set to *scaled*, `x0`, `x1` and x + coordinates within `path` refer to data values + on the x axis or a fraction of the plot area's + width (`xref` set to *paper*). If set to + *pixel*, `xanchor` specifies the x position in + terms of data or plot fraction but `x0`, `x1` + and x coordinates within `path` are pixels + relative to `xanchor`. This way, the shape can + have a fixed width while maintaining a position + relative to data or plot fraction. + y0 + Sets the shape's starting y position. See + `type` and `ysizemode` for more info. + y1 + Sets the shape's end y position. See `type` and + `ysizemode` for more info. + yanchor + Only relevant in conjunction with `ysizemode` + set to *pixel*. Specifies the anchor point on + the y axis to which `y0`, `y1` and y + coordinates within `path` are relative to. E.g. + useful to attach a pixel sized shape to a + certain data value. No effect when `ysizemode` + not set to *pixel*. + yref + Sets the annotation's y coordinate axis. If set + to an y axis id (e.g. *y* or *y2*), the `y` + position refers to an y coordinate If set to + *paper*, the `y` position refers to the + distance from the bottom of the plotting area + in normalized coordinates where *0* (*1*) + corresponds to the bottom (top). + ysizemode + Sets the shapes's sizing mode along the y axis. + If set to *scaled*, `y0`, `y1` and y + coordinates within `path` refer to data values + on the y axis or a fraction of the plot area's + height (`yref` set to *paper*). If set to + *pixel*, `yanchor` specifies the y position in + terms of data or plot fraction but `y0`, `y1` + and y coordinates within `path` are pixels + relative to `yanchor`. This way, the shape can + have a fixed height while maintaining a + position relative to data or plot fraction.""", + **kwargs + ) diff --git a/plotly/validators/layout/_showlegend.py b/plotly/validators/layout/_showlegend.py new file mode 100644 index 0000000000..627f4d0cd8 --- /dev/null +++ b/plotly/validators/layout/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='layout', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_sliders.py b/plotly/validators/layout/_sliders.py new file mode 100644 index 0000000000..4fad121b42 --- /dev/null +++ b/plotly/validators/layout/_sliders.py @@ -0,0 +1,78 @@ +import _plotly_utils.basevalidators + + +class SlidersValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__(self, plotly_name='sliders', parent_name='layout', **kwargs): + super(SlidersValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Slider', + data_docs=""" + active + Determines which button (by index starting from + 0) is considered active. + activebgcolor + Sets the background color of the slider grip + while dragging. + bgcolor + Sets the background color of the slider. + bordercolor + Sets the color of the border enclosing the + slider. + borderwidth + Sets the width (in px) of the border enclosing + the slider. + currentvalue + plotly.graph_objs.layout.slider.Currentvalue + instance or dict with compatible properties + font + Sets the font of the slider step labels. + len + Sets the length of the slider This measure + excludes the padding of both ends. That is, the + slider's length is this length minus the + padding on both ends. + lenmode + Determines whether this slider length is set in + units of plot *fraction* or in *pixels. Use + `len` to set the value. + minorticklen + Sets the length in pixels of minor step tick + marks + pad + Set the padding of the slider component along + each side. + steps + plotly.graph_objs.layout.slider.Step instance + or dict with compatible properties + tickcolor + Sets the color of the border enclosing the + slider. + ticklen + Sets the length in pixels of step tick marks + tickwidth + Sets the tick width (in px). + transition + plotly.graph_objs.layout.slider.Transition + instance or dict with compatible properties + visible + Determines whether or not the slider is + visible. + x + Sets the x position (in normalized coordinates) + of the slider. + xanchor + Sets the slider's horizontal position anchor. + This anchor binds the `x` position to the + *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the slider. + yanchor + Sets the slider's vertical position anchor This + anchor binds the `y` position to the *top*, + *middle* or *bottom* of the range selector.""", + **kwargs + ) diff --git a/plotly/validators/layout/_spikedistance.py b/plotly/validators/layout/_spikedistance.py new file mode 100644 index 0000000000..9814e3368d --- /dev/null +++ b/plotly/validators/layout/_spikedistance.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SpikedistanceValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='spikedistance', parent_name='layout', **kwargs + ): + super(SpikedistanceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + min=-1, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_ternary.py b/plotly/validators/layout/_ternary.py new file mode 100644 index 0000000000..73338221e5 --- /dev/null +++ b/plotly/validators/layout/_ternary.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class TernaryValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='ternary', parent_name='layout', **kwargs): + super(TernaryValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Ternary', + data_docs=""" + aaxis + plotly.graph_objs.layout.ternary.Aaxis instance + or dict with compatible properties + baxis + plotly.graph_objs.layout.ternary.Baxis instance + or dict with compatible properties + bgcolor + Set the background color of the subplot + caxis + plotly.graph_objs.layout.ternary.Caxis instance + or dict with compatible properties + domain + plotly.graph_objs.layout.ternary.Domain + instance or dict with compatible properties + sum + The number each triplet should sum to, and the + maximum range of each axis""", + **kwargs + ) diff --git a/plotly/validators/layout/_title.py b/plotly/validators/layout/_title.py new file mode 100644 index 0000000000..58a9cb8e08 --- /dev/null +++ b/plotly/validators/layout/_title.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='title', parent_name='layout', **kwargs): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_titlefont.py b/plotly/validators/layout/_titlefont.py new file mode 100644 index 0000000000..e38e933956 --- /dev/null +++ b/plotly/validators/layout/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='layout', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/_updatemenus.py b/plotly/validators/layout/_updatemenus.py new file mode 100644 index 0000000000..c240b676a6 --- /dev/null +++ b/plotly/validators/layout/_updatemenus.py @@ -0,0 +1,69 @@ +import _plotly_utils.basevalidators + + +class UpdatemenusValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, plotly_name='updatemenus', parent_name='layout', **kwargs + ): + super(UpdatemenusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Updatemenu', + data_docs=""" + active + Determines which button (by index starting from + 0) is considered active. + bgcolor + Sets the background color of the update menu + buttons. + bordercolor + Sets the color of the border enclosing the + update menu. + borderwidth + Sets the width (in px) of the border enclosing + the update menu. + buttons + plotly.graph_objs.layout.updatemenu.Button + instance or dict with compatible properties + direction + Determines the direction in which the buttons + are laid out, whether in a dropdown menu or a + row/column of buttons. For `left` and `up`, the + buttons will still appear in left-to-right or + top-to-bottom order respectively. + font + Sets the font of the update menu button text. + pad + Sets the padding around the buttons or dropdown + menu. + showactive + Highlights active dropdown item or active + button if true. + type + Determines whether the buttons are accessible + via a dropdown menu or whether the buttons are + stacked horizontally or vertically + visible + Determines whether or not the update menu is + visible. + x + Sets the x position (in normalized coordinates) + of the update menu. + xanchor + Sets the update menu's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the update menu. + yanchor + Sets the update menu's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the range + selector.""", + **kwargs + ) diff --git a/plotly/validators/layout/_violingap.py b/plotly/validators/layout/_violingap.py new file mode 100644 index 0000000000..8a0ae23338 --- /dev/null +++ b/plotly/validators/layout/_violingap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ViolingapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='violingap', parent_name='layout', **kwargs + ): + super(ViolingapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_violingroupgap.py b/plotly/validators/layout/_violingroupgap.py new file mode 100644 index 0000000000..bb37d72b24 --- /dev/null +++ b/plotly/validators/layout/_violingroupgap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ViolingroupgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='violingroupgap', parent_name='layout', **kwargs + ): + super(ViolingroupgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/_violinmode.py b/plotly/validators/layout/_violinmode.py new file mode 100644 index 0000000000..431960595f --- /dev/null +++ b/plotly/validators/layout/_violinmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ViolinmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='violinmode', parent_name='layout', **kwargs + ): + super(ViolinmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['group', 'overlay'], + **kwargs + ) diff --git a/plotly/validators/layout/_width.py b/plotly/validators/layout/_width.py new file mode 100644 index 0000000000..c5bd5a71b4 --- /dev/null +++ b/plotly/validators/layout/_width.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='width', parent_name='layout', **kwargs): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=10, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/_xaxis.py b/plotly/validators/layout/_xaxis.py new file mode 100644 index 0000000000..c735f28db3 --- /dev/null +++ b/plotly/validators/layout/_xaxis.py @@ -0,0 +1,376 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='xaxis', parent_name='layout', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='XAxis', + data_docs=""" + anchor + If set to an opposite-letter axis id (e.g. + `x2`, `y`), this axis is bound to the + corresponding opposite-letter axis. If set to + *free*, this axis' position is determined by + `position`. + automargin + Determines whether long tick labels + automatically grow the figure margins. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + constrain + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines how that + happens: by increasing the *range* (default), + or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines which + direction we push the originally specified plot + area. Options are *left*, *center* (default), + and *right* for x axes, and *top*, *middle* + (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot + fraction). + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + overlaying + If set a same-letter axis id, this axis is + overlaid on top of the corresponding same- + letter axis. If *false*, this axis does not + overlay any same-letter axes. + position + Sets the position of this axis in the plotting + space (in normalized coordinates). Only has an + effect if `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + rangeselector + plotly.graph_objs.layout.xaxis.Rangeselector + instance or dict with compatible properties + rangeslider + plotly.graph_objs.layout.xaxis.Rangeslider + instance or dict with compatible properties + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the + range of this axis changes together with the + range of the corresponding axis such that the + scale of pixels per unit is in a constant + ratio. Both axes are still zoomable, but when + you zoom one, the other will zoom the same + amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce + the constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` + but you can only link axes of the same `type`. + The linked axis can have the opposite letter + (to constrain the aspect ratio) or the same + letter (to match scales across subplots). Loops + (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant + and the last constraint encountered will be + ignored to avoid possible inconsistent + constraints via `scaleratio`. + scaleratio + If this axis is linked to another by + `scaleanchor`, this determines the pixel to + unit scale ratio. For example, if this value is + 10, then every unit on this axis spans 10 times + the number of pixels as a unit on the linked + axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Determines whether or not spikes (aka + droplines) are drawn for this axis. Note: This + only takes affect when hovermode = closest + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned + at the *bottom* (*left*) or *top* (*right*) of + the plotting area. + spikecolor + Sets the spike color. If undefined, will use + the series color + spikedash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line + If *toaxis*, the line is drawn from the data + point to the axis the series is plotted on. If + *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If + *marker*, then a marker dot is drawn on the + axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the + cursor or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.xaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line.""", + **kwargs + ) diff --git a/plotly/validators/layout/_yaxis.py b/plotly/validators/layout/_yaxis.py new file mode 100644 index 0000000000..a64d6c0abb --- /dev/null +++ b/plotly/validators/layout/_yaxis.py @@ -0,0 +1,370 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='yaxis', parent_name='layout', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YAxis', + data_docs=""" + anchor + If set to an opposite-letter axis id (e.g. + `x2`, `y`), this axis is bound to the + corresponding opposite-letter axis. If set to + *free*, this axis' position is determined by + `position`. + automargin + Determines whether long tick labels + automatically grow the figure margins. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + constrain + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines how that + happens: by increasing the *range* (default), + or by decreasing the *domain*. + constraintoward + If this axis needs to be compressed (either due + to its own `scaleanchor` and `scaleratio` or + those of the other axis), determines which + direction we push the originally specified plot + area. Options are *left*, *center* (default), + and *right* for x axes, and *top*, *middle* + (default), and *bottom* for y axes. + domain + Sets the domain of this axis (in plot + fraction). + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + fixedrange + Determines whether or not this axis is zoom- + able. If true, then zoom is disabled. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + overlaying + If set a same-letter axis id, this axis is + overlaid on top of the corresponding same- + letter axis. If *false*, this axis does not + overlay any same-letter axes. + position + Sets the position of this axis in the plotting + space (in normalized coordinates). Only has an + effect if `anchor` is set to *free*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + scaleanchor + If set to another axis id (e.g. `x2`, `y`), the + range of this axis changes together with the + range of the corresponding axis such that the + scale of pixels per unit is in a constant + ratio. Both axes are still zoomable, but when + you zoom one, the other will zoom the same + amount, keeping a fixed midpoint. `constrain` + and `constraintoward` determine how we enforce + the constraint. You can chain these, ie `yaxis: + {scaleanchor: *x*}, xaxis2: {scaleanchor: *y*}` + but you can only link axes of the same `type`. + The linked axis can have the opposite letter + (to constrain the aspect ratio) or the same + letter (to match scales across subplots). Loops + (`yaxis: {scaleanchor: *x*}, xaxis: + {scaleanchor: *y*}` or longer) are redundant + and the last constraint encountered will be + ignored to avoid possible inconsistent + constraints via `scaleratio`. + scaleratio + If this axis is linked to another by + `scaleanchor`, this determines the pixel to + unit scale ratio. For example, if this value is + 10, then every unit on this axis spans 10 times + the number of pixels as a unit on the linked + axis. Use this for example to create an + elevation profile where the vertical scale is + exaggerated a fixed amount with respect to the + horizontal. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Determines whether or not spikes (aka + droplines) are drawn for this axis. Note: This + only takes affect when hovermode = closest + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines whether a x (y) axis is positioned + at the *bottom* (*left*) or *top* (*right*) of + the plotting area. + spikecolor + Sets the spike color. If undefined, will use + the series color + spikedash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + spikemode + Determines the drawing mode for the spike line + If *toaxis*, the line is drawn from the data + point to the axis the series is plotted on. If + *across*, the line is drawn across the entire + plot area, and supercedes *toaxis*. If + *marker*, then a marker dot is drawn on the + axis the series is plotted on + spikesnap + Determines whether spikelines are stuck to the + cursor or to the closest datapoints. + spikethickness + Sets the width (in px) of the zero line. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.yaxis.Tickformatstop + instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line.""", + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/__init__.py b/plotly/validators/layout/angularaxis/__init__.py new file mode 100644 index 0000000000..f5b56d3caf --- /dev/null +++ b/plotly/validators/layout/angularaxis/__init__.py @@ -0,0 +1,10 @@ +from ._visible import VisibleValidator +from ._ticksuffix import TicksuffixValidator +from ._tickorientation import TickorientationValidator +from ._ticklen import TicklenValidator +from ._tickcolor import TickcolorValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._range import RangeValidator +from ._endpadding import EndpaddingValidator +from ._domain import DomainValidator diff --git a/plotly/validators/layout/angularaxis/_domain.py b/plotly/validators/layout/angularaxis/_domain.py new file mode 100644 index 0000000000..7b94e0574c --- /dev/null +++ b/plotly/validators/layout/angularaxis/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.angularaxis', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_endpadding.py b/plotly/validators/layout/angularaxis/_endpadding.py new file mode 100644 index 0000000000..130aa8597f --- /dev/null +++ b/plotly/validators/layout/angularaxis/_endpadding.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class EndpaddingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='endpadding', + parent_name='layout.angularaxis', + **kwargs + ): + super(EndpaddingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_range.py b/plotly/validators/layout/angularaxis/_range.py new file mode 100644 index 0000000000..2a85f15ba5 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_range.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.angularaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'dflt': 0, + 'editType': 'plot' + }, { + 'valType': 'number', + 'dflt': 360, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_showline.py b/plotly/validators/layout/angularaxis/_showline.py new file mode 100644 index 0000000000..65b82bb3a3 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.angularaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_showticklabels.py b/plotly/validators/layout/angularaxis/_showticklabels.py new file mode 100644 index 0000000000..5bb032b01d --- /dev/null +++ b/plotly/validators/layout/angularaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.angularaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_tickcolor.py b/plotly/validators/layout/angularaxis/_tickcolor.py new file mode 100644 index 0000000000..b3aeee904d --- /dev/null +++ b/plotly/validators/layout/angularaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.angularaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_ticklen.py b/plotly/validators/layout/angularaxis/_ticklen.py new file mode 100644 index 0000000000..918ff40813 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.angularaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_tickorientation.py b/plotly/validators/layout/angularaxis/_tickorientation.py new file mode 100644 index 0000000000..7ce68efb53 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_tickorientation.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TickorientationValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='tickorientation', + parent_name='layout.angularaxis', + **kwargs + ): + super(TickorientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['horizontal', 'vertical'], + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_ticksuffix.py b/plotly/validators/layout/angularaxis/_ticksuffix.py new file mode 100644 index 0000000000..7479b96e58 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.angularaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/angularaxis/_visible.py b/plotly/validators/layout/angularaxis/_visible.py new file mode 100644 index 0000000000..ce2340d564 --- /dev/null +++ b/plotly/validators/layout/angularaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.angularaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/__init__.py b/plotly/validators/layout/annotation/__init__.py new file mode 100644 index 0000000000..c61ea383db --- /dev/null +++ b/plotly/validators/layout/annotation/__init__.py @@ -0,0 +1,41 @@ +from ._yshift import YshiftValidator +from ._yref import YrefValidator +from ._yclick import YclickValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xshift import XshiftValidator +from ._xref import XrefValidator +from ._xclick import XclickValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valign import ValignValidator +from ._textangle import TextangleValidator +from ._text import TextValidator +from ._startstandoff import StartstandoffValidator +from ._startarrowsize import StartarrowsizeValidator +from ._startarrowhead import StartarrowheadValidator +from ._standoff import StandoffValidator +from ._showarrow import ShowarrowValidator +from ._opacity import OpacityValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._height import HeightValidator +from ._font import FontValidator +from ._clicktoshow import ClicktoshowValidator +from ._captureevents import CaptureeventsValidator +from ._borderwidth import BorderwidthValidator +from ._borderpad import BorderpadValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._ayref import AyrefValidator +from ._ay import AyValidator +from ._axref import AxrefValidator +from ._ax import AxValidator +from ._arrowwidth import ArrowwidthValidator +from ._arrowsize import ArrowsizeValidator +from ._arrowside import ArrowsideValidator +from ._arrowhead import ArrowheadValidator +from ._arrowcolor import ArrowcolorValidator +from ._align import AlignValidator diff --git a/plotly/validators/layout/annotation/_align.py b/plotly/validators/layout/annotation/_align.py new file mode 100644 index 0000000000..a38251d05e --- /dev/null +++ b/plotly/validators/layout/annotation/_align.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AlignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='align', parent_name='layout.annotation', **kwargs + ): + super(AlignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_arrowcolor.py b/plotly/validators/layout/annotation/_arrowcolor.py new file mode 100644 index 0000000000..0f5847f6e2 --- /dev/null +++ b/plotly/validators/layout/annotation/_arrowcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrowcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='arrowcolor', + parent_name='layout.annotation', + **kwargs + ): + super(ArrowcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_arrowhead.py b/plotly/validators/layout/annotation/_arrowhead.py new file mode 100644 index 0000000000..6f6d1f2408 --- /dev/null +++ b/plotly/validators/layout/annotation/_arrowhead.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ArrowheadValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='arrowhead', + parent_name='layout.annotation', + **kwargs + ): + super(ArrowheadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=8, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_arrowside.py b/plotly/validators/layout/annotation/_arrowside.py new file mode 100644 index 0000000000..b9807e7cac --- /dev/null +++ b/plotly/validators/layout/annotation/_arrowside.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ArrowsideValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, + plotly_name='arrowside', + parent_name='layout.annotation', + **kwargs + ): + super(ArrowsideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + extras=['none'], + flags=['end', 'start'], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_arrowsize.py b/plotly/validators/layout/annotation/_arrowsize.py new file mode 100644 index 0000000000..5cafbb3e89 --- /dev/null +++ b/plotly/validators/layout/annotation/_arrowsize.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ArrowsizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='arrowsize', + parent_name='layout.annotation', + **kwargs + ): + super(ArrowsizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0.3, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_arrowwidth.py b/plotly/validators/layout/annotation/_arrowwidth.py new file mode 100644 index 0000000000..0811044fa6 --- /dev/null +++ b/plotly/validators/layout/annotation/_arrowwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ArrowwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='arrowwidth', + parent_name='layout.annotation', + **kwargs + ): + super(ArrowwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0.1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_ax.py b/plotly/validators/layout/annotation/_ax.py new file mode 100644 index 0000000000..f8ec7a3a90 --- /dev/null +++ b/plotly/validators/layout/annotation/_ax.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AxValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='ax', parent_name='layout.annotation', **kwargs + ): + super(AxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_axref.py b/plotly/validators/layout/annotation/_axref.py new file mode 100644 index 0000000000..6bdf0f61dc --- /dev/null +++ b/plotly/validators/layout/annotation/_axref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AxrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='axref', parent_name='layout.annotation', **kwargs + ): + super(AxrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['pixel', '/^x([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_ay.py b/plotly/validators/layout/annotation/_ay.py new file mode 100644 index 0000000000..064681c846 --- /dev/null +++ b/plotly/validators/layout/annotation/_ay.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AyValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='ay', parent_name='layout.annotation', **kwargs + ): + super(AyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_ayref.py b/plotly/validators/layout/annotation/_ayref.py new file mode 100644 index 0000000000..1cf9b01c0f --- /dev/null +++ b/plotly/validators/layout/annotation/_ayref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AyrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ayref', parent_name='layout.annotation', **kwargs + ): + super(AyrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['pixel', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_bgcolor.py b/plotly/validators/layout/annotation/_bgcolor.py new file mode 100644 index 0000000000..2fe151d65d --- /dev/null +++ b/plotly/validators/layout/annotation/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.annotation', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_bordercolor.py b/plotly/validators/layout/annotation/_bordercolor.py new file mode 100644 index 0000000000..f34485e663 --- /dev/null +++ b/plotly/validators/layout/annotation/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.annotation', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_borderpad.py b/plotly/validators/layout/annotation/_borderpad.py new file mode 100644 index 0000000000..a8661c7098 --- /dev/null +++ b/plotly/validators/layout/annotation/_borderpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderpad', + parent_name='layout.annotation', + **kwargs + ): + super(BorderpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_borderwidth.py b/plotly/validators/layout/annotation/_borderwidth.py new file mode 100644 index 0000000000..65bc9e7ca5 --- /dev/null +++ b/plotly/validators/layout/annotation/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='layout.annotation', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_captureevents.py b/plotly/validators/layout/annotation/_captureevents.py new file mode 100644 index 0000000000..8ff5243705 --- /dev/null +++ b/plotly/validators/layout/annotation/_captureevents.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CaptureeventsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='captureevents', + parent_name='layout.annotation', + **kwargs + ): + super(CaptureeventsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_clicktoshow.py b/plotly/validators/layout/annotation/_clicktoshow.py new file mode 100644 index 0000000000..8b7faf2f3e --- /dev/null +++ b/plotly/validators/layout/annotation/_clicktoshow.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ClicktoshowValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='clicktoshow', + parent_name='layout.annotation', + **kwargs + ): + super(ClicktoshowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + values=[False, 'onoff', 'onout'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_font.py b/plotly/validators/layout/annotation/_font.py new file mode 100644 index 0000000000..296e3f9de5 --- /dev/null +++ b/plotly/validators/layout/annotation/_font.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='layout.annotation', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_height.py b/plotly/validators/layout/annotation/_height.py new file mode 100644 index 0000000000..5c75c840fc --- /dev/null +++ b/plotly/validators/layout/annotation/_height.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HeightValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='height', parent_name='layout.annotation', **kwargs + ): + super(HeightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_hoverlabel.py b/plotly/validators/layout/annotation/_hoverlabel.py new file mode 100644 index 0000000000..bb1cdb746e --- /dev/null +++ b/plotly/validators/layout/annotation/_hoverlabel.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='hoverlabel', + parent_name='layout.annotation', + **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover label. + By default uses the annotation's `bgcolor` made + opaque, or white if it was transparent. + bordercolor + Sets the border color of the hover label. By + default uses either dark grey or white, for + maximum contrast with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses + the global hover font and size, with color from + `hoverlabel.bordercolor`.""", + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_hovertext.py b/plotly/validators/layout/annotation/_hovertext.py new file mode 100644 index 0000000000..266af797f6 --- /dev/null +++ b/plotly/validators/layout/annotation/_hovertext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hovertext', + parent_name='layout.annotation', + **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_opacity.py b/plotly/validators/layout/annotation/_opacity.py new file mode 100644 index 0000000000..0486b878b3 --- /dev/null +++ b/plotly/validators/layout/annotation/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='layout.annotation', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_showarrow.py b/plotly/validators/layout/annotation/_showarrow.py new file mode 100644 index 0000000000..ea99644210 --- /dev/null +++ b/plotly/validators/layout/annotation/_showarrow.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowarrowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showarrow', + parent_name='layout.annotation', + **kwargs + ): + super(ShowarrowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_standoff.py b/plotly/validators/layout/annotation/_standoff.py new file mode 100644 index 0000000000..c9077807b5 --- /dev/null +++ b/plotly/validators/layout/annotation/_standoff.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StandoffValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='standoff', + parent_name='layout.annotation', + **kwargs + ): + super(StandoffValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_startarrowhead.py b/plotly/validators/layout/annotation/_startarrowhead.py new file mode 100644 index 0000000000..1e5c68110a --- /dev/null +++ b/plotly/validators/layout/annotation/_startarrowhead.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class StartarrowheadValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='startarrowhead', + parent_name='layout.annotation', + **kwargs + ): + super(StartarrowheadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=8, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_startarrowsize.py b/plotly/validators/layout/annotation/_startarrowsize.py new file mode 100644 index 0000000000..24e10f26bf --- /dev/null +++ b/plotly/validators/layout/annotation/_startarrowsize.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartarrowsizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startarrowsize', + parent_name='layout.annotation', + **kwargs + ): + super(StartarrowsizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0.3, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_startstandoff.py b/plotly/validators/layout/annotation/_startstandoff.py new file mode 100644 index 0000000000..b49dac39fd --- /dev/null +++ b/plotly/validators/layout/annotation/_startstandoff.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartstandoffValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startstandoff', + parent_name='layout.annotation', + **kwargs + ): + super(StartstandoffValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_text.py b/plotly/validators/layout/annotation/_text.py new file mode 100644 index 0000000000..28042bfed1 --- /dev/null +++ b/plotly/validators/layout/annotation/_text.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='layout.annotation', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_textangle.py b/plotly/validators/layout/annotation/_textangle.py new file mode 100644 index 0000000000..2a4c287e8b --- /dev/null +++ b/plotly/validators/layout/annotation/_textangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='textangle', + parent_name='layout.annotation', + **kwargs + ): + super(TextangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_valign.py b/plotly/validators/layout/annotation/_valign.py new file mode 100644 index 0000000000..284e7be9f7 --- /dev/null +++ b/plotly/validators/layout/annotation/_valign.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='valign', parent_name='layout.annotation', **kwargs + ): + super(ValignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_visible.py b/plotly/validators/layout/annotation/_visible.py new file mode 100644 index 0000000000..193b2d7166 --- /dev/null +++ b/plotly/validators/layout/annotation/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.annotation', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_width.py b/plotly/validators/layout/annotation/_width.py new file mode 100644 index 0000000000..b7b5f555a9 --- /dev/null +++ b/plotly/validators/layout/annotation/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='layout.annotation', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_x.py b/plotly/validators/layout/annotation/_x.py new file mode 100644 index 0000000000..4bbdefe834 --- /dev/null +++ b/plotly/validators/layout/annotation/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.annotation', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_xanchor.py b/plotly/validators/layout/annotation/_xanchor.py new file mode 100644 index 0000000000..8bf0d86383 --- /dev/null +++ b/plotly/validators/layout/annotation/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.annotation', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_xclick.py b/plotly/validators/layout/annotation/_xclick.py new file mode 100644 index 0000000000..9b3954f1f9 --- /dev/null +++ b/plotly/validators/layout/annotation/_xclick.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XclickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='xclick', parent_name='layout.annotation', **kwargs + ): + super(XclickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_xref.py b/plotly/validators/layout/annotation/_xref.py new file mode 100644 index 0000000000..5a3c7a1cdd --- /dev/null +++ b/plotly/validators/layout/annotation/_xref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xref', parent_name='layout.annotation', **kwargs + ): + super(XrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['paper', '/^x([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_xshift.py b/plotly/validators/layout/annotation/_xshift.py new file mode 100644 index 0000000000..03b752b1d6 --- /dev/null +++ b/plotly/validators/layout/annotation/_xshift.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XshiftValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xshift', parent_name='layout.annotation', **kwargs + ): + super(XshiftValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_y.py b/plotly/validators/layout/annotation/_y.py new file mode 100644 index 0000000000..be3bad743c --- /dev/null +++ b/plotly/validators/layout/annotation/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.annotation', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_yanchor.py b/plotly/validators/layout/annotation/_yanchor.py new file mode 100644 index 0000000000..b0374d29ff --- /dev/null +++ b/plotly/validators/layout/annotation/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.annotation', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_yclick.py b/plotly/validators/layout/annotation/_yclick.py new file mode 100644 index 0000000000..2e7d4dfe6c --- /dev/null +++ b/plotly/validators/layout/annotation/_yclick.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YclickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='yclick', parent_name='layout.annotation', **kwargs + ): + super(YclickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_yref.py b/plotly/validators/layout/annotation/_yref.py new file mode 100644 index 0000000000..63f6108d7b --- /dev/null +++ b/plotly/validators/layout/annotation/_yref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yref', parent_name='layout.annotation', **kwargs + ): + super(YrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['paper', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/annotation/_yshift.py b/plotly/validators/layout/annotation/_yshift.py new file mode 100644 index 0000000000..f939a7cc23 --- /dev/null +++ b/plotly/validators/layout/annotation/_yshift.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YshiftValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='yshift', parent_name='layout.annotation', **kwargs + ): + super(YshiftValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/font/__init__.py b/plotly/validators/layout/annotation/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/annotation/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/annotation/font/_color.py b/plotly/validators/layout/annotation/font/_color.py new file mode 100644 index 0000000000..ac62fb7f6b --- /dev/null +++ b/plotly/validators/layout/annotation/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.annotation.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/font/_family.py b/plotly/validators/layout/annotation/font/_family.py new file mode 100644 index 0000000000..31ae548cfc --- /dev/null +++ b/plotly/validators/layout/annotation/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.annotation.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/annotation/font/_size.py b/plotly/validators/layout/annotation/font/_size.py new file mode 100644 index 0000000000..754605fb7e --- /dev/null +++ b/plotly/validators/layout/annotation/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.annotation.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/__init__.py b/plotly/validators/layout/annotation/hoverlabel/__init__.py new file mode 100644 index 0000000000..8a3e67d64a --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/__init__.py @@ -0,0 +1,3 @@ +from ._font import FontValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/layout/annotation/hoverlabel/_bgcolor.py b/plotly/validators/layout/annotation/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..a117ace757 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='layout.annotation.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/_bordercolor.py b/plotly/validators/layout/annotation/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..c735fc6d61 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.annotation.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/_font.py b/plotly/validators/layout/annotation/hoverlabel/_font.py new file mode 100644 index 0000000000..5f5fe9cc38 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/_font.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='layout.annotation.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/font/__init__.py b/plotly/validators/layout/annotation/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/annotation/hoverlabel/font/_color.py b/plotly/validators/layout/annotation/hoverlabel/font/_color.py new file mode 100644 index 0000000000..075c7f6fc5 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.annotation.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/font/_family.py b/plotly/validators/layout/annotation/hoverlabel/font/_family.py new file mode 100644 index 0000000000..2161222ee0 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.annotation.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/annotation/hoverlabel/font/_size.py b/plotly/validators/layout/annotation/hoverlabel/font/_size.py new file mode 100644 index 0000000000..58efad5221 --- /dev/null +++ b/plotly/validators/layout/annotation/hoverlabel/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.annotation.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/font/__init__.py b/plotly/validators/layout/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/font/_color.py b/plotly/validators/layout/font/_color.py new file mode 100644 index 0000000000..80ce9a8738 --- /dev/null +++ b/plotly/validators/layout/font/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/font/_family.py b/plotly/validators/layout/font/_family.py new file mode 100644 index 0000000000..e01be3c16d --- /dev/null +++ b/plotly/validators/layout/font/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='layout.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/font/_size.py b/plotly/validators/layout/font/_size.py new file mode 100644 index 0000000000..25b9805c18 --- /dev/null +++ b/plotly/validators/layout/font/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='layout.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/__init__.py b/plotly/validators/layout/geo/__init__.py new file mode 100644 index 0000000000..a7e6c20e82 --- /dev/null +++ b/plotly/validators/layout/geo/__init__.py @@ -0,0 +1,29 @@ +from ._subunitwidth import SubunitwidthValidator +from ._subunitcolor import SubunitcolorValidator +from ._showsubunits import ShowsubunitsValidator +from ._showrivers import ShowriversValidator +from ._showocean import ShowoceanValidator +from ._showland import ShowlandValidator +from ._showlakes import ShowlakesValidator +from ._showframe import ShowframeValidator +from ._showcountries import ShowcountriesValidator +from ._showcoastlines import ShowcoastlinesValidator +from ._scope import ScopeValidator +from ._riverwidth import RiverwidthValidator +from ._rivercolor import RivercolorValidator +from ._resolution import ResolutionValidator +from ._projection import ProjectionValidator +from ._oceancolor import OceancolorValidator +from ._lonaxis import LonaxisValidator +from ._lataxis import LataxisValidator +from ._landcolor import LandcolorValidator +from ._lakecolor import LakecolorValidator +from ._framewidth import FramewidthValidator +from ._framecolor import FramecolorValidator +from ._domain import DomainValidator +from ._countrywidth import CountrywidthValidator +from ._countrycolor import CountrycolorValidator +from ._coastlinewidth import CoastlinewidthValidator +from ._coastlinecolor import CoastlinecolorValidator +from ._center import CenterValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/layout/geo/_bgcolor.py b/plotly/validators/layout/geo/_bgcolor.py new file mode 100644 index 0000000000..712724f252 --- /dev/null +++ b/plotly/validators/layout/geo/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.geo', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_center.py b/plotly/validators/layout/geo/_center.py new file mode 100644 index 0000000000..eef12d8772 --- /dev/null +++ b/plotly/validators/layout/geo/_center.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class CenterValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='center', parent_name='layout.geo', **kwargs + ): + super(CenterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Center', + data_docs=""" + lat + Sets the latitude of the map's center. For all + projection types, the map's latitude center + lies at the middle of the latitude range by + default. + lon + Sets the longitude of the map's center. By + default, the map's longitude center lies at the + middle of the longitude range for scoped + projection and above `projection.rotation.lon` + otherwise.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/_coastlinecolor.py b/plotly/validators/layout/geo/_coastlinecolor.py new file mode 100644 index 0000000000..348b73310e --- /dev/null +++ b/plotly/validators/layout/geo/_coastlinecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CoastlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='coastlinecolor', parent_name='layout.geo', **kwargs + ): + super(CoastlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_coastlinewidth.py b/plotly/validators/layout/geo/_coastlinewidth.py new file mode 100644 index 0000000000..552c3a9c7a --- /dev/null +++ b/plotly/validators/layout/geo/_coastlinewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CoastlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='coastlinewidth', parent_name='layout.geo', **kwargs + ): + super(CoastlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_countrycolor.py b/plotly/validators/layout/geo/_countrycolor.py new file mode 100644 index 0000000000..37decd07d5 --- /dev/null +++ b/plotly/validators/layout/geo/_countrycolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CountrycolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='countrycolor', parent_name='layout.geo', **kwargs + ): + super(CountrycolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_countrywidth.py b/plotly/validators/layout/geo/_countrywidth.py new file mode 100644 index 0000000000..0936a90d95 --- /dev/null +++ b/plotly/validators/layout/geo/_countrywidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CountrywidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='countrywidth', parent_name='layout.geo', **kwargs + ): + super(CountrywidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_domain.py b/plotly/validators/layout/geo/_domain.py new file mode 100644 index 0000000000..66f7b09bef --- /dev/null +++ b/plotly/validators/layout/geo/_domain.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.geo', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this geo subplot . + Note that geo subplots are constrained by + domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y + domain, but not both. + row + If there is a layout grid, use the domain for + this row in the grid for this geo subplot . + Note that geo subplots are constrained by + domain. In general, when `projection.scale` is + set to 1. a map will fit either its x or y + domain, but not both. + x + Sets the horizontal domain of this geo subplot + (in plot fraction). Note that geo subplots are + constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both. + y + Sets the vertical domain of this geo subplot + (in plot fraction). Note that geo subplots are + constrained by domain. In general, when + `projection.scale` is set to 1. a map will fit + either its x or y domain, but not both.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/_framecolor.py b/plotly/validators/layout/geo/_framecolor.py new file mode 100644 index 0000000000..f9b1150b42 --- /dev/null +++ b/plotly/validators/layout/geo/_framecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FramecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='framecolor', parent_name='layout.geo', **kwargs + ): + super(FramecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_framewidth.py b/plotly/validators/layout/geo/_framewidth.py new file mode 100644 index 0000000000..9ce64c22f1 --- /dev/null +++ b/plotly/validators/layout/geo/_framewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FramewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='framewidth', parent_name='layout.geo', **kwargs + ): + super(FramewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_lakecolor.py b/plotly/validators/layout/geo/_lakecolor.py new file mode 100644 index 0000000000..03a5deea5e --- /dev/null +++ b/plotly/validators/layout/geo/_lakecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LakecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='lakecolor', parent_name='layout.geo', **kwargs + ): + super(LakecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_landcolor.py b/plotly/validators/layout/geo/_landcolor.py new file mode 100644 index 0000000000..c6a8dbd46e --- /dev/null +++ b/plotly/validators/layout/geo/_landcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LandcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='landcolor', parent_name='layout.geo', **kwargs + ): + super(LandcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_lataxis.py b/plotly/validators/layout/geo/_lataxis.py new file mode 100644 index 0000000000..15c675dfe7 --- /dev/null +++ b/plotly/validators/layout/geo/_lataxis.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class LataxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lataxis', parent_name='layout.geo', **kwargs + ): + super(LataxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lataxis', + data_docs=""" + dtick + Sets the graticule's longitude/latitude tick + step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets + the map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the + map. + tick0 + Sets the graticule's starting tick + longitude/latitude.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/_lonaxis.py b/plotly/validators/layout/geo/_lonaxis.py new file mode 100644 index 0000000000..1b3b8a79c3 --- /dev/null +++ b/plotly/validators/layout/geo/_lonaxis.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class LonaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lonaxis', parent_name='layout.geo', **kwargs + ): + super(LonaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lonaxis', + data_docs=""" + dtick + Sets the graticule's longitude/latitude tick + step. + gridcolor + Sets the graticule's stroke color. + gridwidth + Sets the graticule's stroke width (in px). + range + Sets the range of this axis (in degrees), sets + the map's clipped coordinates. + showgrid + Sets whether or not graticule are shown on the + map. + tick0 + Sets the graticule's starting tick + longitude/latitude.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/_oceancolor.py b/plotly/validators/layout/geo/_oceancolor.py new file mode 100644 index 0000000000..3ec1c4aab0 --- /dev/null +++ b/plotly/validators/layout/geo/_oceancolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OceancolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='oceancolor', parent_name='layout.geo', **kwargs + ): + super(OceancolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_projection.py b/plotly/validators/layout/geo/_projection.py new file mode 100644 index 0000000000..81cd135046 --- /dev/null +++ b/plotly/validators/layout/geo/_projection.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class ProjectionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='projection', parent_name='layout.geo', **kwargs + ): + super(ProjectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Projection', + data_docs=""" + parallels + For conic projection types only. Sets the + parallels (tangent, secant) where the cone + intersects the sphere. + rotation + plotly.graph_objs.layout.geo.projection.Rotatio + n instance or dict with compatible properties + scale + Zooms in or out on the map view. A scale of *1* + corresponds to the largest zoom level that fits + the map's lon and lat ranges. + type + Sets the projection type.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/_resolution.py b/plotly/validators/layout/geo/_resolution.py new file mode 100644 index 0000000000..6001be6021 --- /dev/null +++ b/plotly/validators/layout/geo/_resolution.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ResolutionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='resolution', parent_name='layout.geo', **kwargs + ): + super(ResolutionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + coerce_number=True, + edit_type='plot', + role='info', + values=[110, 50], + **kwargs + ) diff --git a/plotly/validators/layout/geo/_rivercolor.py b/plotly/validators/layout/geo/_rivercolor.py new file mode 100644 index 0000000000..bb2c16835e --- /dev/null +++ b/plotly/validators/layout/geo/_rivercolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RivercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='rivercolor', parent_name='layout.geo', **kwargs + ): + super(RivercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_riverwidth.py b/plotly/validators/layout/geo/_riverwidth.py new file mode 100644 index 0000000000..e02364866b --- /dev/null +++ b/plotly/validators/layout/geo/_riverwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RiverwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='riverwidth', parent_name='layout.geo', **kwargs + ): + super(RiverwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_scope.py b/plotly/validators/layout/geo/_scope.py new file mode 100644 index 0000000000..218e36ac25 --- /dev/null +++ b/plotly/validators/layout/geo/_scope.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ScopeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='scope', parent_name='layout.geo', **kwargs + ): + super(ScopeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'world', 'usa', 'europe', 'asia', 'africa', 'north america', + 'south america' + ], + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showcoastlines.py b/plotly/validators/layout/geo/_showcoastlines.py new file mode 100644 index 0000000000..0674071796 --- /dev/null +++ b/plotly/validators/layout/geo/_showcoastlines.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowcoastlinesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showcoastlines', parent_name='layout.geo', **kwargs + ): + super(ShowcoastlinesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showcountries.py b/plotly/validators/layout/geo/_showcountries.py new file mode 100644 index 0000000000..2f4567c93c --- /dev/null +++ b/plotly/validators/layout/geo/_showcountries.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowcountriesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showcountries', parent_name='layout.geo', **kwargs + ): + super(ShowcountriesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showframe.py b/plotly/validators/layout/geo/_showframe.py new file mode 100644 index 0000000000..6e576f4827 --- /dev/null +++ b/plotly/validators/layout/geo/_showframe.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowframeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showframe', parent_name='layout.geo', **kwargs + ): + super(ShowframeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showlakes.py b/plotly/validators/layout/geo/_showlakes.py new file mode 100644 index 0000000000..19a1b17833 --- /dev/null +++ b/plotly/validators/layout/geo/_showlakes.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlakesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlakes', parent_name='layout.geo', **kwargs + ): + super(ShowlakesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showland.py b/plotly/validators/layout/geo/_showland.py new file mode 100644 index 0000000000..8e80ce332a --- /dev/null +++ b/plotly/validators/layout/geo/_showland.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlandValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showland', parent_name='layout.geo', **kwargs + ): + super(ShowlandValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showocean.py b/plotly/validators/layout/geo/_showocean.py new file mode 100644 index 0000000000..065959ea4d --- /dev/null +++ b/plotly/validators/layout/geo/_showocean.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowoceanValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showocean', parent_name='layout.geo', **kwargs + ): + super(ShowoceanValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showrivers.py b/plotly/validators/layout/geo/_showrivers.py new file mode 100644 index 0000000000..174cc8e6df --- /dev/null +++ b/plotly/validators/layout/geo/_showrivers.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowriversValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showrivers', parent_name='layout.geo', **kwargs + ): + super(ShowriversValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_showsubunits.py b/plotly/validators/layout/geo/_showsubunits.py new file mode 100644 index 0000000000..01abef8f8f --- /dev/null +++ b/plotly/validators/layout/geo/_showsubunits.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowsubunitsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showsubunits', parent_name='layout.geo', **kwargs + ): + super(ShowsubunitsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_subunitcolor.py b/plotly/validators/layout/geo/_subunitcolor.py new file mode 100644 index 0000000000..ca915a1aeb --- /dev/null +++ b/plotly/validators/layout/geo/_subunitcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SubunitcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='subunitcolor', parent_name='layout.geo', **kwargs + ): + super(SubunitcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/_subunitwidth.py b/plotly/validators/layout/geo/_subunitwidth.py new file mode 100644 index 0000000000..07b8a0b3f7 --- /dev/null +++ b/plotly/validators/layout/geo/_subunitwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SubunitwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='subunitwidth', parent_name='layout.geo', **kwargs + ): + super(SubunitwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/center/__init__.py b/plotly/validators/layout/geo/center/__init__.py new file mode 100644 index 0000000000..ab3107d784 --- /dev/null +++ b/plotly/validators/layout/geo/center/__init__.py @@ -0,0 +1,2 @@ +from ._lon import LonValidator +from ._lat import LatValidator diff --git a/plotly/validators/layout/geo/center/_lat.py b/plotly/validators/layout/geo/center/_lat.py new file mode 100644 index 0000000000..daa70082cc --- /dev/null +++ b/plotly/validators/layout/geo/center/_lat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LatValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='lat', parent_name='layout.geo.center', **kwargs + ): + super(LatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/center/_lon.py b/plotly/validators/layout/geo/center/_lon.py new file mode 100644 index 0000000000..c9543b1540 --- /dev/null +++ b/plotly/validators/layout/geo/center/_lon.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LonValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='lon', parent_name='layout.geo.center', **kwargs + ): + super(LonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/domain/__init__.py b/plotly/validators/layout/geo/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/layout/geo/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/layout/geo/domain/_column.py b/plotly/validators/layout/geo/domain/_column.py new file mode 100644 index 0000000000..8066def8b0 --- /dev/null +++ b/plotly/validators/layout/geo/domain/_column.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='column', parent_name='layout.geo.domain', **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/domain/_row.py b/plotly/validators/layout/geo/domain/_row.py new file mode 100644 index 0000000000..47b1884ee0 --- /dev/null +++ b/plotly/validators/layout/geo/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='layout.geo.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/domain/_x.py b/plotly/validators/layout/geo/domain/_x.py new file mode 100644 index 0000000000..324ac80519 --- /dev/null +++ b/plotly/validators/layout/geo/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.geo.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/domain/_y.py b/plotly/validators/layout/geo/domain/_y.py new file mode 100644 index 0000000000..a9c2ccb91f --- /dev/null +++ b/plotly/validators/layout/geo/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.geo.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/__init__.py b/plotly/validators/layout/geo/lataxis/__init__.py new file mode 100644 index 0000000000..e9a6ba6b23 --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/__init__.py @@ -0,0 +1,6 @@ +from ._tick0 import Tick0Validator +from ._showgrid import ShowgridValidator +from ._range import RangeValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._dtick import DtickValidator diff --git a/plotly/validators/layout/geo/lataxis/_dtick.py b/plotly/validators/layout/geo/lataxis/_dtick.py new file mode 100644 index 0000000000..875a0f6889 --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_dtick.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.geo.lataxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/_gridcolor.py b/plotly/validators/layout/geo/lataxis/_gridcolor.py new file mode 100644 index 0000000000..4b9fe5a751 --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.geo.lataxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/_gridwidth.py b/plotly/validators/layout/geo/lataxis/_gridwidth.py new file mode 100644 index 0000000000..67dab7594c --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.geo.lataxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/_range.py b/plotly/validators/layout/geo/lataxis/_range.py new file mode 100644 index 0000000000..be2a89cf8c --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.geo.lataxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'editType': 'plot' + }, { + 'valType': 'number', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/_showgrid.py b/plotly/validators/layout/geo/lataxis/_showgrid.py new file mode 100644 index 0000000000..c963c0fe53 --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.geo.lataxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lataxis/_tick0.py b/plotly/validators/layout/geo/lataxis/_tick0.py new file mode 100644 index 0000000000..257703eee3 --- /dev/null +++ b/plotly/validators/layout/geo/lataxis/_tick0.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.geo.lataxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/__init__.py b/plotly/validators/layout/geo/lonaxis/__init__.py new file mode 100644 index 0000000000..e9a6ba6b23 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/__init__.py @@ -0,0 +1,6 @@ +from ._tick0 import Tick0Validator +from ._showgrid import ShowgridValidator +from ._range import RangeValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._dtick import DtickValidator diff --git a/plotly/validators/layout/geo/lonaxis/_dtick.py b/plotly/validators/layout/geo/lonaxis/_dtick.py new file mode 100644 index 0000000000..638cd8388d --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_dtick.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.geo.lonaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/_gridcolor.py b/plotly/validators/layout/geo/lonaxis/_gridcolor.py new file mode 100644 index 0000000000..72cc1e7c77 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.geo.lonaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/_gridwidth.py b/plotly/validators/layout/geo/lonaxis/_gridwidth.py new file mode 100644 index 0000000000..e0e94535d0 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.geo.lonaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/_range.py b/plotly/validators/layout/geo/lonaxis/_range.py new file mode 100644 index 0000000000..9141fb7808 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.geo.lonaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'editType': 'plot' + }, { + 'valType': 'number', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/_showgrid.py b/plotly/validators/layout/geo/lonaxis/_showgrid.py new file mode 100644 index 0000000000..c6dd9f63a7 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.geo.lonaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/lonaxis/_tick0.py b/plotly/validators/layout/geo/lonaxis/_tick0.py new file mode 100644 index 0000000000..b17d92eca6 --- /dev/null +++ b/plotly/validators/layout/geo/lonaxis/_tick0.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.geo.lonaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/__init__.py b/plotly/validators/layout/geo/projection/__init__.py new file mode 100644 index 0000000000..e50803d209 --- /dev/null +++ b/plotly/validators/layout/geo/projection/__init__.py @@ -0,0 +1,4 @@ +from ._type import TypeValidator +from ._scale import ScaleValidator +from ._rotation import RotationValidator +from ._parallels import ParallelsValidator diff --git a/plotly/validators/layout/geo/projection/_parallels.py b/plotly/validators/layout/geo/projection/_parallels.py new file mode 100644 index 0000000000..227c970d6d --- /dev/null +++ b/plotly/validators/layout/geo/projection/_parallels.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class ParallelsValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='parallels', + parent_name='layout.geo.projection', + **kwargs + ): + super(ParallelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'editType': 'plot' + }, { + 'valType': 'number', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/_rotation.py b/plotly/validators/layout/geo/projection/_rotation.py new file mode 100644 index 0000000000..ac94f34844 --- /dev/null +++ b/plotly/validators/layout/geo/projection/_rotation.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class RotationValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='rotation', + parent_name='layout.geo.projection', + **kwargs + ): + super(RotationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Rotation', + data_docs=""" + lat + Rotates the map along meridians (in degrees + North). + lon + Rotates the map along parallels (in degrees + East). Defaults to the center of the + `lonaxis.range` values. + roll + Roll the map (in degrees) For example, a roll + of *180* makes the map appear upside down.""", + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/_scale.py b/plotly/validators/layout/geo/projection/_scale.py new file mode 100644 index 0000000000..76be077189 --- /dev/null +++ b/plotly/validators/layout/geo/projection/_scale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ScaleValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='scale', + parent_name='layout.geo.projection', + **kwargs + ): + super(ScaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/_type.py b/plotly/validators/layout/geo/projection/_type.py new file mode 100644 index 0000000000..f45c749d78 --- /dev/null +++ b/plotly/validators/layout/geo/projection/_type.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='layout.geo.projection', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'equirectangular', 'mercator', 'orthographic', 'natural earth', + 'kavrayskiy7', 'miller', 'robinson', 'eckert4', + 'azimuthal equal area', 'azimuthal equidistant', + 'conic equal area', 'conic conformal', 'conic equidistant', + 'gnomonic', 'stereographic', 'mollweide', 'hammer', + 'transverse mercator', 'albers usa', 'winkel tripel', 'aitoff', + 'sinusoidal' + ], + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/rotation/__init__.py b/plotly/validators/layout/geo/projection/rotation/__init__.py new file mode 100644 index 0000000000..e8823f9d7c --- /dev/null +++ b/plotly/validators/layout/geo/projection/rotation/__init__.py @@ -0,0 +1,3 @@ +from ._roll import RollValidator +from ._lon import LonValidator +from ._lat import LatValidator diff --git a/plotly/validators/layout/geo/projection/rotation/_lat.py b/plotly/validators/layout/geo/projection/rotation/_lat.py new file mode 100644 index 0000000000..59875f3373 --- /dev/null +++ b/plotly/validators/layout/geo/projection/rotation/_lat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LatValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='lat', + parent_name='layout.geo.projection.rotation', + **kwargs + ): + super(LatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/rotation/_lon.py b/plotly/validators/layout/geo/projection/rotation/_lon.py new file mode 100644 index 0000000000..cac369ea93 --- /dev/null +++ b/plotly/validators/layout/geo/projection/rotation/_lon.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LonValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='lon', + parent_name='layout.geo.projection.rotation', + **kwargs + ): + super(LonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/geo/projection/rotation/_roll.py b/plotly/validators/layout/geo/projection/rotation/_roll.py new file mode 100644 index 0000000000..4dd85c3a14 --- /dev/null +++ b/plotly/validators/layout/geo/projection/rotation/_roll.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class RollValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='roll', + parent_name='layout.geo.projection.rotation', + **kwargs + ): + super(RollValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/__init__.py b/plotly/validators/layout/grid/__init__.py new file mode 100644 index 0000000000..ecd5d89215 --- /dev/null +++ b/plotly/validators/layout/grid/__init__.py @@ -0,0 +1,12 @@ +from ._yside import YsideValidator +from ._ygap import YgapValidator +from ._yaxes import YaxesValidator +from ._xside import XsideValidator +from ._xgap import XgapValidator +from ._xaxes import XaxesValidator +from ._subplots import SubplotsValidator +from ._rows import RowsValidator +from ._roworder import RoworderValidator +from ._pattern import PatternValidator +from ._domain import DomainValidator +from ._columns import ColumnsValidator diff --git a/plotly/validators/layout/grid/_columns.py b/plotly/validators/layout/grid/_columns.py new file mode 100644 index 0000000000..9bcf5ee102 --- /dev/null +++ b/plotly/validators/layout/grid/_columns.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnsValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='columns', parent_name='layout.grid', **kwargs + ): + super(ColumnsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_domain.py b/plotly/validators/layout/grid/_domain.py new file mode 100644 index 0000000000..5f4e2883e6 --- /dev/null +++ b/plotly/validators/layout/grid/_domain.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.grid', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + x + Sets the horizontal domain of this grid subplot + (in plot fraction). The first and last cells + end exactly at the domain edges, with no grout + around the edges. + y + Sets the vertical domain of this grid subplot + (in plot fraction). The first and last cells + end exactly at the domain edges, with no grout + around the edges.""", + **kwargs + ) diff --git a/plotly/validators/layout/grid/_pattern.py b/plotly/validators/layout/grid/_pattern.py new file mode 100644 index 0000000000..269bdad38d --- /dev/null +++ b/plotly/validators/layout/grid/_pattern.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class PatternValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='pattern', parent_name='layout.grid', **kwargs + ): + super(PatternValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['independent', 'coupled'], + **kwargs + ) diff --git a/plotly/validators/layout/grid/_roworder.py b/plotly/validators/layout/grid/_roworder.py new file mode 100644 index 0000000000..248ffee36c --- /dev/null +++ b/plotly/validators/layout/grid/_roworder.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RoworderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='roworder', parent_name='layout.grid', **kwargs + ): + super(RoworderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['top to bottom', 'bottom to top'], + **kwargs + ) diff --git a/plotly/validators/layout/grid/_rows.py b/plotly/validators/layout/grid/_rows.py new file mode 100644 index 0000000000..f6b3836103 --- /dev/null +++ b/plotly/validators/layout/grid/_rows.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowsValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='rows', parent_name='layout.grid', **kwargs + ): + super(RowsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_subplots.py b/plotly/validators/layout/grid/_subplots.py new file mode 100644 index 0000000000..d6c49e5f25 --- /dev/null +++ b/plotly/validators/layout/grid/_subplots.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class SubplotsValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='subplots', parent_name='layout.grid', **kwargs + ): + super(SubplotsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dimensions=2, + edit_type='plot', + free_length=True, + items={ + 'valType': 'enumerated', + 'values': + ['/^x([2-9]|[1-9][0-9]+)?y([2-9]|[1-9][0-9]+)?$/', ''], + 'editType': 'plot' + }, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_xaxes.py b/plotly/validators/layout/grid/_xaxes.py new file mode 100644 index 0000000000..aacbe9b013 --- /dev/null +++ b/plotly/validators/layout/grid/_xaxes.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class XaxesValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='xaxes', parent_name='layout.grid', **kwargs + ): + super(XaxesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + free_length=True, + items={ + 'valType': 'enumerated', + 'values': ['/^x([2-9]|[1-9][0-9]+)?$/', ''], + 'editType': 'plot' + }, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_xgap.py b/plotly/validators/layout/grid/_xgap.py new file mode 100644 index 0000000000..57d80fdb77 --- /dev/null +++ b/plotly/validators/layout/grid/_xgap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xgap', parent_name='layout.grid', **kwargs + ): + super(XgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_xside.py b/plotly/validators/layout/grid/_xside.py new file mode 100644 index 0000000000..faddab41a6 --- /dev/null +++ b/plotly/validators/layout/grid/_xside.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XsideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xside', parent_name='layout.grid', **kwargs + ): + super(XsideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['bottom', 'bottom plot', 'top plot', 'top'], + **kwargs + ) diff --git a/plotly/validators/layout/grid/_yaxes.py b/plotly/validators/layout/grid/_yaxes.py new file mode 100644 index 0000000000..a76f3858e6 --- /dev/null +++ b/plotly/validators/layout/grid/_yaxes.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class YaxesValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='yaxes', parent_name='layout.grid', **kwargs + ): + super(YaxesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + free_length=True, + items={ + 'valType': 'enumerated', + 'values': ['/^y([2-9]|[1-9][0-9]+)?$/', ''], + 'editType': 'plot' + }, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_ygap.py b/plotly/validators/layout/grid/_ygap.py new file mode 100644 index 0000000000..8705da5aa7 --- /dev/null +++ b/plotly/validators/layout/grid/_ygap.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ygap', parent_name='layout.grid', **kwargs + ): + super(YgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/_yside.py b/plotly/validators/layout/grid/_yside.py new file mode 100644 index 0000000000..5aab4347e6 --- /dev/null +++ b/plotly/validators/layout/grid/_yside.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YsideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yside', parent_name='layout.grid', **kwargs + ): + super(YsideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['left', 'left plot', 'right plot', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/grid/domain/__init__.py b/plotly/validators/layout/grid/domain/__init__.py new file mode 100644 index 0000000000..a98ad8c5d9 --- /dev/null +++ b/plotly/validators/layout/grid/domain/__init__.py @@ -0,0 +1,2 @@ +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/layout/grid/domain/_x.py b/plotly/validators/layout/grid/domain/_x.py new file mode 100644 index 0000000000..7e34bb7fef --- /dev/null +++ b/plotly/validators/layout/grid/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.grid.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/grid/domain/_y.py b/plotly/validators/layout/grid/domain/_y.py new file mode 100644 index 0000000000..ff0866f07e --- /dev/null +++ b/plotly/validators/layout/grid/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.grid.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/__init__.py b/plotly/validators/layout/hoverlabel/__init__.py new file mode 100644 index 0000000000..ef96a1b146 --- /dev/null +++ b/plotly/validators/layout/hoverlabel/__init__.py @@ -0,0 +1,4 @@ +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/layout/hoverlabel/_bgcolor.py b/plotly/validators/layout/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..42950458aa --- /dev/null +++ b/plotly/validators/layout/hoverlabel/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/_bordercolor.py b/plotly/validators/layout/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..183f663edc --- /dev/null +++ b/plotly/validators/layout/hoverlabel/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/_font.py b/plotly/validators/layout/hoverlabel/_font.py new file mode 100644 index 0000000000..7b96cc2d9c --- /dev/null +++ b/plotly/validators/layout/hoverlabel/_font.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='layout.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/_namelength.py b/plotly/validators/layout/hoverlabel/_namelength.py new file mode 100644 index 0000000000..71d0b98093 --- /dev/null +++ b/plotly/validators/layout/hoverlabel/_namelength.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='layout.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/font/__init__.py b/plotly/validators/layout/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/hoverlabel/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/hoverlabel/font/_color.py b/plotly/validators/layout/hoverlabel/font/_color.py new file mode 100644 index 0000000000..eeb56c98bc --- /dev/null +++ b/plotly/validators/layout/hoverlabel/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/font/_family.py b/plotly/validators/layout/hoverlabel/font/_family.py new file mode 100644 index 0000000000..831fbaa0d8 --- /dev/null +++ b/plotly/validators/layout/hoverlabel/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/hoverlabel/font/_size.py b/plotly/validators/layout/hoverlabel/font/_size.py new file mode 100644 index 0000000000..0891853e37 --- /dev/null +++ b/plotly/validators/layout/hoverlabel/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/image/__init__.py b/plotly/validators/layout/image/__init__.py new file mode 100644 index 0000000000..249a63d0c1 --- /dev/null +++ b/plotly/validators/layout/image/__init__.py @@ -0,0 +1,13 @@ +from ._yref import YrefValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xref import XrefValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._source import SourceValidator +from ._sizing import SizingValidator +from ._sizey import SizeyValidator +from ._sizex import SizexValidator +from ._opacity import OpacityValidator +from ._layer import LayerValidator diff --git a/plotly/validators/layout/image/_layer.py b/plotly/validators/layout/image/_layer.py new file mode 100644 index 0000000000..1bc9434e17 --- /dev/null +++ b/plotly/validators/layout/image/_layer.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='layer', parent_name='layout.image', **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['below', 'above'], + **kwargs + ) diff --git a/plotly/validators/layout/image/_opacity.py b/plotly/validators/layout/image/_opacity.py new file mode 100644 index 0000000000..d3d7578e50 --- /dev/null +++ b/plotly/validators/layout/image/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='layout.image', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_sizex.py b/plotly/validators/layout/image/_sizex.py new file mode 100644 index 0000000000..8e3cba0c87 --- /dev/null +++ b/plotly/validators/layout/image/_sizex.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizexValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizex', parent_name='layout.image', **kwargs + ): + super(SizexValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_sizey.py b/plotly/validators/layout/image/_sizey.py new file mode 100644 index 0000000000..b3c93e4cb5 --- /dev/null +++ b/plotly/validators/layout/image/_sizey.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizeyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizey', parent_name='layout.image', **kwargs + ): + super(SizeyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_sizing.py b/plotly/validators/layout/image/_sizing.py new file mode 100644 index 0000000000..e616c601af --- /dev/null +++ b/plotly/validators/layout/image/_sizing.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizingValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='sizing', parent_name='layout.image', **kwargs + ): + super(SizingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['fill', 'contain', 'stretch'], + **kwargs + ) diff --git a/plotly/validators/layout/image/_source.py b/plotly/validators/layout/image/_source.py new file mode 100644 index 0000000000..634f148dcf --- /dev/null +++ b/plotly/validators/layout/image/_source.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SourceValidator(_plotly_utils.basevalidators.ImageUriValidator): + + def __init__( + self, plotly_name='source', parent_name='layout.image', **kwargs + ): + super(SourceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_visible.py b/plotly/validators/layout/image/_visible.py new file mode 100644 index 0000000000..b589d48211 --- /dev/null +++ b/plotly/validators/layout/image/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.image', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_x.py b/plotly/validators/layout/image/_x.py new file mode 100644 index 0000000000..2bdf37a8b8 --- /dev/null +++ b/plotly/validators/layout/image/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x', parent_name='layout.image', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_xanchor.py b/plotly/validators/layout/image/_xanchor.py new file mode 100644 index 0000000000..e998d3746c --- /dev/null +++ b/plotly/validators/layout/image/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.image', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/image/_xref.py b/plotly/validators/layout/image/_xref.py new file mode 100644 index 0000000000..e94f041678 --- /dev/null +++ b/plotly/validators/layout/image/_xref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xref', parent_name='layout.image', **kwargs + ): + super(XrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['paper', '/^x([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/image/_y.py b/plotly/validators/layout/image/_y.py new file mode 100644 index 0000000000..85de0e15ce --- /dev/null +++ b/plotly/validators/layout/image/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y', parent_name='layout.image', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/image/_yanchor.py b/plotly/validators/layout/image/_yanchor.py new file mode 100644 index 0000000000..fdeba0e2f5 --- /dev/null +++ b/plotly/validators/layout/image/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.image', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/image/_yref.py b/plotly/validators/layout/image/_yref.py new file mode 100644 index 0000000000..f0ea537588 --- /dev/null +++ b/plotly/validators/layout/image/_yref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yref', parent_name='layout.image', **kwargs + ): + super(YrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['paper', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/legend/__init__.py b/plotly/validators/layout/legend/__init__.py new file mode 100644 index 0000000000..65969a1c3b --- /dev/null +++ b/plotly/validators/layout/legend/__init__.py @@ -0,0 +1,11 @@ +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._traceorder import TraceorderValidator +from ._tracegroupgap import TracegroupgapValidator +from ._orientation import OrientationValidator +from ._font import FontValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/layout/legend/_bgcolor.py b/plotly/validators/layout/legend/_bgcolor.py new file mode 100644 index 0000000000..da8d9cfa7b --- /dev/null +++ b/plotly/validators/layout/legend/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.legend', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_bordercolor.py b/plotly/validators/layout/legend/_bordercolor.py new file mode 100644 index 0000000000..3b975382df --- /dev/null +++ b/plotly/validators/layout/legend/_bordercolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bordercolor', parent_name='layout.legend', **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_borderwidth.py b/plotly/validators/layout/legend/_borderwidth.py new file mode 100644 index 0000000000..f395249045 --- /dev/null +++ b/plotly/validators/layout/legend/_borderwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='borderwidth', parent_name='layout.legend', **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_font.py b/plotly/validators/layout/legend/_font.py new file mode 100644 index 0000000000..0d9b465e82 --- /dev/null +++ b/plotly/validators/layout/legend/_font.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='layout.legend', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/legend/_orientation.py b/plotly/validators/layout/legend/_orientation.py new file mode 100644 index 0000000000..1dff0618bd --- /dev/null +++ b/plotly/validators/layout/legend/_orientation.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='orientation', parent_name='layout.legend', **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='info', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/layout/legend/_tracegroupgap.py b/plotly/validators/layout/legend/_tracegroupgap.py new file mode 100644 index 0000000000..f9e3de41e2 --- /dev/null +++ b/plotly/validators/layout/legend/_tracegroupgap.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracegroupgapValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tracegroupgap', + parent_name='layout.legend', + **kwargs + ): + super(TracegroupgapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_traceorder.py b/plotly/validators/layout/legend/_traceorder.py new file mode 100644 index 0000000000..967cdaca0c --- /dev/null +++ b/plotly/validators/layout/legend/_traceorder.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TraceorderValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='traceorder', parent_name='layout.legend', **kwargs + ): + super(TraceorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + extras=['normal'], + flags=['reversed', 'grouped'], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_x.py b/plotly/validators/layout/legend/_x.py new file mode 100644 index 0000000000..fd99ff71c0 --- /dev/null +++ b/plotly/validators/layout/legend/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='x', parent_name='layout.legend', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_xanchor.py b/plotly/validators/layout/legend/_xanchor.py new file mode 100644 index 0000000000..d4016f3ee0 --- /dev/null +++ b/plotly/validators/layout/legend/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.legend', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/legend/_y.py b/plotly/validators/layout/legend/_y.py new file mode 100644 index 0000000000..c67934bca7 --- /dev/null +++ b/plotly/validators/layout/legend/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='y', parent_name='layout.legend', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/_yanchor.py b/plotly/validators/layout/legend/_yanchor.py new file mode 100644 index 0000000000..9c4e573fe8 --- /dev/null +++ b/plotly/validators/layout/legend/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.legend', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/legend/font/__init__.py b/plotly/validators/layout/legend/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/legend/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/legend/font/_color.py b/plotly/validators/layout/legend/font/_color.py new file mode 100644 index 0000000000..a62323b85c --- /dev/null +++ b/plotly/validators/layout/legend/font/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.legend.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/legend/font/_family.py b/plotly/validators/layout/legend/font/_family.py new file mode 100644 index 0000000000..e7b50f427c --- /dev/null +++ b/plotly/validators/layout/legend/font/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='layout.legend.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/legend/font/_size.py b/plotly/validators/layout/legend/font/_size.py new file mode 100644 index 0000000000..e1ef47a49f --- /dev/null +++ b/plotly/validators/layout/legend/font/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='layout.legend.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='legend', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/__init__.py b/plotly/validators/layout/mapbox/__init__.py new file mode 100644 index 0000000000..dbf4ef83e5 --- /dev/null +++ b/plotly/validators/layout/mapbox/__init__.py @@ -0,0 +1,8 @@ +from ._zoom import ZoomValidator +from ._style import StyleValidator +from ._pitch import PitchValidator +from ._layers import LayersValidator +from ._domain import DomainValidator +from ._center import CenterValidator +from ._bearing import BearingValidator +from ._accesstoken import AccesstokenValidator diff --git a/plotly/validators/layout/mapbox/_accesstoken.py b/plotly/validators/layout/mapbox/_accesstoken.py new file mode 100644 index 0000000000..33ad399253 --- /dev/null +++ b/plotly/validators/layout/mapbox/_accesstoken.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AccesstokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='accesstoken', parent_name='layout.mapbox', **kwargs + ): + super(AccesstokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_bearing.py b/plotly/validators/layout/mapbox/_bearing.py new file mode 100644 index 0000000000..f229260206 --- /dev/null +++ b/plotly/validators/layout/mapbox/_bearing.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BearingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='bearing', parent_name='layout.mapbox', **kwargs + ): + super(BearingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_center.py b/plotly/validators/layout/mapbox/_center.py new file mode 100644 index 0000000000..298e1bb60f --- /dev/null +++ b/plotly/validators/layout/mapbox/_center.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CenterValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='center', parent_name='layout.mapbox', **kwargs + ): + super(CenterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Center', + data_docs=""" + lat + Sets the latitude of the center of the map (in + degrees North). + lon + Sets the longitude of the center of the map (in + degrees East).""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_domain.py b/plotly/validators/layout/mapbox/_domain.py new file mode 100644 index 0000000000..9540b45494 --- /dev/null +++ b/plotly/validators/layout/mapbox/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.mapbox', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this mapbox subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this mapbox subplot . + x + Sets the horizontal domain of this mapbox + subplot (in plot fraction). + y + Sets the vertical domain of this mapbox subplot + (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_layers.py b/plotly/validators/layout/mapbox/_layers.py new file mode 100644 index 0000000000..52bef38b2d --- /dev/null +++ b/plotly/validators/layout/mapbox/_layers.py @@ -0,0 +1,59 @@ +import _plotly_utils.basevalidators + + +class LayersValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, plotly_name='layers', parent_name='layout.mapbox', **kwargs + ): + super(LayersValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Layer', + data_docs=""" + below + Determines if the layer will be inserted before + the layer with the specified ID. If omitted or + set to '', the layer will be inserted above + every existing layer. + circle + plotly.graph_objs.layout.mapbox.layer.Circle + instance or dict with compatible properties + color + Sets the primary layer color. If `type` is + *circle*, color corresponds to the circle color + If `type` is *line*, color corresponds to the + line color If `type` is *fill*, color + corresponds to the fill color If `type` is + *symbol*, color corresponds to the icon color + fill + plotly.graph_objs.layout.mapbox.layer.Fill + instance or dict with compatible properties + line + plotly.graph_objs.layout.mapbox.layer.Line + instance or dict with compatible properties + opacity + Sets the opacity of the layer. + source + Sets the source data for this layer. Source can + be either a URL, a geojson object (with + `sourcetype` set to *geojson*) or an array of + tile URLS (with `sourcetype` set to *vector*). + sourcelayer + Specifies the layer to use from a vector tile + source. Required for *vector* source type that + supports multiple layers. + sourcetype + Sets the source type for this layer. Support + for *raster*, *image* and *video* source types + is coming soon. + symbol + plotly.graph_objs.layout.mapbox.layer.Symbol + instance or dict with compatible properties + type + Sets the layer type. Support for *raster*, + *background* types is coming soon. Note that + *line* and *fill* are not compatible with Point + GeoJSON geometries.""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_pitch.py b/plotly/validators/layout/mapbox/_pitch.py new file mode 100644 index 0000000000..a8626f6319 --- /dev/null +++ b/plotly/validators/layout/mapbox/_pitch.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PitchValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='pitch', parent_name='layout.mapbox', **kwargs + ): + super(PitchValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_style.py b/plotly/validators/layout/mapbox/_style.py new file mode 100644 index 0000000000..6e1ee96287 --- /dev/null +++ b/plotly/validators/layout/mapbox/_style.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StyleValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='style', parent_name='layout.mapbox', **kwargs + ): + super(StyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=[ + 'basic', 'streets', 'outdoors', 'light', 'dark', 'satellite', + 'satellite-streets' + ], + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/_zoom.py b/plotly/validators/layout/mapbox/_zoom.py new file mode 100644 index 0000000000..a43b806722 --- /dev/null +++ b/plotly/validators/layout/mapbox/_zoom.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZoomValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='zoom', parent_name='layout.mapbox', **kwargs + ): + super(ZoomValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/center/__init__.py b/plotly/validators/layout/mapbox/center/__init__.py new file mode 100644 index 0000000000..ab3107d784 --- /dev/null +++ b/plotly/validators/layout/mapbox/center/__init__.py @@ -0,0 +1,2 @@ +from ._lon import LonValidator +from ._lat import LatValidator diff --git a/plotly/validators/layout/mapbox/center/_lat.py b/plotly/validators/layout/mapbox/center/_lat.py new file mode 100644 index 0000000000..a576712af6 --- /dev/null +++ b/plotly/validators/layout/mapbox/center/_lat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LatValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='lat', parent_name='layout.mapbox.center', **kwargs + ): + super(LatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/center/_lon.py b/plotly/validators/layout/mapbox/center/_lon.py new file mode 100644 index 0000000000..95947f3995 --- /dev/null +++ b/plotly/validators/layout/mapbox/center/_lon.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LonValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='lon', parent_name='layout.mapbox.center', **kwargs + ): + super(LonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/domain/__init__.py b/plotly/validators/layout/mapbox/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/layout/mapbox/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/layout/mapbox/domain/_column.py b/plotly/validators/layout/mapbox/domain/_column.py new file mode 100644 index 0000000000..92ece24dd1 --- /dev/null +++ b/plotly/validators/layout/mapbox/domain/_column.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='column', + parent_name='layout.mapbox.domain', + **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/domain/_row.py b/plotly/validators/layout/mapbox/domain/_row.py new file mode 100644 index 0000000000..ab95bf21c5 --- /dev/null +++ b/plotly/validators/layout/mapbox/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='layout.mapbox.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/domain/_x.py b/plotly/validators/layout/mapbox/domain/_x.py new file mode 100644 index 0000000000..6069d01d3f --- /dev/null +++ b/plotly/validators/layout/mapbox/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.mapbox.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/domain/_y.py b/plotly/validators/layout/mapbox/domain/_y.py new file mode 100644 index 0000000000..36885e03eb --- /dev/null +++ b/plotly/validators/layout/mapbox/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.mapbox.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/__init__.py b/plotly/validators/layout/mapbox/layer/__init__.py new file mode 100644 index 0000000000..ec9f7f73f6 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/__init__.py @@ -0,0 +1,11 @@ +from ._type import TypeValidator +from ._symbol import SymbolValidator +from ._sourcetype import SourcetypeValidator +from ._sourcelayer import SourcelayerValidator +from ._source import SourceValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._fill import FillValidator +from ._color import ColorValidator +from ._circle import CircleValidator +from ._below import BelowValidator diff --git a/plotly/validators/layout/mapbox/layer/_below.py b/plotly/validators/layout/mapbox/layer/_below.py new file mode 100644 index 0000000000..1134c3a423 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_below.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BelowValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='below', parent_name='layout.mapbox.layer', **kwargs + ): + super(BelowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_circle.py b/plotly/validators/layout/mapbox/layer/_circle.py new file mode 100644 index 0000000000..e6aecc638b --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_circle.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CircleValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='circle', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(CircleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Circle', + data_docs=""" + radius + Sets the circle radius. Has an effect only when + `type` is set to *circle*.""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_color.py b/plotly/validators/layout/mapbox/layer/_color.py new file mode 100644 index 0000000000..2a2ef0b0de --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.mapbox.layer', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_fill.py b/plotly/validators/layout/mapbox/layer/_fill.py new file mode 100644 index 0000000000..330ea3376a --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_fill.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='fill', parent_name='layout.mapbox.layer', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Fill', + data_docs=""" + outlinecolor + Sets the fill outline color. Has an effect only + when `type` is set to *fill*.""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_line.py b/plotly/validators/layout/mapbox/layer/_line.py new file mode 100644 index 0000000000..b03398d972 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_line.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='layout.mapbox.layer', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + width + Sets the line width. Has an effect only when + `type` is set to *line*.""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_opacity.py b/plotly/validators/layout/mapbox/layer/_opacity.py new file mode 100644 index 0000000000..10a6f805f8 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_source.py b/plotly/validators/layout/mapbox/layer/_source.py new file mode 100644 index 0000000000..d03cd78580 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_source.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SourceValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='source', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(SourceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_sourcelayer.py b/plotly/validators/layout/mapbox/layer/_sourcelayer.py new file mode 100644 index 0000000000..34e4ca9107 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_sourcelayer.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SourcelayerValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='sourcelayer', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(SourcelayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_sourcetype.py b/plotly/validators/layout/mapbox/layer/_sourcetype.py new file mode 100644 index 0000000000..3712e1bc11 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_sourcetype.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SourcetypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sourcetype', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(SourcetypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['geojson', 'vector'], + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_symbol.py b/plotly/validators/layout/mapbox/layer/_symbol.py new file mode 100644 index 0000000000..a98630a7ab --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_symbol.py @@ -0,0 +1,32 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='layout.mapbox.layer', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Symbol', + data_docs=""" + icon + Sets the symbol icon image. Full list: + https://www.mapbox.com/maki-icons/ + iconsize + Sets the symbol icon size. Has an effect only + when `type` is set to *symbol*. + text + Sets the symbol text. + textfont + Sets the icon text font. Has an effect only + when `type` is set to *symbol*. + textposition + Sets the positions of the `text` elements with + respects to the (x,y) coordinates.""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/_type.py b/plotly/validators/layout/mapbox/layer/_type.py new file mode 100644 index 0000000000..12a36fab36 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.mapbox.layer', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['circle', 'line', 'fill', 'symbol'], + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/circle/__init__.py b/plotly/validators/layout/mapbox/layer/circle/__init__.py new file mode 100644 index 0000000000..42599ad609 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/circle/__init__.py @@ -0,0 +1 @@ +from ._radius import RadiusValidator diff --git a/plotly/validators/layout/mapbox/layer/circle/_radius.py b/plotly/validators/layout/mapbox/layer/circle/_radius.py new file mode 100644 index 0000000000..658411971c --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/circle/_radius.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class RadiusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='radius', + parent_name='layout.mapbox.layer.circle', + **kwargs + ): + super(RadiusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/fill/__init__.py b/plotly/validators/layout/mapbox/layer/fill/__init__.py new file mode 100644 index 0000000000..0e7deb56f3 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/fill/__init__.py @@ -0,0 +1 @@ +from ._outlinecolor import OutlinecolorValidator diff --git a/plotly/validators/layout/mapbox/layer/fill/_outlinecolor.py b/plotly/validators/layout/mapbox/layer/fill/_outlinecolor.py new file mode 100644 index 0000000000..b559497a47 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/fill/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='layout.mapbox.layer.fill', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/line/__init__.py b/plotly/validators/layout/mapbox/layer/line/__init__.py new file mode 100644 index 0000000000..6b3cef5b7d --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/line/__init__.py @@ -0,0 +1 @@ +from ._width import WidthValidator diff --git a/plotly/validators/layout/mapbox/layer/line/_width.py b/plotly/validators/layout/mapbox/layer/line/_width.py new file mode 100644 index 0000000000..b66b61a11b --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/line/_width.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='layout.mapbox.layer.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/__init__.py b/plotly/validators/layout/mapbox/layer/symbol/__init__.py new file mode 100644 index 0000000000..aa5f972a7b --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/__init__.py @@ -0,0 +1,5 @@ +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._iconsize import IconsizeValidator +from ._icon import IconValidator diff --git a/plotly/validators/layout/mapbox/layer/symbol/_icon.py b/plotly/validators/layout/mapbox/layer/symbol/_icon.py new file mode 100644 index 0000000000..0a83c4ba60 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/_icon.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class IconValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='icon', + parent_name='layout.mapbox.layer.symbol', + **kwargs + ): + super(IconValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/_iconsize.py b/plotly/validators/layout/mapbox/layer/symbol/_iconsize.py new file mode 100644 index 0000000000..7becefd6d2 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/_iconsize.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class IconsizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='iconsize', + parent_name='layout.mapbox.layer.symbol', + **kwargs + ): + super(IconsizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/_text.py b/plotly/validators/layout/mapbox/layer/symbol/_text.py new file mode 100644 index 0000000000..be32a67e74 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/_text.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='text', + parent_name='layout.mapbox.layer.symbol', + **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/_textfont.py b/plotly/validators/layout/mapbox/layer/symbol/_textfont.py new file mode 100644 index 0000000000..5f3c43f168 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/_textfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='layout.mapbox.layer.symbol', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/_textposition.py b/plotly/validators/layout/mapbox/layer/symbol/_textposition.py new file mode 100644 index 0000000000..51c9a95655 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/_textposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='textposition', + parent_name='layout.mapbox.layer.symbol', + **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='plot', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/textfont/__init__.py b/plotly/validators/layout/mapbox/layer/symbol/textfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/textfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/mapbox/layer/symbol/textfont/_color.py b/plotly/validators/layout/mapbox/layer/symbol/textfont/_color.py new file mode 100644 index 0000000000..bde9c6e503 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.mapbox.layer.symbol.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/textfont/_family.py b/plotly/validators/layout/mapbox/layer/symbol/textfont/_family.py new file mode 100644 index 0000000000..cb5b1feeea --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/textfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.mapbox.layer.symbol.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/mapbox/layer/symbol/textfont/_size.py b/plotly/validators/layout/mapbox/layer/symbol/textfont/_size.py new file mode 100644 index 0000000000..d48a1635c5 --- /dev/null +++ b/plotly/validators/layout/mapbox/layer/symbol/textfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.mapbox.layer.symbol.textfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/margin/__init__.py b/plotly/validators/layout/margin/__init__.py new file mode 100644 index 0000000000..7d24ee5aeb --- /dev/null +++ b/plotly/validators/layout/margin/__init__.py @@ -0,0 +1,6 @@ +from ._t import TValidator +from ._r import RValidator +from ._pad import PadValidator +from ._l import LValidator +from ._b import BValidator +from ._autoexpand import AutoexpandValidator diff --git a/plotly/validators/layout/margin/_autoexpand.py b/plotly/validators/layout/margin/_autoexpand.py new file mode 100644 index 0000000000..63247bb8b7 --- /dev/null +++ b/plotly/validators/layout/margin/_autoexpand.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AutoexpandValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autoexpand', parent_name='layout.margin', **kwargs + ): + super(AutoexpandValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/margin/_b.py b/plotly/validators/layout/margin/_b.py new file mode 100644 index 0000000000..cc46e2b0b8 --- /dev/null +++ b/plotly/validators/layout/margin/_b.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='b', parent_name='layout.margin', **kwargs): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/margin/_l.py b/plotly/validators/layout/margin/_l.py new file mode 100644 index 0000000000..d81938f81e --- /dev/null +++ b/plotly/validators/layout/margin/_l.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class LValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='l', parent_name='layout.margin', **kwargs): + super(LValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/margin/_pad.py b/plotly/validators/layout/margin/_pad.py new file mode 100644 index 0000000000..0f0681f6d3 --- /dev/null +++ b/plotly/validators/layout/margin/_pad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class PadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='pad', parent_name='layout.margin', **kwargs + ): + super(PadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/margin/_r.py b/plotly/validators/layout/margin/_r.py new file mode 100644 index 0000000000..b9e60dba3a --- /dev/null +++ b/plotly/validators/layout/margin/_r.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='r', parent_name='layout.margin', **kwargs): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/margin/_t.py b/plotly/validators/layout/margin/_t.py new file mode 100644 index 0000000000..f90d599f97 --- /dev/null +++ b/plotly/validators/layout/margin/_t.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='t', parent_name='layout.margin', **kwargs): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/__init__.py b/plotly/validators/layout/polar/__init__.py new file mode 100644 index 0000000000..03516101eb --- /dev/null +++ b/plotly/validators/layout/polar/__init__.py @@ -0,0 +1,5 @@ +from ._sector import SectorValidator +from ._radialaxis import RadialAxisValidator +from ._domain import DomainValidator +from ._bgcolor import BgcolorValidator +from ._angularaxis import AngularAxisValidator diff --git a/plotly/validators/layout/polar/_angularaxis.py b/plotly/validators/layout/polar/_angularaxis.py new file mode 100644 index 0000000000..8021975b04 --- /dev/null +++ b/plotly/validators/layout/polar/_angularaxis.py @@ -0,0 +1,246 @@ +import _plotly_utils.basevalidators + + +class AngularAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='angularaxis', parent_name='layout.polar', **kwargs + ): + super(AngularAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='AngularAxis', + data_docs=""" + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + direction + Sets the direction corresponding to positive + angles. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + period + Set the angular period. Has an effect only when + `angularaxis.type` is *category*. + rotation + Sets that start position (in degrees) of the + angular axis By default, polar subplots with + `direction` set to *counterclockwise* get a + `rotation` of *0* which corresponds to due East + (like what mathematicians prefer). In turn, + polar with `direction` set to *clockwise* get a + rotation of *90* which corresponds to due North + (like on a compass), + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thetaunit + Sets the format unit of the formatted *theta* + values. Has an effect only when + `angularaxis.type` is *linear*. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.angularaxis.Tick + formatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + type + Sets the angular axis type. If *linear*, set + `thetaunit` to determine the unit in which axis + value are shown. If *category, use `period` to + set the number of integer coordinates around + polar axis. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/_bgcolor.py b/plotly/validators/layout/polar/_bgcolor.py new file mode 100644 index 0000000000..7a0a1368b6 --- /dev/null +++ b/plotly/validators/layout/polar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.polar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/_domain.py b/plotly/validators/layout/polar/_domain.py new file mode 100644 index 0000000000..97cfbc6e03 --- /dev/null +++ b/plotly/validators/layout/polar/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.polar', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this polar subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this polar subplot . + x + Sets the horizontal domain of this polar + subplot (in plot fraction). + y + Sets the vertical domain of this polar subplot + (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/_radialaxis.py b/plotly/validators/layout/polar/_radialaxis.py new file mode 100644 index 0000000000..b2d96934e6 --- /dev/null +++ b/plotly/validators/layout/polar/_radialaxis.py @@ -0,0 +1,270 @@ +import _plotly_utils.basevalidators + + +class RadialAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='radialaxis', parent_name='layout.polar', **kwargs + ): + super(RadialAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='RadialAxis', + data_docs=""" + angle + Sets the angle (in degrees) from which the + radial axis is drawn. Note that by default, + radial axis line on the theta=0 line + corresponds to a line pointing right (like what + mathematicians prefer). Defaults to the first + `polar.sector` angle. + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *tozero*`, the range extends to 0, + regardless of the input data If *nonnegative*, + the range is non-negative, regardless of the + input data. If *normal*, the range is computed + in relation to the extrema of the input data + (same behavior as for cartesian axes). + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + side + Determines on which side of radial axis line + the tick and tick labels appear. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.polar.radialaxis.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/_sector.py b/plotly/validators/layout/polar/_sector.py new file mode 100644 index 0000000000..ee5c249d03 --- /dev/null +++ b/plotly/validators/layout/polar/_sector.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class SectorValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='sector', parent_name='layout.polar', **kwargs + ): + super(SectorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'editType': 'plot' + }, { + 'valType': 'number', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/__init__.py b/plotly/validators/layout/polar/angularaxis/__init__.py new file mode 100644 index 0000000000..2d78e912f5 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/__init__.py @@ -0,0 +1,42 @@ +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thetaunit import ThetaunitValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._rotation import RotationValidator +from ._period import PeriodValidator +from ._nticks import NticksValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._direction import DirectionValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator diff --git a/plotly/validators/layout/polar/angularaxis/_categoryarray.py b/plotly/validators/layout/polar/angularaxis/_categoryarray.py new file mode 100644 index 0000000000..93f104cd20 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_categoryarraysrc.py b/plotly/validators/layout/polar/angularaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..a541c4706b --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_categoryorder.py b/plotly/validators/layout/polar/angularaxis/_categoryorder.py new file mode 100644 index 0000000000..035cb9b80e --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_color.py b/plotly/validators/layout/polar/angularaxis/_color.py new file mode 100644 index 0000000000..3407c5934a --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_direction.py b/plotly/validators/layout/polar/angularaxis/_direction.py new file mode 100644 index 0000000000..281fcf44c5 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_direction.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DirectionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='direction', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(DirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['counterclockwise', 'clockwise'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_dtick.py b/plotly/validators/layout/polar/angularaxis/_dtick.py new file mode 100644 index 0000000000..045611abb2 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_exponentformat.py b/plotly/validators/layout/polar/angularaxis/_exponentformat.py new file mode 100644 index 0000000000..b8311a939f --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_gridcolor.py b/plotly/validators/layout/polar/angularaxis/_gridcolor.py new file mode 100644 index 0000000000..48d824bea4 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_gridwidth.py b/plotly/validators/layout/polar/angularaxis/_gridwidth.py new file mode 100644 index 0000000000..5f8f33bada --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_hoverformat.py b/plotly/validators/layout/polar/angularaxis/_hoverformat.py new file mode 100644 index 0000000000..4fc9a4888c --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_layer.py b/plotly/validators/layout/polar/angularaxis/_layer.py new file mode 100644 index 0000000000..613cf1454b --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_layer.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='layer', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_linecolor.py b/plotly/validators/layout/polar/angularaxis/_linecolor.py new file mode 100644 index 0000000000..6b593d7847 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_linewidth.py b/plotly/validators/layout/polar/angularaxis/_linewidth.py new file mode 100644 index 0000000000..5aa249acb5 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_nticks.py b/plotly/validators/layout/polar/angularaxis/_nticks.py new file mode 100644 index 0000000000..de0eb3e147 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_period.py b/plotly/validators/layout/polar/angularaxis/_period.py new file mode 100644 index 0000000000..7287f640db --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_period.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class PeriodValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='period', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(PeriodValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_rotation.py b/plotly/validators/layout/polar/angularaxis/_rotation.py new file mode 100644 index 0000000000..d9b79dab7b --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_rotation.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class RotationValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='rotation', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(RotationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_separatethousands.py b/plotly/validators/layout/polar/angularaxis/_separatethousands.py new file mode 100644 index 0000000000..a4c5426367 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showexponent.py b/plotly/validators/layout/polar/angularaxis/_showexponent.py new file mode 100644 index 0000000000..e7c0e7036d --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showgrid.py b/plotly/validators/layout/polar/angularaxis/_showgrid.py new file mode 100644 index 0000000000..12c22398ce --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showline.py b/plotly/validators/layout/polar/angularaxis/_showline.py new file mode 100644 index 0000000000..66c683b271 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showticklabels.py b/plotly/validators/layout/polar/angularaxis/_showticklabels.py new file mode 100644 index 0000000000..356f77cf64 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showtickprefix.py b/plotly/validators/layout/polar/angularaxis/_showtickprefix.py new file mode 100644 index 0000000000..71b0b63b56 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_showticksuffix.py b/plotly/validators/layout/polar/angularaxis/_showticksuffix.py new file mode 100644 index 0000000000..005ca51d6c --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_thetaunit.py b/plotly/validators/layout/polar/angularaxis/_thetaunit.py new file mode 100644 index 0000000000..7662b6a612 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_thetaunit.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThetaunitValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thetaunit', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(ThetaunitValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['radians', 'degrees'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tick0.py b/plotly/validators/layout/polar/angularaxis/_tick0.py new file mode 100644 index 0000000000..6f82029818 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickangle.py b/plotly/validators/layout/polar/angularaxis/_tickangle.py new file mode 100644 index 0000000000..9095d1b070 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickcolor.py b/plotly/validators/layout/polar/angularaxis/_tickcolor.py new file mode 100644 index 0000000000..c767e80531 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickfont.py b/plotly/validators/layout/polar/angularaxis/_tickfont.py new file mode 100644 index 0000000000..9a46fa5aa1 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickformat.py b/plotly/validators/layout/polar/angularaxis/_tickformat.py new file mode 100644 index 0000000000..14c5739479 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickformatstops.py b/plotly/validators/layout/polar/angularaxis/_tickformatstops.py new file mode 100644 index 0000000000..148a85bf4e --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_ticklen.py b/plotly/validators/layout/polar/angularaxis/_ticklen.py new file mode 100644 index 0000000000..0ebd705cd3 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickmode.py b/plotly/validators/layout/polar/angularaxis/_tickmode.py new file mode 100644 index 0000000000..073e3cd228 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickprefix.py b/plotly/validators/layout/polar/angularaxis/_tickprefix.py new file mode 100644 index 0000000000..4cca482e21 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_ticks.py b/plotly/validators/layout/polar/angularaxis/_ticks.py new file mode 100644 index 0000000000..4411d2f869 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_ticksuffix.py b/plotly/validators/layout/polar/angularaxis/_ticksuffix.py new file mode 100644 index 0000000000..addf9c0aa0 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_ticktext.py b/plotly/validators/layout/polar/angularaxis/_ticktext.py new file mode 100644 index 0000000000..0a37763fbe --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_ticktextsrc.py b/plotly/validators/layout/polar/angularaxis/_ticktextsrc.py new file mode 100644 index 0000000000..4aae6fabc2 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickvals.py b/plotly/validators/layout/polar/angularaxis/_tickvals.py new file mode 100644 index 0000000000..a627481cee --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickvalssrc.py b/plotly/validators/layout/polar/angularaxis/_tickvalssrc.py new file mode 100644 index 0000000000..362d5092d1 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_tickwidth.py b/plotly/validators/layout/polar/angularaxis/_tickwidth.py new file mode 100644 index 0000000000..8f82b769b1 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_type.py b/plotly/validators/layout/polar/angularaxis/_type.py new file mode 100644 index 0000000000..72d26d3d18 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_type.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/_visible.py b/plotly/validators/layout/polar/angularaxis/_visible.py new file mode 100644 index 0000000000..c353a98715 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.polar.angularaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/tickfont/__init__.py b/plotly/validators/layout/polar/angularaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/polar/angularaxis/tickfont/_color.py b/plotly/validators/layout/polar/angularaxis/tickfont/_color.py new file mode 100644 index 0000000000..ff0d13f1fa --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.polar.angularaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/tickfont/_family.py b/plotly/validators/layout/polar/angularaxis/tickfont/_family.py new file mode 100644 index 0000000000..8ad48c5386 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.polar.angularaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/tickfont/_size.py b/plotly/validators/layout/polar/angularaxis/tickfont/_size.py new file mode 100644 index 0000000000..9bd9944c06 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.polar.angularaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/tickformatstop/__init__.py b/plotly/validators/layout/polar/angularaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/polar/angularaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/polar/angularaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..e0534694d1 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.polar.angularaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/angularaxis/tickformatstop/_value.py b/plotly/validators/layout/polar/angularaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..9913586491 --- /dev/null +++ b/plotly/validators/layout/polar/angularaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.polar.angularaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/domain/__init__.py b/plotly/validators/layout/polar/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/layout/polar/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/layout/polar/domain/_column.py b/plotly/validators/layout/polar/domain/_column.py new file mode 100644 index 0000000000..61b2485126 --- /dev/null +++ b/plotly/validators/layout/polar/domain/_column.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='column', + parent_name='layout.polar.domain', + **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/domain/_row.py b/plotly/validators/layout/polar/domain/_row.py new file mode 100644 index 0000000000..3d542c3ee0 --- /dev/null +++ b/plotly/validators/layout/polar/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='layout.polar.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/domain/_x.py b/plotly/validators/layout/polar/domain/_x.py new file mode 100644 index 0000000000..481077944e --- /dev/null +++ b/plotly/validators/layout/polar/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.polar.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/domain/_y.py b/plotly/validators/layout/polar/domain/_y.py new file mode 100644 index 0000000000..74897a5e21 --- /dev/null +++ b/plotly/validators/layout/polar/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.polar.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/__init__.py b/plotly/validators/layout/polar/radialaxis/__init__.py new file mode 100644 index 0000000000..90c2868eab --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/__init__.py @@ -0,0 +1,46 @@ +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._side import SideValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._autorange import AutorangeValidator +from ._angle import AngleValidator diff --git a/plotly/validators/layout/polar/radialaxis/_angle.py b/plotly/validators/layout/polar/radialaxis/_angle.py new file mode 100644 index 0000000000..7cf7f06a88 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_angle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class AngleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='angle', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(AngleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_autorange.py b/plotly/validators/layout/polar/radialaxis/_autorange.py new file mode 100644 index 0000000000..71e41dd24b --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_autorange.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='autorange', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_calendar.py b/plotly/validators/layout/polar/radialaxis/_calendar.py new file mode 100644 index 0000000000..9a2d23e991 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_calendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='calendar', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_categoryarray.py b/plotly/validators/layout/polar/radialaxis/_categoryarray.py new file mode 100644 index 0000000000..7c235fad6c --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_categoryarraysrc.py b/plotly/validators/layout/polar/radialaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..bd54b0deb0 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_categoryorder.py b/plotly/validators/layout/polar/radialaxis/_categoryorder.py new file mode 100644 index 0000000000..62cc587935 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_color.py b/plotly/validators/layout/polar/radialaxis/_color.py new file mode 100644 index 0000000000..9f331793fe --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_dtick.py b/plotly/validators/layout/polar/radialaxis/_dtick.py new file mode 100644 index 0000000000..d18b7deb9b --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_exponentformat.py b/plotly/validators/layout/polar/radialaxis/_exponentformat.py new file mode 100644 index 0000000000..334e384af4 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_gridcolor.py b/plotly/validators/layout/polar/radialaxis/_gridcolor.py new file mode 100644 index 0000000000..b58beafb3a --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_gridwidth.py b/plotly/validators/layout/polar/radialaxis/_gridwidth.py new file mode 100644 index 0000000000..8e7036ce43 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_hoverformat.py b/plotly/validators/layout/polar/radialaxis/_hoverformat.py new file mode 100644 index 0000000000..4e1d34fadd --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_layer.py b/plotly/validators/layout/polar/radialaxis/_layer.py new file mode 100644 index 0000000000..95dd7de856 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_layer.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='layer', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_linecolor.py b/plotly/validators/layout/polar/radialaxis/_linecolor.py new file mode 100644 index 0000000000..29c5e17b02 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_linewidth.py b/plotly/validators/layout/polar/radialaxis/_linewidth.py new file mode 100644 index 0000000000..8258f753b4 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_nticks.py b/plotly/validators/layout/polar/radialaxis/_nticks.py new file mode 100644 index 0000000000..1b441e61f8 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_range.py b/plotly/validators/layout/polar/radialaxis/_range.py new file mode 100644 index 0000000000..c0d4e2cc65 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_range.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='range', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='axrange+margins', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_rangemode.py b/plotly/validators/layout/polar/radialaxis/_rangemode.py new file mode 100644 index 0000000000..3a80adde9c --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_rangemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='rangemode', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['tozero', 'nonnegative', 'normal'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_separatethousands.py b/plotly/validators/layout/polar/radialaxis/_separatethousands.py new file mode 100644 index 0000000000..bfb597fa32 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showexponent.py b/plotly/validators/layout/polar/radialaxis/_showexponent.py new file mode 100644 index 0000000000..eafad425f0 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showgrid.py b/plotly/validators/layout/polar/radialaxis/_showgrid.py new file mode 100644 index 0000000000..f2aca08ebc --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showline.py b/plotly/validators/layout/polar/radialaxis/_showline.py new file mode 100644 index 0000000000..780e8f341d --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showticklabels.py b/plotly/validators/layout/polar/radialaxis/_showticklabels.py new file mode 100644 index 0000000000..5c440b45ed --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showtickprefix.py b/plotly/validators/layout/polar/radialaxis/_showtickprefix.py new file mode 100644 index 0000000000..bb49379e1b --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_showticksuffix.py b/plotly/validators/layout/polar/radialaxis/_showticksuffix.py new file mode 100644 index 0000000000..31848d6cf0 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_side.py b/plotly/validators/layout/polar/radialaxis/_side.py new file mode 100644 index 0000000000..ef54844874 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_side.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='side', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(SideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['clockwise', 'counterclockwise'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tick0.py b/plotly/validators/layout/polar/radialaxis/_tick0.py new file mode 100644 index 0000000000..725179d9af --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickangle.py b/plotly/validators/layout/polar/radialaxis/_tickangle.py new file mode 100644 index 0000000000..92deb5bb74 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickcolor.py b/plotly/validators/layout/polar/radialaxis/_tickcolor.py new file mode 100644 index 0000000000..e38921523e --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickfont.py b/plotly/validators/layout/polar/radialaxis/_tickfont.py new file mode 100644 index 0000000000..5361be98b1 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickformat.py b/plotly/validators/layout/polar/radialaxis/_tickformat.py new file mode 100644 index 0000000000..6eec6879b6 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickformatstops.py b/plotly/validators/layout/polar/radialaxis/_tickformatstops.py new file mode 100644 index 0000000000..3be91d3a9b --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_ticklen.py b/plotly/validators/layout/polar/radialaxis/_ticklen.py new file mode 100644 index 0000000000..d6fffecc05 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickmode.py b/plotly/validators/layout/polar/radialaxis/_tickmode.py new file mode 100644 index 0000000000..53caf5ebdf --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickprefix.py b/plotly/validators/layout/polar/radialaxis/_tickprefix.py new file mode 100644 index 0000000000..72c708d73c --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_ticks.py b/plotly/validators/layout/polar/radialaxis/_ticks.py new file mode 100644 index 0000000000..633e3f0e01 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_ticksuffix.py b/plotly/validators/layout/polar/radialaxis/_ticksuffix.py new file mode 100644 index 0000000000..64bce12e50 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_ticktext.py b/plotly/validators/layout/polar/radialaxis/_ticktext.py new file mode 100644 index 0000000000..472934caf7 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_ticktextsrc.py b/plotly/validators/layout/polar/radialaxis/_ticktextsrc.py new file mode 100644 index 0000000000..e6f463536e --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickvals.py b/plotly/validators/layout/polar/radialaxis/_tickvals.py new file mode 100644 index 0000000000..59e11480ad --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickvalssrc.py b/plotly/validators/layout/polar/radialaxis/_tickvalssrc.py new file mode 100644 index 0000000000..401bb3f14e --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_tickwidth.py b/plotly/validators/layout/polar/radialaxis/_tickwidth.py new file mode 100644 index 0000000000..5c83e12e9b --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_title.py b/plotly/validators/layout/polar/radialaxis/_title.py new file mode 100644 index 0000000000..0766e57dd7 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_titlefont.py b/plotly/validators/layout/polar/radialaxis/_titlefont.py new file mode 100644 index 0000000000..03125653c9 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_type.py b/plotly/validators/layout/polar/radialaxis/_type.py new file mode 100644 index 0000000000..743c32baed --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_type.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/_visible.py b/plotly/validators/layout/polar/radialaxis/_visible.py new file mode 100644 index 0000000000..0953528730 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.polar.radialaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/tickfont/__init__.py b/plotly/validators/layout/polar/radialaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/polar/radialaxis/tickfont/_color.py b/plotly/validators/layout/polar/radialaxis/tickfont/_color.py new file mode 100644 index 0000000000..a56faa1f02 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.polar.radialaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/tickfont/_family.py b/plotly/validators/layout/polar/radialaxis/tickfont/_family.py new file mode 100644 index 0000000000..ca404245b6 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.polar.radialaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/tickfont/_size.py b/plotly/validators/layout/polar/radialaxis/tickfont/_size.py new file mode 100644 index 0000000000..5ef35a7923 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.polar.radialaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/tickformatstop/__init__.py b/plotly/validators/layout/polar/radialaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/polar/radialaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/polar/radialaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..f6be6e13ce --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.polar.radialaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/tickformatstop/_value.py b/plotly/validators/layout/polar/radialaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..d76d7f7ff2 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.polar.radialaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/titlefont/__init__.py b/plotly/validators/layout/polar/radialaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/polar/radialaxis/titlefont/_color.py b/plotly/validators/layout/polar/radialaxis/titlefont/_color.py new file mode 100644 index 0000000000..6e8975a6a5 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.polar.radialaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/titlefont/_family.py b/plotly/validators/layout/polar/radialaxis/titlefont/_family.py new file mode 100644 index 0000000000..bfecacb833 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.polar.radialaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/polar/radialaxis/titlefont/_size.py b/plotly/validators/layout/polar/radialaxis/titlefont/_size.py new file mode 100644 index 0000000000..1c1ed525a9 --- /dev/null +++ b/plotly/validators/layout/polar/radialaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.polar.radialaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/__init__.py b/plotly/validators/layout/radialaxis/__init__.py new file mode 100644 index 0000000000..b773a44149 --- /dev/null +++ b/plotly/validators/layout/radialaxis/__init__.py @@ -0,0 +1,11 @@ +from ._visible import VisibleValidator +from ._ticksuffix import TicksuffixValidator +from ._tickorientation import TickorientationValidator +from ._ticklen import TicklenValidator +from ._tickcolor import TickcolorValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._range import RangeValidator +from ._orientation import OrientationValidator +from ._endpadding import EndpaddingValidator +from ._domain import DomainValidator diff --git a/plotly/validators/layout/radialaxis/_domain.py b/plotly/validators/layout/radialaxis/_domain.py new file mode 100644 index 0000000000..fdd1945450 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.radialaxis', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_endpadding.py b/plotly/validators/layout/radialaxis/_endpadding.py new file mode 100644 index 0000000000..db430dbe0d --- /dev/null +++ b/plotly/validators/layout/radialaxis/_endpadding.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class EndpaddingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='endpadding', + parent_name='layout.radialaxis', + **kwargs + ): + super(EndpaddingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_orientation.py b/plotly/validators/layout/radialaxis/_orientation.py new file mode 100644 index 0000000000..e7b35768bc --- /dev/null +++ b/plotly/validators/layout/radialaxis/_orientation.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='orientation', + parent_name='layout.radialaxis', + **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_range.py b/plotly/validators/layout/radialaxis/_range.py new file mode 100644 index 0000000000..9df0bf9398 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.radialaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'editType': 'plot' + }, { + 'valType': 'number', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_showline.py b/plotly/validators/layout/radialaxis/_showline.py new file mode 100644 index 0000000000..329127ec8a --- /dev/null +++ b/plotly/validators/layout/radialaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.radialaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_showticklabels.py b/plotly/validators/layout/radialaxis/_showticklabels.py new file mode 100644 index 0000000000..cfdc4516c1 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.radialaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_tickcolor.py b/plotly/validators/layout/radialaxis/_tickcolor.py new file mode 100644 index 0000000000..caace94b27 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.radialaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_ticklen.py b/plotly/validators/layout/radialaxis/_ticklen.py new file mode 100644 index 0000000000..cc971695fe --- /dev/null +++ b/plotly/validators/layout/radialaxis/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='layout.radialaxis', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_tickorientation.py b/plotly/validators/layout/radialaxis/_tickorientation.py new file mode 100644 index 0000000000..ba38a19c00 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_tickorientation.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TickorientationValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='tickorientation', + parent_name='layout.radialaxis', + **kwargs + ): + super(TickorientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['horizontal', 'vertical'], + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_ticksuffix.py b/plotly/validators/layout/radialaxis/_ticksuffix.py new file mode 100644 index 0000000000..40442b42e7 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.radialaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/radialaxis/_visible.py b/plotly/validators/layout/radialaxis/_visible.py new file mode 100644 index 0000000000..6f9ce5a180 --- /dev/null +++ b/plotly/validators/layout/radialaxis/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.radialaxis', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/__init__.py b/plotly/validators/layout/scene/__init__.py new file mode 100644 index 0000000000..43ee26f8d2 --- /dev/null +++ b/plotly/validators/layout/scene/__init__.py @@ -0,0 +1,11 @@ +from ._zaxis import ZAxisValidator +from ._yaxis import YAxisValidator +from ._xaxis import XAxisValidator +from ._hovermode import HovermodeValidator +from ._dragmode import DragmodeValidator +from ._domain import DomainValidator +from ._camera import CameraValidator +from ._bgcolor import BgcolorValidator +from ._aspectratio import AspectratioValidator +from ._aspectmode import AspectmodeValidator +from ._annotations import AnnotationsValidator diff --git a/plotly/validators/layout/scene/_annotations.py b/plotly/validators/layout/scene/_annotations.py new file mode 100644 index 0000000000..c50f35ff9a --- /dev/null +++ b/plotly/validators/layout/scene/_annotations.py @@ -0,0 +1,173 @@ +import _plotly_utils.basevalidators + + +class AnnotationsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, plotly_name='annotations', parent_name='layout.scene', **kwargs + ): + super(AnnotationsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Annotation', + data_docs=""" + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + arrowcolor + Sets the color of the annotation arrow. + arrowhead + Sets the end annotation arrow head style. + arrowside + Sets the annotation arrow head position. + arrowsize + Sets the size of the end annotation arrow head, + relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + arrowwidth + Sets the width (in px) of annotation arrow + line. + ax + Sets the x component of the arrow tail about + the arrow head (in pixels). + ay + Sets the y component of the arrow tail about + the arrow head (in pixels). + bgcolor + Sets the background color of the annotation. + bordercolor + Sets the color of the border enclosing the + annotation `text`. + borderpad + Sets the padding (in px) between the `text` and + the enclosing border. + borderwidth + Sets the width (in px) of the border enclosing + the annotation `text`. + captureevents + Determines whether the annotation text box + captures mouse move and click events, or allows + those events to pass through to data points in + the plot that may be behind the annotation. By + default `captureevents` is *false* unless + `hovertext` is provided. If you use the event + `plotly_clickannotation` without `hovertext` + you must explicitly enable `captureevents`. + font + Sets the annotation text font. + height + Sets an explicit height for the text box. null + (default) lets the text set the box height. + Taller text will be clipped. + hoverlabel + plotly.graph_objs.layout.scene.annotation.Hover + label instance or dict with compatible + properties + hovertext + Sets text to appear when hovering over this + annotation. If omitted or blank, no hover label + will appear. + opacity + Sets the opacity of the annotation (text + + arrow). + showarrow + Determines whether or not the annotation is + drawn with an arrow. If *true*, `text` is + placed near the arrow's tail. If *false*, + `text` lines up with the `x` and `y` provided. + standoff + Sets a distance, in pixels, to move the end + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + startarrowhead + Sets the start annotation arrow head style. + startarrowsize + Sets the size of the start annotation arrow + head, relative to `arrowwidth`. A value of 1 + (default) gives a head about 3x as wide as the + line. + startstandoff + Sets a distance, in pixels, to move the start + arrowhead away from the position it is pointing + at, for example to point at the edge of a + marker independent of zoom. Note that this + shortens the arrow from the `ax` / `ay` vector, + in contrast to `xshift` / `yshift` which moves + everything by this amount. + text + Sets the text associated with this annotation. + Plotly uses a subset of HTML tags to do things + like newline (
), bold (), italics + (), hyperlinks (). + Tags , , are also + supported. + textangle + Sets the angle at which the `text` is drawn + with respect to the horizontal. + valign + Sets the vertical alignment of the `text` + within the box. Has an effect only if an + explicit height is set to override the text + height. + visible + Determines whether or not this annotation is + visible. + width + Sets an explicit width for the text box. null + (default) lets the text set the box width. + Wider text will be clipped. There is no + automatic wrapping; use
to start a new + line. + x + Sets the annotation's x position. + xanchor + Sets the text box's horizontal position anchor + This anchor binds the `x` position to the + *left*, *center* or *right* of the annotation. + For example, if `x` is set to 1, `xref` to + *paper* and `xanchor` to *right* then the + right-most portion of the annotation lines up + with the right-most edge of the plotting area. + If *auto*, the anchor is equivalent to *center* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + xshift + Shifts the position of the whole annotation and + arrow to the right (positive) or left + (negative) by this many pixels. + y + Sets the annotation's y position. + yanchor + Sets the text box's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the annotation. + For example, if `y` is set to 1, `yref` to + *paper* and `yanchor` to *top* then the top- + most portion of the annotation lines up with + the top-most edge of the plotting area. If + *auto*, the anchor is equivalent to *middle* + for data-referenced annotations or if there is + an arrow, whereas for paper-referenced with no + arrow, the anchor picked corresponds to the + closest side. + yshift + Shifts the position of the whole annotation and + arrow up (positive) or down (negative) by this + many pixels. + z + Sets the annotation's z position.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_aspectmode.py b/plotly/validators/layout/scene/_aspectmode.py new file mode 100644 index 0000000000..8cec964dab --- /dev/null +++ b/plotly/validators/layout/scene/_aspectmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AspectmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='aspectmode', parent_name='layout.scene', **kwargs + ): + super(AspectmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'cube', 'data', 'manual'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/_aspectratio.py b/plotly/validators/layout/scene/_aspectratio.py new file mode 100644 index 0000000000..741063344d --- /dev/null +++ b/plotly/validators/layout/scene/_aspectratio.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class AspectratioValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='aspectratio', parent_name='layout.scene', **kwargs + ): + super(AspectratioValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Aspectratio', + data_docs=""" + x + + y + + z +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_bgcolor.py b/plotly/validators/layout/scene/_bgcolor.py new file mode 100644 index 0000000000..0f27c574ce --- /dev/null +++ b/plotly/validators/layout/scene/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.scene', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/_camera.py b/plotly/validators/layout/scene/_camera.py new file mode 100644 index 0000000000..21e5502989 --- /dev/null +++ b/plotly/validators/layout/scene/_camera.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class CameraValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='camera', parent_name='layout.scene', **kwargs + ): + super(CameraValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Camera', + data_docs=""" + center + Sets the (x,y,z) components of the 'center' + camera vector This vector determines the + translation (x,y,z) space about the center of + this scene. By default, there is no such + translation. + eye + Sets the (x,y,z) components of the 'eye' camera + vector. This vector determines the view point + about the origin of this scene. + up + Sets the (x,y,z) components of the 'up' camera + vector. This vector determines the up direction + of this scene with respect to the page. The + default is *{x: 0, y: 0, z: 1}* which means + that the z axis points up.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_domain.py b/plotly/validators/layout/scene/_domain.py new file mode 100644 index 0000000000..63925ca11e --- /dev/null +++ b/plotly/validators/layout/scene/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.scene', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this scene subplot + . + row + If there is a layout grid, use the domain for + this row in the grid for this scene subplot . + x + Sets the horizontal domain of this scene + subplot (in plot fraction). + y + Sets the vertical domain of this scene subplot + (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_dragmode.py b/plotly/validators/layout/scene/_dragmode.py new file mode 100644 index 0000000000..b5bc84a85e --- /dev/null +++ b/plotly/validators/layout/scene/_dragmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DragmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='dragmode', parent_name='layout.scene', **kwargs + ): + super(DragmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['orbit', 'turntable', 'zoom', 'pan', False], + **kwargs + ) diff --git a/plotly/validators/layout/scene/_hovermode.py b/plotly/validators/layout/scene/_hovermode.py new file mode 100644 index 0000000000..07c03d3594 --- /dev/null +++ b/plotly/validators/layout/scene/_hovermode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovermodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='hovermode', parent_name='layout.scene', **kwargs + ): + super(HovermodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='modebar', + role='info', + values=['closest', False], + **kwargs + ) diff --git a/plotly/validators/layout/scene/_xaxis.py b/plotly/validators/layout/scene/_xaxis.py new file mode 100644 index 0000000000..17fe6e0f5c --- /dev/null +++ b/plotly/validators/layout/scene/_xaxis.py @@ -0,0 +1,285 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='layout.scene', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='XAxis', + data_docs=""" + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.xaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_yaxis.py b/plotly/validators/layout/scene/_yaxis.py new file mode 100644 index 0000000000..258261ae99 --- /dev/null +++ b/plotly/validators/layout/scene/_yaxis.py @@ -0,0 +1,285 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='layout.scene', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YAxis', + data_docs=""" + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.yaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/_zaxis.py b/plotly/validators/layout/scene/_zaxis.py new file mode 100644 index 0000000000..282904e52f --- /dev/null +++ b/plotly/validators/layout/scene/_zaxis.py @@ -0,0 +1,285 @@ +import _plotly_utils.basevalidators + + +class ZAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='zaxis', parent_name='layout.scene', **kwargs + ): + super(ZAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ZAxis', + data_docs=""" + autorange + Determines whether or not the range of this + axis is computed in relation to the input data. + See `rangemode` for more info. If `range` is + provided, then `autorange` is set to *false*. + backgroundcolor + Sets the background color of this axis' wall. + calendar + Sets the calendar system to use for `range` and + `tick0` if this is a date axis. This does not + set the calendar for interpreting data on this + axis, that's specified in the trace or via the + global `layout.calendar` + categoryarray + Sets the order in which categories on this axis + appear. Only has an effect if `categoryorder` + is set to *array*. Used with `categoryorder`. + categoryarraysrc + Sets the source reference on plot.ly for + categoryarray . + categoryorder + Specifies the ordering logic for the case of + categorical variables. By default, plotly uses + *trace*, which specifies the order that is + present in the data supplied. Set + `categoryorder` to *category ascending* or + *category descending* if order should be + determined by the alphanumerical order of the + category names. Set `categoryorder` to *array* + to derive the ordering from the attribute + `categoryarray`. If a category is not found in + the `categoryarray` array, the sorting behavior + for that attribute will be identical to the + *trace* mode. The unspecified categories will + follow the categories in `categoryarray`. + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + mirror + Determines if the axis lines or/and ticks are + mirrored to the opposite side of the plotting + area. If *true*, the axis lines are mirrored. + If *ticks*, the axis lines and ticks are + mirrored. If *false*, mirroring is disable. If + *all*, axis lines are mirrored on all shared- + axes subplots. If *allticks*, axis lines and + ticks are mirrored on all shared-axes subplots. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + range + Sets the range of this axis. If the axis `type` + is *log*, then you must take the log of your + desired range (e.g. to set the range from 1 to + 100, set the range from 0 to 2). If the axis + `type` is *date*, it should be date strings, + like date data, though Date objects and unix + milliseconds will be accepted and converted to + strings. If the axis `type` is *category*, it + should be numbers, using the scale where each + category is assigned a serial number from zero + in the order it appears. + rangemode + If *normal*, the range is computed in relation + to the extrema of the input data. If *tozero*`, + the range extends to 0, regardless of the input + data If *nonnegative*, the range is non- + negative, regardless of the input data. + separatethousands + If "true", even 4-digit integers are separated + showaxeslabels + Sets whether or not this axis is labeled + showbackground + Sets whether or not this axis' wall has a + background color. + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showspikes + Sets whether or not spikes starting from data + points to this axis' wall are shown on hover. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + spikecolor + Sets the color of the spikes. + spikesides + Sets whether or not spikes extending from the + projection data points to this axis' wall + boundaries are shown on hover. + spikethickness + Sets the thickness (in px) of the spikes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.scene.zaxis.Tickformat + stop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font. + type + Sets the axis type. By default, plotly attempts + to determined the axis type by looking into the + data of the traces that referenced the axis in + question. + visible + A single toggle to hide the axis while + preserving interaction like dragging. Default + is true when a cheater plot is present on the + axis, otherwise false + zeroline + Determines whether or not a line is drawn at + along the 0 value of this axis. If *true*, the + zero line is drawn on top of the grid lines. + zerolinecolor + Sets the line color of the zero line. + zerolinewidth + Sets the width (in px) of the zero line.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/__init__.py b/plotly/validators/layout/scene/annotation/__init__.py new file mode 100644 index 0000000000..f8ce91f731 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/__init__.py @@ -0,0 +1,35 @@ +from ._z import ZValidator +from ._yshift import YshiftValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xshift import XshiftValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valign import ValignValidator +from ._textangle import TextangleValidator +from ._text import TextValidator +from ._startstandoff import StartstandoffValidator +from ._startarrowsize import StartarrowsizeValidator +from ._startarrowhead import StartarrowheadValidator +from ._standoff import StandoffValidator +from ._showarrow import ShowarrowValidator +from ._opacity import OpacityValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._height import HeightValidator +from ._font import FontValidator +from ._captureevents import CaptureeventsValidator +from ._borderwidth import BorderwidthValidator +from ._borderpad import BorderpadValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._ay import AyValidator +from ._ax import AxValidator +from ._arrowwidth import ArrowwidthValidator +from ._arrowsize import ArrowsizeValidator +from ._arrowside import ArrowsideValidator +from ._arrowhead import ArrowheadValidator +from ._arrowcolor import ArrowcolorValidator +from ._align import AlignValidator diff --git a/plotly/validators/layout/scene/annotation/_align.py b/plotly/validators/layout/scene/annotation/_align.py new file mode 100644 index 0000000000..acfc2eda70 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_align.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AlignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='align', + parent_name='layout.scene.annotation', + **kwargs + ): + super(AlignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_arrowcolor.py b/plotly/validators/layout/scene/annotation/_arrowcolor.py new file mode 100644 index 0000000000..38caaa45d8 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_arrowcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrowcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='arrowcolor', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ArrowcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_arrowhead.py b/plotly/validators/layout/scene/annotation/_arrowhead.py new file mode 100644 index 0000000000..2dcaa89998 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_arrowhead.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ArrowheadValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='arrowhead', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ArrowheadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=8, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_arrowside.py b/plotly/validators/layout/scene/annotation/_arrowside.py new file mode 100644 index 0000000000..326944ce9a --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_arrowside.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ArrowsideValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, + plotly_name='arrowside', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ArrowsideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['end', 'start'], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_arrowsize.py b/plotly/validators/layout/scene/annotation/_arrowsize.py new file mode 100644 index 0000000000..cf7729b56e --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_arrowsize.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ArrowsizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='arrowsize', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ArrowsizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0.3, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_arrowwidth.py b/plotly/validators/layout/scene/annotation/_arrowwidth.py new file mode 100644 index 0000000000..38b67a41e8 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_arrowwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ArrowwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='arrowwidth', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ArrowwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0.1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_ax.py b/plotly/validators/layout/scene/annotation/_ax.py new file mode 100644 index 0000000000..6768b15263 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_ax.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class AxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ax', + parent_name='layout.scene.annotation', + **kwargs + ): + super(AxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_ay.py b/plotly/validators/layout/scene/annotation/_ay.py new file mode 100644 index 0000000000..1d30b22af0 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_ay.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class AyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ay', + parent_name='layout.scene.annotation', + **kwargs + ): + super(AyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_bgcolor.py b/plotly/validators/layout/scene/annotation/_bgcolor.py new file mode 100644 index 0000000000..63a4a62da7 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='layout.scene.annotation', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_bordercolor.py b/plotly/validators/layout/scene/annotation/_bordercolor.py new file mode 100644 index 0000000000..6a52b41f00 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.scene.annotation', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_borderpad.py b/plotly/validators/layout/scene/annotation/_borderpad.py new file mode 100644 index 0000000000..8a49ba20f4 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_borderpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderpad', + parent_name='layout.scene.annotation', + **kwargs + ): + super(BorderpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_borderwidth.py b/plotly/validators/layout/scene/annotation/_borderwidth.py new file mode 100644 index 0000000000..f68615b691 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='layout.scene.annotation', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_captureevents.py b/plotly/validators/layout/scene/annotation/_captureevents.py new file mode 100644 index 0000000000..9acc3f6815 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_captureevents.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CaptureeventsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='captureevents', + parent_name='layout.scene.annotation', + **kwargs + ): + super(CaptureeventsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_font.py b/plotly/validators/layout/scene/annotation/_font.py new file mode 100644 index 0000000000..c15e1429aa --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_font.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='layout.scene.annotation', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_height.py b/plotly/validators/layout/scene/annotation/_height.py new file mode 100644 index 0000000000..c8589f6c59 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_height.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class HeightValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='height', + parent_name='layout.scene.annotation', + **kwargs + ): + super(HeightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_hoverlabel.py b/plotly/validators/layout/scene/annotation/_hoverlabel.py new file mode 100644 index 0000000000..f1cb6b308d --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_hoverlabel.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='hoverlabel', + parent_name='layout.scene.annotation', + **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover label. + By default uses the annotation's `bgcolor` made + opaque, or white if it was transparent. + bordercolor + Sets the border color of the hover label. By + default uses either dark grey or white, for + maximum contrast with `hoverlabel.bgcolor`. + font + Sets the hover label text font. By default uses + the global hover font and size, with color from + `hoverlabel.bordercolor`.""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_hovertext.py b/plotly/validators/layout/scene/annotation/_hovertext.py new file mode 100644 index 0000000000..7286a61ec3 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_hovertext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hovertext', + parent_name='layout.scene.annotation', + **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_opacity.py b/plotly/validators/layout/scene/annotation/_opacity.py new file mode 100644 index 0000000000..cfc5c79d49 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='layout.scene.annotation', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_showarrow.py b/plotly/validators/layout/scene/annotation/_showarrow.py new file mode 100644 index 0000000000..8b206f1973 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_showarrow.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowarrowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showarrow', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ShowarrowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_standoff.py b/plotly/validators/layout/scene/annotation/_standoff.py new file mode 100644 index 0000000000..e26de84506 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_standoff.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StandoffValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='standoff', + parent_name='layout.scene.annotation', + **kwargs + ): + super(StandoffValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_startarrowhead.py b/plotly/validators/layout/scene/annotation/_startarrowhead.py new file mode 100644 index 0000000000..3d91ac6933 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_startarrowhead.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class StartarrowheadValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='startarrowhead', + parent_name='layout.scene.annotation', + **kwargs + ): + super(StartarrowheadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=8, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_startarrowsize.py b/plotly/validators/layout/scene/annotation/_startarrowsize.py new file mode 100644 index 0000000000..dc2809721a --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_startarrowsize.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartarrowsizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startarrowsize', + parent_name='layout.scene.annotation', + **kwargs + ): + super(StartarrowsizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0.3, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_startstandoff.py b/plotly/validators/layout/scene/annotation/_startstandoff.py new file mode 100644 index 0000000000..dc5f7635d9 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_startstandoff.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StartstandoffValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='startstandoff', + parent_name='layout.scene.annotation', + **kwargs + ): + super(StartstandoffValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_text.py b/plotly/validators/layout/scene/annotation/_text.py new file mode 100644 index 0000000000..7bb819360f --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_text.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='text', + parent_name='layout.scene.annotation', + **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_textangle.py b/plotly/validators/layout/scene/annotation/_textangle.py new file mode 100644 index 0000000000..73bfe57178 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_textangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='textangle', + parent_name='layout.scene.annotation', + **kwargs + ): + super(TextangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_valign.py b/plotly/validators/layout/scene/annotation/_valign.py new file mode 100644 index 0000000000..8434956911 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_valign.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='valign', + parent_name='layout.scene.annotation', + **kwargs + ): + super(ValignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_visible.py b/plotly/validators/layout/scene/annotation/_visible.py new file mode 100644 index 0000000000..bf81e503c9 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.scene.annotation', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_width.py b/plotly/validators/layout/scene/annotation/_width.py new file mode 100644 index 0000000000..6caa7ea9e1 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='layout.scene.annotation', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_x.py b/plotly/validators/layout/scene/annotation/_x.py new file mode 100644 index 0000000000..7965e286c0 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.scene.annotation', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_xanchor.py b/plotly/validators/layout/scene/annotation/_xanchor.py new file mode 100644 index 0000000000..1a8241f6fe --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='layout.scene.annotation', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_xshift.py b/plotly/validators/layout/scene/annotation/_xshift.py new file mode 100644 index 0000000000..2174969005 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_xshift.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XshiftValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xshift', + parent_name='layout.scene.annotation', + **kwargs + ): + super(XshiftValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_y.py b/plotly/validators/layout/scene/annotation/_y.py new file mode 100644 index 0000000000..0ec030c20f --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.scene.annotation', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_yanchor.py b/plotly/validators/layout/scene/annotation/_yanchor.py new file mode 100644 index 0000000000..931cba4728 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='layout.scene.annotation', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_yshift.py b/plotly/validators/layout/scene/annotation/_yshift.py new file mode 100644 index 0000000000..7477992ee8 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_yshift.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YshiftValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='yshift', + parent_name='layout.scene.annotation', + **kwargs + ): + super(YshiftValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/_z.py b/plotly/validators/layout/scene/annotation/_z.py new file mode 100644 index 0000000000..f2f89e916b --- /dev/null +++ b/plotly/validators/layout/scene/annotation/_z.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='z', parent_name='layout.scene.annotation', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/font/__init__.py b/plotly/validators/layout/scene/annotation/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/annotation/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/annotation/font/_color.py b/plotly/validators/layout/scene/annotation/font/_color.py new file mode 100644 index 0000000000..38e3ee9be6 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.annotation.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/font/_family.py b/plotly/validators/layout/scene/annotation/font/_family.py new file mode 100644 index 0000000000..3ac7bd82ea --- /dev/null +++ b/plotly/validators/layout/scene/annotation/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.annotation.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/font/_size.py b/plotly/validators/layout/scene/annotation/font/_size.py new file mode 100644 index 0000000000..90a918e4ae --- /dev/null +++ b/plotly/validators/layout/scene/annotation/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.annotation.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/__init__.py b/plotly/validators/layout/scene/annotation/hoverlabel/__init__.py new file mode 100644 index 0000000000..8a3e67d64a --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/__init__.py @@ -0,0 +1,3 @@ +from ._font import FontValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/_bgcolor.py b/plotly/validators/layout/scene/annotation/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..695c7a598f --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='layout.scene.annotation.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/_bordercolor.py b/plotly/validators/layout/scene/annotation/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..e14029ae84 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.scene.annotation.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/_font.py b/plotly/validators/layout/scene/annotation/hoverlabel/_font.py new file mode 100644 index 0000000000..f68c51a2fe --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/_font.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='layout.scene.annotation.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/font/__init__.py b/plotly/validators/layout/scene/annotation/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/font/_color.py b/plotly/validators/layout/scene/annotation/hoverlabel/font/_color.py new file mode 100644 index 0000000000..abb156e9ed --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.annotation.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/font/_family.py b/plotly/validators/layout/scene/annotation/hoverlabel/font/_family.py new file mode 100644 index 0000000000..e8361df857 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.annotation.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/annotation/hoverlabel/font/_size.py b/plotly/validators/layout/scene/annotation/hoverlabel/font/_size.py new file mode 100644 index 0000000000..3bc856c4e2 --- /dev/null +++ b/plotly/validators/layout/scene/annotation/hoverlabel/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.annotation.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/aspectratio/__init__.py b/plotly/validators/layout/scene/aspectratio/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/layout/scene/aspectratio/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/layout/scene/aspectratio/_x.py b/plotly/validators/layout/scene/aspectratio/_x.py new file mode 100644 index 0000000000..5df1399b54 --- /dev/null +++ b/plotly/validators/layout/scene/aspectratio/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='layout.scene.aspectratio', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^aspectmode': 'manual'}, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/aspectratio/_y.py b/plotly/validators/layout/scene/aspectratio/_y.py new file mode 100644 index 0000000000..821458e343 --- /dev/null +++ b/plotly/validators/layout/scene/aspectratio/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='layout.scene.aspectratio', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^aspectmode': 'manual'}, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/aspectratio/_z.py b/plotly/validators/layout/scene/aspectratio/_z.py new file mode 100644 index 0000000000..73534034cc --- /dev/null +++ b/plotly/validators/layout/scene/aspectratio/_z.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='z', + parent_name='layout.scene.aspectratio', + **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'^aspectmode': 'manual'}, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/__init__.py b/plotly/validators/layout/scene/camera/__init__.py new file mode 100644 index 0000000000..e893b43b3e --- /dev/null +++ b/plotly/validators/layout/scene/camera/__init__.py @@ -0,0 +1,3 @@ +from ._up import UpValidator +from ._eye import EyeValidator +from ._center import CenterValidator diff --git a/plotly/validators/layout/scene/camera/_center.py b/plotly/validators/layout/scene/camera/_center.py new file mode 100644 index 0000000000..b0ec33b4c0 --- /dev/null +++ b/plotly/validators/layout/scene/camera/_center.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class CenterValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='center', + parent_name='layout.scene.camera', + **kwargs + ): + super(CenterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Center', + data_docs=""" + x + + y + + z +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/_eye.py b/plotly/validators/layout/scene/camera/_eye.py new file mode 100644 index 0000000000..1723be7c2c --- /dev/null +++ b/plotly/validators/layout/scene/camera/_eye.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class EyeValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='eye', parent_name='layout.scene.camera', **kwargs + ): + super(EyeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Eye', + data_docs=""" + x + + y + + z +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/_up.py b/plotly/validators/layout/scene/camera/_up.py new file mode 100644 index 0000000000..ff98534f74 --- /dev/null +++ b/plotly/validators/layout/scene/camera/_up.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class UpValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='up', parent_name='layout.scene.camera', **kwargs + ): + super(UpValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Up', + data_docs=""" + x + + y + + z +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/center/__init__.py b/plotly/validators/layout/scene/camera/center/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/layout/scene/camera/center/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/layout/scene/camera/center/_x.py b/plotly/validators/layout/scene/camera/center/_x.py new file mode 100644 index 0000000000..53a0a221d5 --- /dev/null +++ b/plotly/validators/layout/scene/camera/center/_x.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='layout.scene.camera.center', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/center/_y.py b/plotly/validators/layout/scene/camera/center/_y.py new file mode 100644 index 0000000000..94155da84b --- /dev/null +++ b/plotly/validators/layout/scene/camera/center/_y.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='layout.scene.camera.center', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/center/_z.py b/plotly/validators/layout/scene/camera/center/_z.py new file mode 100644 index 0000000000..85e4882b39 --- /dev/null +++ b/plotly/validators/layout/scene/camera/center/_z.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='z', + parent_name='layout.scene.camera.center', + **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/eye/__init__.py b/plotly/validators/layout/scene/camera/eye/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/layout/scene/camera/eye/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/layout/scene/camera/eye/_x.py b/plotly/validators/layout/scene/camera/eye/_x.py new file mode 100644 index 0000000000..aa42abc2dc --- /dev/null +++ b/plotly/validators/layout/scene/camera/eye/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.scene.camera.eye', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/eye/_y.py b/plotly/validators/layout/scene/camera/eye/_y.py new file mode 100644 index 0000000000..4a4050b908 --- /dev/null +++ b/plotly/validators/layout/scene/camera/eye/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.scene.camera.eye', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/eye/_z.py b/plotly/validators/layout/scene/camera/eye/_z.py new file mode 100644 index 0000000000..3b63a349b7 --- /dev/null +++ b/plotly/validators/layout/scene/camera/eye/_z.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='z', parent_name='layout.scene.camera.eye', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/up/__init__.py b/plotly/validators/layout/scene/camera/up/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/layout/scene/camera/up/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/layout/scene/camera/up/_x.py b/plotly/validators/layout/scene/camera/up/_x.py new file mode 100644 index 0000000000..803fe4f349 --- /dev/null +++ b/plotly/validators/layout/scene/camera/up/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.scene.camera.up', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/up/_y.py b/plotly/validators/layout/scene/camera/up/_y.py new file mode 100644 index 0000000000..f13ca75de4 --- /dev/null +++ b/plotly/validators/layout/scene/camera/up/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.scene.camera.up', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/camera/up/_z.py b/plotly/validators/layout/scene/camera/up/_z.py new file mode 100644 index 0000000000..aff1261c74 --- /dev/null +++ b/plotly/validators/layout/scene/camera/up/_z.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='z', parent_name='layout.scene.camera.up', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='camera', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/domain/__init__.py b/plotly/validators/layout/scene/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/layout/scene/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/layout/scene/domain/_column.py b/plotly/validators/layout/scene/domain/_column.py new file mode 100644 index 0000000000..eae12eff07 --- /dev/null +++ b/plotly/validators/layout/scene/domain/_column.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='column', + parent_name='layout.scene.domain', + **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/domain/_row.py b/plotly/validators/layout/scene/domain/_row.py new file mode 100644 index 0000000000..a7e6e6d302 --- /dev/null +++ b/plotly/validators/layout/scene/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='layout.scene.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/domain/_x.py b/plotly/validators/layout/scene/domain/_x.py new file mode 100644 index 0000000000..cbfbae1ffd --- /dev/null +++ b/plotly/validators/layout/scene/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.scene.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/domain/_y.py b/plotly/validators/layout/scene/domain/_y.py new file mode 100644 index 0000000000..bd167624e4 --- /dev/null +++ b/plotly/validators/layout/scene/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.scene.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/__init__.py b/plotly/validators/layout/scene/xaxis/__init__.py new file mode 100644 index 0000000000..d5feb7a0b2 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/__init__.py @@ -0,0 +1,54 @@ +from ._zerolinewidth import ZerolinewidthValidator +from ._zerolinecolor import ZerolinecolorValidator +from ._zeroline import ZerolineValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._spikethickness import SpikethicknessValidator +from ._spikesides import SpikesidesValidator +from ._spikecolor import SpikecolorValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showspikes import ShowspikesValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._showbackground import ShowbackgroundValidator +from ._showaxeslabels import ShowaxeslabelsValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._mirror import MirrorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._backgroundcolor import BackgroundcolorValidator +from ._autorange import AutorangeValidator diff --git a/plotly/validators/layout/scene/xaxis/_autorange.py b/plotly/validators/layout/scene/xaxis/_autorange.py new file mode 100644 index 0000000000..21ca8d281d --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_autorange.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='autorange', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_backgroundcolor.py b/plotly/validators/layout/scene/xaxis/_backgroundcolor.py new file mode 100644 index 0000000000..8788bcbebd --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_backgroundcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BackgroundcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='backgroundcolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(BackgroundcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_calendar.py b/plotly/validators/layout/scene/xaxis/_calendar.py new file mode 100644 index 0000000000..7e780ca790 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_calendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='calendar', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_categoryarray.py b/plotly/validators/layout/scene/xaxis/_categoryarray.py new file mode 100644 index 0000000000..5e2760bd08 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_categoryarraysrc.py b/plotly/validators/layout/scene/xaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..5c4fbb349f --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_categoryorder.py b/plotly/validators/layout/scene/xaxis/_categoryorder.py new file mode 100644 index 0000000000..35c35350af --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_color.py b/plotly/validators/layout/scene/xaxis/_color.py new file mode 100644 index 0000000000..1d18247f2b --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.scene.xaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_dtick.py b/plotly/validators/layout/scene/xaxis/_dtick.py new file mode 100644 index 0000000000..79efd2f1a0 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.scene.xaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_exponentformat.py b/plotly/validators/layout/scene/xaxis/_exponentformat.py new file mode 100644 index 0000000000..fcae4bb501 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_gridcolor.py b/plotly/validators/layout/scene/xaxis/_gridcolor.py new file mode 100644 index 0000000000..dd9e1fff34 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_gridwidth.py b/plotly/validators/layout/scene/xaxis/_gridwidth.py new file mode 100644 index 0000000000..71334a21f2 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_hoverformat.py b/plotly/validators/layout/scene/xaxis/_hoverformat.py new file mode 100644 index 0000000000..5096720779 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_linecolor.py b/plotly/validators/layout/scene/xaxis/_linecolor.py new file mode 100644 index 0000000000..873786cb7c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_linewidth.py b/plotly/validators/layout/scene/xaxis/_linewidth.py new file mode 100644 index 0000000000..5a88e3b14d --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_mirror.py b/plotly/validators/layout/scene/xaxis/_mirror.py new file mode 100644 index 0000000000..25a31a5774 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_mirror.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MirrorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='mirror', parent_name='layout.scene.xaxis', **kwargs + ): + super(MirrorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=[True, 'ticks', False, 'all', 'allticks'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_nticks.py b/plotly/validators/layout/scene/xaxis/_nticks.py new file mode 100644 index 0000000000..051bbd66c2 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='layout.scene.xaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_range.py b/plotly/validators/layout/scene/xaxis/_range.py new file mode 100644 index 0000000000..ea02bf4443 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_range.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.scene.xaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_rangemode.py b/plotly/validators/layout/scene/xaxis/_rangemode.py new file mode 100644 index 0000000000..5965ad36c6 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_rangemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='rangemode', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_separatethousands.py b/plotly/validators/layout/scene/xaxis/_separatethousands.py new file mode 100644 index 0000000000..62546f6182 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showaxeslabels.py b/plotly/validators/layout/scene/xaxis/_showaxeslabels.py new file mode 100644 index 0000000000..f16f0ff7c5 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showaxeslabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowaxeslabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showaxeslabels', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowaxeslabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showbackground.py b/plotly/validators/layout/scene/xaxis/_showbackground.py new file mode 100644 index 0000000000..11c4649642 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showbackground.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowbackgroundValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showbackground', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowbackgroundValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showexponent.py b/plotly/validators/layout/scene/xaxis/_showexponent.py new file mode 100644 index 0000000000..85cb3ed56c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showgrid.py b/plotly/validators/layout/scene/xaxis/_showgrid.py new file mode 100644 index 0000000000..e47c4fa616 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showline.py b/plotly/validators/layout/scene/xaxis/_showline.py new file mode 100644 index 0000000000..271f54aeae --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showspikes.py b/plotly/validators/layout/scene/xaxis/_showspikes.py new file mode 100644 index 0000000000..3894d4d4c1 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showspikes.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowspikesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showspikes', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowspikesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showticklabels.py b/plotly/validators/layout/scene/xaxis/_showticklabels.py new file mode 100644 index 0000000000..5f8aecd80e --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showtickprefix.py b/plotly/validators/layout/scene/xaxis/_showtickprefix.py new file mode 100644 index 0000000000..3f838f45c1 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_showticksuffix.py b/plotly/validators/layout/scene/xaxis/_showticksuffix.py new file mode 100644 index 0000000000..a6de3c540a --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_spikecolor.py b/plotly/validators/layout/scene/xaxis/_spikecolor.py new file mode 100644 index 0000000000..10b0ff3780 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_spikecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='spikecolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(SpikecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_spikesides.py b/plotly/validators/layout/scene/xaxis/_spikesides.py new file mode 100644 index 0000000000..5d1b96baf3 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_spikesides.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikesidesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='spikesides', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(SpikesidesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_spikethickness.py b/plotly/validators/layout/scene/xaxis/_spikethickness.py new file mode 100644 index 0000000000..af482c1e9f --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_spikethickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SpikethicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='spikethickness', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(SpikethicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tick0.py b/plotly/validators/layout/scene/xaxis/_tick0.py new file mode 100644 index 0000000000..b19f83ab92 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.scene.xaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickangle.py b/plotly/validators/layout/scene/xaxis/_tickangle.py new file mode 100644 index 0000000000..ebd4aba873 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickcolor.py b/plotly/validators/layout/scene/xaxis/_tickcolor.py new file mode 100644 index 0000000000..11837bf29c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickfont.py b/plotly/validators/layout/scene/xaxis/_tickfont.py new file mode 100644 index 0000000000..efc6258cf2 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickformat.py b/plotly/validators/layout/scene/xaxis/_tickformat.py new file mode 100644 index 0000000000..74fe2c2e33 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickformatstops.py b/plotly/validators/layout/scene/xaxis/_tickformatstops.py new file mode 100644 index 0000000000..0eb7d291cd --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_ticklen.py b/plotly/validators/layout/scene/xaxis/_ticklen.py new file mode 100644 index 0000000000..dea3d07700 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickmode.py b/plotly/validators/layout/scene/xaxis/_tickmode.py new file mode 100644 index 0000000000..0ab1690ac4 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickprefix.py b/plotly/validators/layout/scene/xaxis/_tickprefix.py new file mode 100644 index 0000000000..682a25ea8c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_ticks.py b/plotly/validators/layout/scene/xaxis/_ticks.py new file mode 100644 index 0000000000..9dd00a64f9 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='layout.scene.xaxis', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_ticksuffix.py b/plotly/validators/layout/scene/xaxis/_ticksuffix.py new file mode 100644 index 0000000000..5e836ba883 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_ticktext.py b/plotly/validators/layout/scene/xaxis/_ticktext.py new file mode 100644 index 0000000000..d0f638fe86 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_ticktextsrc.py b/plotly/validators/layout/scene/xaxis/_ticktextsrc.py new file mode 100644 index 0000000000..99607cd2c3 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickvals.py b/plotly/validators/layout/scene/xaxis/_tickvals.py new file mode 100644 index 0000000000..e3a741598c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickvalssrc.py b/plotly/validators/layout/scene/xaxis/_tickvalssrc.py new file mode 100644 index 0000000000..e5cf1e2096 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_tickwidth.py b/plotly/validators/layout/scene/xaxis/_tickwidth.py new file mode 100644 index 0000000000..75afa95eb3 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_title.py b/plotly/validators/layout/scene/xaxis/_title.py new file mode 100644 index 0000000000..03b2333863 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='layout.scene.xaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_titlefont.py b/plotly/validators/layout/scene/xaxis/_titlefont.py new file mode 100644 index 0000000000..b57d373727 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_type.py b/plotly/validators/layout/scene/xaxis/_type.py new file mode 100644 index 0000000000..2e10963115 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.scene.xaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_visible.py b/plotly/validators/layout/scene/xaxis/_visible.py new file mode 100644 index 0000000000..c4a40f64c0 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_zeroline.py b/plotly/validators/layout/scene/xaxis/_zeroline.py new file mode 100644 index 0000000000..8477809a65 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_zeroline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='zeroline', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ZerolineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_zerolinecolor.py b/plotly/validators/layout/scene/xaxis/_zerolinecolor.py new file mode 100644 index 0000000000..f3cec9684e --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_zerolinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='zerolinecolor', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ZerolinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/_zerolinewidth.py b/plotly/validators/layout/scene/xaxis/_zerolinewidth.py new file mode 100644 index 0000000000..72dfb10265 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/_zerolinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='zerolinewidth', + parent_name='layout.scene.xaxis', + **kwargs + ): + super(ZerolinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/tickfont/__init__.py b/plotly/validators/layout/scene/xaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/xaxis/tickfont/_color.py b/plotly/validators/layout/scene/xaxis/tickfont/_color.py new file mode 100644 index 0000000000..5f5da07a26 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.xaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/tickfont/_family.py b/plotly/validators/layout/scene/xaxis/tickfont/_family.py new file mode 100644 index 0000000000..61c31b33cd --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.xaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/tickfont/_size.py b/plotly/validators/layout/scene/xaxis/tickfont/_size.py new file mode 100644 index 0000000000..02fd330bcb --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.xaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/tickformatstop/__init__.py b/plotly/validators/layout/scene/xaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/scene/xaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/scene/xaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..f245c47ab3 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.scene.xaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/tickformatstop/_value.py b/plotly/validators/layout/scene/xaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..904a2208c1 --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.scene.xaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/titlefont/__init__.py b/plotly/validators/layout/scene/xaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/xaxis/titlefont/_color.py b/plotly/validators/layout/scene/xaxis/titlefont/_color.py new file mode 100644 index 0000000000..369ba5b96e --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.xaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/titlefont/_family.py b/plotly/validators/layout/scene/xaxis/titlefont/_family.py new file mode 100644 index 0000000000..81fb29572a --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.xaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/xaxis/titlefont/_size.py b/plotly/validators/layout/scene/xaxis/titlefont/_size.py new file mode 100644 index 0000000000..b0f806313c --- /dev/null +++ b/plotly/validators/layout/scene/xaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.xaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/__init__.py b/plotly/validators/layout/scene/yaxis/__init__.py new file mode 100644 index 0000000000..d5feb7a0b2 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/__init__.py @@ -0,0 +1,54 @@ +from ._zerolinewidth import ZerolinewidthValidator +from ._zerolinecolor import ZerolinecolorValidator +from ._zeroline import ZerolineValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._spikethickness import SpikethicknessValidator +from ._spikesides import SpikesidesValidator +from ._spikecolor import SpikecolorValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showspikes import ShowspikesValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._showbackground import ShowbackgroundValidator +from ._showaxeslabels import ShowaxeslabelsValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._mirror import MirrorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._backgroundcolor import BackgroundcolorValidator +from ._autorange import AutorangeValidator diff --git a/plotly/validators/layout/scene/yaxis/_autorange.py b/plotly/validators/layout/scene/yaxis/_autorange.py new file mode 100644 index 0000000000..6709341575 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_autorange.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='autorange', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_backgroundcolor.py b/plotly/validators/layout/scene/yaxis/_backgroundcolor.py new file mode 100644 index 0000000000..88b0949765 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_backgroundcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BackgroundcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='backgroundcolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(BackgroundcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_calendar.py b/plotly/validators/layout/scene/yaxis/_calendar.py new file mode 100644 index 0000000000..73d444cb5c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_calendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='calendar', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_categoryarray.py b/plotly/validators/layout/scene/yaxis/_categoryarray.py new file mode 100644 index 0000000000..c32b5dcc16 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_categoryarraysrc.py b/plotly/validators/layout/scene/yaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..8b0e0d45a3 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_categoryorder.py b/plotly/validators/layout/scene/yaxis/_categoryorder.py new file mode 100644 index 0000000000..91fa10dc17 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_color.py b/plotly/validators/layout/scene/yaxis/_color.py new file mode 100644 index 0000000000..54ec7baeb8 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.scene.yaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_dtick.py b/plotly/validators/layout/scene/yaxis/_dtick.py new file mode 100644 index 0000000000..a43ff6fe33 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.scene.yaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_exponentformat.py b/plotly/validators/layout/scene/yaxis/_exponentformat.py new file mode 100644 index 0000000000..9e1c6d0069 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_gridcolor.py b/plotly/validators/layout/scene/yaxis/_gridcolor.py new file mode 100644 index 0000000000..2da7f92ef0 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_gridwidth.py b/plotly/validators/layout/scene/yaxis/_gridwidth.py new file mode 100644 index 0000000000..d94b696e3b --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_hoverformat.py b/plotly/validators/layout/scene/yaxis/_hoverformat.py new file mode 100644 index 0000000000..54c6eeacf1 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_linecolor.py b/plotly/validators/layout/scene/yaxis/_linecolor.py new file mode 100644 index 0000000000..29cd3d0825 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_linewidth.py b/plotly/validators/layout/scene/yaxis/_linewidth.py new file mode 100644 index 0000000000..cab3aa4017 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_mirror.py b/plotly/validators/layout/scene/yaxis/_mirror.py new file mode 100644 index 0000000000..3a90626a64 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_mirror.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MirrorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='mirror', parent_name='layout.scene.yaxis', **kwargs + ): + super(MirrorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=[True, 'ticks', False, 'all', 'allticks'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_nticks.py b/plotly/validators/layout/scene/yaxis/_nticks.py new file mode 100644 index 0000000000..564a6503bd --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='layout.scene.yaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_range.py b/plotly/validators/layout/scene/yaxis/_range.py new file mode 100644 index 0000000000..0661d0114e --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_range.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.scene.yaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_rangemode.py b/plotly/validators/layout/scene/yaxis/_rangemode.py new file mode 100644 index 0000000000..95a3e961f3 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_rangemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='rangemode', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_separatethousands.py b/plotly/validators/layout/scene/yaxis/_separatethousands.py new file mode 100644 index 0000000000..5a09abc8c2 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showaxeslabels.py b/plotly/validators/layout/scene/yaxis/_showaxeslabels.py new file mode 100644 index 0000000000..4f4c59f1ab --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showaxeslabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowaxeslabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showaxeslabels', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowaxeslabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showbackground.py b/plotly/validators/layout/scene/yaxis/_showbackground.py new file mode 100644 index 0000000000..236a57b41d --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showbackground.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowbackgroundValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showbackground', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowbackgroundValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showexponent.py b/plotly/validators/layout/scene/yaxis/_showexponent.py new file mode 100644 index 0000000000..b988a37d21 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showgrid.py b/plotly/validators/layout/scene/yaxis/_showgrid.py new file mode 100644 index 0000000000..d2b7c7e6b0 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showline.py b/plotly/validators/layout/scene/yaxis/_showline.py new file mode 100644 index 0000000000..afa95bc01b --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showspikes.py b/plotly/validators/layout/scene/yaxis/_showspikes.py new file mode 100644 index 0000000000..470fcbfcc4 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showspikes.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowspikesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showspikes', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowspikesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showticklabels.py b/plotly/validators/layout/scene/yaxis/_showticklabels.py new file mode 100644 index 0000000000..93cc76e2d5 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showtickprefix.py b/plotly/validators/layout/scene/yaxis/_showtickprefix.py new file mode 100644 index 0000000000..1555b57aa5 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_showticksuffix.py b/plotly/validators/layout/scene/yaxis/_showticksuffix.py new file mode 100644 index 0000000000..c1251e858c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_spikecolor.py b/plotly/validators/layout/scene/yaxis/_spikecolor.py new file mode 100644 index 0000000000..1ee06bcc07 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_spikecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='spikecolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(SpikecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_spikesides.py b/plotly/validators/layout/scene/yaxis/_spikesides.py new file mode 100644 index 0000000000..a17f2ae115 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_spikesides.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikesidesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='spikesides', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(SpikesidesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_spikethickness.py b/plotly/validators/layout/scene/yaxis/_spikethickness.py new file mode 100644 index 0000000000..37cb76562f --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_spikethickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SpikethicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='spikethickness', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(SpikethicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tick0.py b/plotly/validators/layout/scene/yaxis/_tick0.py new file mode 100644 index 0000000000..0a0177e100 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.scene.yaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickangle.py b/plotly/validators/layout/scene/yaxis/_tickangle.py new file mode 100644 index 0000000000..579cb0464d --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickcolor.py b/plotly/validators/layout/scene/yaxis/_tickcolor.py new file mode 100644 index 0000000000..39abb35d88 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickfont.py b/plotly/validators/layout/scene/yaxis/_tickfont.py new file mode 100644 index 0000000000..80dd646d0f --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickformat.py b/plotly/validators/layout/scene/yaxis/_tickformat.py new file mode 100644 index 0000000000..574d562cbe --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickformatstops.py b/plotly/validators/layout/scene/yaxis/_tickformatstops.py new file mode 100644 index 0000000000..970376f1fb --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_ticklen.py b/plotly/validators/layout/scene/yaxis/_ticklen.py new file mode 100644 index 0000000000..fb54f12d1c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickmode.py b/plotly/validators/layout/scene/yaxis/_tickmode.py new file mode 100644 index 0000000000..90000ad84e --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickprefix.py b/plotly/validators/layout/scene/yaxis/_tickprefix.py new file mode 100644 index 0000000000..4ef2e72b33 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_ticks.py b/plotly/validators/layout/scene/yaxis/_ticks.py new file mode 100644 index 0000000000..9afc668280 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='layout.scene.yaxis', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_ticksuffix.py b/plotly/validators/layout/scene/yaxis/_ticksuffix.py new file mode 100644 index 0000000000..39927124c5 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_ticktext.py b/plotly/validators/layout/scene/yaxis/_ticktext.py new file mode 100644 index 0000000000..bfdfd9f486 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_ticktextsrc.py b/plotly/validators/layout/scene/yaxis/_ticktextsrc.py new file mode 100644 index 0000000000..a2e5ad944a --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickvals.py b/plotly/validators/layout/scene/yaxis/_tickvals.py new file mode 100644 index 0000000000..2a9602d24d --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickvalssrc.py b/plotly/validators/layout/scene/yaxis/_tickvalssrc.py new file mode 100644 index 0000000000..bbf989c474 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_tickwidth.py b/plotly/validators/layout/scene/yaxis/_tickwidth.py new file mode 100644 index 0000000000..e05932f56f --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_title.py b/plotly/validators/layout/scene/yaxis/_title.py new file mode 100644 index 0000000000..69d5c28d11 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='layout.scene.yaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_titlefont.py b/plotly/validators/layout/scene/yaxis/_titlefont.py new file mode 100644 index 0000000000..ced600b04c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_type.py b/plotly/validators/layout/scene/yaxis/_type.py new file mode 100644 index 0000000000..83af05ba80 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.scene.yaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_visible.py b/plotly/validators/layout/scene/yaxis/_visible.py new file mode 100644 index 0000000000..4936cb4b31 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_zeroline.py b/plotly/validators/layout/scene/yaxis/_zeroline.py new file mode 100644 index 0000000000..3231ee6299 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_zeroline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='zeroline', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ZerolineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_zerolinecolor.py b/plotly/validators/layout/scene/yaxis/_zerolinecolor.py new file mode 100644 index 0000000000..8ee576696a --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_zerolinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='zerolinecolor', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ZerolinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/_zerolinewidth.py b/plotly/validators/layout/scene/yaxis/_zerolinewidth.py new file mode 100644 index 0000000000..4c6297b8c5 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/_zerolinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='zerolinewidth', + parent_name='layout.scene.yaxis', + **kwargs + ): + super(ZerolinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/tickfont/__init__.py b/plotly/validators/layout/scene/yaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/yaxis/tickfont/_color.py b/plotly/validators/layout/scene/yaxis/tickfont/_color.py new file mode 100644 index 0000000000..2683a35651 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.yaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/tickfont/_family.py b/plotly/validators/layout/scene/yaxis/tickfont/_family.py new file mode 100644 index 0000000000..80f3425c36 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.yaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/tickfont/_size.py b/plotly/validators/layout/scene/yaxis/tickfont/_size.py new file mode 100644 index 0000000000..884f7dc650 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.yaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/tickformatstop/__init__.py b/plotly/validators/layout/scene/yaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/scene/yaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/scene/yaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..67cc1d6a90 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.scene.yaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/tickformatstop/_value.py b/plotly/validators/layout/scene/yaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..dd3d4c95af --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.scene.yaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/titlefont/__init__.py b/plotly/validators/layout/scene/yaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/yaxis/titlefont/_color.py b/plotly/validators/layout/scene/yaxis/titlefont/_color.py new file mode 100644 index 0000000000..b3d43466df --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.yaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/titlefont/_family.py b/plotly/validators/layout/scene/yaxis/titlefont/_family.py new file mode 100644 index 0000000000..e18a73f87a --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.yaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/yaxis/titlefont/_size.py b/plotly/validators/layout/scene/yaxis/titlefont/_size.py new file mode 100644 index 0000000000..04b9021df2 --- /dev/null +++ b/plotly/validators/layout/scene/yaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.yaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/__init__.py b/plotly/validators/layout/scene/zaxis/__init__.py new file mode 100644 index 0000000000..d5feb7a0b2 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/__init__.py @@ -0,0 +1,54 @@ +from ._zerolinewidth import ZerolinewidthValidator +from ._zerolinecolor import ZerolinecolorValidator +from ._zeroline import ZerolineValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._spikethickness import SpikethicknessValidator +from ._spikesides import SpikesidesValidator +from ._spikecolor import SpikecolorValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showspikes import ShowspikesValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._showbackground import ShowbackgroundValidator +from ._showaxeslabels import ShowaxeslabelsValidator +from ._separatethousands import SeparatethousandsValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._nticks import NticksValidator +from ._mirror import MirrorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._backgroundcolor import BackgroundcolorValidator +from ._autorange import AutorangeValidator diff --git a/plotly/validators/layout/scene/zaxis/_autorange.py b/plotly/validators/layout/scene/zaxis/_autorange.py new file mode 100644 index 0000000000..9d83e610a8 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_autorange.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='autorange', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_backgroundcolor.py b/plotly/validators/layout/scene/zaxis/_backgroundcolor.py new file mode 100644 index 0000000000..5f274501e1 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_backgroundcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BackgroundcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='backgroundcolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(BackgroundcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_calendar.py b/plotly/validators/layout/scene/zaxis/_calendar.py new file mode 100644 index 0000000000..a838853ca9 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_calendar.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='calendar', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_categoryarray.py b/plotly/validators/layout/scene/zaxis/_categoryarray.py new file mode 100644 index 0000000000..d584e12b8e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_categoryarraysrc.py b/plotly/validators/layout/scene/zaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..f700d1f41e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_categoryorder.py b/plotly/validators/layout/scene/zaxis/_categoryorder.py new file mode 100644 index 0000000000..f0da728371 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_color.py b/plotly/validators/layout/scene/zaxis/_color.py new file mode 100644 index 0000000000..7e93fdc29b --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.scene.zaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_dtick.py b/plotly/validators/layout/scene/zaxis/_dtick.py new file mode 100644 index 0000000000..940fc61bba --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.scene.zaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_exponentformat.py b/plotly/validators/layout/scene/zaxis/_exponentformat.py new file mode 100644 index 0000000000..72de21f753 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_gridcolor.py b/plotly/validators/layout/scene/zaxis/_gridcolor.py new file mode 100644 index 0000000000..8e17c6796e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_gridwidth.py b/plotly/validators/layout/scene/zaxis/_gridwidth.py new file mode 100644 index 0000000000..4a1688976e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_hoverformat.py b/plotly/validators/layout/scene/zaxis/_hoverformat.py new file mode 100644 index 0000000000..a87ac69bc1 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_linecolor.py b/plotly/validators/layout/scene/zaxis/_linecolor.py new file mode 100644 index 0000000000..eeaa27af45 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_linewidth.py b/plotly/validators/layout/scene/zaxis/_linewidth.py new file mode 100644 index 0000000000..6afb1c1ff7 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_mirror.py b/plotly/validators/layout/scene/zaxis/_mirror.py new file mode 100644 index 0000000000..1da116609d --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_mirror.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MirrorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='mirror', parent_name='layout.scene.zaxis', **kwargs + ): + super(MirrorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=[True, 'ticks', False, 'all', 'allticks'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_nticks.py b/plotly/validators/layout/scene/zaxis/_nticks.py new file mode 100644 index 0000000000..6376e4b1f4 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='layout.scene.zaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_range.py b/plotly/validators/layout/scene/zaxis/_range.py new file mode 100644 index 0000000000..a31759cd12 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_range.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.scene.zaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'plot', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_rangemode.py b/plotly/validators/layout/scene/zaxis/_rangemode.py new file mode 100644 index 0000000000..173c9a1541 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_rangemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='rangemode', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_separatethousands.py b/plotly/validators/layout/scene/zaxis/_separatethousands.py new file mode 100644 index 0000000000..fa276cdfdf --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showaxeslabels.py b/plotly/validators/layout/scene/zaxis/_showaxeslabels.py new file mode 100644 index 0000000000..f7f1e9985d --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showaxeslabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowaxeslabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showaxeslabels', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowaxeslabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showbackground.py b/plotly/validators/layout/scene/zaxis/_showbackground.py new file mode 100644 index 0000000000..000fb7fcb2 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showbackground.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowbackgroundValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showbackground', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowbackgroundValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showexponent.py b/plotly/validators/layout/scene/zaxis/_showexponent.py new file mode 100644 index 0000000000..c4a80fed31 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showgrid.py b/plotly/validators/layout/scene/zaxis/_showgrid.py new file mode 100644 index 0000000000..eb90c9bfe8 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showline.py b/plotly/validators/layout/scene/zaxis/_showline.py new file mode 100644 index 0000000000..ca7045215c --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showspikes.py b/plotly/validators/layout/scene/zaxis/_showspikes.py new file mode 100644 index 0000000000..b947d29626 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showspikes.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowspikesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showspikes', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowspikesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showticklabels.py b/plotly/validators/layout/scene/zaxis/_showticklabels.py new file mode 100644 index 0000000000..324c98b2a8 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showtickprefix.py b/plotly/validators/layout/scene/zaxis/_showtickprefix.py new file mode 100644 index 0000000000..f74cce4f55 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_showticksuffix.py b/plotly/validators/layout/scene/zaxis/_showticksuffix.py new file mode 100644 index 0000000000..6286cfedd9 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_spikecolor.py b/plotly/validators/layout/scene/zaxis/_spikecolor.py new file mode 100644 index 0000000000..f6bc51b31e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_spikecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='spikecolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(SpikecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_spikesides.py b/plotly/validators/layout/scene/zaxis/_spikesides.py new file mode 100644 index 0000000000..a766b4e52e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_spikesides.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikesidesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='spikesides', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(SpikesidesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_spikethickness.py b/plotly/validators/layout/scene/zaxis/_spikethickness.py new file mode 100644 index 0000000000..ff221d85b9 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_spikethickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SpikethicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='spikethickness', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(SpikethicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tick0.py b/plotly/validators/layout/scene/zaxis/_tick0.py new file mode 100644 index 0000000000..45cf4b86ea --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.scene.zaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickangle.py b/plotly/validators/layout/scene/zaxis/_tickangle.py new file mode 100644 index 0000000000..6a90288e49 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickcolor.py b/plotly/validators/layout/scene/zaxis/_tickcolor.py new file mode 100644 index 0000000000..3a673e206f --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickfont.py b/plotly/validators/layout/scene/zaxis/_tickfont.py new file mode 100644 index 0000000000..a4f324193b --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickformat.py b/plotly/validators/layout/scene/zaxis/_tickformat.py new file mode 100644 index 0000000000..e1e4478e67 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickformatstops.py b/plotly/validators/layout/scene/zaxis/_tickformatstops.py new file mode 100644 index 0000000000..8f4e308836 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_ticklen.py b/plotly/validators/layout/scene/zaxis/_ticklen.py new file mode 100644 index 0000000000..f19ee3175c --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickmode.py b/plotly/validators/layout/scene/zaxis/_tickmode.py new file mode 100644 index 0000000000..380dfc899c --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickprefix.py b/plotly/validators/layout/scene/zaxis/_tickprefix.py new file mode 100644 index 0000000000..ae23875847 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_ticks.py b/plotly/validators/layout/scene/zaxis/_ticks.py new file mode 100644 index 0000000000..de6ff94557 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='layout.scene.zaxis', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_ticksuffix.py b/plotly/validators/layout/scene/zaxis/_ticksuffix.py new file mode 100644 index 0000000000..0d802ac1c1 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_ticktext.py b/plotly/validators/layout/scene/zaxis/_ticktext.py new file mode 100644 index 0000000000..14e100b852 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_ticktextsrc.py b/plotly/validators/layout/scene/zaxis/_ticktextsrc.py new file mode 100644 index 0000000000..e1906c898e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickvals.py b/plotly/validators/layout/scene/zaxis/_tickvals.py new file mode 100644 index 0000000000..cdd5fc56df --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickvalssrc.py b/plotly/validators/layout/scene/zaxis/_tickvalssrc.py new file mode 100644 index 0000000000..068ea57755 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_tickwidth.py b/plotly/validators/layout/scene/zaxis/_tickwidth.py new file mode 100644 index 0000000000..0a8f757f21 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_title.py b/plotly/validators/layout/scene/zaxis/_title.py new file mode 100644 index 0000000000..496a7de935 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='layout.scene.zaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_titlefont.py b/plotly/validators/layout/scene/zaxis/_titlefont.py new file mode 100644 index 0000000000..33468a5151 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_type.py b/plotly/validators/layout/scene/zaxis/_type.py new file mode 100644 index 0000000000..8c8116f906 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.scene.zaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_visible.py b/plotly/validators/layout/scene/zaxis/_visible.py new file mode 100644 index 0000000000..4c3e295030 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_zeroline.py b/plotly/validators/layout/scene/zaxis/_zeroline.py new file mode 100644 index 0000000000..f0e5475528 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_zeroline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='zeroline', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ZerolineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_zerolinecolor.py b/plotly/validators/layout/scene/zaxis/_zerolinecolor.py new file mode 100644 index 0000000000..ad8cc743cb --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_zerolinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='zerolinecolor', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ZerolinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/_zerolinewidth.py b/plotly/validators/layout/scene/zaxis/_zerolinewidth.py new file mode 100644 index 0000000000..a3902d44b5 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/_zerolinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='zerolinewidth', + parent_name='layout.scene.zaxis', + **kwargs + ): + super(ZerolinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/tickfont/__init__.py b/plotly/validators/layout/scene/zaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/zaxis/tickfont/_color.py b/plotly/validators/layout/scene/zaxis/tickfont/_color.py new file mode 100644 index 0000000000..c9c85093d3 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.zaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/tickfont/_family.py b/plotly/validators/layout/scene/zaxis/tickfont/_family.py new file mode 100644 index 0000000000..c4c417659f --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.zaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/tickfont/_size.py b/plotly/validators/layout/scene/zaxis/tickfont/_size.py new file mode 100644 index 0000000000..b16f720674 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.zaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/tickformatstop/__init__.py b/plotly/validators/layout/scene/zaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/scene/zaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/scene/zaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..552ba079a2 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.scene.zaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/tickformatstop/_value.py b/plotly/validators/layout/scene/zaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..478ee8d408 --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.scene.zaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/titlefont/__init__.py b/plotly/validators/layout/scene/zaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/scene/zaxis/titlefont/_color.py b/plotly/validators/layout/scene/zaxis/titlefont/_color.py new file mode 100644 index 0000000000..d7f6be574e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.scene.zaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/titlefont/_family.py b/plotly/validators/layout/scene/zaxis/titlefont/_family.py new file mode 100644 index 0000000000..9cc136be6f --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.scene.zaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/scene/zaxis/titlefont/_size.py b/plotly/validators/layout/scene/zaxis/titlefont/_size.py new file mode 100644 index 0000000000..937fc83d4e --- /dev/null +++ b/plotly/validators/layout/scene/zaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.scene.zaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/shape/__init__.py b/plotly/validators/layout/shape/__init__.py new file mode 100644 index 0000000000..fd4a172298 --- /dev/null +++ b/plotly/validators/layout/shape/__init__.py @@ -0,0 +1,17 @@ +from ._ysizemode import YsizemodeValidator +from ._yref import YrefValidator +from ._yanchor import YanchorValidator +from ._y1 import Y1Validator +from ._y0 import Y0Validator +from ._xsizemode import XsizemodeValidator +from ._xref import XrefValidator +from ._xanchor import XanchorValidator +from ._x1 import X1Validator +from ._x0 import X0Validator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._path import PathValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._layer import LayerValidator +from ._fillcolor import FillcolorValidator diff --git a/plotly/validators/layout/shape/_fillcolor.py b/plotly/validators/layout/shape/_fillcolor.py new file mode 100644 index 0000000000..e8eccb2077 --- /dev/null +++ b/plotly/validators/layout/shape/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='layout.shape', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_layer.py b/plotly/validators/layout/shape/_layer.py new file mode 100644 index 0000000000..9b6b57b0a1 --- /dev/null +++ b/plotly/validators/layout/shape/_layer.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='layer', parent_name='layout.shape', **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['below', 'above'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/_line.py b/plotly/validators/layout/shape/_line.py new file mode 100644 index 0000000000..db3d490cba --- /dev/null +++ b/plotly/validators/layout/shape/_line.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='layout.shape', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/layout/shape/_opacity.py b/plotly/validators/layout/shape/_opacity.py new file mode 100644 index 0000000000..0f0538dd58 --- /dev/null +++ b/plotly/validators/layout/shape/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='layout.shape', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_path.py b/plotly/validators/layout/shape/_path.py new file mode 100644 index 0000000000..7a3fd878d2 --- /dev/null +++ b/plotly/validators/layout/shape/_path.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PathValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='path', parent_name='layout.shape', **kwargs + ): + super(PathValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_type.py b/plotly/validators/layout/shape/_type.py new file mode 100644 index 0000000000..56274005d1 --- /dev/null +++ b/plotly/validators/layout/shape/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.shape', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + values=['circle', 'rect', 'path', 'line'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/_visible.py b/plotly/validators/layout/shape/_visible.py new file mode 100644 index 0000000000..816630f3f2 --- /dev/null +++ b/plotly/validators/layout/shape/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.shape', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_x0.py b/plotly/validators/layout/shape/_x0.py new file mode 100644 index 0000000000..2f24786e7a --- /dev/null +++ b/plotly/validators/layout/shape/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='layout.shape', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_x1.py b/plotly/validators/layout/shape/_x1.py new file mode 100644 index 0000000000..da4ddc7f48 --- /dev/null +++ b/plotly/validators/layout/shape/_x1.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X1Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x1', parent_name='layout.shape', **kwargs): + super(X1Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_xanchor.py b/plotly/validators/layout/shape/_xanchor.py new file mode 100644 index 0000000000..3deb7e0a13 --- /dev/null +++ b/plotly/validators/layout/shape/_xanchor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.shape', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_xref.py b/plotly/validators/layout/shape/_xref.py new file mode 100644 index 0000000000..99243453bc --- /dev/null +++ b/plotly/validators/layout/shape/_xref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xref', parent_name='layout.shape', **kwargs + ): + super(XrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['paper', '/^x([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/_xsizemode.py b/plotly/validators/layout/shape/_xsizemode.py new file mode 100644 index 0000000000..fbb129fe81 --- /dev/null +++ b/plotly/validators/layout/shape/_xsizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XsizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xsizemode', parent_name='layout.shape', **kwargs + ): + super(XsizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + values=['scaled', 'pixel'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/_y0.py b/plotly/validators/layout/shape/_y0.py new file mode 100644 index 0000000000..5e0a9fbf3b --- /dev/null +++ b/plotly/validators/layout/shape/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='layout.shape', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_y1.py b/plotly/validators/layout/shape/_y1.py new file mode 100644 index 0000000000..49e610c85b --- /dev/null +++ b/plotly/validators/layout/shape/_y1.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y1Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y1', parent_name='layout.shape', **kwargs): + super(Y1Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_yanchor.py b/plotly/validators/layout/shape/_yanchor.py new file mode 100644 index 0000000000..09488cb50c --- /dev/null +++ b/plotly/validators/layout/shape/_yanchor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.shape', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/shape/_yref.py b/plotly/validators/layout/shape/_yref.py new file mode 100644 index 0000000000..62ecddac7d --- /dev/null +++ b/plotly/validators/layout/shape/_yref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YrefValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yref', parent_name='layout.shape', **kwargs + ): + super(YrefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['paper', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/_ysizemode.py b/plotly/validators/layout/shape/_ysizemode.py new file mode 100644 index 0000000000..494066d677 --- /dev/null +++ b/plotly/validators/layout/shape/_ysizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YsizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ysizemode', parent_name='layout.shape', **kwargs + ): + super(YsizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + role='info', + values=['scaled', 'pixel'], + **kwargs + ) diff --git a/plotly/validators/layout/shape/line/__init__.py b/plotly/validators/layout/shape/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/layout/shape/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/shape/line/_color.py b/plotly/validators/layout/shape/line/_color.py new file mode 100644 index 0000000000..5615766e00 --- /dev/null +++ b/plotly/validators/layout/shape/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.shape.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/shape/line/_dash.py b/plotly/validators/layout/shape/line/_dash.py new file mode 100644 index 0000000000..8df2b971f2 --- /dev/null +++ b/plotly/validators/layout/shape/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='layout.shape.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/layout/shape/line/_width.py b/plotly/validators/layout/shape/line/_width.py new file mode 100644 index 0000000000..50430c48e4 --- /dev/null +++ b/plotly/validators/layout/shape/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='layout.shape.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange+arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/__init__.py b/plotly/validators/layout/slider/__init__.py new file mode 100644 index 0000000000..48f844da96 --- /dev/null +++ b/plotly/validators/layout/slider/__init__.py @@ -0,0 +1,21 @@ +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._transition import TransitionValidator +from ._tickwidth import TickwidthValidator +from ._ticklen import TicklenValidator +from ._tickcolor import TickcolorValidator +from ._steps import StepsValidator +from ._pad import PadValidator +from ._minorticklen import MinorticklenValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._font import FontValidator +from ._currentvalue import CurrentvalueValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._activebgcolor import ActivebgcolorValidator +from ._active import ActiveValidator diff --git a/plotly/validators/layout/slider/_active.py b/plotly/validators/layout/slider/_active.py new file mode 100644 index 0000000000..6471267f8b --- /dev/null +++ b/plotly/validators/layout/slider/_active.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ActiveValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='active', parent_name='layout.slider', **kwargs + ): + super(ActiveValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_activebgcolor.py b/plotly/validators/layout/slider/_activebgcolor.py new file mode 100644 index 0000000000..77809195fe --- /dev/null +++ b/plotly/validators/layout/slider/_activebgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ActivebgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='activebgcolor', + parent_name='layout.slider', + **kwargs + ): + super(ActivebgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_bgcolor.py b/plotly/validators/layout/slider/_bgcolor.py new file mode 100644 index 0000000000..0dc66f871c --- /dev/null +++ b/plotly/validators/layout/slider/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.slider', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_bordercolor.py b/plotly/validators/layout/slider/_bordercolor.py new file mode 100644 index 0000000000..3036731064 --- /dev/null +++ b/plotly/validators/layout/slider/_bordercolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bordercolor', parent_name='layout.slider', **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_borderwidth.py b/plotly/validators/layout/slider/_borderwidth.py new file mode 100644 index 0000000000..266f93aa28 --- /dev/null +++ b/plotly/validators/layout/slider/_borderwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='borderwidth', parent_name='layout.slider', **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_currentvalue.py b/plotly/validators/layout/slider/_currentvalue.py new file mode 100644 index 0000000000..81454c6b2e --- /dev/null +++ b/plotly/validators/layout/slider/_currentvalue.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class CurrentvalueValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='currentvalue', + parent_name='layout.slider', + **kwargs + ): + super(CurrentvalueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Currentvalue', + data_docs=""" + font + Sets the font of the current value label text. + offset + The amount of space, in pixels, between the + current value label and the slider. + prefix + When currentvalue.visible is true, this sets + the prefix of the label. + suffix + When currentvalue.visible is true, this sets + the suffix of the label. + visible + Shows the currently-selected value above the + slider. + xanchor + The alignment of the value readout relative to + the length of the slider.""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/_font.py b/plotly/validators/layout/slider/_font.py new file mode 100644 index 0000000000..9502b542cb --- /dev/null +++ b/plotly/validators/layout/slider/_font.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='layout.slider', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/_len.py b/plotly/validators/layout/slider/_len.py new file mode 100644 index 0000000000..8fdaf5297e --- /dev/null +++ b/plotly/validators/layout/slider/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='layout.slider', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_lenmode.py b/plotly/validators/layout/slider/_lenmode.py new file mode 100644 index 0000000000..f9d2603a7b --- /dev/null +++ b/plotly/validators/layout/slider/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='layout.slider', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/layout/slider/_minorticklen.py b/plotly/validators/layout/slider/_minorticklen.py new file mode 100644 index 0000000000..20db9f0db0 --- /dev/null +++ b/plotly/validators/layout/slider/_minorticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MinorticklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='minorticklen', + parent_name='layout.slider', + **kwargs + ): + super(MinorticklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_pad.py b/plotly/validators/layout/slider/_pad.py new file mode 100644 index 0000000000..d33d402d74 --- /dev/null +++ b/plotly/validators/layout/slider/_pad.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class PadValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='pad', parent_name='layout.slider', **kwargs + ): + super(PadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Pad', + data_docs=""" + b + The amount of padding (in px) along the bottom + of the component. + l + The amount of padding (in px) on the left side + of the component. + r + The amount of padding (in px) on the right side + of the component. + t + The amount of padding (in px) along the top of + the component.""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/_steps.py b/plotly/validators/layout/slider/_steps.py new file mode 100644 index 0000000000..99f9e57c09 --- /dev/null +++ b/plotly/validators/layout/slider/_steps.py @@ -0,0 +1,42 @@ +import _plotly_utils.basevalidators + + +class StepsValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, plotly_name='steps', parent_name='layout.slider', **kwargs + ): + super(StepsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Step', + data_docs=""" + args + Sets the arguments values to be passed to the + Plotly method set in `method` on slide. + execute + When true, the API method is executed. When + false, all other behaviors are the same and + command execution is skipped. This may be + useful when hooking into, for example, the + `plotly_sliderchange` method and executing the + API command manually without losing the benefit + of the slider automatically binding to the + state of the plot through the specification of + `method` and `args`. + label + Sets the text label to appear on the slider + method + Sets the Plotly method to be called when the + slider value is changed. If the `skip` method + is used, the API slider will function as normal + but will perform no API calls and will not bind + automatically to state updates. This may be + used to create a component interface and attach + to slider events manually via JavaScript. + value + Sets the value of the slider step, used to + refer to the step programatically. Defaults to + the slider label if not provided.""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/_tickcolor.py b/plotly/validators/layout/slider/_tickcolor.py new file mode 100644 index 0000000000..7b375f085d --- /dev/null +++ b/plotly/validators/layout/slider/_tickcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='tickcolor', parent_name='layout.slider', **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_ticklen.py b/plotly/validators/layout/slider/_ticklen.py new file mode 100644 index 0000000000..52de8ed7fe --- /dev/null +++ b/plotly/validators/layout/slider/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='layout.slider', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_tickwidth.py b/plotly/validators/layout/slider/_tickwidth.py new file mode 100644 index 0000000000..a93810f29f --- /dev/null +++ b/plotly/validators/layout/slider/_tickwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tickwidth', parent_name='layout.slider', **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_transition.py b/plotly/validators/layout/slider/_transition.py new file mode 100644 index 0000000000..52c226e7fb --- /dev/null +++ b/plotly/validators/layout/slider/_transition.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TransitionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='transition', parent_name='layout.slider', **kwargs + ): + super(TransitionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Transition', + data_docs=""" + duration + Sets the duration of the slider transition + easing + Sets the easing function of the slider + transition""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/_visible.py b/plotly/validators/layout/slider/_visible.py new file mode 100644 index 0000000000..a1447bcee0 --- /dev/null +++ b/plotly/validators/layout/slider/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.slider', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_x.py b/plotly/validators/layout/slider/_x.py new file mode 100644 index 0000000000..0e494725d9 --- /dev/null +++ b/plotly/validators/layout/slider/_x.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='x', parent_name='layout.slider', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_xanchor.py b/plotly/validators/layout/slider/_xanchor.py new file mode 100644 index 0000000000..03cfffcd57 --- /dev/null +++ b/plotly/validators/layout/slider/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.slider', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/slider/_y.py b/plotly/validators/layout/slider/_y.py new file mode 100644 index 0000000000..1401253a3e --- /dev/null +++ b/plotly/validators/layout/slider/_y.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='y', parent_name='layout.slider', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/_yanchor.py b/plotly/validators/layout/slider/_yanchor.py new file mode 100644 index 0000000000..97ad9a3c60 --- /dev/null +++ b/plotly/validators/layout/slider/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.slider', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/__init__.py b/plotly/validators/layout/slider/currentvalue/__init__.py new file mode 100644 index 0000000000..4c520d55af --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/__init__.py @@ -0,0 +1,6 @@ +from ._xanchor import XanchorValidator +from ._visible import VisibleValidator +from ._suffix import SuffixValidator +from ._prefix import PrefixValidator +from ._offset import OffsetValidator +from ._font import FontValidator diff --git a/plotly/validators/layout/slider/currentvalue/_font.py b/plotly/validators/layout/slider/currentvalue/_font.py new file mode 100644 index 0000000000..b7f4353afb --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_font.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/_offset.py b/plotly/validators/layout/slider/currentvalue/_offset.py new file mode 100644 index 0000000000..885c5fe449 --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_offset.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OffsetValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='offset', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(OffsetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/_prefix.py b/plotly/validators/layout/slider/currentvalue/_prefix.py new file mode 100644 index 0000000000..19fa930579 --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_prefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class PrefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='prefix', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(PrefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/_suffix.py b/plotly/validators/layout/slider/currentvalue/_suffix.py new file mode 100644 index 0000000000..e1ea3551d6 --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_suffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='suffix', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(SuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/_visible.py b/plotly/validators/layout/slider/currentvalue/_visible.py new file mode 100644 index 0000000000..32827440f0 --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/_xanchor.py b/plotly/validators/layout/slider/currentvalue/_xanchor.py new file mode 100644 index 0000000000..55369232fb --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='layout.slider.currentvalue', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/font/__init__.py b/plotly/validators/layout/slider/currentvalue/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/slider/currentvalue/font/_color.py b/plotly/validators/layout/slider/currentvalue/font/_color.py new file mode 100644 index 0000000000..c0a9c947eb --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.slider.currentvalue.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/font/_family.py b/plotly/validators/layout/slider/currentvalue/font/_family.py new file mode 100644 index 0000000000..6350bcbe4e --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.slider.currentvalue.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/slider/currentvalue/font/_size.py b/plotly/validators/layout/slider/currentvalue/font/_size.py new file mode 100644 index 0000000000..add3667ea6 --- /dev/null +++ b/plotly/validators/layout/slider/currentvalue/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.slider.currentvalue.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/font/__init__.py b/plotly/validators/layout/slider/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/slider/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/slider/font/_color.py b/plotly/validators/layout/slider/font/_color.py new file mode 100644 index 0000000000..d39eef86ca --- /dev/null +++ b/plotly/validators/layout/slider/font/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.slider.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/font/_family.py b/plotly/validators/layout/slider/font/_family.py new file mode 100644 index 0000000000..866ce30db6 --- /dev/null +++ b/plotly/validators/layout/slider/font/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='layout.slider.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/slider/font/_size.py b/plotly/validators/layout/slider/font/_size.py new file mode 100644 index 0000000000..572f54bc9c --- /dev/null +++ b/plotly/validators/layout/slider/font/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='layout.slider.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/pad/__init__.py b/plotly/validators/layout/slider/pad/__init__.py new file mode 100644 index 0000000000..f2aa8ac13b --- /dev/null +++ b/plotly/validators/layout/slider/pad/__init__.py @@ -0,0 +1,4 @@ +from ._t import TValidator +from ._r import RValidator +from ._l import LValidator +from ._b import BValidator diff --git a/plotly/validators/layout/slider/pad/_b.py b/plotly/validators/layout/slider/pad/_b.py new file mode 100644 index 0000000000..ced20c128f --- /dev/null +++ b/plotly/validators/layout/slider/pad/_b.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='b', parent_name='layout.slider.pad', **kwargs + ): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/pad/_l.py b/plotly/validators/layout/slider/pad/_l.py new file mode 100644 index 0000000000..f2f34b15e6 --- /dev/null +++ b/plotly/validators/layout/slider/pad/_l.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='l', parent_name='layout.slider.pad', **kwargs + ): + super(LValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/pad/_r.py b/plotly/validators/layout/slider/pad/_r.py new file mode 100644 index 0000000000..a1b022bcce --- /dev/null +++ b/plotly/validators/layout/slider/pad/_r.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='r', parent_name='layout.slider.pad', **kwargs + ): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/pad/_t.py b/plotly/validators/layout/slider/pad/_t.py new file mode 100644 index 0000000000..40c4a457b9 --- /dev/null +++ b/plotly/validators/layout/slider/pad/_t.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='t', parent_name='layout.slider.pad', **kwargs + ): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/slider/step/__init__.py b/plotly/validators/layout/slider/step/__init__.py new file mode 100644 index 0000000000..27afb3bcad --- /dev/null +++ b/plotly/validators/layout/slider/step/__init__.py @@ -0,0 +1,5 @@ +from ._value import ValueValidator +from ._method import MethodValidator +from ._label import LabelValidator +from ._execute import ExecuteValidator +from ._args import ArgsValidator diff --git a/plotly/validators/layout/slider/step/_args.py b/plotly/validators/layout/slider/step/_args.py new file mode 100644 index 0000000000..68cfd8dd9f --- /dev/null +++ b/plotly/validators/layout/slider/step/_args.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class ArgsValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='args', parent_name='layout.slider.step', **kwargs + ): + super(ArgsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + free_length=True, + items=[ + { + 'valType': 'any', + 'editType': 'arraydraw' + }, { + 'valType': 'any', + 'editType': 'arraydraw' + }, { + 'valType': 'any', + 'editType': 'arraydraw' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/step/_execute.py b/plotly/validators/layout/slider/step/_execute.py new file mode 100644 index 0000000000..475b13e9e0 --- /dev/null +++ b/plotly/validators/layout/slider/step/_execute.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ExecuteValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='execute', + parent_name='layout.slider.step', + **kwargs + ): + super(ExecuteValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/step/_label.py b/plotly/validators/layout/slider/step/_label.py new file mode 100644 index 0000000000..b6d16814f4 --- /dev/null +++ b/plotly/validators/layout/slider/step/_label.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='label', parent_name='layout.slider.step', **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/step/_method.py b/plotly/validators/layout/slider/step/_method.py new file mode 100644 index 0000000000..16f00f81fe --- /dev/null +++ b/plotly/validators/layout/slider/step/_method.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MethodValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='method', parent_name='layout.slider.step', **kwargs + ): + super(MethodValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['restyle', 'relayout', 'animate', 'update', 'skip'], + **kwargs + ) diff --git a/plotly/validators/layout/slider/step/_value.py b/plotly/validators/layout/slider/step/_value.py new file mode 100644 index 0000000000..eb2ab86140 --- /dev/null +++ b/plotly/validators/layout/slider/step/_value.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='value', parent_name='layout.slider.step', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/transition/__init__.py b/plotly/validators/layout/slider/transition/__init__.py new file mode 100644 index 0000000000..a128142121 --- /dev/null +++ b/plotly/validators/layout/slider/transition/__init__.py @@ -0,0 +1,2 @@ +from ._easing import EasingValidator +from ._duration import DurationValidator diff --git a/plotly/validators/layout/slider/transition/_duration.py b/plotly/validators/layout/slider/transition/_duration.py new file mode 100644 index 0000000000..e63dda4593 --- /dev/null +++ b/plotly/validators/layout/slider/transition/_duration.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DurationValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='duration', + parent_name='layout.slider.transition', + **kwargs + ): + super(DurationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/slider/transition/_easing.py b/plotly/validators/layout/slider/transition/_easing.py new file mode 100644 index 0000000000..f4430d0d49 --- /dev/null +++ b/plotly/validators/layout/slider/transition/_easing.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class EasingValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='easing', + parent_name='layout.slider.transition', + **kwargs + ): + super(EasingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=[ + 'linear', 'quad', 'cubic', 'sin', 'exp', 'circle', 'elastic', + 'back', 'bounce', 'linear-in', 'quad-in', 'cubic-in', 'sin-in', + 'exp-in', 'circle-in', 'elastic-in', 'back-in', 'bounce-in', + 'linear-out', 'quad-out', 'cubic-out', 'sin-out', 'exp-out', + 'circle-out', 'elastic-out', 'back-out', 'bounce-out', + 'linear-in-out', 'quad-in-out', 'cubic-in-out', 'sin-in-out', + 'exp-in-out', 'circle-in-out', 'elastic-in-out', 'back-in-out', + 'bounce-in-out' + ], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/__init__.py b/plotly/validators/layout/ternary/__init__.py new file mode 100644 index 0000000000..df20e7e9ce --- /dev/null +++ b/plotly/validators/layout/ternary/__init__.py @@ -0,0 +1,6 @@ +from ._sum import SumValidator +from ._domain import DomainValidator +from ._caxis import CaxisValidator +from ._bgcolor import BgcolorValidator +from ._baxis import BaxisValidator +from ._aaxis import AaxisValidator diff --git a/plotly/validators/layout/ternary/_aaxis.py b/plotly/validators/layout/ternary/_aaxis.py new file mode 100644 index 0000000000..5f7081cef6 --- /dev/null +++ b/plotly/validators/layout/ternary/_aaxis.py @@ -0,0 +1,203 @@ +import _plotly_utils.basevalidators + + +class AaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='aaxis', parent_name='layout.ternary', **kwargs + ): + super(AaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Aaxis', + data_docs=""" + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.aaxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font.""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/_baxis.py b/plotly/validators/layout/ternary/_baxis.py new file mode 100644 index 0000000000..cfeb84ba17 --- /dev/null +++ b/plotly/validators/layout/ternary/_baxis.py @@ -0,0 +1,203 @@ +import _plotly_utils.basevalidators + + +class BaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='baxis', parent_name='layout.ternary', **kwargs + ): + super(BaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Baxis', + data_docs=""" + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.baxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font.""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/_bgcolor.py b/plotly/validators/layout/ternary/_bgcolor.py new file mode 100644 index 0000000000..473a6c0260 --- /dev/null +++ b/plotly/validators/layout/ternary/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.ternary', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/_caxis.py b/plotly/validators/layout/ternary/_caxis.py new file mode 100644 index 0000000000..d4183d74f7 --- /dev/null +++ b/plotly/validators/layout/ternary/_caxis.py @@ -0,0 +1,203 @@ +import _plotly_utils.basevalidators + + +class CaxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='caxis', parent_name='layout.ternary', **kwargs + ): + super(CaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Caxis', + data_docs=""" + color + Sets default for all colors associated with + this axis all at once: line, font, tick, and + grid colors. Grid color is lightened by + blending this with the plot background + Individual pieces can override this. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + gridcolor + Sets the color of the grid lines. + gridwidth + Sets the width (in px) of the grid lines. + hoverformat + Sets the hover text formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + layer + Sets the layer on which this axis is displayed. + If *above traces*, this axis is displayed above + all the subplot's traces If *below traces*, + this axis is displayed below all the subplot's + traces, but above the grid lines. Useful when + used together with scatter-like traces with + `cliponaxis` set to *false* to show markers + and/or text nodes above this axis. + linecolor + Sets the axis line color. + linewidth + Sets the width (in px) of the axis line. + min + The minimum value visible on this axis. The + maximum is determined by the sum minus the + minimum values of the other two axes. The full + view corresponds to all the minima set to zero. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showgrid + Determines whether or not grid lines are drawn. + If *true*, the grid lines are drawn at every + tick mark. + showline + Determines whether or not a line bounding this + axis is drawn. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the tick font. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.layout.ternary.caxis.Tickform + atstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of this axis. + titlefont + Sets this axis' title font.""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/_domain.py b/plotly/validators/layout/ternary/_domain.py new file mode 100644 index 0000000000..f77368c16f --- /dev/null +++ b/plotly/validators/layout/ternary/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.ternary', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this ternary + subplot . + row + If there is a layout grid, use the domain for + this row in the grid for this ternary subplot . + x + Sets the horizontal domain of this ternary + subplot (in plot fraction). + y + Sets the vertical domain of this ternary + subplot (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/_sum.py b/plotly/validators/layout/ternary/_sum.py new file mode 100644 index 0000000000..6a517f6492 --- /dev/null +++ b/plotly/validators/layout/ternary/_sum.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SumValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sum', parent_name='layout.ternary', **kwargs + ): + super(SumValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/__init__.py b/plotly/validators/layout/ternary/aaxis/__init__.py new file mode 100644 index 0000000000..5160bfc643 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/__init__.py @@ -0,0 +1,36 @@ +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._nticks import NticksValidator +from ._min import MinValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/aaxis/_color.py b/plotly/validators/layout/ternary/aaxis/_color.py new file mode 100644 index 0000000000..d441e40f90 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_dtick.py b/plotly/validators/layout/ternary/aaxis/_dtick.py new file mode 100644 index 0000000000..b2c84618f3 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_exponentformat.py b/plotly/validators/layout/ternary/aaxis/_exponentformat.py new file mode 100644 index 0000000000..d18b11eb8a --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_gridcolor.py b/plotly/validators/layout/ternary/aaxis/_gridcolor.py new file mode 100644 index 0000000000..066ea53b24 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_gridwidth.py b/plotly/validators/layout/ternary/aaxis/_gridwidth.py new file mode 100644 index 0000000000..77cd8321ed --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_hoverformat.py b/plotly/validators/layout/ternary/aaxis/_hoverformat.py new file mode 100644 index 0000000000..9bb07e342a --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_layer.py b/plotly/validators/layout/ternary/aaxis/_layer.py new file mode 100644 index 0000000000..e45dd5d843 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_layer.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='layer', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_linecolor.py b/plotly/validators/layout/ternary/aaxis/_linecolor.py new file mode 100644 index 0000000000..852cf4e9a3 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_linewidth.py b/plotly/validators/layout/ternary/aaxis/_linewidth.py new file mode 100644 index 0000000000..024167e770 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_min.py b/plotly/validators/layout/ternary/aaxis/_min.py new file mode 100644 index 0000000000..07ba72f8a8 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_min.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MinValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='min', parent_name='layout.ternary.aaxis', **kwargs + ): + super(MinValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_nticks.py b/plotly/validators/layout/ternary/aaxis/_nticks.py new file mode 100644 index 0000000000..d6b3462373 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_separatethousands.py b/plotly/validators/layout/ternary/aaxis/_separatethousands.py new file mode 100644 index 0000000000..bf429b3da8 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showexponent.py b/plotly/validators/layout/ternary/aaxis/_showexponent.py new file mode 100644 index 0000000000..3e8274469e --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showgrid.py b/plotly/validators/layout/ternary/aaxis/_showgrid.py new file mode 100644 index 0000000000..57bff07a60 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showline.py b/plotly/validators/layout/ternary/aaxis/_showline.py new file mode 100644 index 0000000000..0ff54103c7 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showticklabels.py b/plotly/validators/layout/ternary/aaxis/_showticklabels.py new file mode 100644 index 0000000000..7dab3e37e6 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showtickprefix.py b/plotly/validators/layout/ternary/aaxis/_showtickprefix.py new file mode 100644 index 0000000000..f5be7b7098 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_showticksuffix.py b/plotly/validators/layout/ternary/aaxis/_showticksuffix.py new file mode 100644 index 0000000000..2a1b061ea7 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tick0.py b/plotly/validators/layout/ternary/aaxis/_tick0.py new file mode 100644 index 0000000000..d97ab75e4a --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickangle.py b/plotly/validators/layout/ternary/aaxis/_tickangle.py new file mode 100644 index 0000000000..cd9e79c7e9 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickcolor.py b/plotly/validators/layout/ternary/aaxis/_tickcolor.py new file mode 100644 index 0000000000..2321ccf980 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickfont.py b/plotly/validators/layout/ternary/aaxis/_tickfont.py new file mode 100644 index 0000000000..189b1ed170 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickformat.py b/plotly/validators/layout/ternary/aaxis/_tickformat.py new file mode 100644 index 0000000000..06ff393ba8 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickformatstops.py b/plotly/validators/layout/ternary/aaxis/_tickformatstops.py new file mode 100644 index 0000000000..08daa2ce6c --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_ticklen.py b/plotly/validators/layout/ternary/aaxis/_ticklen.py new file mode 100644 index 0000000000..ab667f5820 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickmode.py b/plotly/validators/layout/ternary/aaxis/_tickmode.py new file mode 100644 index 0000000000..b9402f1b37 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickprefix.py b/plotly/validators/layout/ternary/aaxis/_tickprefix.py new file mode 100644 index 0000000000..6ca696a3e5 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_ticks.py b/plotly/validators/layout/ternary/aaxis/_ticks.py new file mode 100644 index 0000000000..cc66cac6c5 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_ticksuffix.py b/plotly/validators/layout/ternary/aaxis/_ticksuffix.py new file mode 100644 index 0000000000..0124937eef --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_ticktext.py b/plotly/validators/layout/ternary/aaxis/_ticktext.py new file mode 100644 index 0000000000..fa44613761 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_ticktextsrc.py b/plotly/validators/layout/ternary/aaxis/_ticktextsrc.py new file mode 100644 index 0000000000..28410e966d --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickvals.py b/plotly/validators/layout/ternary/aaxis/_tickvals.py new file mode 100644 index 0000000000..628d0f4e4c --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickvalssrc.py b/plotly/validators/layout/ternary/aaxis/_tickvalssrc.py new file mode 100644 index 0000000000..2ef093ec76 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_tickwidth.py b/plotly/validators/layout/ternary/aaxis/_tickwidth.py new file mode 100644 index 0000000000..b9f87db77a --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_title.py b/plotly/validators/layout/ternary/aaxis/_title.py new file mode 100644 index 0000000000..240164d66c --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/_titlefont.py b/plotly/validators/layout/ternary/aaxis/_titlefont.py new file mode 100644 index 0000000000..096e8b3a03 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.ternary.aaxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/tickfont/__init__.py b/plotly/validators/layout/ternary/aaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/aaxis/tickfont/_color.py b/plotly/validators/layout/ternary/aaxis/tickfont/_color.py new file mode 100644 index 0000000000..70e4f68159 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.aaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/tickfont/_family.py b/plotly/validators/layout/ternary/aaxis/tickfont/_family.py new file mode 100644 index 0000000000..865440fd43 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.aaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/tickfont/_size.py b/plotly/validators/layout/ternary/aaxis/tickfont/_size.py new file mode 100644 index 0000000000..77b69b065f --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.aaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/tickformatstop/__init__.py b/plotly/validators/layout/ternary/aaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/ternary/aaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/ternary/aaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..aa28f8e3d2 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.ternary.aaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/tickformatstop/_value.py b/plotly/validators/layout/ternary/aaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..5ea6ba7eda --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.ternary.aaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/titlefont/__init__.py b/plotly/validators/layout/ternary/aaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/aaxis/titlefont/_color.py b/plotly/validators/layout/ternary/aaxis/titlefont/_color.py new file mode 100644 index 0000000000..a3c44e9d12 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.aaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/titlefont/_family.py b/plotly/validators/layout/ternary/aaxis/titlefont/_family.py new file mode 100644 index 0000000000..a7eb0d7422 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.aaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/aaxis/titlefont/_size.py b/plotly/validators/layout/ternary/aaxis/titlefont/_size.py new file mode 100644 index 0000000000..d12a8e5df2 --- /dev/null +++ b/plotly/validators/layout/ternary/aaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.aaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/__init__.py b/plotly/validators/layout/ternary/baxis/__init__.py new file mode 100644 index 0000000000..5160bfc643 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/__init__.py @@ -0,0 +1,36 @@ +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._nticks import NticksValidator +from ._min import MinValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/baxis/_color.py b/plotly/validators/layout/ternary/baxis/_color.py new file mode 100644 index 0000000000..4391dd55e0 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_dtick.py b/plotly/validators/layout/ternary/baxis/_dtick.py new file mode 100644 index 0000000000..ade5dcfa70 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_exponentformat.py b/plotly/validators/layout/ternary/baxis/_exponentformat.py new file mode 100644 index 0000000000..74a3b4b941 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_gridcolor.py b/plotly/validators/layout/ternary/baxis/_gridcolor.py new file mode 100644 index 0000000000..584ca2b104 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_gridwidth.py b/plotly/validators/layout/ternary/baxis/_gridwidth.py new file mode 100644 index 0000000000..f2f2fa60b6 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_hoverformat.py b/plotly/validators/layout/ternary/baxis/_hoverformat.py new file mode 100644 index 0000000000..e927391798 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_layer.py b/plotly/validators/layout/ternary/baxis/_layer.py new file mode 100644 index 0000000000..e4088b6a51 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_layer.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='layer', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_linecolor.py b/plotly/validators/layout/ternary/baxis/_linecolor.py new file mode 100644 index 0000000000..153d7475d3 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_linewidth.py b/plotly/validators/layout/ternary/baxis/_linewidth.py new file mode 100644 index 0000000000..998e782243 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_min.py b/plotly/validators/layout/ternary/baxis/_min.py new file mode 100644 index 0000000000..7d823c967e --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_min.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MinValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='min', parent_name='layout.ternary.baxis', **kwargs + ): + super(MinValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_nticks.py b/plotly/validators/layout/ternary/baxis/_nticks.py new file mode 100644 index 0000000000..6132a9906a --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_separatethousands.py b/plotly/validators/layout/ternary/baxis/_separatethousands.py new file mode 100644 index 0000000000..35167c623f --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showexponent.py b/plotly/validators/layout/ternary/baxis/_showexponent.py new file mode 100644 index 0000000000..585a48ee50 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showgrid.py b/plotly/validators/layout/ternary/baxis/_showgrid.py new file mode 100644 index 0000000000..dafbbc2123 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showline.py b/plotly/validators/layout/ternary/baxis/_showline.py new file mode 100644 index 0000000000..84f94916f4 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showticklabels.py b/plotly/validators/layout/ternary/baxis/_showticklabels.py new file mode 100644 index 0000000000..c3df6bf091 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showtickprefix.py b/plotly/validators/layout/ternary/baxis/_showtickprefix.py new file mode 100644 index 0000000000..4e756eb032 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_showticksuffix.py b/plotly/validators/layout/ternary/baxis/_showticksuffix.py new file mode 100644 index 0000000000..a175c798b0 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tick0.py b/plotly/validators/layout/ternary/baxis/_tick0.py new file mode 100644 index 0000000000..dfe0a0f0f6 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickangle.py b/plotly/validators/layout/ternary/baxis/_tickangle.py new file mode 100644 index 0000000000..7ed94b3c12 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickcolor.py b/plotly/validators/layout/ternary/baxis/_tickcolor.py new file mode 100644 index 0000000000..a64845042a --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickfont.py b/plotly/validators/layout/ternary/baxis/_tickfont.py new file mode 100644 index 0000000000..c1b8a96778 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickformat.py b/plotly/validators/layout/ternary/baxis/_tickformat.py new file mode 100644 index 0000000000..28a0d8ce66 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickformatstops.py b/plotly/validators/layout/ternary/baxis/_tickformatstops.py new file mode 100644 index 0000000000..ead1158006 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_ticklen.py b/plotly/validators/layout/ternary/baxis/_ticklen.py new file mode 100644 index 0000000000..0c6f773f86 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickmode.py b/plotly/validators/layout/ternary/baxis/_tickmode.py new file mode 100644 index 0000000000..f021014678 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickprefix.py b/plotly/validators/layout/ternary/baxis/_tickprefix.py new file mode 100644 index 0000000000..85a633d660 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_ticks.py b/plotly/validators/layout/ternary/baxis/_ticks.py new file mode 100644 index 0000000000..0e24f78c09 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_ticksuffix.py b/plotly/validators/layout/ternary/baxis/_ticksuffix.py new file mode 100644 index 0000000000..865dc608f1 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_ticktext.py b/plotly/validators/layout/ternary/baxis/_ticktext.py new file mode 100644 index 0000000000..ec603f7696 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_ticktextsrc.py b/plotly/validators/layout/ternary/baxis/_ticktextsrc.py new file mode 100644 index 0000000000..5403a266ee --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickvals.py b/plotly/validators/layout/ternary/baxis/_tickvals.py new file mode 100644 index 0000000000..224535b96f --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickvalssrc.py b/plotly/validators/layout/ternary/baxis/_tickvalssrc.py new file mode 100644 index 0000000000..def987635c --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_tickwidth.py b/plotly/validators/layout/ternary/baxis/_tickwidth.py new file mode 100644 index 0000000000..03d4585e18 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_title.py b/plotly/validators/layout/ternary/baxis/_title.py new file mode 100644 index 0000000000..896d61447a --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/_titlefont.py b/plotly/validators/layout/ternary/baxis/_titlefont.py new file mode 100644 index 0000000000..8ea6c75073 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.ternary.baxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/tickfont/__init__.py b/plotly/validators/layout/ternary/baxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/baxis/tickfont/_color.py b/plotly/validators/layout/ternary/baxis/tickfont/_color.py new file mode 100644 index 0000000000..04088ad001 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.baxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/tickfont/_family.py b/plotly/validators/layout/ternary/baxis/tickfont/_family.py new file mode 100644 index 0000000000..7ae0cf3f74 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.baxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/tickfont/_size.py b/plotly/validators/layout/ternary/baxis/tickfont/_size.py new file mode 100644 index 0000000000..76465822b6 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.baxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/tickformatstop/__init__.py b/plotly/validators/layout/ternary/baxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/ternary/baxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/ternary/baxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..6269ecdb4c --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.ternary.baxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/tickformatstop/_value.py b/plotly/validators/layout/ternary/baxis/tickformatstop/_value.py new file mode 100644 index 0000000000..b1eebb1c05 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.ternary.baxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/titlefont/__init__.py b/plotly/validators/layout/ternary/baxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/baxis/titlefont/_color.py b/plotly/validators/layout/ternary/baxis/titlefont/_color.py new file mode 100644 index 0000000000..af517b764b --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.baxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/titlefont/_family.py b/plotly/validators/layout/ternary/baxis/titlefont/_family.py new file mode 100644 index 0000000000..0f43c4396a --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.baxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/baxis/titlefont/_size.py b/plotly/validators/layout/ternary/baxis/titlefont/_size.py new file mode 100644 index 0000000000..77c2f95781 --- /dev/null +++ b/plotly/validators/layout/ternary/baxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.baxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/__init__.py b/plotly/validators/layout/ternary/caxis/__init__.py new file mode 100644 index 0000000000..5160bfc643 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/__init__.py @@ -0,0 +1,36 @@ +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._nticks import NticksValidator +from ._min import MinValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/caxis/_color.py b/plotly/validators/layout/ternary/caxis/_color.py new file mode 100644 index 0000000000..5f0fff69f3 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_dtick.py b/plotly/validators/layout/ternary/caxis/_dtick.py new file mode 100644 index 0000000000..16afac0e07 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_exponentformat.py b/plotly/validators/layout/ternary/caxis/_exponentformat.py new file mode 100644 index 0000000000..aefd4c6579 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_gridcolor.py b/plotly/validators/layout/ternary/caxis/_gridcolor.py new file mode 100644 index 0000000000..cb8e6e6db5 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_gridcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='gridcolor', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_gridwidth.py b/plotly/validators/layout/ternary/caxis/_gridwidth.py new file mode 100644 index 0000000000..cfb689b045 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_gridwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='gridwidth', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_hoverformat.py b/plotly/validators/layout/ternary/caxis/_hoverformat.py new file mode 100644 index 0000000000..8203aebb43 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_hoverformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='hoverformat', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_layer.py b/plotly/validators/layout/ternary/caxis/_layer.py new file mode 100644 index 0000000000..2f59d031da --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_layer.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='layer', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_linecolor.py b/plotly/validators/layout/ternary/caxis/_linecolor.py new file mode 100644 index 0000000000..7002836945 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_linecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='linecolor', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_linewidth.py b/plotly/validators/layout/ternary/caxis/_linewidth.py new file mode 100644 index 0000000000..10f7e82791 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_linewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='linewidth', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_min.py b/plotly/validators/layout/ternary/caxis/_min.py new file mode 100644 index 0000000000..ccaebbc6d3 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_min.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MinValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='min', parent_name='layout.ternary.caxis', **kwargs + ): + super(MinValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_nticks.py b/plotly/validators/layout/ternary/caxis/_nticks.py new file mode 100644 index 0000000000..a62c2cfc8f --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_separatethousands.py b/plotly/validators/layout/ternary/caxis/_separatethousands.py new file mode 100644 index 0000000000..bc5db6e317 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showexponent.py b/plotly/validators/layout/ternary/caxis/_showexponent.py new file mode 100644 index 0000000000..9c90d3a0a5 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showgrid.py b/plotly/validators/layout/ternary/caxis/_showgrid.py new file mode 100644 index 0000000000..d6ac7db511 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showgrid.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showgrid', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showline.py b/plotly/validators/layout/ternary/caxis/_showline.py new file mode 100644 index 0000000000..4037b6290b --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showline.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showline', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showticklabels.py b/plotly/validators/layout/ternary/caxis/_showticklabels.py new file mode 100644 index 0000000000..1901c31bc8 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showtickprefix.py b/plotly/validators/layout/ternary/caxis/_showtickprefix.py new file mode 100644 index 0000000000..2ff314369b --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_showticksuffix.py b/plotly/validators/layout/ternary/caxis/_showticksuffix.py new file mode 100644 index 0000000000..99e77ec707 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tick0.py b/plotly/validators/layout/ternary/caxis/_tick0.py new file mode 100644 index 0000000000..e3b637e8ef --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickangle.py b/plotly/validators/layout/ternary/caxis/_tickangle.py new file mode 100644 index 0000000000..291d15d716 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickcolor.py b/plotly/validators/layout/ternary/caxis/_tickcolor.py new file mode 100644 index 0000000000..e670cbd2b5 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickfont.py b/plotly/validators/layout/ternary/caxis/_tickfont.py new file mode 100644 index 0000000000..e81383a58c --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickformat.py b/plotly/validators/layout/ternary/caxis/_tickformat.py new file mode 100644 index 0000000000..96324f181a --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickformatstops.py b/plotly/validators/layout/ternary/caxis/_tickformatstops.py new file mode 100644 index 0000000000..da00f635d5 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_ticklen.py b/plotly/validators/layout/ternary/caxis/_ticklen.py new file mode 100644 index 0000000000..665e4bddbc --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickmode.py b/plotly/validators/layout/ternary/caxis/_tickmode.py new file mode 100644 index 0000000000..a4fe018a0c --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickprefix.py b/plotly/validators/layout/ternary/caxis/_tickprefix.py new file mode 100644 index 0000000000..4c11381469 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_ticks.py b/plotly/validators/layout/ternary/caxis/_ticks.py new file mode 100644 index 0000000000..f66a5b7f3f --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_ticksuffix.py b/plotly/validators/layout/ternary/caxis/_ticksuffix.py new file mode 100644 index 0000000000..6131feeae0 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_ticktext.py b/plotly/validators/layout/ternary/caxis/_ticktext.py new file mode 100644 index 0000000000..925ec1f1e3 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_ticktextsrc.py b/plotly/validators/layout/ternary/caxis/_ticktextsrc.py new file mode 100644 index 0000000000..c91d693a48 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickvals.py b/plotly/validators/layout/ternary/caxis/_tickvals.py new file mode 100644 index 0000000000..35a4558d98 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickvalssrc.py b/plotly/validators/layout/ternary/caxis/_tickvalssrc.py new file mode 100644 index 0000000000..3bc58d1f6c --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_tickwidth.py b/plotly/validators/layout/ternary/caxis/_tickwidth.py new file mode 100644 index 0000000000..0471d0cd38 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_title.py b/plotly/validators/layout/ternary/caxis/_title.py new file mode 100644 index 0000000000..35f1193eb7 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/_titlefont.py b/plotly/validators/layout/ternary/caxis/_titlefont.py new file mode 100644 index 0000000000..7b065adae9 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='layout.ternary.caxis', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/tickfont/__init__.py b/plotly/validators/layout/ternary/caxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/caxis/tickfont/_color.py b/plotly/validators/layout/ternary/caxis/tickfont/_color.py new file mode 100644 index 0000000000..a9e8aec730 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.caxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/tickfont/_family.py b/plotly/validators/layout/ternary/caxis/tickfont/_family.py new file mode 100644 index 0000000000..27d19f1d48 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.caxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/tickfont/_size.py b/plotly/validators/layout/ternary/caxis/tickfont/_size.py new file mode 100644 index 0000000000..6c8d59b34f --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.caxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/tickformatstop/__init__.py b/plotly/validators/layout/ternary/caxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/ternary/caxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/ternary/caxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..2f6af43c74 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.ternary.caxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/tickformatstop/_value.py b/plotly/validators/layout/ternary/caxis/tickformatstop/_value.py new file mode 100644 index 0000000000..506f864a76 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.ternary.caxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/titlefont/__init__.py b/plotly/validators/layout/ternary/caxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/ternary/caxis/titlefont/_color.py b/plotly/validators/layout/ternary/caxis/titlefont/_color.py new file mode 100644 index 0000000000..98db7cd7cc --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.ternary.caxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/titlefont/_family.py b/plotly/validators/layout/ternary/caxis/titlefont/_family.py new file mode 100644 index 0000000000..2f2ee2c616 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.ternary.caxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/ternary/caxis/titlefont/_size.py b/plotly/validators/layout/ternary/caxis/titlefont/_size.py new file mode 100644 index 0000000000..f18c706c30 --- /dev/null +++ b/plotly/validators/layout/ternary/caxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.ternary.caxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/domain/__init__.py b/plotly/validators/layout/ternary/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/layout/ternary/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/layout/ternary/domain/_column.py b/plotly/validators/layout/ternary/domain/_column.py new file mode 100644 index 0000000000..b544391c86 --- /dev/null +++ b/plotly/validators/layout/ternary/domain/_column.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='column', + parent_name='layout.ternary.domain', + **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/domain/_row.py b/plotly/validators/layout/ternary/domain/_row.py new file mode 100644 index 0000000000..6afb3a6aa3 --- /dev/null +++ b/plotly/validators/layout/ternary/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='layout.ternary.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/domain/_x.py b/plotly/validators/layout/ternary/domain/_x.py new file mode 100644 index 0000000000..430d5927c1 --- /dev/null +++ b/plotly/validators/layout/ternary/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.ternary.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/ternary/domain/_y.py b/plotly/validators/layout/ternary/domain/_y.py new file mode 100644 index 0000000000..2bdfd672f3 --- /dev/null +++ b/plotly/validators/layout/ternary/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.ternary.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/titlefont/__init__.py b/plotly/validators/layout/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/titlefont/_color.py b/plotly/validators/layout/titlefont/_color.py new file mode 100644 index 0000000000..85d3ef705e --- /dev/null +++ b/plotly/validators/layout/titlefont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.titlefont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/titlefont/_family.py b/plotly/validators/layout/titlefont/_family.py new file mode 100644 index 0000000000..1380a45854 --- /dev/null +++ b/plotly/validators/layout/titlefont/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='layout.titlefont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/titlefont/_size.py b/plotly/validators/layout/titlefont/_size.py new file mode 100644 index 0000000000..4ddbee6a6e --- /dev/null +++ b/plotly/validators/layout/titlefont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='layout.titlefont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/__init__.py b/plotly/validators/layout/updatemenu/__init__.py new file mode 100644 index 0000000000..76f0507fec --- /dev/null +++ b/plotly/validators/layout/updatemenu/__init__.py @@ -0,0 +1,15 @@ +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._showactive import ShowactiveValidator +from ._pad import PadValidator +from ._font import FontValidator +from ._direction import DirectionValidator +from ._buttons import ButtonsValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._active import ActiveValidator diff --git a/plotly/validators/layout/updatemenu/_active.py b/plotly/validators/layout/updatemenu/_active.py new file mode 100644 index 0000000000..e1f5fd239b --- /dev/null +++ b/plotly/validators/layout/updatemenu/_active.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ActiveValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='active', parent_name='layout.updatemenu', **kwargs + ): + super(ActiveValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=-1, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_bgcolor.py b/plotly/validators/layout/updatemenu/_bgcolor.py new file mode 100644 index 0000000000..87220d96b6 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='layout.updatemenu', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_bordercolor.py b/plotly/validators/layout/updatemenu/_bordercolor.py new file mode 100644 index 0000000000..aa624ad840 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.updatemenu', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_borderwidth.py b/plotly/validators/layout/updatemenu/_borderwidth.py new file mode 100644 index 0000000000..5a16f9dba2 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='layout.updatemenu', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_buttons.py b/plotly/validators/layout/updatemenu/_buttons.py new file mode 100644 index 0000000000..13fa2ebf8e --- /dev/null +++ b/plotly/validators/layout/updatemenu/_buttons.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class ButtonsValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, plotly_name='buttons', parent_name='layout.updatemenu', **kwargs + ): + super(ButtonsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Button', + data_docs=""" + args + Sets the arguments values to be passed to the + Plotly method set in `method` on click. + execute + When true, the API method is executed. When + false, all other behaviors are the same and + command execution is skipped. This may be + useful when hooking into, for example, the + `plotly_buttonclicked` method and executing the + API command manually without losing the benefit + of the updatemenu automatically binding to the + state of the plot through the specification of + `method` and `args`. + label + Sets the text label to appear on the button. + method + Sets the Plotly method to be called on click. + If the `skip` method is used, the API + updatemenu will function as normal but will + perform no API calls and will not bind + automatically to state updates. This may be + used to create a component interface and attach + to updatemenu events manually via JavaScript.""", + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_direction.py b/plotly/validators/layout/updatemenu/_direction.py new file mode 100644 index 0000000000..056dff8327 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_direction.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DirectionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='direction', + parent_name='layout.updatemenu', + **kwargs + ): + super(DirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['left', 'right', 'up', 'down'], + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_font.py b/plotly/validators/layout/updatemenu/_font.py new file mode 100644 index 0000000000..46222f4556 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_font.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='layout.updatemenu', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_pad.py b/plotly/validators/layout/updatemenu/_pad.py new file mode 100644 index 0000000000..f67722763c --- /dev/null +++ b/plotly/validators/layout/updatemenu/_pad.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class PadValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='pad', parent_name='layout.updatemenu', **kwargs + ): + super(PadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Pad', + data_docs=""" + b + The amount of padding (in px) along the bottom + of the component. + l + The amount of padding (in px) on the left side + of the component. + r + The amount of padding (in px) on the right side + of the component. + t + The amount of padding (in px) along the top of + the component.""", + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_showactive.py b/plotly/validators/layout/updatemenu/_showactive.py new file mode 100644 index 0000000000..3689dbf352 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_showactive.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowactiveValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showactive', + parent_name='layout.updatemenu', + **kwargs + ): + super(ShowactiveValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_type.py b/plotly/validators/layout/updatemenu/_type.py new file mode 100644 index 0000000000..ce2a0eb08e --- /dev/null +++ b/plotly/validators/layout/updatemenu/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.updatemenu', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['dropdown', 'buttons'], + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_visible.py b/plotly/validators/layout/updatemenu/_visible.py new file mode 100644 index 0000000000..ddbbb842fc --- /dev/null +++ b/plotly/validators/layout/updatemenu/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.updatemenu', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_x.py b/plotly/validators/layout/updatemenu/_x.py new file mode 100644 index 0000000000..cf3c9e56a4 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='layout.updatemenu', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_xanchor.py b/plotly/validators/layout/updatemenu/_xanchor.py new file mode 100644 index 0000000000..d8bf19a691 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='layout.updatemenu', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_y.py b/plotly/validators/layout/updatemenu/_y.py new file mode 100644 index 0000000000..d31b553b48 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='layout.updatemenu', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/_yanchor.py b/plotly/validators/layout/updatemenu/_yanchor.py new file mode 100644 index 0000000000..d37e4e5832 --- /dev/null +++ b/plotly/validators/layout/updatemenu/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='layout.updatemenu', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/button/__init__.py b/plotly/validators/layout/updatemenu/button/__init__.py new file mode 100644 index 0000000000..abd0850a78 --- /dev/null +++ b/plotly/validators/layout/updatemenu/button/__init__.py @@ -0,0 +1,4 @@ +from ._method import MethodValidator +from ._label import LabelValidator +from ._execute import ExecuteValidator +from ._args import ArgsValidator diff --git a/plotly/validators/layout/updatemenu/button/_args.py b/plotly/validators/layout/updatemenu/button/_args.py new file mode 100644 index 0000000000..ecb568d879 --- /dev/null +++ b/plotly/validators/layout/updatemenu/button/_args.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class ArgsValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='args', + parent_name='layout.updatemenu.button', + **kwargs + ): + super(ArgsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + free_length=True, + items=[ + { + 'valType': 'any', + 'editType': 'arraydraw' + }, { + 'valType': 'any', + 'editType': 'arraydraw' + }, { + 'valType': 'any', + 'editType': 'arraydraw' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/button/_execute.py b/plotly/validators/layout/updatemenu/button/_execute.py new file mode 100644 index 0000000000..7f0dfab31b --- /dev/null +++ b/plotly/validators/layout/updatemenu/button/_execute.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ExecuteValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='execute', + parent_name='layout.updatemenu.button', + **kwargs + ): + super(ExecuteValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/button/_label.py b/plotly/validators/layout/updatemenu/button/_label.py new file mode 100644 index 0000000000..900d98fc59 --- /dev/null +++ b/plotly/validators/layout/updatemenu/button/_label.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='label', + parent_name='layout.updatemenu.button', + **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/button/_method.py b/plotly/validators/layout/updatemenu/button/_method.py new file mode 100644 index 0000000000..c78b9214b6 --- /dev/null +++ b/plotly/validators/layout/updatemenu/button/_method.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MethodValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='method', + parent_name='layout.updatemenu.button', + **kwargs + ): + super(MethodValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='info', + values=['restyle', 'relayout', 'animate', 'update', 'skip'], + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/font/__init__.py b/plotly/validators/layout/updatemenu/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/updatemenu/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/updatemenu/font/_color.py b/plotly/validators/layout/updatemenu/font/_color.py new file mode 100644 index 0000000000..37a02d6323 --- /dev/null +++ b/plotly/validators/layout/updatemenu/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.updatemenu.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/font/_family.py b/plotly/validators/layout/updatemenu/font/_family.py new file mode 100644 index 0000000000..ccab0cddaa --- /dev/null +++ b/plotly/validators/layout/updatemenu/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.updatemenu.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/font/_size.py b/plotly/validators/layout/updatemenu/font/_size.py new file mode 100644 index 0000000000..67121f2c96 --- /dev/null +++ b/plotly/validators/layout/updatemenu/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.updatemenu.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/pad/__init__.py b/plotly/validators/layout/updatemenu/pad/__init__.py new file mode 100644 index 0000000000..f2aa8ac13b --- /dev/null +++ b/plotly/validators/layout/updatemenu/pad/__init__.py @@ -0,0 +1,4 @@ +from ._t import TValidator +from ._r import RValidator +from ._l import LValidator +from ._b import BValidator diff --git a/plotly/validators/layout/updatemenu/pad/_b.py b/plotly/validators/layout/updatemenu/pad/_b.py new file mode 100644 index 0000000000..9a97a3154e --- /dev/null +++ b/plotly/validators/layout/updatemenu/pad/_b.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='b', parent_name='layout.updatemenu.pad', **kwargs + ): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/pad/_l.py b/plotly/validators/layout/updatemenu/pad/_l.py new file mode 100644 index 0000000000..7fa5d5626d --- /dev/null +++ b/plotly/validators/layout/updatemenu/pad/_l.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='l', parent_name='layout.updatemenu.pad', **kwargs + ): + super(LValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/pad/_r.py b/plotly/validators/layout/updatemenu/pad/_r.py new file mode 100644 index 0000000000..4e67b17b1f --- /dev/null +++ b/plotly/validators/layout/updatemenu/pad/_r.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='r', parent_name='layout.updatemenu.pad', **kwargs + ): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/updatemenu/pad/_t.py b/plotly/validators/layout/updatemenu/pad/_t.py new file mode 100644 index 0000000000..9d0bcd91c2 --- /dev/null +++ b/plotly/validators/layout/updatemenu/pad/_t.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='t', parent_name='layout.updatemenu.pad', **kwargs + ): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='arraydraw', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/__init__.py b/plotly/validators/layout/xaxis/__init__.py new file mode 100644 index 0000000000..4af4c7585f --- /dev/null +++ b/plotly/validators/layout/xaxis/__init__.py @@ -0,0 +1,67 @@ +from ._zerolinewidth import ZerolinewidthValidator +from ._zerolinecolor import ZerolinecolorValidator +from ._zeroline import ZerolineValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._spikethickness import SpikethicknessValidator +from ._spikesnap import SpikesnapValidator +from ._spikemode import SpikemodeValidator +from ._spikedash import SpikedashValidator +from ._spikecolor import SpikecolorValidator +from ._side import SideValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showspikes import ShowspikesValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._scaleratio import ScaleratioValidator +from ._scaleanchor import ScaleanchorValidator +from ._rangeslider import RangesliderValidator +from ._rangeselector import RangeselectorValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._position import PositionValidator +from ._overlaying import OverlayingValidator +from ._nticks import NticksValidator +from ._mirror import MirrorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._fixedrange import FixedrangeValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._domain import DomainValidator +from ._constraintoward import ConstraintowardValidator +from ._constrain import ConstrainValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._autorange import AutorangeValidator +from ._automargin import AutomarginValidator +from ._anchor import AnchorValidator diff --git a/plotly/validators/layout/xaxis/_anchor.py b/plotly/validators/layout/xaxis/_anchor.py new file mode 100644 index 0000000000..8c8d2594fe --- /dev/null +++ b/plotly/validators/layout/xaxis/_anchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AnchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='anchor', parent_name='layout.xaxis', **kwargs + ): + super(AnchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + role='info', + values=[ + 'free', '/^x([2-9]|[1-9][0-9]+)?$/', + '/^y([2-9]|[1-9][0-9]+)?$/' + ], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_automargin.py b/plotly/validators/layout/xaxis/_automargin.py new file mode 100644 index 0000000000..3e98e746fe --- /dev/null +++ b/plotly/validators/layout/xaxis/_automargin.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AutomarginValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='automargin', parent_name='layout.xaxis', **kwargs + ): + super(AutomarginValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_autorange.py b/plotly/validators/layout/xaxis/_autorange.py new file mode 100644 index 0000000000..dfade1cbd8 --- /dev/null +++ b/plotly/validators/layout/xaxis/_autorange.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='autorange', parent_name='layout.xaxis', **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_calendar.py b/plotly/validators/layout/xaxis/_calendar.py new file mode 100644 index 0000000000..533fb45526 --- /dev/null +++ b/plotly/validators/layout/xaxis/_calendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='calendar', parent_name='layout.xaxis', **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_categoryarray.py b/plotly/validators/layout/xaxis/_categoryarray.py new file mode 100644 index 0000000000..da2c037bc4 --- /dev/null +++ b/plotly/validators/layout/xaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.xaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_categoryarraysrc.py b/plotly/validators/layout/xaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..4835a61871 --- /dev/null +++ b/plotly/validators/layout/xaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.xaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_categoryorder.py b/plotly/validators/layout/xaxis/_categoryorder.py new file mode 100644 index 0000000000..198f67e2ab --- /dev/null +++ b/plotly/validators/layout/xaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.xaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_color.py b/plotly/validators/layout/xaxis/_color.py new file mode 100644 index 0000000000..ad3b5e5d20 --- /dev/null +++ b/plotly/validators/layout/xaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.xaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_constrain.py b/plotly/validators/layout/xaxis/_constrain.py new file mode 100644 index 0000000000..ff14c1d4c3 --- /dev/null +++ b/plotly/validators/layout/xaxis/_constrain.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ConstrainValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='constrain', parent_name='layout.xaxis', **kwargs + ): + super(ConstrainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['range', 'domain'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_constraintoward.py b/plotly/validators/layout/xaxis/_constraintoward.py new file mode 100644 index 0000000000..3b0ab33a40 --- /dev/null +++ b/plotly/validators/layout/xaxis/_constraintoward.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ConstraintowardValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='constraintoward', + parent_name='layout.xaxis', + **kwargs + ): + super(ConstraintowardValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['left', 'center', 'right', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_domain.py b/plotly/validators/layout/xaxis/_domain.py new file mode 100644 index 0000000000..c71a3ff0b2 --- /dev/null +++ b/plotly/validators/layout/xaxis/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.xaxis', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot+margins' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot+margins' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_dtick.py b/plotly/validators/layout/xaxis/_dtick.py new file mode 100644 index 0000000000..1d6a76d040 --- /dev/null +++ b/plotly/validators/layout/xaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.xaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_exponentformat.py b/plotly/validators/layout/xaxis/_exponentformat.py new file mode 100644 index 0000000000..8b87398881 --- /dev/null +++ b/plotly/validators/layout/xaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.xaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_fixedrange.py b/plotly/validators/layout/xaxis/_fixedrange.py new file mode 100644 index 0000000000..c3eae04f17 --- /dev/null +++ b/plotly/validators/layout/xaxis/_fixedrange.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FixedrangeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='fixedrange', parent_name='layout.xaxis', **kwargs + ): + super(FixedrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_gridcolor.py b/plotly/validators/layout/xaxis/_gridcolor.py new file mode 100644 index 0000000000..8de1c9b76a --- /dev/null +++ b/plotly/validators/layout/xaxis/_gridcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='gridcolor', parent_name='layout.xaxis', **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_gridwidth.py b/plotly/validators/layout/xaxis/_gridwidth.py new file mode 100644 index 0000000000..de98ef003e --- /dev/null +++ b/plotly/validators/layout/xaxis/_gridwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='gridwidth', parent_name='layout.xaxis', **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_hoverformat.py b/plotly/validators/layout/xaxis/_hoverformat.py new file mode 100644 index 0000000000..2da7907fc8 --- /dev/null +++ b/plotly/validators/layout/xaxis/_hoverformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hoverformat', parent_name='layout.xaxis', **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_layer.py b/plotly/validators/layout/xaxis/_layer.py new file mode 100644 index 0000000000..434ac62673 --- /dev/null +++ b/plotly/validators/layout/xaxis/_layer.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='layer', parent_name='layout.xaxis', **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_linecolor.py b/plotly/validators/layout/xaxis/_linecolor.py new file mode 100644 index 0000000000..311c32831f --- /dev/null +++ b/plotly/validators/layout/xaxis/_linecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='linecolor', parent_name='layout.xaxis', **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_linewidth.py b/plotly/validators/layout/xaxis/_linewidth.py new file mode 100644 index 0000000000..633a6f03ff --- /dev/null +++ b/plotly/validators/layout/xaxis/_linewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='linewidth', parent_name='layout.xaxis', **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+layoutstyle', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_mirror.py b/plotly/validators/layout/xaxis/_mirror.py new file mode 100644 index 0000000000..5a35ada1ff --- /dev/null +++ b/plotly/validators/layout/xaxis/_mirror.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MirrorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='mirror', parent_name='layout.xaxis', **kwargs + ): + super(MirrorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+layoutstyle', + role='style', + values=[True, 'ticks', False, 'all', 'allticks'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_nticks.py b/plotly/validators/layout/xaxis/_nticks.py new file mode 100644 index 0000000000..979c838f40 --- /dev/null +++ b/plotly/validators/layout/xaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='layout.xaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_overlaying.py b/plotly/validators/layout/xaxis/_overlaying.py new file mode 100644 index 0000000000..1d941ea1e5 --- /dev/null +++ b/plotly/validators/layout/xaxis/_overlaying.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OverlayingValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='overlaying', parent_name='layout.xaxis', **kwargs + ): + super(OverlayingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'free', '/^x([2-9]|[1-9][0-9]+)?$/', + '/^y([2-9]|[1-9][0-9]+)?$/' + ], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_position.py b/plotly/validators/layout/xaxis/_position.py new file mode 100644 index 0000000000..f39da08f26 --- /dev/null +++ b/plotly/validators/layout/xaxis/_position.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class PositionValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='position', parent_name='layout.xaxis', **kwargs + ): + super(PositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_range.py b/plotly/validators/layout/xaxis/_range.py new file mode 100644 index 0000000000..fda22d9f28 --- /dev/null +++ b/plotly/validators/layout/xaxis/_range.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.xaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='axrange+margins', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_rangemode.py b/plotly/validators/layout/xaxis/_rangemode.py new file mode 100644 index 0000000000..d570e7f197 --- /dev/null +++ b/plotly/validators/layout/xaxis/_rangemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='rangemode', parent_name='layout.xaxis', **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_rangeselector.py b/plotly/validators/layout/xaxis/_rangeselector.py new file mode 100644 index 0000000000..6a40a9a18d --- /dev/null +++ b/plotly/validators/layout/xaxis/_rangeselector.py @@ -0,0 +1,58 @@ +import _plotly_utils.basevalidators + + +class RangeselectorValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='rangeselector', + parent_name='layout.xaxis', + **kwargs + ): + super(RangeselectorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Rangeselector', + data_docs=""" + activecolor + Sets the background color of the active range + selector button. + bgcolor + Sets the background color of the range selector + buttons. + bordercolor + Sets the color of the border enclosing the + range selector. + borderwidth + Sets the width (in px) of the border enclosing + the range selector. + buttons + Sets the specifications for each buttons. By + default, a range selector comes with no + buttons. + font + Sets the font of the range selector button + text. + visible + Determines whether or not this range selector + is visible. Note that range selectors are only + available for x axes of `type` set to or auto- + typed to *date*. + x + Sets the x position (in normalized coordinates) + of the range selector. + xanchor + Sets the range selector's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the range + selector. + y + Sets the y position (in normalized coordinates) + of the range selector. + yanchor + Sets the range selector's vertical position + anchor This anchor binds the `y` position to + the *top*, *middle* or *bottom* of the range + selector.""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_rangeslider.py b/plotly/validators/layout/xaxis/_rangeslider.py new file mode 100644 index 0000000000..089c19ed16 --- /dev/null +++ b/plotly/validators/layout/xaxis/_rangeslider.py @@ -0,0 +1,48 @@ +import _plotly_utils.basevalidators + + +class RangesliderValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='rangeslider', parent_name='layout.xaxis', **kwargs + ): + super(RangesliderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Rangeslider', + data_docs=""" + autorange + Determines whether or not the range slider + range is computed in relation to the input + data. If `range` is provided, then `autorange` + is set to *false*. + bgcolor + Sets the background color of the range slider. + bordercolor + Sets the border color of the range slider. + borderwidth + Sets the border color of the range slider. + range + Sets the range of the range slider. If not set, + defaults to the full xaxis range. If the axis + `type` is *log*, then you must take the log of + your desired range. If the axis `type` is + *date*, it should be date strings, like date + data, though Date objects and unix milliseconds + will be accepted and converted to strings. If + the axis `type` is *category*, it should be + numbers, using the scale where each category is + assigned a serial number from zero in the order + it appears. + thickness + The height of the range slider as a fraction of + the total plot area height. + visible + Determines whether or not the range slider will + be visible. If visible, perpendicular axes will + be set to `fixedrange` + yaxis + plotly.graph_objs.layout.xaxis.rangeslider.YAxi + s instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_scaleanchor.py b/plotly/validators/layout/xaxis/_scaleanchor.py new file mode 100644 index 0000000000..d857702fc4 --- /dev/null +++ b/plotly/validators/layout/xaxis/_scaleanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ScaleanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='scaleanchor', parent_name='layout.xaxis', **kwargs + ): + super(ScaleanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['/^x([2-9]|[1-9][0-9]+)?$/', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_scaleratio.py b/plotly/validators/layout/xaxis/_scaleratio.py new file mode 100644 index 0000000000..a37ada20f3 --- /dev/null +++ b/plotly/validators/layout/xaxis/_scaleratio.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ScaleratioValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='scaleratio', parent_name='layout.xaxis', **kwargs + ): + super(ScaleratioValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_separatethousands.py b/plotly/validators/layout/xaxis/_separatethousands.py new file mode 100644 index 0000000000..b048e01b2a --- /dev/null +++ b/plotly/validators/layout/xaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.xaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showexponent.py b/plotly/validators/layout/xaxis/_showexponent.py new file mode 100644 index 0000000000..af1e954a57 --- /dev/null +++ b/plotly/validators/layout/xaxis/_showexponent.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='showexponent', parent_name='layout.xaxis', **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showgrid.py b/plotly/validators/layout/xaxis/_showgrid.py new file mode 100644 index 0000000000..08fe363825 --- /dev/null +++ b/plotly/validators/layout/xaxis/_showgrid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showgrid', parent_name='layout.xaxis', **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showline.py b/plotly/validators/layout/xaxis/_showline.py new file mode 100644 index 0000000000..fa30018bdf --- /dev/null +++ b/plotly/validators/layout/xaxis/_showline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showline', parent_name='layout.xaxis', **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showspikes.py b/plotly/validators/layout/xaxis/_showspikes.py new file mode 100644 index 0000000000..24a0a76fd3 --- /dev/null +++ b/plotly/validators/layout/xaxis/_showspikes.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowspikesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showspikes', parent_name='layout.xaxis', **kwargs + ): + super(ShowspikesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='modebar', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showticklabels.py b/plotly/validators/layout/xaxis/_showticklabels.py new file mode 100644 index 0000000000..c279cf19cc --- /dev/null +++ b/plotly/validators/layout/xaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.xaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showtickprefix.py b/plotly/validators/layout/xaxis/_showtickprefix.py new file mode 100644 index 0000000000..25a09bde0e --- /dev/null +++ b/plotly/validators/layout/xaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.xaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_showticksuffix.py b/plotly/validators/layout/xaxis/_showticksuffix.py new file mode 100644 index 0000000000..835521d8ac --- /dev/null +++ b/plotly/validators/layout/xaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.xaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_side.py b/plotly/validators/layout/xaxis/_side.py new file mode 100644 index 0000000000..fe4e7e4755 --- /dev/null +++ b/plotly/validators/layout/xaxis/_side.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='side', parent_name='layout.xaxis', **kwargs + ): + super(SideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + role='info', + values=['top', 'bottom', 'left', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_spikecolor.py b/plotly/validators/layout/xaxis/_spikecolor.py new file mode 100644 index 0000000000..5e7cdfd17c --- /dev/null +++ b/plotly/validators/layout/xaxis/_spikecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SpikecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='spikecolor', parent_name='layout.xaxis', **kwargs + ): + super(SpikecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_spikedash.py b/plotly/validators/layout/xaxis/_spikedash.py new file mode 100644 index 0000000000..076606299a --- /dev/null +++ b/plotly/validators/layout/xaxis/_spikedash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikedashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='spikedash', parent_name='layout.xaxis', **kwargs + ): + super(SpikedashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_spikemode.py b/plotly/validators/layout/xaxis/_spikemode.py new file mode 100644 index 0000000000..d520d78d54 --- /dev/null +++ b/plotly/validators/layout/xaxis/_spikemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SpikemodeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='spikemode', parent_name='layout.xaxis', **kwargs + ): + super(SpikemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + flags=['toaxis', 'across', 'marker'], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_spikesnap.py b/plotly/validators/layout/xaxis/_spikesnap.py new file mode 100644 index 0000000000..81a84da1bf --- /dev/null +++ b/plotly/validators/layout/xaxis/_spikesnap.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SpikesnapValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='spikesnap', parent_name='layout.xaxis', **kwargs + ): + super(SpikesnapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + values=['data', 'cursor'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_spikethickness.py b/plotly/validators/layout/xaxis/_spikethickness.py new file mode 100644 index 0000000000..e6a15c442b --- /dev/null +++ b/plotly/validators/layout/xaxis/_spikethickness.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikethicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='spikethickness', + parent_name='layout.xaxis', + **kwargs + ): + super(SpikethicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tick0.py b/plotly/validators/layout/xaxis/_tick0.py new file mode 100644 index 0000000000..688a6ae95a --- /dev/null +++ b/plotly/validators/layout/xaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.xaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickangle.py b/plotly/validators/layout/xaxis/_tickangle.py new file mode 100644 index 0000000000..16bdbdd08f --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='layout.xaxis', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickcolor.py b/plotly/validators/layout/xaxis/_tickcolor.py new file mode 100644 index 0000000000..621bbb1157 --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='tickcolor', parent_name='layout.xaxis', **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickfont.py b/plotly/validators/layout/xaxis/_tickfont.py new file mode 100644 index 0000000000..f861b9d62c --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='layout.xaxis', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickformat.py b/plotly/validators/layout/xaxis/_tickformat.py new file mode 100644 index 0000000000..0befa7f951 --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickformat', parent_name='layout.xaxis', **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickformatstops.py b/plotly/validators/layout/xaxis/_tickformatstops.py new file mode 100644 index 0000000000..fe5f82a36b --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.xaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_ticklen.py b/plotly/validators/layout/xaxis/_ticklen.py new file mode 100644 index 0000000000..eaf4ee5aef --- /dev/null +++ b/plotly/validators/layout/xaxis/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='layout.xaxis', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickmode.py b/plotly/validators/layout/xaxis/_tickmode.py new file mode 100644 index 0000000000..46d4830d75 --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='layout.xaxis', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickprefix.py b/plotly/validators/layout/xaxis/_tickprefix.py new file mode 100644 index 0000000000..4eeb2895cd --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickprefix', parent_name='layout.xaxis', **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_ticks.py b/plotly/validators/layout/xaxis/_ticks.py new file mode 100644 index 0000000000..c1e2ac6c56 --- /dev/null +++ b/plotly/validators/layout/xaxis/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='layout.xaxis', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_ticksuffix.py b/plotly/validators/layout/xaxis/_ticksuffix.py new file mode 100644 index 0000000000..05d8b1e94a --- /dev/null +++ b/plotly/validators/layout/xaxis/_ticksuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='ticksuffix', parent_name='layout.xaxis', **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_ticktext.py b/plotly/validators/layout/xaxis/_ticktext.py new file mode 100644 index 0000000000..3189505895 --- /dev/null +++ b/plotly/validators/layout/xaxis/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='layout.xaxis', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_ticktextsrc.py b/plotly/validators/layout/xaxis/_ticktextsrc.py new file mode 100644 index 0000000000..fea46d0df3 --- /dev/null +++ b/plotly/validators/layout/xaxis/_ticktextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ticktextsrc', parent_name='layout.xaxis', **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickvals.py b/plotly/validators/layout/xaxis/_tickvals.py new file mode 100644 index 0000000000..1eb6540a83 --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='layout.xaxis', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickvalssrc.py b/plotly/validators/layout/xaxis/_tickvalssrc.py new file mode 100644 index 0000000000..8b38359f00 --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickvalssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='tickvalssrc', parent_name='layout.xaxis', **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_tickwidth.py b/plotly/validators/layout/xaxis/_tickwidth.py new file mode 100644 index 0000000000..5f171b1ecf --- /dev/null +++ b/plotly/validators/layout/xaxis/_tickwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tickwidth', parent_name='layout.xaxis', **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_title.py b/plotly/validators/layout/xaxis/_title.py new file mode 100644 index 0000000000..49b0fa6a97 --- /dev/null +++ b/plotly/validators/layout/xaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='layout.xaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_titlefont.py b/plotly/validators/layout/xaxis/_titlefont.py new file mode 100644 index 0000000000..f57d8ff375 --- /dev/null +++ b/plotly/validators/layout/xaxis/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='layout.xaxis', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_type.py b/plotly/validators/layout/xaxis/_type.py new file mode 100644 index 0000000000..e2be543d56 --- /dev/null +++ b/plotly/validators/layout/xaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.xaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_visible.py b/plotly/validators/layout/xaxis/_visible.py new file mode 100644 index 0000000000..e8da310c79 --- /dev/null +++ b/plotly/validators/layout/xaxis/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.xaxis', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_zeroline.py b/plotly/validators/layout/xaxis/_zeroline.py new file mode 100644 index 0000000000..72021b77c3 --- /dev/null +++ b/plotly/validators/layout/xaxis/_zeroline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZerolineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zeroline', parent_name='layout.xaxis', **kwargs + ): + super(ZerolineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_zerolinecolor.py b/plotly/validators/layout/xaxis/_zerolinecolor.py new file mode 100644 index 0000000000..52af9a239a --- /dev/null +++ b/plotly/validators/layout/xaxis/_zerolinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='zerolinecolor', + parent_name='layout.xaxis', + **kwargs + ): + super(ZerolinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/_zerolinewidth.py b/plotly/validators/layout/xaxis/_zerolinewidth.py new file mode 100644 index 0000000000..79711a48ba --- /dev/null +++ b/plotly/validators/layout/xaxis/_zerolinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='zerolinewidth', + parent_name='layout.xaxis', + **kwargs + ): + super(ZerolinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/__init__.py b/plotly/validators/layout/xaxis/rangeselector/__init__.py new file mode 100644 index 0000000000..2f846ea48d --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/__init__.py @@ -0,0 +1,11 @@ +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._font import FontValidator +from ._buttons import ButtonsValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._activecolor import ActivecolorValidator diff --git a/plotly/validators/layout/xaxis/rangeselector/_activecolor.py b/plotly/validators/layout/xaxis/rangeselector/_activecolor.py new file mode 100644 index 0000000000..5a64c525b0 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_activecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ActivecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='activecolor', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(ActivecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_bgcolor.py b/plotly/validators/layout/xaxis/rangeselector/_bgcolor.py new file mode 100644 index 0000000000..3ac9e6adf4 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_bordercolor.py b/plotly/validators/layout/xaxis/rangeselector/_bordercolor.py new file mode 100644 index 0000000000..34ab202d44 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_borderwidth.py b/plotly/validators/layout/xaxis/rangeselector/_borderwidth.py new file mode 100644 index 0000000000..b9576f12ed --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_buttons.py b/plotly/validators/layout/xaxis/rangeselector/_buttons.py new file mode 100644 index 0000000000..3d7b955e80 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_buttons.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class ButtonsValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, + plotly_name='buttons', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(ButtonsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Button', + data_docs=""" + count + Sets the number of steps to take to update the + range. Use with `step` to specify the update + interval. + label + Sets the text label to appear on the button. + step + The unit of measurement that the `count` value + will set the range by. + stepmode + Sets the range update mode. If *backward*, the + range update shifts the start of range back + *count* times *step* milliseconds. If *todate*, + the range update shifts the start of range back + to the first timestamp from *count* times + *step* milliseconds back. For example, with + `step` set to *year* and `count` set to *1* the + range update shifts the start of the range back + to January 01 of the current year. Month and + year *todate* are currently available only for + the built-in (Gregorian) calendar.""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_font.py b/plotly/validators/layout/xaxis/rangeselector/_font.py new file mode 100644 index 0000000000..1a09921c6c --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_font.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_visible.py b/plotly/validators/layout/xaxis/rangeselector/_visible.py new file mode 100644 index 0000000000..c41edd0362 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_x.py b/plotly/validators/layout/xaxis/rangeselector/_x.py new file mode 100644 index 0000000000..3a3878b90b --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_xanchor.py b/plotly/validators/layout/xaxis/rangeselector/_xanchor.py new file mode 100644 index 0000000000..a67aebbe2c --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['auto', 'left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_y.py b/plotly/validators/layout/xaxis/rangeselector/_y.py new file mode 100644 index 0000000000..b5dd6879e7 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/_yanchor.py b/plotly/validators/layout/xaxis/rangeselector/_yanchor.py new file mode 100644 index 0000000000..9b5f188a5f --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='layout.xaxis.rangeselector', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['auto', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/button/__init__.py b/plotly/validators/layout/xaxis/rangeselector/button/__init__.py new file mode 100644 index 0000000000..e89e82ffb7 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/button/__init__.py @@ -0,0 +1,4 @@ +from ._stepmode import StepmodeValidator +from ._step import StepValidator +from ._label import LabelValidator +from ._count import CountValidator diff --git a/plotly/validators/layout/xaxis/rangeselector/button/_count.py b/plotly/validators/layout/xaxis/rangeselector/button/_count.py new file mode 100644 index 0000000000..5e513293c0 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/button/_count.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CountValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='count', + parent_name='layout.xaxis.rangeselector.button', + **kwargs + ): + super(CountValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/button/_label.py b/plotly/validators/layout/xaxis/rangeselector/button/_label.py new file mode 100644 index 0000000000..660ec719cb --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/button/_label.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='label', + parent_name='layout.xaxis.rangeselector.button', + **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/button/_step.py b/plotly/validators/layout/xaxis/rangeselector/button/_step.py new file mode 100644 index 0000000000..6ceb3d438e --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/button/_step.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StepValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='step', + parent_name='layout.xaxis.rangeselector.button', + **kwargs + ): + super(StepValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['month', 'year', 'day', 'hour', 'minute', 'second', 'all'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/button/_stepmode.py b/plotly/validators/layout/xaxis/rangeselector/button/_stepmode.py new file mode 100644 index 0000000000..64cc451271 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/button/_stepmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class StepmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='stepmode', + parent_name='layout.xaxis.rangeselector.button', + **kwargs + ): + super(StepmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['backward', 'todate'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/font/__init__.py b/plotly/validators/layout/xaxis/rangeselector/font/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/font/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/xaxis/rangeselector/font/_color.py b/plotly/validators/layout/xaxis/rangeselector/font/_color.py new file mode 100644 index 0000000000..80034b026e --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/font/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.xaxis.rangeselector.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/font/_family.py b/plotly/validators/layout/xaxis/rangeselector/font/_family.py new file mode 100644 index 0000000000..92260ba6a7 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/font/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.xaxis.rangeselector.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeselector/font/_size.py b/plotly/validators/layout/xaxis/rangeselector/font/_size.py new file mode 100644 index 0000000000..fb0d1a805b --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeselector/font/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.xaxis.rangeselector.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/__init__.py b/plotly/validators/layout/xaxis/rangeslider/__init__.py new file mode 100644 index 0000000000..f8e02bfe7f --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/__init__.py @@ -0,0 +1,8 @@ +from ._yaxis import YAxisValidator +from ._visible import VisibleValidator +from ._thickness import ThicknessValidator +from ._range import RangeValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator +from ._autorange import AutorangeValidator diff --git a/plotly/validators/layout/xaxis/rangeslider/_autorange.py b/plotly/validators/layout/xaxis/rangeslider/_autorange.py new file mode 100644 index 0000000000..13225205e6 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_autorange.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autorange', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_bgcolor.py b/plotly/validators/layout/xaxis/rangeslider/_bgcolor.py new file mode 100644 index 0000000000..15ddbbfe07 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_bordercolor.py b/plotly/validators/layout/xaxis/rangeslider/_bordercolor.py new file mode 100644 index 0000000000..54c27f9bbe --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_borderwidth.py b/plotly/validators/layout/xaxis/rangeslider/_borderwidth.py new file mode 100644 index 0000000000..1b7f1ae61d --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_range.py b/plotly/validators/layout/xaxis/rangeslider/_range.py new file mode 100644 index 0000000000..c5ab15441c --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_range.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='range', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'calc', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'calc', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_thickness.py b/plotly/validators/layout/xaxis/rangeslider/_thickness.py new file mode 100644 index 0000000000..f135c06b99 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_thickness.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_visible.py b/plotly/validators/layout/xaxis/rangeslider/_visible.py new file mode 100644 index 0000000000..e6ec6c6c77 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/_yaxis.py b/plotly/validators/layout/xaxis/rangeslider/_yaxis.py new file mode 100644 index 0000000000..e465355b86 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/_yaxis.py @@ -0,0 +1,29 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='yaxis', + parent_name='layout.xaxis.rangeslider', + **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='YAxis', + data_docs=""" + range + Sets the range of this axis for the + rangeslider. + rangemode + Determines whether or not the range of this + axis in the rangeslider use the same value than + in the main plot when zooming in/out. If + *auto*, the autorange will be used. If *fixed*, + the `range` is used. If *match*, the current + range of the corresponding y-axis on the main + subplot is used.""", + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/yaxis/__init__.py b/plotly/validators/layout/xaxis/rangeslider/yaxis/__init__.py new file mode 100644 index 0000000000..37e0eeb340 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/yaxis/__init__.py @@ -0,0 +1,2 @@ +from ._rangemode import RangemodeValidator +from ._range import RangeValidator diff --git a/plotly/validators/layout/xaxis/rangeslider/yaxis/_range.py b/plotly/validators/layout/xaxis/rangeslider/yaxis/_range.py new file mode 100644 index 0000000000..84003e2710 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/yaxis/_range.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='range', + parent_name='layout.xaxis.rangeslider.yaxis', + **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + items=[ + { + 'valType': 'any', + 'editType': 'plot' + }, { + 'valType': 'any', + 'editType': 'plot' + } + ], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/rangeslider/yaxis/_rangemode.py b/plotly/validators/layout/xaxis/rangeslider/yaxis/_rangemode.py new file mode 100644 index 0000000000..86956f3193 --- /dev/null +++ b/plotly/validators/layout/xaxis/rangeslider/yaxis/_rangemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='rangemode', + parent_name='layout.xaxis.rangeslider.yaxis', + **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['auto', 'fixed', 'match'], + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/tickfont/__init__.py b/plotly/validators/layout/xaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/xaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/xaxis/tickfont/_color.py b/plotly/validators/layout/xaxis/tickfont/_color.py new file mode 100644 index 0000000000..8956894232 --- /dev/null +++ b/plotly/validators/layout/xaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.xaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/tickfont/_family.py b/plotly/validators/layout/xaxis/tickfont/_family.py new file mode 100644 index 0000000000..df27e9a59f --- /dev/null +++ b/plotly/validators/layout/xaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.xaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/tickfont/_size.py b/plotly/validators/layout/xaxis/tickfont/_size.py new file mode 100644 index 0000000000..eb299db667 --- /dev/null +++ b/plotly/validators/layout/xaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.xaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/tickformatstop/__init__.py b/plotly/validators/layout/xaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/xaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/xaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/xaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..2e4debd349 --- /dev/null +++ b/plotly/validators/layout/xaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.xaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + items=[ + { + 'valType': 'any', + 'editType': 'ticks+margins' + }, { + 'valType': 'any', + 'editType': 'ticks+margins' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/tickformatstop/_value.py b/plotly/validators/layout/xaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..28c219be31 --- /dev/null +++ b/plotly/validators/layout/xaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.xaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/titlefont/__init__.py b/plotly/validators/layout/xaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/xaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/xaxis/titlefont/_color.py b/plotly/validators/layout/xaxis/titlefont/_color.py new file mode 100644 index 0000000000..ca0e554694 --- /dev/null +++ b/plotly/validators/layout/xaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.xaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/titlefont/_family.py b/plotly/validators/layout/xaxis/titlefont/_family.py new file mode 100644 index 0000000000..fd2d76e9b1 --- /dev/null +++ b/plotly/validators/layout/xaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.xaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/xaxis/titlefont/_size.py b/plotly/validators/layout/xaxis/titlefont/_size.py new file mode 100644 index 0000000000..d8ee8c5840 --- /dev/null +++ b/plotly/validators/layout/xaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.xaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/__init__.py b/plotly/validators/layout/yaxis/__init__.py new file mode 100644 index 0000000000..c927e92e2a --- /dev/null +++ b/plotly/validators/layout/yaxis/__init__.py @@ -0,0 +1,65 @@ +from ._zerolinewidth import ZerolinewidthValidator +from ._zerolinecolor import ZerolinecolorValidator +from ._zeroline import ZerolineValidator +from ._visible import VisibleValidator +from ._type import TypeValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._spikethickness import SpikethicknessValidator +from ._spikesnap import SpikesnapValidator +from ._spikemode import SpikemodeValidator +from ._spikedash import SpikedashValidator +from ._spikecolor import SpikecolorValidator +from ._side import SideValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showspikes import ShowspikesValidator +from ._showline import ShowlineValidator +from ._showgrid import ShowgridValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._scaleratio import ScaleratioValidator +from ._scaleanchor import ScaleanchorValidator +from ._rangemode import RangemodeValidator +from ._range import RangeValidator +from ._position import PositionValidator +from ._overlaying import OverlayingValidator +from ._nticks import NticksValidator +from ._mirror import MirrorValidator +from ._linewidth import LinewidthValidator +from ._linecolor import LinecolorValidator +from ._layer import LayerValidator +from ._hoverformat import HoverformatValidator +from ._gridwidth import GridwidthValidator +from ._gridcolor import GridcolorValidator +from ._fixedrange import FixedrangeValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._domain import DomainValidator +from ._constraintoward import ConstraintowardValidator +from ._constrain import ConstrainValidator +from ._color import ColorValidator +from ._categoryorder import CategoryorderValidator +from ._categoryarraysrc import CategoryarraysrcValidator +from ._categoryarray import CategoryarrayValidator +from ._calendar import CalendarValidator +from ._autorange import AutorangeValidator +from ._automargin import AutomarginValidator +from ._anchor import AnchorValidator diff --git a/plotly/validators/layout/yaxis/_anchor.py b/plotly/validators/layout/yaxis/_anchor.py new file mode 100644 index 0000000000..6cc09c6ac1 --- /dev/null +++ b/plotly/validators/layout/yaxis/_anchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AnchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='anchor', parent_name='layout.yaxis', **kwargs + ): + super(AnchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + role='info', + values=[ + 'free', '/^x([2-9]|[1-9][0-9]+)?$/', + '/^y([2-9]|[1-9][0-9]+)?$/' + ], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_automargin.py b/plotly/validators/layout/yaxis/_automargin.py new file mode 100644 index 0000000000..666af26c30 --- /dev/null +++ b/plotly/validators/layout/yaxis/_automargin.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AutomarginValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='automargin', parent_name='layout.yaxis', **kwargs + ): + super(AutomarginValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_autorange.py b/plotly/validators/layout/yaxis/_autorange.py new file mode 100644 index 0000000000..82c017a305 --- /dev/null +++ b/plotly/validators/layout/yaxis/_autorange.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AutorangeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='autorange', parent_name='layout.yaxis', **kwargs + ): + super(AutorangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + values=[True, False, 'reversed'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_calendar.py b/plotly/validators/layout/yaxis/_calendar.py new file mode 100644 index 0000000000..7bdf855572 --- /dev/null +++ b/plotly/validators/layout/yaxis/_calendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class CalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='calendar', parent_name='layout.yaxis', **kwargs + ): + super(CalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_categoryarray.py b/plotly/validators/layout/yaxis/_categoryarray.py new file mode 100644 index 0000000000..584af9ed78 --- /dev/null +++ b/plotly/validators/layout/yaxis/_categoryarray.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='categoryarray', + parent_name='layout.yaxis', + **kwargs + ): + super(CategoryarrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_categoryarraysrc.py b/plotly/validators/layout/yaxis/_categoryarraysrc.py new file mode 100644 index 0000000000..6c755ae0e2 --- /dev/null +++ b/plotly/validators/layout/yaxis/_categoryarraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CategoryarraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='categoryarraysrc', + parent_name='layout.yaxis', + **kwargs + ): + super(CategoryarraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_categoryorder.py b/plotly/validators/layout/yaxis/_categoryorder.py new file mode 100644 index 0000000000..700973f432 --- /dev/null +++ b/plotly/validators/layout/yaxis/_categoryorder.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class CategoryorderValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='categoryorder', + parent_name='layout.yaxis', + **kwargs + ): + super(CategoryorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'trace', 'category ascending', 'category descending', 'array' + ], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_color.py b/plotly/validators/layout/yaxis/_color.py new file mode 100644 index 0000000000..809f4692ea --- /dev/null +++ b/plotly/validators/layout/yaxis/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='layout.yaxis', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_constrain.py b/plotly/validators/layout/yaxis/_constrain.py new file mode 100644 index 0000000000..0bb8dfc833 --- /dev/null +++ b/plotly/validators/layout/yaxis/_constrain.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ConstrainValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='constrain', parent_name='layout.yaxis', **kwargs + ): + super(ConstrainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['range', 'domain'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_constraintoward.py b/plotly/validators/layout/yaxis/_constraintoward.py new file mode 100644 index 0000000000..7b123526ff --- /dev/null +++ b/plotly/validators/layout/yaxis/_constraintoward.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ConstraintowardValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='constraintoward', + parent_name='layout.yaxis', + **kwargs + ): + super(ConstraintowardValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['left', 'center', 'right', 'top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_domain.py b/plotly/validators/layout/yaxis/_domain.py new file mode 100644 index 0000000000..77823b8cbc --- /dev/null +++ b/plotly/validators/layout/yaxis/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='domain', parent_name='layout.yaxis', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot+margins' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'plot+margins' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_dtick.py b/plotly/validators/layout/yaxis/_dtick.py new file mode 100644 index 0000000000..e6a6625b46 --- /dev/null +++ b/plotly/validators/layout/yaxis/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='layout.yaxis', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_exponentformat.py b/plotly/validators/layout/yaxis/_exponentformat.py new file mode 100644 index 0000000000..d898ff9c6d --- /dev/null +++ b/plotly/validators/layout/yaxis/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='layout.yaxis', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_fixedrange.py b/plotly/validators/layout/yaxis/_fixedrange.py new file mode 100644 index 0000000000..2c10b146dc --- /dev/null +++ b/plotly/validators/layout/yaxis/_fixedrange.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FixedrangeValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='fixedrange', parent_name='layout.yaxis', **kwargs + ): + super(FixedrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_gridcolor.py b/plotly/validators/layout/yaxis/_gridcolor.py new file mode 100644 index 0000000000..95e1987c62 --- /dev/null +++ b/plotly/validators/layout/yaxis/_gridcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class GridcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='gridcolor', parent_name='layout.yaxis', **kwargs + ): + super(GridcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_gridwidth.py b/plotly/validators/layout/yaxis/_gridwidth.py new file mode 100644 index 0000000000..ba1b6fc95d --- /dev/null +++ b/plotly/validators/layout/yaxis/_gridwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class GridwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='gridwidth', parent_name='layout.yaxis', **kwargs + ): + super(GridwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_hoverformat.py b/plotly/validators/layout/yaxis/_hoverformat.py new file mode 100644 index 0000000000..59859139cf --- /dev/null +++ b/plotly/validators/layout/yaxis/_hoverformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hoverformat', parent_name='layout.yaxis', **kwargs + ): + super(HoverformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_layer.py b/plotly/validators/layout/yaxis/_layer.py new file mode 100644 index 0000000000..e5c972732a --- /dev/null +++ b/plotly/validators/layout/yaxis/_layer.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LayerValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='layer', parent_name='layout.yaxis', **kwargs + ): + super(LayerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['above traces', 'below traces'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_linecolor.py b/plotly/validators/layout/yaxis/_linecolor.py new file mode 100644 index 0000000000..2a7542aff9 --- /dev/null +++ b/plotly/validators/layout/yaxis/_linecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='linecolor', parent_name='layout.yaxis', **kwargs + ): + super(LinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_linewidth.py b/plotly/validators/layout/yaxis/_linewidth.py new file mode 100644 index 0000000000..066f978738 --- /dev/null +++ b/plotly/validators/layout/yaxis/_linewidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='linewidth', parent_name='layout.yaxis', **kwargs + ): + super(LinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+layoutstyle', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_mirror.py b/plotly/validators/layout/yaxis/_mirror.py new file mode 100644 index 0000000000..a03956fbca --- /dev/null +++ b/plotly/validators/layout/yaxis/_mirror.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class MirrorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='mirror', parent_name='layout.yaxis', **kwargs + ): + super(MirrorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+layoutstyle', + role='style', + values=[True, 'ticks', False, 'all', 'allticks'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_nticks.py b/plotly/validators/layout/yaxis/_nticks.py new file mode 100644 index 0000000000..fb12e21032 --- /dev/null +++ b/plotly/validators/layout/yaxis/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='layout.yaxis', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_overlaying.py b/plotly/validators/layout/yaxis/_overlaying.py new file mode 100644 index 0000000000..fa09cf1a45 --- /dev/null +++ b/plotly/validators/layout/yaxis/_overlaying.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OverlayingValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='overlaying', parent_name='layout.yaxis', **kwargs + ): + super(OverlayingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=[ + 'free', '/^x([2-9]|[1-9][0-9]+)?$/', + '/^y([2-9]|[1-9][0-9]+)?$/' + ], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_position.py b/plotly/validators/layout/yaxis/_position.py new file mode 100644 index 0000000000..8672de5946 --- /dev/null +++ b/plotly/validators/layout/yaxis/_position.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class PositionValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='position', parent_name='layout.yaxis', **kwargs + ): + super(PositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_range.py b/plotly/validators/layout/yaxis/_range.py new file mode 100644 index 0000000000..20b2181347 --- /dev/null +++ b/plotly/validators/layout/yaxis/_range.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='layout.yaxis', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='axrange+margins', + implied_edits={'autorange': False}, + items=[ + { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + }, { + 'valType': 'any', + 'editType': 'axrange+margins', + 'impliedEdits': { + '^autorange': False + } + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_rangemode.py b/plotly/validators/layout/yaxis/_rangemode.py new file mode 100644 index 0000000000..8160fb4815 --- /dev/null +++ b/plotly/validators/layout/yaxis/_rangemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RangemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='rangemode', parent_name='layout.yaxis', **kwargs + ): + super(RangemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['normal', 'tozero', 'nonnegative'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_scaleanchor.py b/plotly/validators/layout/yaxis/_scaleanchor.py new file mode 100644 index 0000000000..627de4a88b --- /dev/null +++ b/plotly/validators/layout/yaxis/_scaleanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ScaleanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='scaleanchor', parent_name='layout.yaxis', **kwargs + ): + super(ScaleanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['/^x([2-9]|[1-9][0-9]+)?$/', '/^y([2-9]|[1-9][0-9]+)?$/'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_scaleratio.py b/plotly/validators/layout/yaxis/_scaleratio.py new file mode 100644 index 0000000000..bfcb7a1c46 --- /dev/null +++ b/plotly/validators/layout/yaxis/_scaleratio.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ScaleratioValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='scaleratio', parent_name='layout.yaxis', **kwargs + ): + super(ScaleratioValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_separatethousands.py b/plotly/validators/layout/yaxis/_separatethousands.py new file mode 100644 index 0000000000..7a328c0ba9 --- /dev/null +++ b/plotly/validators/layout/yaxis/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='layout.yaxis', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showexponent.py b/plotly/validators/layout/yaxis/_showexponent.py new file mode 100644 index 0000000000..eb42821fc5 --- /dev/null +++ b/plotly/validators/layout/yaxis/_showexponent.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='showexponent', parent_name='layout.yaxis', **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showgrid.py b/plotly/validators/layout/yaxis/_showgrid.py new file mode 100644 index 0000000000..78acc0c96c --- /dev/null +++ b/plotly/validators/layout/yaxis/_showgrid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowgridValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showgrid', parent_name='layout.yaxis', **kwargs + ): + super(ShowgridValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showline.py b/plotly/validators/layout/yaxis/_showline.py new file mode 100644 index 0000000000..e080006daf --- /dev/null +++ b/plotly/validators/layout/yaxis/_showline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showline', parent_name='layout.yaxis', **kwargs + ): + super(ShowlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='layoutstyle', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showspikes.py b/plotly/validators/layout/yaxis/_showspikes.py new file mode 100644 index 0000000000..d7bfb94449 --- /dev/null +++ b/plotly/validators/layout/yaxis/_showspikes.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowspikesValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showspikes', parent_name='layout.yaxis', **kwargs + ): + super(ShowspikesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='modebar', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showticklabels.py b/plotly/validators/layout/yaxis/_showticklabels.py new file mode 100644 index 0000000000..5ac763e686 --- /dev/null +++ b/plotly/validators/layout/yaxis/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='layout.yaxis', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showtickprefix.py b/plotly/validators/layout/yaxis/_showtickprefix.py new file mode 100644 index 0000000000..270b9fdd8b --- /dev/null +++ b/plotly/validators/layout/yaxis/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='layout.yaxis', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_showticksuffix.py b/plotly/validators/layout/yaxis/_showticksuffix.py new file mode 100644 index 0000000000..19a5981882 --- /dev/null +++ b/plotly/validators/layout/yaxis/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='layout.yaxis', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_side.py b/plotly/validators/layout/yaxis/_side.py new file mode 100644 index 0000000000..0a473fdc80 --- /dev/null +++ b/plotly/validators/layout/yaxis/_side.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='side', parent_name='layout.yaxis', **kwargs + ): + super(SideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot+margins', + role='info', + values=['top', 'bottom', 'left', 'right'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_spikecolor.py b/plotly/validators/layout/yaxis/_spikecolor.py new file mode 100644 index 0000000000..bc0d1612c1 --- /dev/null +++ b/plotly/validators/layout/yaxis/_spikecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SpikecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='spikecolor', parent_name='layout.yaxis', **kwargs + ): + super(SpikecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_spikedash.py b/plotly/validators/layout/yaxis/_spikedash.py new file mode 100644 index 0000000000..2915b56265 --- /dev/null +++ b/plotly/validators/layout/yaxis/_spikedash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikedashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='spikedash', parent_name='layout.yaxis', **kwargs + ): + super(SpikedashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_spikemode.py b/plotly/validators/layout/yaxis/_spikemode.py new file mode 100644 index 0000000000..dab0b51e5b --- /dev/null +++ b/plotly/validators/layout/yaxis/_spikemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SpikemodeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='spikemode', parent_name='layout.yaxis', **kwargs + ): + super(SpikemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + flags=['toaxis', 'across', 'marker'], + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_spikesnap.py b/plotly/validators/layout/yaxis/_spikesnap.py new file mode 100644 index 0000000000..ce684bfaae --- /dev/null +++ b/plotly/validators/layout/yaxis/_spikesnap.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SpikesnapValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='spikesnap', parent_name='layout.yaxis', **kwargs + ): + super(SpikesnapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + values=['data', 'cursor'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_spikethickness.py b/plotly/validators/layout/yaxis/_spikethickness.py new file mode 100644 index 0000000000..0a91af77ee --- /dev/null +++ b/plotly/validators/layout/yaxis/_spikethickness.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SpikethicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='spikethickness', + parent_name='layout.yaxis', + **kwargs + ): + super(SpikethicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tick0.py b/plotly/validators/layout/yaxis/_tick0.py new file mode 100644 index 0000000000..4ca640d590 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='layout.yaxis', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickangle.py b/plotly/validators/layout/yaxis/_tickangle.py new file mode 100644 index 0000000000..4206e6ffe0 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='layout.yaxis', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickcolor.py b/plotly/validators/layout/yaxis/_tickcolor.py new file mode 100644 index 0000000000..a874e71313 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='tickcolor', parent_name='layout.yaxis', **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickfont.py b/plotly/validators/layout/yaxis/_tickfont.py new file mode 100644 index 0000000000..c2e89297e4 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='layout.yaxis', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickformat.py b/plotly/validators/layout/yaxis/_tickformat.py new file mode 100644 index 0000000000..364d2648e0 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickformat', parent_name='layout.yaxis', **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickformatstops.py b/plotly/validators/layout/yaxis/_tickformatstops.py new file mode 100644 index 0000000000..52269e7eaf --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='layout.yaxis', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_ticklen.py b/plotly/validators/layout/yaxis/_ticklen.py new file mode 100644 index 0000000000..efc5770290 --- /dev/null +++ b/plotly/validators/layout/yaxis/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='layout.yaxis', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickmode.py b/plotly/validators/layout/yaxis/_tickmode.py new file mode 100644 index 0000000000..5320db6384 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='layout.yaxis', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickprefix.py b/plotly/validators/layout/yaxis/_tickprefix.py new file mode 100644 index 0000000000..5d5348bde7 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickprefix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='tickprefix', parent_name='layout.yaxis', **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_ticks.py b/plotly/validators/layout/yaxis/_ticks.py new file mode 100644 index 0000000000..e213e945c6 --- /dev/null +++ b/plotly/validators/layout/yaxis/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='layout.yaxis', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_ticksuffix.py b/plotly/validators/layout/yaxis/_ticksuffix.py new file mode 100644 index 0000000000..6ada9cb1dd --- /dev/null +++ b/plotly/validators/layout/yaxis/_ticksuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='ticksuffix', parent_name='layout.yaxis', **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_ticktext.py b/plotly/validators/layout/yaxis/_ticktext.py new file mode 100644 index 0000000000..3bb4ebd2e6 --- /dev/null +++ b/plotly/validators/layout/yaxis/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='layout.yaxis', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_ticktextsrc.py b/plotly/validators/layout/yaxis/_ticktextsrc.py new file mode 100644 index 0000000000..394389e1b2 --- /dev/null +++ b/plotly/validators/layout/yaxis/_ticktextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='ticktextsrc', parent_name='layout.yaxis', **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickvals.py b/plotly/validators/layout/yaxis/_tickvals.py new file mode 100644 index 0000000000..730780f861 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='layout.yaxis', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='data', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickvalssrc.py b/plotly/validators/layout/yaxis/_tickvalssrc.py new file mode 100644 index 0000000000..3bce10d8cd --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickvalssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='tickvalssrc', parent_name='layout.yaxis', **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_tickwidth.py b/plotly/validators/layout/yaxis/_tickwidth.py new file mode 100644 index 0000000000..21956ac271 --- /dev/null +++ b/plotly/validators/layout/yaxis/_tickwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tickwidth', parent_name='layout.yaxis', **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_title.py b/plotly/validators/layout/yaxis/_title.py new file mode 100644 index 0000000000..e2ae4f092d --- /dev/null +++ b/plotly/validators/layout/yaxis/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='layout.yaxis', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_titlefont.py b/plotly/validators/layout/yaxis/_titlefont.py new file mode 100644 index 0000000000..91c24a940c --- /dev/null +++ b/plotly/validators/layout/yaxis/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='layout.yaxis', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_type.py b/plotly/validators/layout/yaxis/_type.py new file mode 100644 index 0000000000..042502b17f --- /dev/null +++ b/plotly/validators/layout/yaxis/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='layout.yaxis', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['-', 'linear', 'log', 'date', 'category'], + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_visible.py b/plotly/validators/layout/yaxis/_visible.py new file mode 100644 index 0000000000..2d2394384d --- /dev/null +++ b/plotly/validators/layout/yaxis/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='layout.yaxis', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_zeroline.py b/plotly/validators/layout/yaxis/_zeroline.py new file mode 100644 index 0000000000..94f420c43d --- /dev/null +++ b/plotly/validators/layout/yaxis/_zeroline.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ZerolineValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='zeroline', parent_name='layout.yaxis', **kwargs + ): + super(ZerolineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_zerolinecolor.py b/plotly/validators/layout/yaxis/_zerolinecolor.py new file mode 100644 index 0000000000..cc2cd1dd3c --- /dev/null +++ b/plotly/validators/layout/yaxis/_zerolinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='zerolinecolor', + parent_name='layout.yaxis', + **kwargs + ): + super(ZerolinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/_zerolinewidth.py b/plotly/validators/layout/yaxis/_zerolinewidth.py new file mode 100644 index 0000000000..7317469197 --- /dev/null +++ b/plotly/validators/layout/yaxis/_zerolinewidth.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZerolinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='zerolinewidth', + parent_name='layout.yaxis', + **kwargs + ): + super(ZerolinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/tickfont/__init__.py b/plotly/validators/layout/yaxis/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/yaxis/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/yaxis/tickfont/_color.py b/plotly/validators/layout/yaxis/tickfont/_color.py new file mode 100644 index 0000000000..71c41ffc10 --- /dev/null +++ b/plotly/validators/layout/yaxis/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.yaxis.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/tickfont/_family.py b/plotly/validators/layout/yaxis/tickfont/_family.py new file mode 100644 index 0000000000..6df7dcf268 --- /dev/null +++ b/plotly/validators/layout/yaxis/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.yaxis.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/tickfont/_size.py b/plotly/validators/layout/yaxis/tickfont/_size.py new file mode 100644 index 0000000000..eafd3b532b --- /dev/null +++ b/plotly/validators/layout/yaxis/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.yaxis.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/tickformatstop/__init__.py b/plotly/validators/layout/yaxis/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/layout/yaxis/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/layout/yaxis/tickformatstop/_dtickrange.py b/plotly/validators/layout/yaxis/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..a1939f17b0 --- /dev/null +++ b/plotly/validators/layout/yaxis/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='layout.yaxis.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + items=[ + { + 'valType': 'any', + 'editType': 'ticks+margins' + }, { + 'valType': 'any', + 'editType': 'ticks+margins' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/tickformatstop/_value.py b/plotly/validators/layout/yaxis/tickformatstop/_value.py new file mode 100644 index 0000000000..627e5e3a14 --- /dev/null +++ b/plotly/validators/layout/yaxis/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='layout.yaxis.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/titlefont/__init__.py b/plotly/validators/layout/yaxis/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/layout/yaxis/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/layout/yaxis/titlefont/_color.py b/plotly/validators/layout/yaxis/titlefont/_color.py new file mode 100644 index 0000000000..36b1cd23c0 --- /dev/null +++ b/plotly/validators/layout/yaxis/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='layout.yaxis.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + role='style', + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/titlefont/_family.py b/plotly/validators/layout/yaxis/titlefont/_family.py new file mode 100644 index 0000000000..f0889c4680 --- /dev/null +++ b/plotly/validators/layout/yaxis/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='layout.yaxis.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/layout/yaxis/titlefont/_size.py b/plotly/validators/layout/yaxis/titlefont/_size.py new file mode 100644 index 0000000000..228f4f458b --- /dev/null +++ b/plotly/validators/layout/yaxis/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='layout.yaxis.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='ticks+margins', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/__init__.py b/plotly/validators/mesh3d/__init__.py new file mode 100644 index 0000000000..03ef1eb594 --- /dev/null +++ b/plotly/validators/mesh3d/__init__.py @@ -0,0 +1,54 @@ +from ._zsrc import ZsrcValidator +from ._zcalendar import ZcalendarValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._vertexcolorsrc import VertexcolorsrcValidator +from ._vertexcolor import VertexcolorValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._scene import SceneValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._lightposition import LightpositionValidator +from ._lighting import LightingValidator +from ._legendgroup import LegendgroupValidator +from ._ksrc import KsrcValidator +from ._k import KValidator +from ._jsrc import JsrcValidator +from ._j import JValidator +from ._isrc import IsrcValidator +from ._intensitysrc import IntensitysrcValidator +from ._intensity import IntensityValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._i import IValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._flatshading import FlatshadingValidator +from ._facecolorsrc import FacecolorsrcValidator +from ._facecolor import FacecolorValidator +from ._delaunayaxis import DelaunayaxisValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._contour import ContourValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator +from ._alphahull import AlphahullValidator diff --git a/plotly/validators/mesh3d/_alphahull.py b/plotly/validators/mesh3d/_alphahull.py new file mode 100644 index 0000000000..dc491dd3c0 --- /dev/null +++ b/plotly/validators/mesh3d/_alphahull.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AlphahullValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='alphahull', parent_name='mesh3d', **kwargs + ): + super(AlphahullValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_autocolorscale.py b/plotly/validators/mesh3d/_autocolorscale.py new file mode 100644 index 0000000000..f3d206e916 --- /dev/null +++ b/plotly/validators/mesh3d/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='mesh3d', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_cauto.py b/plotly/validators/mesh3d/_cauto.py new file mode 100644 index 0000000000..ac457ecffc --- /dev/null +++ b/plotly/validators/mesh3d/_cauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='cauto', parent_name='mesh3d', **kwargs): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_cmax.py b/plotly/validators/mesh3d/_cmax.py new file mode 100644 index 0000000000..551848429e --- /dev/null +++ b/plotly/validators/mesh3d/_cmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmax', parent_name='mesh3d', **kwargs): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_cmin.py b/plotly/validators/mesh3d/_cmin.py new file mode 100644 index 0000000000..cb633e87d3 --- /dev/null +++ b/plotly/validators/mesh3d/_cmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmin', parent_name='mesh3d', **kwargs): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_color.py b/plotly/validators/mesh3d/_color.py new file mode 100644 index 0000000000..af840f394f --- /dev/null +++ b/plotly/validators/mesh3d/_color.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__(self, plotly_name='color', parent_name='mesh3d', **kwargs): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + colorscale_path='mesh3d.colorscale', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_colorbar.py b/plotly/validators/mesh3d/_colorbar.py new file mode 100644 index 0000000000..af6690488f --- /dev/null +++ b/plotly/validators/mesh3d/_colorbar.py @@ -0,0 +1,207 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='colorbar', parent_name='mesh3d', **kwargs): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.mesh3d.colorbar.Tickformatsto + p instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_colorscale.py b/plotly/validators/mesh3d/_colorscale.py new file mode 100644 index 0000000000..4644b6de8b --- /dev/null +++ b/plotly/validators/mesh3d/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='mesh3d', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_contour.py b/plotly/validators/mesh3d/_contour.py new file mode 100644 index 0000000000..8ef0fe1439 --- /dev/null +++ b/plotly/validators/mesh3d/_contour.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ContourValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='contour', parent_name='mesh3d', **kwargs): + super(ContourValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contour', + data_docs=""" + color + Sets the color of the contour lines. + show + Sets whether or not dynamic contours are shown + on hover + width + Sets the width of the contour lines.""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_customdata.py b/plotly/validators/mesh3d/_customdata.py new file mode 100644 index 0000000000..8f6364b141 --- /dev/null +++ b/plotly/validators/mesh3d/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='mesh3d', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_customdatasrc.py b/plotly/validators/mesh3d/_customdatasrc.py new file mode 100644 index 0000000000..ad22066771 --- /dev/null +++ b/plotly/validators/mesh3d/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='mesh3d', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_delaunayaxis.py b/plotly/validators/mesh3d/_delaunayaxis.py new file mode 100644 index 0000000000..e605fbeaaf --- /dev/null +++ b/plotly/validators/mesh3d/_delaunayaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DelaunayaxisValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='delaunayaxis', parent_name='mesh3d', **kwargs + ): + super(DelaunayaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['x', 'y', 'z'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/_facecolor.py b/plotly/validators/mesh3d/_facecolor.py new file mode 100644 index 0000000000..2a16608b01 --- /dev/null +++ b/plotly/validators/mesh3d/_facecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FacecolorValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='facecolor', parent_name='mesh3d', **kwargs + ): + super(FacecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_facecolorsrc.py b/plotly/validators/mesh3d/_facecolorsrc.py new file mode 100644 index 0000000000..62b006e869 --- /dev/null +++ b/plotly/validators/mesh3d/_facecolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FacecolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='facecolorsrc', parent_name='mesh3d', **kwargs + ): + super(FacecolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_flatshading.py b/plotly/validators/mesh3d/_flatshading.py new file mode 100644 index 0000000000..088966a04b --- /dev/null +++ b/plotly/validators/mesh3d/_flatshading.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FlatshadingValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='flatshading', parent_name='mesh3d', **kwargs + ): + super(FlatshadingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_hoverinfo.py b/plotly/validators/mesh3d/_hoverinfo.py new file mode 100644 index 0000000000..98ccceec42 --- /dev/null +++ b/plotly/validators/mesh3d/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='mesh3d', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_hoverinfosrc.py b/plotly/validators/mesh3d/_hoverinfosrc.py new file mode 100644 index 0000000000..5b13c3e1a1 --- /dev/null +++ b/plotly/validators/mesh3d/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='mesh3d', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_hoverlabel.py b/plotly/validators/mesh3d/_hoverlabel.py new file mode 100644 index 0000000000..28436efc1b --- /dev/null +++ b/plotly/validators/mesh3d/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='mesh3d', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_i.py b/plotly/validators/mesh3d/_i.py new file mode 100644 index 0000000000..c6d92cd406 --- /dev/null +++ b/plotly/validators/mesh3d/_i.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='i', parent_name='mesh3d', **kwargs): + super(IValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_ids.py b/plotly/validators/mesh3d/_ids.py new file mode 100644 index 0000000000..20bfa878f4 --- /dev/null +++ b/plotly/validators/mesh3d/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='mesh3d', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_idssrc.py b/plotly/validators/mesh3d/_idssrc.py new file mode 100644 index 0000000000..9b642217c2 --- /dev/null +++ b/plotly/validators/mesh3d/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='mesh3d', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_intensity.py b/plotly/validators/mesh3d/_intensity.py new file mode 100644 index 0000000000..112e0298b3 --- /dev/null +++ b/plotly/validators/mesh3d/_intensity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IntensityValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='intensity', parent_name='mesh3d', **kwargs + ): + super(IntensityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_intensitysrc.py b/plotly/validators/mesh3d/_intensitysrc.py new file mode 100644 index 0000000000..14593a1048 --- /dev/null +++ b/plotly/validators/mesh3d/_intensitysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IntensitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='intensitysrc', parent_name='mesh3d', **kwargs + ): + super(IntensitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_isrc.py b/plotly/validators/mesh3d/_isrc.py new file mode 100644 index 0000000000..c75a2fc7a4 --- /dev/null +++ b/plotly/validators/mesh3d/_isrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='isrc', parent_name='mesh3d', **kwargs): + super(IsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_j.py b/plotly/validators/mesh3d/_j.py new file mode 100644 index 0000000000..84f9872cfd --- /dev/null +++ b/plotly/validators/mesh3d/_j.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class JValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='j', parent_name='mesh3d', **kwargs): + super(JValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_jsrc.py b/plotly/validators/mesh3d/_jsrc.py new file mode 100644 index 0000000000..2d1e18d7db --- /dev/null +++ b/plotly/validators/mesh3d/_jsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class JsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='jsrc', parent_name='mesh3d', **kwargs): + super(JsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_k.py b/plotly/validators/mesh3d/_k.py new file mode 100644 index 0000000000..c0fc4333e7 --- /dev/null +++ b/plotly/validators/mesh3d/_k.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class KValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='k', parent_name='mesh3d', **kwargs): + super(KValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_ksrc.py b/plotly/validators/mesh3d/_ksrc.py new file mode 100644 index 0000000000..e99440fcce --- /dev/null +++ b/plotly/validators/mesh3d/_ksrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class KsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ksrc', parent_name='mesh3d', **kwargs): + super(KsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_legendgroup.py b/plotly/validators/mesh3d/_legendgroup.py new file mode 100644 index 0000000000..2baa72ef9d --- /dev/null +++ b/plotly/validators/mesh3d/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='mesh3d', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_lighting.py b/plotly/validators/mesh3d/_lighting.py new file mode 100644 index 0000000000..de4e81ad74 --- /dev/null +++ b/plotly/validators/mesh3d/_lighting.py @@ -0,0 +1,37 @@ +import _plotly_utils.basevalidators + + +class LightingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='lighting', parent_name='mesh3d', **kwargs): + super(LightingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lighting', + data_docs=""" + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + facenormalsepsilon + Epsilon for face normals calculation avoids + math issues arising from degenerate geometry. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine. + vertexnormalsepsilon + Epsilon for vertex normals calculation avoids + math issues arising from degenerate geometry.""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_lightposition.py b/plotly/validators/mesh3d/_lightposition.py new file mode 100644 index 0000000000..7c8ba3f9f8 --- /dev/null +++ b/plotly/validators/mesh3d/_lightposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LightpositionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lightposition', parent_name='mesh3d', **kwargs + ): + super(LightpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lightposition', + data_docs=""" + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex.""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_name.py b/plotly/validators/mesh3d/_name.py new file mode 100644 index 0000000000..779c0ae740 --- /dev/null +++ b/plotly/validators/mesh3d/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='mesh3d', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_opacity.py b/plotly/validators/mesh3d/_opacity.py new file mode 100644 index 0000000000..0d27e83c6f --- /dev/null +++ b/plotly/validators/mesh3d/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='mesh3d', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_reversescale.py b/plotly/validators/mesh3d/_reversescale.py new file mode 100644 index 0000000000..e3053a1ffc --- /dev/null +++ b/plotly/validators/mesh3d/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='mesh3d', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_scene.py b/plotly/validators/mesh3d/_scene.py new file mode 100644 index 0000000000..6032eb1b0c --- /dev/null +++ b/plotly/validators/mesh3d/_scene.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SceneValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='scene', parent_name='mesh3d', **kwargs): + super(SceneValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='scene', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_selectedpoints.py b/plotly/validators/mesh3d/_selectedpoints.py new file mode 100644 index 0000000000..4bd46372ba --- /dev/null +++ b/plotly/validators/mesh3d/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='mesh3d', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_showlegend.py b/plotly/validators/mesh3d/_showlegend.py new file mode 100644 index 0000000000..2d91884214 --- /dev/null +++ b/plotly/validators/mesh3d/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='mesh3d', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_showscale.py b/plotly/validators/mesh3d/_showscale.py new file mode 100644 index 0000000000..2ae327015b --- /dev/null +++ b/plotly/validators/mesh3d/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='mesh3d', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_stream.py b/plotly/validators/mesh3d/_stream.py new file mode 100644 index 0000000000..7da2733df2 --- /dev/null +++ b/plotly/validators/mesh3d/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='mesh3d', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/_text.py b/plotly/validators/mesh3d/_text.py new file mode 100644 index 0000000000..6c95ffd874 --- /dev/null +++ b/plotly/validators/mesh3d/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='mesh3d', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_textsrc.py b/plotly/validators/mesh3d/_textsrc.py new file mode 100644 index 0000000000..12b8f1cffe --- /dev/null +++ b/plotly/validators/mesh3d/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='mesh3d', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_uid.py b/plotly/validators/mesh3d/_uid.py new file mode 100644 index 0000000000..ac5ff8f3b5 --- /dev/null +++ b/plotly/validators/mesh3d/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='mesh3d', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_vertexcolor.py b/plotly/validators/mesh3d/_vertexcolor.py new file mode 100644 index 0000000000..3dce760b41 --- /dev/null +++ b/plotly/validators/mesh3d/_vertexcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VertexcolorValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='vertexcolor', parent_name='mesh3d', **kwargs + ): + super(VertexcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_vertexcolorsrc.py b/plotly/validators/mesh3d/_vertexcolorsrc.py new file mode 100644 index 0000000000..5097affe16 --- /dev/null +++ b/plotly/validators/mesh3d/_vertexcolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VertexcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='vertexcolorsrc', parent_name='mesh3d', **kwargs + ): + super(VertexcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_visible.py b/plotly/validators/mesh3d/_visible.py new file mode 100644 index 0000000000..8c0da09bb8 --- /dev/null +++ b/plotly/validators/mesh3d/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='mesh3d', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/_x.py b/plotly/validators/mesh3d/_x.py new file mode 100644 index 0000000000..0f015b2a36 --- /dev/null +++ b/plotly/validators/mesh3d/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='mesh3d', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_xcalendar.py b/plotly/validators/mesh3d/_xcalendar.py new file mode 100644 index 0000000000..227c4c13a3 --- /dev/null +++ b/plotly/validators/mesh3d/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='mesh3d', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/mesh3d/_xsrc.py b/plotly/validators/mesh3d/_xsrc.py new file mode 100644 index 0000000000..91bd41000f --- /dev/null +++ b/plotly/validators/mesh3d/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='mesh3d', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_y.py b/plotly/validators/mesh3d/_y.py new file mode 100644 index 0000000000..d05c7b81fd --- /dev/null +++ b/plotly/validators/mesh3d/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='mesh3d', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_ycalendar.py b/plotly/validators/mesh3d/_ycalendar.py new file mode 100644 index 0000000000..0c0b6f5dbe --- /dev/null +++ b/plotly/validators/mesh3d/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='mesh3d', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/mesh3d/_ysrc.py b/plotly/validators/mesh3d/_ysrc.py new file mode 100644 index 0000000000..1659e8a0da --- /dev/null +++ b/plotly/validators/mesh3d/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='mesh3d', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_z.py b/plotly/validators/mesh3d/_z.py new file mode 100644 index 0000000000..63aeecb6f3 --- /dev/null +++ b/plotly/validators/mesh3d/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='mesh3d', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/_zcalendar.py b/plotly/validators/mesh3d/_zcalendar.py new file mode 100644 index 0000000000..801f441f6d --- /dev/null +++ b/plotly/validators/mesh3d/_zcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ZcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='zcalendar', parent_name='mesh3d', **kwargs + ): + super(ZcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/mesh3d/_zsrc.py b/plotly/validators/mesh3d/_zsrc.py new file mode 100644 index 0000000000..2b0be5fa4b --- /dev/null +++ b/plotly/validators/mesh3d/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='mesh3d', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/__init__.py b/plotly/validators/mesh3d/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/mesh3d/colorbar/_bgcolor.py b/plotly/validators/mesh3d/colorbar/_bgcolor.py new file mode 100644 index 0000000000..8e9d883032 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='mesh3d.colorbar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_bordercolor.py b/plotly/validators/mesh3d/colorbar/_bordercolor.py new file mode 100644 index 0000000000..1730d64842 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_borderwidth.py b/plotly/validators/mesh3d/colorbar/_borderwidth.py new file mode 100644 index 0000000000..f1d69d1cf8 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_dtick.py b/plotly/validators/mesh3d/colorbar/_dtick.py new file mode 100644 index 0000000000..5719c8a96b --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='mesh3d.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_exponentformat.py b/plotly/validators/mesh3d/colorbar/_exponentformat.py new file mode 100644 index 0000000000..b78a8f9a18 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_len.py b/plotly/validators/mesh3d/colorbar/_len.py new file mode 100644 index 0000000000..2420b7a1d0 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='mesh3d.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_lenmode.py b/plotly/validators/mesh3d/colorbar/_lenmode.py new file mode 100644 index 0000000000..8c53751bdc --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='mesh3d.colorbar', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_nticks.py b/plotly/validators/mesh3d/colorbar/_nticks.py new file mode 100644 index 0000000000..bcbd0c0a47 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='mesh3d.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_outlinecolor.py b/plotly/validators/mesh3d/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..ee674c4d55 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_outlinewidth.py b/plotly/validators/mesh3d/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..63610b41a5 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_separatethousands.py b/plotly/validators/mesh3d/colorbar/_separatethousands.py new file mode 100644 index 0000000000..4c49630a94 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_showexponent.py b/plotly/validators/mesh3d/colorbar/_showexponent.py new file mode 100644 index 0000000000..51a76e92f2 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_showticklabels.py b/plotly/validators/mesh3d/colorbar/_showticklabels.py new file mode 100644 index 0000000000..4229bdec93 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_showtickprefix.py b/plotly/validators/mesh3d/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..577135a714 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_showticksuffix.py b/plotly/validators/mesh3d/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..18bd15a2f6 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_thickness.py b/plotly/validators/mesh3d/colorbar/_thickness.py new file mode 100644 index 0000000000..6887a3ae21 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='mesh3d.colorbar', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_thicknessmode.py b/plotly/validators/mesh3d/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..132727e224 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tick0.py b/plotly/validators/mesh3d/colorbar/_tick0.py new file mode 100644 index 0000000000..9a3255d9c7 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='mesh3d.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickangle.py b/plotly/validators/mesh3d/colorbar/_tickangle.py new file mode 100644 index 0000000000..4a04937e82 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickangle.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, plotly_name='tickangle', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickcolor.py b/plotly/validators/mesh3d/colorbar/_tickcolor.py new file mode 100644 index 0000000000..918012fc7d --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='tickcolor', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickfont.py b/plotly/validators/mesh3d/colorbar/_tickfont.py new file mode 100644 index 0000000000..57cde23f4c --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickformat.py b/plotly/validators/mesh3d/colorbar/_tickformat.py new file mode 100644 index 0000000000..fd9a52f98f --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickformatstops.py b/plotly/validators/mesh3d/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..daf0518267 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ticklen.py b/plotly/validators/mesh3d/colorbar/_ticklen.py new file mode 100644 index 0000000000..3f0a8f3889 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='mesh3d.colorbar', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickmode.py b/plotly/validators/mesh3d/colorbar/_tickmode.py new file mode 100644 index 0000000000..9f88d458b1 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickprefix.py b/plotly/validators/mesh3d/colorbar/_tickprefix.py new file mode 100644 index 0000000000..cbba069bba --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ticks.py b/plotly/validators/mesh3d/colorbar/_ticks.py new file mode 100644 index 0000000000..6cee91740f --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='mesh3d.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ticksuffix.py b/plotly/validators/mesh3d/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..11e14d528d --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ticktext.py b/plotly/validators/mesh3d/colorbar/_ticktext.py new file mode 100644 index 0000000000..dc44ccc41c --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='mesh3d.colorbar', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ticktextsrc.py b/plotly/validators/mesh3d/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..204d9563ed --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickvals.py b/plotly/validators/mesh3d/colorbar/_tickvals.py new file mode 100644 index 0000000000..b49259fee7 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickvalssrc.py b/plotly/validators/mesh3d/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..814162f8b2 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='mesh3d.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_tickwidth.py b/plotly/validators/mesh3d/colorbar/_tickwidth.py new file mode 100644 index 0000000000..c686087f9b --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_tickwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='tickwidth', parent_name='mesh3d.colorbar', **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_title.py b/plotly/validators/mesh3d/colorbar/_title.py new file mode 100644 index 0000000000..4f6895d3a6 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='mesh3d.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_titlefont.py b/plotly/validators/mesh3d/colorbar/_titlefont.py new file mode 100644 index 0000000000..3402e593a6 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_titlefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='titlefont', parent_name='mesh3d.colorbar', **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_titleside.py b/plotly/validators/mesh3d/colorbar/_titleside.py new file mode 100644 index 0000000000..9438d01d08 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_titleside.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='titleside', parent_name='mesh3d.colorbar', **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_x.py b/plotly/validators/mesh3d/colorbar/_x.py new file mode 100644 index 0000000000..d1434433df --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='mesh3d.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_xanchor.py b/plotly/validators/mesh3d/colorbar/_xanchor.py new file mode 100644 index 0000000000..da9d825be5 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='mesh3d.colorbar', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_xpad.py b/plotly/validators/mesh3d/colorbar/_xpad.py new file mode 100644 index 0000000000..5f0c36fa5b --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='mesh3d.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_y.py b/plotly/validators/mesh3d/colorbar/_y.py new file mode 100644 index 0000000000..aa622e0bf4 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='mesh3d.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_yanchor.py b/plotly/validators/mesh3d/colorbar/_yanchor.py new file mode 100644 index 0000000000..712e9feaed --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='mesh3d.colorbar', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/_ypad.py b/plotly/validators/mesh3d/colorbar/_ypad.py new file mode 100644 index 0000000000..11d553575e --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='mesh3d.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/tickfont/__init__.py b/plotly/validators/mesh3d/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/mesh3d/colorbar/tickfont/_color.py b/plotly/validators/mesh3d/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..dff377a31e --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='mesh3d.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/tickfont/_family.py b/plotly/validators/mesh3d/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..a1a8349dcb --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='mesh3d.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/tickfont/_size.py b/plotly/validators/mesh3d/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..58fca31338 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='mesh3d.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/tickformatstop/__init__.py b/plotly/validators/mesh3d/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/mesh3d/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/mesh3d/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..1c6a3893ec --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='mesh3d.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/tickformatstop/_value.py b/plotly/validators/mesh3d/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..562621f983 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='mesh3d.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/titlefont/__init__.py b/plotly/validators/mesh3d/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/mesh3d/colorbar/titlefont/_color.py b/plotly/validators/mesh3d/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..7d6a93c5a0 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='mesh3d.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/titlefont/_family.py b/plotly/validators/mesh3d/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..911fc83d5a --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='mesh3d.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/mesh3d/colorbar/titlefont/_size.py b/plotly/validators/mesh3d/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..b1e23a8a43 --- /dev/null +++ b/plotly/validators/mesh3d/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='mesh3d.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/contour/__init__.py b/plotly/validators/mesh3d/contour/__init__.py new file mode 100644 index 0000000000..54b6fd5357 --- /dev/null +++ b/plotly/validators/mesh3d/contour/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._show import ShowValidator +from ._color import ColorValidator diff --git a/plotly/validators/mesh3d/contour/_color.py b/plotly/validators/mesh3d/contour/_color.py new file mode 100644 index 0000000000..36766c1ce9 --- /dev/null +++ b/plotly/validators/mesh3d/contour/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='mesh3d.contour', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/contour/_show.py b/plotly/validators/mesh3d/contour/_show.py new file mode 100644 index 0000000000..e744a6b545 --- /dev/null +++ b/plotly/validators/mesh3d/contour/_show.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='show', parent_name='mesh3d.contour', **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/contour/_width.py b/plotly/validators/mesh3d/contour/_width.py new file mode 100644 index 0000000000..19a513d8fa --- /dev/null +++ b/plotly/validators/mesh3d/contour/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='mesh3d.contour', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/__init__.py b/plotly/validators/mesh3d/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/mesh3d/hoverlabel/_bgcolor.py b/plotly/validators/mesh3d/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..73a188d416 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='mesh3d.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_bgcolorsrc.py b/plotly/validators/mesh3d/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..7c18d226e5 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='mesh3d.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_bordercolor.py b/plotly/validators/mesh3d/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..1abe775da2 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='mesh3d.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_bordercolorsrc.py b/plotly/validators/mesh3d/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..8438985f19 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='mesh3d.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_font.py b/plotly/validators/mesh3d/hoverlabel/_font.py new file mode 100644 index 0000000000..69e1620956 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='mesh3d.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_namelength.py b/plotly/validators/mesh3d/hoverlabel/_namelength.py new file mode 100644 index 0000000000..4b5effe336 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='mesh3d.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/_namelengthsrc.py b/plotly/validators/mesh3d/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..e485be0977 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='mesh3d.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/__init__.py b/plotly/validators/mesh3d/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/mesh3d/hoverlabel/font/_color.py b/plotly/validators/mesh3d/hoverlabel/font/_color.py new file mode 100644 index 0000000000..4f316bd5ee --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/_colorsrc.py b/plotly/validators/mesh3d/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..cd5d629e2c --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/_family.py b/plotly/validators/mesh3d/hoverlabel/font/_family.py new file mode 100644 index 0000000000..7821857609 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/_familysrc.py b/plotly/validators/mesh3d/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..d3f20b4007 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/_size.py b/plotly/validators/mesh3d/hoverlabel/font/_size.py new file mode 100644 index 0000000000..521c132459 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/hoverlabel/font/_sizesrc.py b/plotly/validators/mesh3d/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..9da22e5cf1 --- /dev/null +++ b/plotly/validators/mesh3d/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='mesh3d.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/__init__.py b/plotly/validators/mesh3d/lighting/__init__.py new file mode 100644 index 0000000000..6abe696b0d --- /dev/null +++ b/plotly/validators/mesh3d/lighting/__init__.py @@ -0,0 +1,7 @@ +from ._vertexnormalsepsilon import VertexnormalsepsilonValidator +from ._specular import SpecularValidator +from ._roughness import RoughnessValidator +from ._fresnel import FresnelValidator +from ._facenormalsepsilon import FacenormalsepsilonValidator +from ._diffuse import DiffuseValidator +from ._ambient import AmbientValidator diff --git a/plotly/validators/mesh3d/lighting/_ambient.py b/plotly/validators/mesh3d/lighting/_ambient.py new file mode 100644 index 0000000000..5101522d78 --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_ambient.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AmbientValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ambient', parent_name='mesh3d.lighting', **kwargs + ): + super(AmbientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_diffuse.py b/plotly/validators/mesh3d/lighting/_diffuse.py new file mode 100644 index 0000000000..9734daa403 --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_diffuse.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class DiffuseValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='diffuse', parent_name='mesh3d.lighting', **kwargs + ): + super(DiffuseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_facenormalsepsilon.py b/plotly/validators/mesh3d/lighting/_facenormalsepsilon.py new file mode 100644 index 0000000000..dc46619435 --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_facenormalsepsilon.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class FacenormalsepsilonValidator( + _plotly_utils.basevalidators.NumberValidator +): + + def __init__( + self, + plotly_name='facenormalsepsilon', + parent_name='mesh3d.lighting', + **kwargs + ): + super(FacenormalsepsilonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_fresnel.py b/plotly/validators/mesh3d/lighting/_fresnel.py new file mode 100644 index 0000000000..01ac8fcbc7 --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_fresnel.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FresnelValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='fresnel', parent_name='mesh3d.lighting', **kwargs + ): + super(FresnelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=5, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_roughness.py b/plotly/validators/mesh3d/lighting/_roughness.py new file mode 100644 index 0000000000..5b69e67d2c --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_roughness.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class RoughnessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='roughness', parent_name='mesh3d.lighting', **kwargs + ): + super(RoughnessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_specular.py b/plotly/validators/mesh3d/lighting/_specular.py new file mode 100644 index 0000000000..71f17a393d --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_specular.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SpecularValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='specular', parent_name='mesh3d.lighting', **kwargs + ): + super(SpecularValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=2, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lighting/_vertexnormalsepsilon.py b/plotly/validators/mesh3d/lighting/_vertexnormalsepsilon.py new file mode 100644 index 0000000000..eab584a83b --- /dev/null +++ b/plotly/validators/mesh3d/lighting/_vertexnormalsepsilon.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class VertexnormalsepsilonValidator( + _plotly_utils.basevalidators.NumberValidator +): + + def __init__( + self, + plotly_name='vertexnormalsepsilon', + parent_name='mesh3d.lighting', + **kwargs + ): + super(VertexnormalsepsilonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lightposition/__init__.py b/plotly/validators/mesh3d/lightposition/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/mesh3d/lightposition/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/mesh3d/lightposition/_x.py b/plotly/validators/mesh3d/lightposition/_x.py new file mode 100644 index 0000000000..b5263f94e4 --- /dev/null +++ b/plotly/validators/mesh3d/lightposition/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='mesh3d.lightposition', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lightposition/_y.py b/plotly/validators/mesh3d/lightposition/_y.py new file mode 100644 index 0000000000..b525b90747 --- /dev/null +++ b/plotly/validators/mesh3d/lightposition/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='mesh3d.lightposition', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/lightposition/_z.py b/plotly/validators/mesh3d/lightposition/_z.py new file mode 100644 index 0000000000..47cf86119d --- /dev/null +++ b/plotly/validators/mesh3d/lightposition/_z.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='z', parent_name='mesh3d.lightposition', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/mesh3d/stream/__init__.py b/plotly/validators/mesh3d/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/mesh3d/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/mesh3d/stream/_maxpoints.py b/plotly/validators/mesh3d/stream/_maxpoints.py new file mode 100644 index 0000000000..d56c87aecb --- /dev/null +++ b/plotly/validators/mesh3d/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='mesh3d.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/mesh3d/stream/_token.py b/plotly/validators/mesh3d/stream/_token.py new file mode 100644 index 0000000000..1995b1f485 --- /dev/null +++ b/plotly/validators/mesh3d/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='mesh3d.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/ohlc/__init__.py b/plotly/validators/ohlc/__init__.py new file mode 100644 index 0000000000..53782bf539 --- /dev/null +++ b/plotly/validators/ohlc/__init__.py @@ -0,0 +1,34 @@ +from ._yaxis import YAxisValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._tickwidth import TickwidthValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._opensrc import OpensrcValidator +from ._open import OpenValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._lowsrc import LowsrcValidator +from ._low import LowValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._increasing import IncreasingValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._highsrc import HighsrcValidator +from ._high import HighValidator +from ._decreasing import DecreasingValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._closesrc import ClosesrcValidator +from ._close import CloseValidator diff --git a/plotly/validators/ohlc/_close.py b/plotly/validators/ohlc/_close.py new file mode 100644 index 0000000000..052fe7f672 --- /dev/null +++ b/plotly/validators/ohlc/_close.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CloseValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='close', parent_name='ohlc', **kwargs): + super(CloseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_closesrc.py b/plotly/validators/ohlc/_closesrc.py new file mode 100644 index 0000000000..f63178f92e --- /dev/null +++ b/plotly/validators/ohlc/_closesrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ClosesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='closesrc', parent_name='ohlc', **kwargs): + super(ClosesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_customdata.py b/plotly/validators/ohlc/_customdata.py new file mode 100644 index 0000000000..26def4c0ab --- /dev/null +++ b/plotly/validators/ohlc/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='ohlc', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_customdatasrc.py b/plotly/validators/ohlc/_customdatasrc.py new file mode 100644 index 0000000000..e5e8892f32 --- /dev/null +++ b/plotly/validators/ohlc/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='ohlc', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_decreasing.py b/plotly/validators/ohlc/_decreasing.py new file mode 100644 index 0000000000..9c93f60fa0 --- /dev/null +++ b/plotly/validators/ohlc/_decreasing.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DecreasingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='decreasing', parent_name='ohlc', **kwargs): + super(DecreasingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Decreasing', + data_docs=""" + line + plotly.graph_objs.ohlc.decreasing.Line instance + or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/ohlc/_high.py b/plotly/validators/ohlc/_high.py new file mode 100644 index 0000000000..15f2dd9a7d --- /dev/null +++ b/plotly/validators/ohlc/_high.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class HighValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='high', parent_name='ohlc', **kwargs): + super(HighValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_highsrc.py b/plotly/validators/ohlc/_highsrc.py new file mode 100644 index 0000000000..2d3f366102 --- /dev/null +++ b/plotly/validators/ohlc/_highsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class HighsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='highsrc', parent_name='ohlc', **kwargs): + super(HighsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_hoverinfo.py b/plotly/validators/ohlc/_hoverinfo.py new file mode 100644 index 0000000000..fd36db1802 --- /dev/null +++ b/plotly/validators/ohlc/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='ohlc', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_hoverinfosrc.py b/plotly/validators/ohlc/_hoverinfosrc.py new file mode 100644 index 0000000000..e84a01e79b --- /dev/null +++ b/plotly/validators/ohlc/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='ohlc', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_hoverlabel.py b/plotly/validators/ohlc/_hoverlabel.py new file mode 100644 index 0000000000..802c146a24 --- /dev/null +++ b/plotly/validators/ohlc/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='ohlc', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/ohlc/_ids.py b/plotly/validators/ohlc/_ids.py new file mode 100644 index 0000000000..76e15bcfe9 --- /dev/null +++ b/plotly/validators/ohlc/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='ohlc', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_idssrc.py b/plotly/validators/ohlc/_idssrc.py new file mode 100644 index 0000000000..346f5bcc30 --- /dev/null +++ b/plotly/validators/ohlc/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='ohlc', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_increasing.py b/plotly/validators/ohlc/_increasing.py new file mode 100644 index 0000000000..ec6d4c1a36 --- /dev/null +++ b/plotly/validators/ohlc/_increasing.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class IncreasingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='increasing', parent_name='ohlc', **kwargs): + super(IncreasingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Increasing', + data_docs=""" + line + plotly.graph_objs.ohlc.increasing.Line instance + or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/ohlc/_legendgroup.py b/plotly/validators/ohlc/_legendgroup.py new file mode 100644 index 0000000000..a3859cb482 --- /dev/null +++ b/plotly/validators/ohlc/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='ohlc', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_line.py b/plotly/validators/ohlc/_line.py new file mode 100644 index 0000000000..e403125110 --- /dev/null +++ b/plotly/validators/ohlc/_line.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='ohlc', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + Note that this style setting can also be set + per direction via `increasing.line.dash` and + `decreasing.line.dash`. + width + [object Object] Note that this style setting + can also be set per direction via + `increasing.line.width` and + `decreasing.line.width`.""", + **kwargs + ) diff --git a/plotly/validators/ohlc/_low.py b/plotly/validators/ohlc/_low.py new file mode 100644 index 0000000000..a1f130890f --- /dev/null +++ b/plotly/validators/ohlc/_low.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LowValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='low', parent_name='ohlc', **kwargs): + super(LowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_lowsrc.py b/plotly/validators/ohlc/_lowsrc.py new file mode 100644 index 0000000000..52ff485d92 --- /dev/null +++ b/plotly/validators/ohlc/_lowsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LowsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='lowsrc', parent_name='ohlc', **kwargs): + super(LowsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_name.py b/plotly/validators/ohlc/_name.py new file mode 100644 index 0000000000..1f01d3f161 --- /dev/null +++ b/plotly/validators/ohlc/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='ohlc', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_opacity.py b/plotly/validators/ohlc/_opacity.py new file mode 100644 index 0000000000..af8bef2003 --- /dev/null +++ b/plotly/validators/ohlc/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='ohlc', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/_open.py b/plotly/validators/ohlc/_open.py new file mode 100644 index 0000000000..39035fb507 --- /dev/null +++ b/plotly/validators/ohlc/_open.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class OpenValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='open', parent_name='ohlc', **kwargs): + super(OpenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_opensrc.py b/plotly/validators/ohlc/_opensrc.py new file mode 100644 index 0000000000..c72e294f8f --- /dev/null +++ b/plotly/validators/ohlc/_opensrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class OpensrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='opensrc', parent_name='ohlc', **kwargs): + super(OpensrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_selectedpoints.py b/plotly/validators/ohlc/_selectedpoints.py new file mode 100644 index 0000000000..e2f5b2342f --- /dev/null +++ b/plotly/validators/ohlc/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='ohlc', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_showlegend.py b/plotly/validators/ohlc/_showlegend.py new file mode 100644 index 0000000000..e6431bede5 --- /dev/null +++ b/plotly/validators/ohlc/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='ohlc', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_stream.py b/plotly/validators/ohlc/_stream.py new file mode 100644 index 0000000000..5d199ea0a9 --- /dev/null +++ b/plotly/validators/ohlc/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='ohlc', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/ohlc/_text.py b/plotly/validators/ohlc/_text.py new file mode 100644 index 0000000000..d73e6ef87c --- /dev/null +++ b/plotly/validators/ohlc/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='ohlc', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_textsrc.py b/plotly/validators/ohlc/_textsrc.py new file mode 100644 index 0000000000..904c3c8c66 --- /dev/null +++ b/plotly/validators/ohlc/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='ohlc', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_tickwidth.py b/plotly/validators/ohlc/_tickwidth.py new file mode 100644 index 0000000000..686d3faa93 --- /dev/null +++ b/plotly/validators/ohlc/_tickwidth.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='tickwidth', parent_name='ohlc', **kwargs): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=0.5, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/_uid.py b/plotly/validators/ohlc/_uid.py new file mode 100644 index 0000000000..2dc76dce3b --- /dev/null +++ b/plotly/validators/ohlc/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='ohlc', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_visible.py b/plotly/validators/ohlc/_visible.py new file mode 100644 index 0000000000..62778fc137 --- /dev/null +++ b/plotly/validators/ohlc/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='ohlc', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/ohlc/_x.py b/plotly/validators/ohlc/_x.py new file mode 100644 index 0000000000..eecc5a5efd --- /dev/null +++ b/plotly/validators/ohlc/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='ohlc', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/ohlc/_xaxis.py b/plotly/validators/ohlc/_xaxis.py new file mode 100644 index 0000000000..4bc8f38b14 --- /dev/null +++ b/plotly/validators/ohlc/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='ohlc', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_xcalendar.py b/plotly/validators/ohlc/_xcalendar.py new file mode 100644 index 0000000000..36a30a0640 --- /dev/null +++ b/plotly/validators/ohlc/_xcalendar.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='xcalendar', parent_name='ohlc', **kwargs): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/ohlc/_xsrc.py b/plotly/validators/ohlc/_xsrc.py new file mode 100644 index 0000000000..d067dfb116 --- /dev/null +++ b/plotly/validators/ohlc/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='ohlc', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/_yaxis.py b/plotly/validators/ohlc/_yaxis.py new file mode 100644 index 0000000000..3ea6ba4508 --- /dev/null +++ b/plotly/validators/ohlc/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='ohlc', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/decreasing/__init__.py b/plotly/validators/ohlc/decreasing/__init__.py new file mode 100644 index 0000000000..180bd6ac8a --- /dev/null +++ b/plotly/validators/ohlc/decreasing/__init__.py @@ -0,0 +1 @@ +from ._line import LineValidator diff --git a/plotly/validators/ohlc/decreasing/_line.py b/plotly/validators/ohlc/decreasing/_line.py new file mode 100644 index 0000000000..0796ae2a1f --- /dev/null +++ b/plotly/validators/ohlc/decreasing/_line.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='ohlc.decreasing', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/ohlc/decreasing/line/__init__.py b/plotly/validators/ohlc/decreasing/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/ohlc/decreasing/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/ohlc/decreasing/line/_color.py b/plotly/validators/ohlc/decreasing/line/_color.py new file mode 100644 index 0000000000..6d541d1d5b --- /dev/null +++ b/plotly/validators/ohlc/decreasing/line/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='ohlc.decreasing.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/decreasing/line/_dash.py b/plotly/validators/ohlc/decreasing/line/_dash.py new file mode 100644 index 0000000000..e7fe7e185d --- /dev/null +++ b/plotly/validators/ohlc/decreasing/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='ohlc.decreasing.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/ohlc/decreasing/line/_width.py b/plotly/validators/ohlc/decreasing/line/_width.py new file mode 100644 index 0000000000..6fb1868f3e --- /dev/null +++ b/plotly/validators/ohlc/decreasing/line/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='ohlc.decreasing.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/__init__.py b/plotly/validators/ohlc/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/ohlc/hoverlabel/_bgcolor.py b/plotly/validators/ohlc/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..c25cf3230c --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='ohlc.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_bgcolorsrc.py b/plotly/validators/ohlc/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..3436387a5e --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='ohlc.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_bordercolor.py b/plotly/validators/ohlc/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..bc27f43b99 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='ohlc.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_bordercolorsrc.py b/plotly/validators/ohlc/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..f54eb761b0 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='ohlc.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_font.py b/plotly/validators/ohlc/hoverlabel/_font.py new file mode 100644 index 0000000000..13349eeca8 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='ohlc.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_namelength.py b/plotly/validators/ohlc/hoverlabel/_namelength.py new file mode 100644 index 0000000000..244311d4a5 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='ohlc.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/_namelengthsrc.py b/plotly/validators/ohlc/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..f49b451d71 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='ohlc.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/__init__.py b/plotly/validators/ohlc/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/ohlc/hoverlabel/font/_color.py b/plotly/validators/ohlc/hoverlabel/font/_color.py new file mode 100644 index 0000000000..f651cf3671 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='ohlc.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/_colorsrc.py b/plotly/validators/ohlc/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..f24b8b349c --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='ohlc.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/_family.py b/plotly/validators/ohlc/hoverlabel/font/_family.py new file mode 100644 index 0000000000..ed00602d11 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='ohlc.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/_familysrc.py b/plotly/validators/ohlc/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..dad66ff1f7 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='ohlc.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/_size.py b/plotly/validators/ohlc/hoverlabel/font/_size.py new file mode 100644 index 0000000000..73ede29190 --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='ohlc.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/hoverlabel/font/_sizesrc.py b/plotly/validators/ohlc/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..a2116df28a --- /dev/null +++ b/plotly/validators/ohlc/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='ohlc.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/increasing/__init__.py b/plotly/validators/ohlc/increasing/__init__.py new file mode 100644 index 0000000000..180bd6ac8a --- /dev/null +++ b/plotly/validators/ohlc/increasing/__init__.py @@ -0,0 +1 @@ +from ._line import LineValidator diff --git a/plotly/validators/ohlc/increasing/_line.py b/plotly/validators/ohlc/increasing/_line.py new file mode 100644 index 0000000000..12d678ecf9 --- /dev/null +++ b/plotly/validators/ohlc/increasing/_line.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='ohlc.increasing', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/ohlc/increasing/line/__init__.py b/plotly/validators/ohlc/increasing/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/ohlc/increasing/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/ohlc/increasing/line/_color.py b/plotly/validators/ohlc/increasing/line/_color.py new file mode 100644 index 0000000000..7a71a11895 --- /dev/null +++ b/plotly/validators/ohlc/increasing/line/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='ohlc.increasing.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/increasing/line/_dash.py b/plotly/validators/ohlc/increasing/line/_dash.py new file mode 100644 index 0000000000..ff0e526cac --- /dev/null +++ b/plotly/validators/ohlc/increasing/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='ohlc.increasing.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/ohlc/increasing/line/_width.py b/plotly/validators/ohlc/increasing/line/_width.py new file mode 100644 index 0000000000..935b03d736 --- /dev/null +++ b/plotly/validators/ohlc/increasing/line/_width.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='ohlc.increasing.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/line/__init__.py b/plotly/validators/ohlc/line/__init__.py new file mode 100644 index 0000000000..eb6697b755 --- /dev/null +++ b/plotly/validators/ohlc/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._dash import DashValidator diff --git a/plotly/validators/ohlc/line/_dash.py b/plotly/validators/ohlc/line/_dash.py new file mode 100644 index 0000000000..9744f9c5c8 --- /dev/null +++ b/plotly/validators/ohlc/line/_dash.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='dash', parent_name='ohlc.line', **kwargs): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/ohlc/line/_width.py b/plotly/validators/ohlc/line/_width.py new file mode 100644 index 0000000000..0168bc252e --- /dev/null +++ b/plotly/validators/ohlc/line/_width.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='width', parent_name='ohlc.line', **kwargs): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/ohlc/stream/__init__.py b/plotly/validators/ohlc/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/ohlc/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/ohlc/stream/_maxpoints.py b/plotly/validators/ohlc/stream/_maxpoints.py new file mode 100644 index 0000000000..561cfdced3 --- /dev/null +++ b/plotly/validators/ohlc/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='ohlc.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/ohlc/stream/_token.py b/plotly/validators/ohlc/stream/_token.py new file mode 100644 index 0000000000..34cc15f8bc --- /dev/null +++ b/plotly/validators/ohlc/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='ohlc.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/__init__.py b/plotly/validators/parcoords/__init__.py new file mode 100644 index 0000000000..423d615d51 --- /dev/null +++ b/plotly/validators/parcoords/__init__.py @@ -0,0 +1,21 @@ +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._tickfont import TickfontValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._rangefont import RangefontValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._labelfont import LabelfontValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._domain import DomainValidator +from ._dimensions import DimensionsValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator diff --git a/plotly/validators/parcoords/_customdata.py b/plotly/validators/parcoords/_customdata.py new file mode 100644 index 0000000000..0f282379bd --- /dev/null +++ b/plotly/validators/parcoords/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='parcoords', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/_customdatasrc.py b/plotly/validators/parcoords/_customdatasrc.py new file mode 100644 index 0000000000..9ffdaecd71 --- /dev/null +++ b/plotly/validators/parcoords/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='parcoords', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_dimensions.py b/plotly/validators/parcoords/_dimensions.py new file mode 100644 index 0000000000..268227f4e3 --- /dev/null +++ b/plotly/validators/parcoords/_dimensions.py @@ -0,0 +1,65 @@ +import _plotly_utils.basevalidators + + +class DimensionsValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, plotly_name='dimensions', parent_name='parcoords', **kwargs + ): + super(DimensionsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Dimension', + data_docs=""" + constraintrange + The domain range to which the filter on the + dimension is constrained. Must be an array of + `[fromValue, toValue]` with `fromValue <= + toValue`, or if `multiselect` is not disabled, + you may give an array of arrays, where each + inner array is `[fromValue, toValue]`. + label + The shown name of the dimension. + multiselect + Do we allow multiple selection ranges or just a + single range? + range + The domain range that represents the full, + shown axis extent. Defaults to the `values` + extent. Must be an array of `[fromValue, + toValue]` with finite numbers as elements. + tickformat + Sets the tick label formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + values + Dimension values. `values[n]` represents the + value of the `n`th point in the dataset, + therefore the `values` vector for all + dimensions must be the same (longer vectors + will be truncated). Each value must be a finite + number. + valuessrc + Sets the source reference on plot.ly for + values . + visible + Shows the dimension when set to `true` (the + default). Hides the dimension for `false`.""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_domain.py b/plotly/validators/parcoords/_domain.py new file mode 100644 index 0000000000..0ccd9d87cb --- /dev/null +++ b/plotly/validators/parcoords/_domain.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='domain', parent_name='parcoords', **kwargs + ): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this parcoords + trace . + row + If there is a layout grid, use the domain for + this row in the grid for this parcoords trace . + x + Sets the horizontal domain of this parcoords + trace (in plot fraction). + y + Sets the vertical domain of this parcoords + trace (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_hoverinfo.py b/plotly/validators/parcoords/_hoverinfo.py new file mode 100644 index 0000000000..dbb9b12266 --- /dev/null +++ b/plotly/validators/parcoords/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='parcoords', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_hoverinfosrc.py b/plotly/validators/parcoords/_hoverinfosrc.py new file mode 100644 index 0000000000..95c666d413 --- /dev/null +++ b/plotly/validators/parcoords/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='parcoords', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_hoverlabel.py b/plotly/validators/parcoords/_hoverlabel.py new file mode 100644 index 0000000000..1c225c6d70 --- /dev/null +++ b/plotly/validators/parcoords/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='parcoords', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_ids.py b/plotly/validators/parcoords/_ids.py new file mode 100644 index 0000000000..6ca3dcef35 --- /dev/null +++ b/plotly/validators/parcoords/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='parcoords', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/_idssrc.py b/plotly/validators/parcoords/_idssrc.py new file mode 100644 index 0000000000..bfd918b4f8 --- /dev/null +++ b/plotly/validators/parcoords/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='parcoords', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_labelfont.py b/plotly/validators/parcoords/_labelfont.py new file mode 100644 index 0000000000..0071e780aa --- /dev/null +++ b/plotly/validators/parcoords/_labelfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class LabelfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='labelfont', parent_name='parcoords', **kwargs + ): + super(LabelfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Labelfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_legendgroup.py b/plotly/validators/parcoords/_legendgroup.py new file mode 100644 index 0000000000..d60f947a36 --- /dev/null +++ b/plotly/validators/parcoords/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='parcoords', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_line.py b/plotly/validators/parcoords/_line.py new file mode 100644 index 0000000000..0567d4726a --- /dev/null +++ b/plotly/validators/parcoords/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='parcoords', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if line.color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + The default value is false, so that `parcoords` + colorscale can default to `Viridis`. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmin` must be set as well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmax` must be set as well. + color + Sets the line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.parcoords.line.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `line.cmin` and `line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a + colorbar is displayed.""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_name.py b/plotly/validators/parcoords/_name.py new file mode 100644 index 0000000000..58a62f3b54 --- /dev/null +++ b/plotly/validators/parcoords/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='parcoords', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_opacity.py b/plotly/validators/parcoords/_opacity.py new file mode 100644 index 0000000000..c0ce1eb23e --- /dev/null +++ b/plotly/validators/parcoords/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='parcoords', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/_rangefont.py b/plotly/validators/parcoords/_rangefont.py new file mode 100644 index 0000000000..1358928eb2 --- /dev/null +++ b/plotly/validators/parcoords/_rangefont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class RangefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='rangefont', parent_name='parcoords', **kwargs + ): + super(RangefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Rangefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_selectedpoints.py b/plotly/validators/parcoords/_selectedpoints.py new file mode 100644 index 0000000000..abfa4ca1b2 --- /dev/null +++ b/plotly/validators/parcoords/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='parcoords', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_showlegend.py b/plotly/validators/parcoords/_showlegend.py new file mode 100644 index 0000000000..73052c3233 --- /dev/null +++ b/plotly/validators/parcoords/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='parcoords', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_stream.py b/plotly/validators/parcoords/_stream.py new file mode 100644 index 0000000000..53dd22f0f5 --- /dev/null +++ b/plotly/validators/parcoords/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='parcoords', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_tickfont.py b/plotly/validators/parcoords/_tickfont.py new file mode 100644 index 0000000000..74bb142c5c --- /dev/null +++ b/plotly/validators/parcoords/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='parcoords', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/parcoords/_uid.py b/plotly/validators/parcoords/_uid.py new file mode 100644 index 0000000000..45f852e60c --- /dev/null +++ b/plotly/validators/parcoords/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='parcoords', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/_visible.py b/plotly/validators/parcoords/_visible.py new file mode 100644 index 0000000000..ff7ad5c9be --- /dev/null +++ b/plotly/validators/parcoords/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='parcoords', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/__init__.py b/plotly/validators/parcoords/dimension/__init__.py new file mode 100644 index 0000000000..9a3d852f6d --- /dev/null +++ b/plotly/validators/parcoords/dimension/__init__.py @@ -0,0 +1,12 @@ +from ._visible import VisibleValidator +from ._valuessrc import ValuessrcValidator +from ._values import ValuesValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._tickformat import TickformatValidator +from ._range import RangeValidator +from ._multiselect import MultiselectValidator +from ._label import LabelValidator +from ._constraintrange import ConstraintrangeValidator diff --git a/plotly/validators/parcoords/dimension/_constraintrange.py b/plotly/validators/parcoords/dimension/_constraintrange.py new file mode 100644 index 0000000000..efe803fc31 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_constraintrange.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class ConstraintrangeValidator( + _plotly_utils.basevalidators.InfoArrayValidator +): + + def __init__( + self, + plotly_name='constraintrange', + parent_name='parcoords.dimension', + **kwargs + ): + super(ConstraintrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dimensions='1-2', + edit_type='calc', + free_length=True, + items=[ + { + 'valType': 'number', + 'editType': 'calc' + }, { + 'valType': 'number', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_label.py b/plotly/validators/parcoords/dimension/_label.py new file mode 100644 index 0000000000..c64cb0985e --- /dev/null +++ b/plotly/validators/parcoords/dimension/_label.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='label', parent_name='parcoords.dimension', **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_multiselect.py b/plotly/validators/parcoords/dimension/_multiselect.py new file mode 100644 index 0000000000..046f5e3312 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_multiselect.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class MultiselectValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='multiselect', + parent_name='parcoords.dimension', + **kwargs + ): + super(MultiselectValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_range.py b/plotly/validators/parcoords/dimension/_range.py new file mode 100644 index 0000000000..6929f036f7 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_range.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class RangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='range', parent_name='parcoords.dimension', **kwargs + ): + super(RangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'editType': 'calc' + }, { + 'valType': 'number', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_tickformat.py b/plotly/validators/parcoords/dimension/_tickformat.py new file mode 100644 index 0000000000..e1e71e6f04 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='parcoords.dimension', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_ticktext.py b/plotly/validators/parcoords/dimension/_ticktext.py new file mode 100644 index 0000000000..f81661669d --- /dev/null +++ b/plotly/validators/parcoords/dimension/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='parcoords.dimension', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_ticktextsrc.py b/plotly/validators/parcoords/dimension/_ticktextsrc.py new file mode 100644 index 0000000000..56214c3779 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='parcoords.dimension', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_tickvals.py b/plotly/validators/parcoords/dimension/_tickvals.py new file mode 100644 index 0000000000..6da6f69605 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='parcoords.dimension', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_tickvalssrc.py b/plotly/validators/parcoords/dimension/_tickvalssrc.py new file mode 100644 index 0000000000..c37273381d --- /dev/null +++ b/plotly/validators/parcoords/dimension/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='parcoords.dimension', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_values.py b/plotly/validators/parcoords/dimension/_values.py new file mode 100644 index 0000000000..82ba21bfef --- /dev/null +++ b/plotly/validators/parcoords/dimension/_values.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValuesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='values', + parent_name='parcoords.dimension', + **kwargs + ): + super(ValuesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_valuessrc.py b/plotly/validators/parcoords/dimension/_valuessrc.py new file mode 100644 index 0000000000..75b17a5b8f --- /dev/null +++ b/plotly/validators/parcoords/dimension/_valuessrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValuessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='valuessrc', + parent_name='parcoords.dimension', + **kwargs + ): + super(ValuessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/dimension/_visible.py b/plotly/validators/parcoords/dimension/_visible.py new file mode 100644 index 0000000000..400410a324 --- /dev/null +++ b/plotly/validators/parcoords/dimension/_visible.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='visible', + parent_name='parcoords.dimension', + **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/domain/__init__.py b/plotly/validators/parcoords/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/parcoords/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/parcoords/domain/_column.py b/plotly/validators/parcoords/domain/_column.py new file mode 100644 index 0000000000..d8a49c2658 --- /dev/null +++ b/plotly/validators/parcoords/domain/_column.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='column', parent_name='parcoords.domain', **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/domain/_row.py b/plotly/validators/parcoords/domain/_row.py new file mode 100644 index 0000000000..d43a0c9ed9 --- /dev/null +++ b/plotly/validators/parcoords/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='parcoords.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/domain/_x.py b/plotly/validators/parcoords/domain/_x.py new file mode 100644 index 0000000000..1bdeedaa00 --- /dev/null +++ b/plotly/validators/parcoords/domain/_x.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='x', parent_name='parcoords.domain', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/domain/_y.py b/plotly/validators/parcoords/domain/_y.py new file mode 100644 index 0000000000..e0fbf83430 --- /dev/null +++ b/plotly/validators/parcoords/domain/_y.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, plotly_name='y', parent_name='parcoords.domain', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/__init__.py b/plotly/validators/parcoords/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/parcoords/hoverlabel/_bgcolor.py b/plotly/validators/parcoords/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..6a1853199c --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_bgcolorsrc.py b/plotly/validators/parcoords/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..e1d6f8248a --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_bordercolor.py b/plotly/validators/parcoords/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..ca42cb4e41 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_bordercolorsrc.py b/plotly/validators/parcoords/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..6179648272 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_font.py b/plotly/validators/parcoords/hoverlabel/_font.py new file mode 100644 index 0000000000..99bbdccdb7 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='parcoords.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_namelength.py b/plotly/validators/parcoords/hoverlabel/_namelength.py new file mode 100644 index 0000000000..3170bf9eed --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/_namelengthsrc.py b/plotly/validators/parcoords/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..f8393b23c1 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='parcoords.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/__init__.py b/plotly/validators/parcoords/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/hoverlabel/font/_color.py b/plotly/validators/parcoords/hoverlabel/font/_color.py new file mode 100644 index 0000000000..2510ae8d6e --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/_colorsrc.py b/plotly/validators/parcoords/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..ae68feac7b --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/_family.py b/plotly/validators/parcoords/hoverlabel/font/_family.py new file mode 100644 index 0000000000..de0bc8c4ca --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/_familysrc.py b/plotly/validators/parcoords/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..e7ca5d7f9a --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/_size.py b/plotly/validators/parcoords/hoverlabel/font/_size.py new file mode 100644 index 0000000000..ff157ed065 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/hoverlabel/font/_sizesrc.py b/plotly/validators/parcoords/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..b5dd2eb372 --- /dev/null +++ b/plotly/validators/parcoords/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='parcoords.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/labelfont/__init__.py b/plotly/validators/parcoords/labelfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/parcoords/labelfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/labelfont/_color.py b/plotly/validators/parcoords/labelfont/_color.py new file mode 100644 index 0000000000..11d1c6aa41 --- /dev/null +++ b/plotly/validators/parcoords/labelfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='parcoords.labelfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/labelfont/_family.py b/plotly/validators/parcoords/labelfont/_family.py new file mode 100644 index 0000000000..edc7ebe250 --- /dev/null +++ b/plotly/validators/parcoords/labelfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='parcoords.labelfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/labelfont/_size.py b/plotly/validators/parcoords/labelfont/_size.py new file mode 100644 index 0000000000..74b2864745 --- /dev/null +++ b/plotly/validators/parcoords/labelfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='parcoords.labelfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/__init__.py b/plotly/validators/parcoords/line/__init__.py new file mode 100644 index 0000000000..7c2b9405d5 --- /dev/null +++ b/plotly/validators/parcoords/line/__init__.py @@ -0,0 +1,10 @@ +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/parcoords/line/_autocolorscale.py b/plotly/validators/parcoords/line/_autocolorscale.py new file mode 100644 index 0000000000..1ab8031c4b --- /dev/null +++ b/plotly/validators/parcoords/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='parcoords.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_cauto.py b/plotly/validators/parcoords/line/_cauto.py new file mode 100644 index 0000000000..6296fb9115 --- /dev/null +++ b/plotly/validators/parcoords/line/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='parcoords.line', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_cmax.py b/plotly/validators/parcoords/line/_cmax.py new file mode 100644 index 0000000000..294a1c33cb --- /dev/null +++ b/plotly/validators/parcoords/line/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='parcoords.line', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_cmin.py b/plotly/validators/parcoords/line/_cmin.py new file mode 100644 index 0000000000..e3aab862fc --- /dev/null +++ b/plotly/validators/parcoords/line/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='parcoords.line', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_color.py b/plotly/validators/parcoords/line/_color.py new file mode 100644 index 0000000000..6ccf432239 --- /dev/null +++ b/plotly/validators/parcoords/line/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='parcoords.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='parcoords.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_colorbar.py b/plotly/validators/parcoords/line/_colorbar.py new file mode 100644 index 0000000000..4d0e852dfe --- /dev/null +++ b/plotly/validators/parcoords/line/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='parcoords.line', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.parcoords.line.colorbar.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_colorscale.py b/plotly/validators/parcoords/line/_colorscale.py new file mode 100644 index 0000000000..215238110d --- /dev/null +++ b/plotly/validators/parcoords/line/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='parcoords.line', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_colorsrc.py b/plotly/validators/parcoords/line/_colorsrc.py new file mode 100644 index 0000000000..9dd8d363d6 --- /dev/null +++ b/plotly/validators/parcoords/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='parcoords.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_reversescale.py b/plotly/validators/parcoords/line/_reversescale.py new file mode 100644 index 0000000000..679eeb2af0 --- /dev/null +++ b/plotly/validators/parcoords/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='parcoords.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/_showscale.py b/plotly/validators/parcoords/line/_showscale.py new file mode 100644 index 0000000000..5b081c3da0 --- /dev/null +++ b/plotly/validators/parcoords/line/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='parcoords.line', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/__init__.py b/plotly/validators/parcoords/line/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/parcoords/line/colorbar/_bgcolor.py b/plotly/validators/parcoords/line/colorbar/_bgcolor.py new file mode 100644 index 0000000000..a6b7dd759a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_bordercolor.py b/plotly/validators/parcoords/line/colorbar/_bordercolor.py new file mode 100644 index 0000000000..04022e4a54 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_borderwidth.py b/plotly/validators/parcoords/line/colorbar/_borderwidth.py new file mode 100644 index 0000000000..f0b7641c2e --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_dtick.py b/plotly/validators/parcoords/line/colorbar/_dtick.py new file mode 100644 index 0000000000..90204cac6a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_exponentformat.py b/plotly/validators/parcoords/line/colorbar/_exponentformat.py new file mode 100644 index 0000000000..fb3a62b08e --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_len.py b/plotly/validators/parcoords/line/colorbar/_len.py new file mode 100644 index 0000000000..c782bfb8c5 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_lenmode.py b/plotly/validators/parcoords/line/colorbar/_lenmode.py new file mode 100644 index 0000000000..838886fabd --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_nticks.py b/plotly/validators/parcoords/line/colorbar/_nticks.py new file mode 100644 index 0000000000..fd32e0b646 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_outlinecolor.py b/plotly/validators/parcoords/line/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..2520b5a5e4 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_outlinewidth.py b/plotly/validators/parcoords/line/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..0d99a42f03 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_separatethousands.py b/plotly/validators/parcoords/line/colorbar/_separatethousands.py new file mode 100644 index 0000000000..50e91344f6 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_showexponent.py b/plotly/validators/parcoords/line/colorbar/_showexponent.py new file mode 100644 index 0000000000..29bd34c129 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_showticklabels.py b/plotly/validators/parcoords/line/colorbar/_showticklabels.py new file mode 100644 index 0000000000..865e80e33f --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_showtickprefix.py b/plotly/validators/parcoords/line/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..2038d0c2b8 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_showticksuffix.py b/plotly/validators/parcoords/line/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..ae7cae3c70 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_thickness.py b/plotly/validators/parcoords/line/colorbar/_thickness.py new file mode 100644 index 0000000000..069d4da665 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_thicknessmode.py b/plotly/validators/parcoords/line/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..ed04ae32f7 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tick0.py b/plotly/validators/parcoords/line/colorbar/_tick0.py new file mode 100644 index 0000000000..645535a428 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickangle.py b/plotly/validators/parcoords/line/colorbar/_tickangle.py new file mode 100644 index 0000000000..3f3e55b075 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickcolor.py b/plotly/validators/parcoords/line/colorbar/_tickcolor.py new file mode 100644 index 0000000000..ba2e6e5dd3 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickfont.py b/plotly/validators/parcoords/line/colorbar/_tickfont.py new file mode 100644 index 0000000000..479ad6d05a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickformat.py b/plotly/validators/parcoords/line/colorbar/_tickformat.py new file mode 100644 index 0000000000..782fff449b --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickformatstops.py b/plotly/validators/parcoords/line/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..d6002e7e19 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ticklen.py b/plotly/validators/parcoords/line/colorbar/_ticklen.py new file mode 100644 index 0000000000..c2932bf85f --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickmode.py b/plotly/validators/parcoords/line/colorbar/_tickmode.py new file mode 100644 index 0000000000..5b248b9a53 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickprefix.py b/plotly/validators/parcoords/line/colorbar/_tickprefix.py new file mode 100644 index 0000000000..cc30662eba --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ticks.py b/plotly/validators/parcoords/line/colorbar/_ticks.py new file mode 100644 index 0000000000..d10dc4068b --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ticksuffix.py b/plotly/validators/parcoords/line/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..111036348a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ticktext.py b/plotly/validators/parcoords/line/colorbar/_ticktext.py new file mode 100644 index 0000000000..c06c46fb4a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ticktextsrc.py b/plotly/validators/parcoords/line/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..47b314df47 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickvals.py b/plotly/validators/parcoords/line/colorbar/_tickvals.py new file mode 100644 index 0000000000..2323975e1a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickvalssrc.py b/plotly/validators/parcoords/line/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..f4a3b6521e --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_tickwidth.py b/plotly/validators/parcoords/line/colorbar/_tickwidth.py new file mode 100644 index 0000000000..fad1a8f607 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_title.py b/plotly/validators/parcoords/line/colorbar/_title.py new file mode 100644 index 0000000000..a9e8e0206d --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_titlefont.py b/plotly/validators/parcoords/line/colorbar/_titlefont.py new file mode 100644 index 0000000000..2d28497ad9 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_titleside.py b/plotly/validators/parcoords/line/colorbar/_titleside.py new file mode 100644 index 0000000000..ec305740b5 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_x.py b/plotly/validators/parcoords/line/colorbar/_x.py new file mode 100644 index 0000000000..5c9d2a0d04 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='parcoords.line.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_xanchor.py b/plotly/validators/parcoords/line/colorbar/_xanchor.py new file mode 100644 index 0000000000..6e1d006d39 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_xpad.py b/plotly/validators/parcoords/line/colorbar/_xpad.py new file mode 100644 index 0000000000..afa7ab7c8d --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_y.py b/plotly/validators/parcoords/line/colorbar/_y.py new file mode 100644 index 0000000000..329e54c721 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='parcoords.line.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_yanchor.py b/plotly/validators/parcoords/line/colorbar/_yanchor.py new file mode 100644 index 0000000000..cd9707ed5e --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/_ypad.py b/plotly/validators/parcoords/line/colorbar/_ypad.py new file mode 100644 index 0000000000..0dd7e356cb --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='parcoords.line.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/tickfont/__init__.py b/plotly/validators/parcoords/line/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/line/colorbar/tickfont/_color.py b/plotly/validators/parcoords/line/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..8aa9645027 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='parcoords.line.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/tickfont/_family.py b/plotly/validators/parcoords/line/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..81b0f6ae18 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='parcoords.line.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/tickfont/_size.py b/plotly/validators/parcoords/line/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..906d86fafc --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='parcoords.line.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/tickformatstop/__init__.py b/plotly/validators/parcoords/line/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/parcoords/line/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/parcoords/line/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..44bc2ff807 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='parcoords.line.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/tickformatstop/_value.py b/plotly/validators/parcoords/line/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..2097961a64 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='parcoords.line.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/titlefont/__init__.py b/plotly/validators/parcoords/line/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/line/colorbar/titlefont/_color.py b/plotly/validators/parcoords/line/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..7964517d61 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='parcoords.line.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/titlefont/_family.py b/plotly/validators/parcoords/line/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..f19d864345 --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='parcoords.line.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/line/colorbar/titlefont/_size.py b/plotly/validators/parcoords/line/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..8ad5477e1a --- /dev/null +++ b/plotly/validators/parcoords/line/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='parcoords.line.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/rangefont/__init__.py b/plotly/validators/parcoords/rangefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/parcoords/rangefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/rangefont/_color.py b/plotly/validators/parcoords/rangefont/_color.py new file mode 100644 index 0000000000..b91843bb89 --- /dev/null +++ b/plotly/validators/parcoords/rangefont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='parcoords.rangefont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/rangefont/_family.py b/plotly/validators/parcoords/rangefont/_family.py new file mode 100644 index 0000000000..f2a002abce --- /dev/null +++ b/plotly/validators/parcoords/rangefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='parcoords.rangefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/rangefont/_size.py b/plotly/validators/parcoords/rangefont/_size.py new file mode 100644 index 0000000000..4a7450fcd1 --- /dev/null +++ b/plotly/validators/parcoords/rangefont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='parcoords.rangefont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/stream/__init__.py b/plotly/validators/parcoords/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/parcoords/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/parcoords/stream/_maxpoints.py b/plotly/validators/parcoords/stream/_maxpoints.py new file mode 100644 index 0000000000..44bd0e056a --- /dev/null +++ b/plotly/validators/parcoords/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='parcoords.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/parcoords/stream/_token.py b/plotly/validators/parcoords/stream/_token.py new file mode 100644 index 0000000000..0c4ac62d5a --- /dev/null +++ b/plotly/validators/parcoords/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='parcoords.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/tickfont/__init__.py b/plotly/validators/parcoords/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/parcoords/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/parcoords/tickfont/_color.py b/plotly/validators/parcoords/tickfont/_color.py new file mode 100644 index 0000000000..31c3a0b3dd --- /dev/null +++ b/plotly/validators/parcoords/tickfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='parcoords.tickfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/parcoords/tickfont/_family.py b/plotly/validators/parcoords/tickfont/_family.py new file mode 100644 index 0000000000..8de8d5041e --- /dev/null +++ b/plotly/validators/parcoords/tickfont/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='parcoords.tickfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/parcoords/tickfont/_size.py b/plotly/validators/parcoords/tickfont/_size.py new file mode 100644 index 0000000000..6f1207b53b --- /dev/null +++ b/plotly/validators/parcoords/tickfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='parcoords.tickfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/__init__.py b/plotly/validators/pie/__init__.py new file mode 100644 index 0000000000..5abb2d227d --- /dev/null +++ b/plotly/validators/pie/__init__.py @@ -0,0 +1,40 @@ +from ._visible import VisibleValidator +from ._valuessrc import ValuessrcValidator +from ._values import ValuesValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textinfo import TextinfoValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._sort import SortValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._scalegroup import ScalegroupValidator +from ._rotation import RotationValidator +from ._pullsrc import PullsrcValidator +from ._pull import PullValidator +from ._outsidetextfont import OutsidetextfontValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._labelssrc import LabelssrcValidator +from ._labels import LabelsValidator +from ._label0 import Label0Validator +from ._insidetextfont import InsidetextfontValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._hole import HoleValidator +from ._domain import DomainValidator +from ._dlabel import DlabelValidator +from ._direction import DirectionValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator diff --git a/plotly/validators/pie/_customdata.py b/plotly/validators/pie/_customdata.py new file mode 100644 index 0000000000..3e4f8ee754 --- /dev/null +++ b/plotly/validators/pie/_customdata.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='customdata', parent_name='pie', **kwargs): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/_customdatasrc.py b/plotly/validators/pie/_customdatasrc.py new file mode 100644 index 0000000000..40f54097e5 --- /dev/null +++ b/plotly/validators/pie/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='pie', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_direction.py b/plotly/validators/pie/_direction.py new file mode 100644 index 0000000000..d60981a070 --- /dev/null +++ b/plotly/validators/pie/_direction.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class DirectionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='direction', parent_name='pie', **kwargs): + super(DirectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['clockwise', 'counterclockwise'], + **kwargs + ) diff --git a/plotly/validators/pie/_dlabel.py b/plotly/validators/pie/_dlabel.py new file mode 100644 index 0000000000..a293c36cbf --- /dev/null +++ b/plotly/validators/pie/_dlabel.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DlabelValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dlabel', parent_name='pie', **kwargs): + super(DlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_domain.py b/plotly/validators/pie/_domain.py new file mode 100644 index 0000000000..877159c37b --- /dev/null +++ b/plotly/validators/pie/_domain.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='domain', parent_name='pie', **kwargs): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this pie trace . + row + If there is a layout grid, use the domain for + this row in the grid for this pie trace . + x + Sets the horizontal domain of this pie trace + (in plot fraction). + y + Sets the vertical domain of this pie trace (in + plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/pie/_hole.py b/plotly/validators/pie/_hole.py new file mode 100644 index 0000000000..e62b16a0e0 --- /dev/null +++ b/plotly/validators/pie/_hole.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoleValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='hole', parent_name='pie', **kwargs): + super(HoleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/_hoverinfo.py b/plotly/validators/pie/_hoverinfo.py new file mode 100644 index 0000000000..8fa18b5b49 --- /dev/null +++ b/plotly/validators/pie/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='pie', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['label', 'text', 'value', 'percent', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_hoverinfosrc.py b/plotly/validators/pie/_hoverinfosrc.py new file mode 100644 index 0000000000..3bd832754f --- /dev/null +++ b/plotly/validators/pie/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='pie', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_hoverlabel.py b/plotly/validators/pie/_hoverlabel.py new file mode 100644 index 0000000000..34430e9f90 --- /dev/null +++ b/plotly/validators/pie/_hoverlabel.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='hoverlabel', parent_name='pie', **kwargs): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/pie/_hovertext.py b/plotly/validators/pie/_hovertext.py new file mode 100644 index 0000000000..795c18bd89 --- /dev/null +++ b/plotly/validators/pie/_hovertext.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='hovertext', parent_name='pie', **kwargs): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_hovertextsrc.py b/plotly/validators/pie/_hovertextsrc.py new file mode 100644 index 0000000000..9cd83921e7 --- /dev/null +++ b/plotly/validators/pie/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='pie', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_ids.py b/plotly/validators/pie/_ids.py new file mode 100644 index 0000000000..70960cb703 --- /dev/null +++ b/plotly/validators/pie/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='pie', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/_idssrc.py b/plotly/validators/pie/_idssrc.py new file mode 100644 index 0000000000..96268b8ace --- /dev/null +++ b/plotly/validators/pie/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='pie', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_insidetextfont.py b/plotly/validators/pie/_insidetextfont.py new file mode 100644 index 0000000000..366a27fed3 --- /dev/null +++ b/plotly/validators/pie/_insidetextfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class InsidetextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='insidetextfont', parent_name='pie', **kwargs + ): + super(InsidetextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Insidetextfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/pie/_label0.py b/plotly/validators/pie/_label0.py new file mode 100644 index 0000000000..e940a67c0c --- /dev/null +++ b/plotly/validators/pie/_label0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Label0Validator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='label0', parent_name='pie', **kwargs): + super(Label0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_labels.py b/plotly/validators/pie/_labels.py new file mode 100644 index 0000000000..8576c59710 --- /dev/null +++ b/plotly/validators/pie/_labels.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LabelsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='labels', parent_name='pie', **kwargs): + super(LabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/_labelssrc.py b/plotly/validators/pie/_labelssrc.py new file mode 100644 index 0000000000..83bfa7dcb7 --- /dev/null +++ b/plotly/validators/pie/_labelssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LabelssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='labelssrc', parent_name='pie', **kwargs): + super(LabelssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_legendgroup.py b/plotly/validators/pie/_legendgroup.py new file mode 100644 index 0000000000..16e182fbd4 --- /dev/null +++ b/plotly/validators/pie/_legendgroup.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='legendgroup', parent_name='pie', **kwargs): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_marker.py b/plotly/validators/pie/_marker.py new file mode 100644 index 0000000000..4920c3cef7 --- /dev/null +++ b/plotly/validators/pie/_marker.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='pie', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + colors + Sets the color of each sector of this pie + chart. If not specified, the default trace + color set is used to pick the sector colors. + colorssrc + Sets the source reference on plot.ly for + colors . + line + plotly.graph_objs.pie.marker.Line instance or + dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/pie/_name.py b/plotly/validators/pie/_name.py new file mode 100644 index 0000000000..500ef350cb --- /dev/null +++ b/plotly/validators/pie/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='pie', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_opacity.py b/plotly/validators/pie/_opacity.py new file mode 100644 index 0000000000..194dd4d50e --- /dev/null +++ b/plotly/validators/pie/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='pie', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/_outsidetextfont.py b/plotly/validators/pie/_outsidetextfont.py new file mode 100644 index 0000000000..8749d77d86 --- /dev/null +++ b/plotly/validators/pie/_outsidetextfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class OutsidetextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='outsidetextfont', parent_name='pie', **kwargs + ): + super(OutsidetextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Outsidetextfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/pie/_pull.py b/plotly/validators/pie/_pull.py new file mode 100644 index 0000000000..39a62cd7a9 --- /dev/null +++ b/plotly/validators/pie/_pull.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class PullValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='pull', parent_name='pie', **kwargs): + super(PullValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/_pullsrc.py b/plotly/validators/pie/_pullsrc.py new file mode 100644 index 0000000000..32922d9c41 --- /dev/null +++ b/plotly/validators/pie/_pullsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class PullsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='pullsrc', parent_name='pie', **kwargs): + super(PullsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_rotation.py b/plotly/validators/pie/_rotation.py new file mode 100644 index 0000000000..b3939ef2ac --- /dev/null +++ b/plotly/validators/pie/_rotation.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RotationValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='rotation', parent_name='pie', **kwargs): + super(RotationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=360, + min=-360, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/_scalegroup.py b/plotly/validators/pie/_scalegroup.py new file mode 100644 index 0000000000..dde7d84340 --- /dev/null +++ b/plotly/validators/pie/_scalegroup.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ScalegroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='scalegroup', parent_name='pie', **kwargs): + super(ScalegroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_selectedpoints.py b/plotly/validators/pie/_selectedpoints.py new file mode 100644 index 0000000000..1a0469c6af --- /dev/null +++ b/plotly/validators/pie/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='pie', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_showlegend.py b/plotly/validators/pie/_showlegend.py new file mode 100644 index 0000000000..89110417fd --- /dev/null +++ b/plotly/validators/pie/_showlegend.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='showlegend', parent_name='pie', **kwargs): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_sort.py b/plotly/validators/pie/_sort.py new file mode 100644 index 0000000000..a133de8915 --- /dev/null +++ b/plotly/validators/pie/_sort.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class SortValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='sort', parent_name='pie', **kwargs): + super(SortValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/_stream.py b/plotly/validators/pie/_stream.py new file mode 100644 index 0000000000..5cf00a6bdf --- /dev/null +++ b/plotly/validators/pie/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='pie', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/pie/_text.py b/plotly/validators/pie/_text.py new file mode 100644 index 0000000000..6eebf4f5de --- /dev/null +++ b/plotly/validators/pie/_text.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='text', parent_name='pie', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/_textfont.py b/plotly/validators/pie/_textfont.py new file mode 100644 index 0000000000..69fe29e78d --- /dev/null +++ b/plotly/validators/pie/_textfont.py @@ -0,0 +1,33 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='textfont', parent_name='pie', **kwargs): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/pie/_textinfo.py b/plotly/validators/pie/_textinfo.py new file mode 100644 index 0000000000..e5f304c877 --- /dev/null +++ b/plotly/validators/pie/_textinfo.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='textinfo', parent_name='pie', **kwargs): + super(TextinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['label', 'text', 'value', 'percent'], + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_textposition.py b/plotly/validators/pie/_textposition.py new file mode 100644 index 0000000000..6dcf154f52 --- /dev/null +++ b/plotly/validators/pie/_textposition.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='pie', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + values=['inside', 'outside', 'auto', 'none'], + **kwargs + ) diff --git a/plotly/validators/pie/_textpositionsrc.py b/plotly/validators/pie/_textpositionsrc.py new file mode 100644 index 0000000000..b1a4d2f3ba --- /dev/null +++ b/plotly/validators/pie/_textpositionsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textpositionsrc', parent_name='pie', **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_textsrc.py b/plotly/validators/pie/_textsrc.py new file mode 100644 index 0000000000..0ebc19a248 --- /dev/null +++ b/plotly/validators/pie/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='pie', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_uid.py b/plotly/validators/pie/_uid.py new file mode 100644 index 0000000000..736866893c --- /dev/null +++ b/plotly/validators/pie/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='pie', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_values.py b/plotly/validators/pie/_values.py new file mode 100644 index 0000000000..efee8fc9d3 --- /dev/null +++ b/plotly/validators/pie/_values.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ValuesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='values', parent_name='pie', **kwargs): + super(ValuesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/_valuessrc.py b/plotly/validators/pie/_valuessrc.py new file mode 100644 index 0000000000..7588e4cf8c --- /dev/null +++ b/plotly/validators/pie/_valuessrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ValuessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='valuessrc', parent_name='pie', **kwargs): + super(ValuessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/_visible.py b/plotly/validators/pie/_visible.py new file mode 100644 index 0000000000..909e01aa41 --- /dev/null +++ b/plotly/validators/pie/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='pie', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/pie/domain/__init__.py b/plotly/validators/pie/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/pie/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/pie/domain/_column.py b/plotly/validators/pie/domain/_column.py new file mode 100644 index 0000000000..9eaa7fd4bc --- /dev/null +++ b/plotly/validators/pie/domain/_column.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='column', parent_name='pie.domain', **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/domain/_row.py b/plotly/validators/pie/domain/_row.py new file mode 100644 index 0000000000..5998f28915 --- /dev/null +++ b/plotly/validators/pie/domain/_row.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__(self, plotly_name='row', parent_name='pie.domain', **kwargs): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/domain/_x.py b/plotly/validators/pie/domain/_x.py new file mode 100644 index 0000000000..a61d36454c --- /dev/null +++ b/plotly/validators/pie/domain/_x.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='x', parent_name='pie.domain', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/domain/_y.py b/plotly/validators/pie/domain/_y.py new file mode 100644 index 0000000000..7eda3735aa --- /dev/null +++ b/plotly/validators/pie/domain/_y.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='y', parent_name='pie.domain', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/__init__.py b/plotly/validators/pie/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/pie/hoverlabel/_bgcolor.py b/plotly/validators/pie/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..84d4851d5f --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='pie.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_bgcolorsrc.py b/plotly/validators/pie/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..fba04e3db0 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bgcolorsrc', parent_name='pie.hoverlabel', **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_bordercolor.py b/plotly/validators/pie/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..e86ba04086 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='pie.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_bordercolorsrc.py b/plotly/validators/pie/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..a362975d76 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='pie.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_font.py b/plotly/validators/pie/hoverlabel/_font.py new file mode 100644 index 0000000000..0cf92108f0 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='pie.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_namelength.py b/plotly/validators/pie/hoverlabel/_namelength.py new file mode 100644 index 0000000000..f12de382be --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_namelength.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='namelength', parent_name='pie.hoverlabel', **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/_namelengthsrc.py b/plotly/validators/pie/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..6956992619 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='pie.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/__init__.py b/plotly/validators/pie/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/pie/hoverlabel/font/_color.py b/plotly/validators/pie/hoverlabel/font/_color.py new file mode 100644 index 0000000000..23ac9e5d46 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pie.hoverlabel.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/_colorsrc.py b/plotly/validators/pie/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..367451fa75 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='pie.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/_family.py b/plotly/validators/pie/hoverlabel/font/_family.py new file mode 100644 index 0000000000..18aa28530d --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='pie.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/_familysrc.py b/plotly/validators/pie/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..df5d292213 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='pie.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/_size.py b/plotly/validators/pie/hoverlabel/font/_size.py new file mode 100644 index 0000000000..031d0107bb --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='pie.hoverlabel.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/hoverlabel/font/_sizesrc.py b/plotly/validators/pie/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..24327ec961 --- /dev/null +++ b/plotly/validators/pie/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='pie.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/insidetextfont/__init__.py b/plotly/validators/pie/insidetextfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/pie/insidetextfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/pie/insidetextfont/_color.py b/plotly/validators/pie/insidetextfont/_color.py new file mode 100644 index 0000000000..06cf042b7f --- /dev/null +++ b/plotly/validators/pie/insidetextfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pie.insidetextfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/insidetextfont/_family.py b/plotly/validators/pie/insidetextfont/_family.py new file mode 100644 index 0000000000..7c49fbf36e --- /dev/null +++ b/plotly/validators/pie/insidetextfont/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='pie.insidetextfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pie/insidetextfont/_size.py b/plotly/validators/pie/insidetextfont/_size.py new file mode 100644 index 0000000000..75845903c4 --- /dev/null +++ b/plotly/validators/pie/insidetextfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='pie.insidetextfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/marker/__init__.py b/plotly/validators/pie/marker/__init__.py new file mode 100644 index 0000000000..899d77e755 --- /dev/null +++ b/plotly/validators/pie/marker/__init__.py @@ -0,0 +1,3 @@ +from ._line import LineValidator +from ._colorssrc import ColorssrcValidator +from ._colors import ColorsValidator diff --git a/plotly/validators/pie/marker/_colors.py b/plotly/validators/pie/marker/_colors.py new file mode 100644 index 0000000000..6dba4d263b --- /dev/null +++ b/plotly/validators/pie/marker/_colors.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='colors', parent_name='pie.marker', **kwargs + ): + super(ColorsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pie/marker/_colorssrc.py b/plotly/validators/pie/marker/_colorssrc.py new file mode 100644 index 0000000000..cba3b3bad9 --- /dev/null +++ b/plotly/validators/pie/marker/_colorssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorssrc', parent_name='pie.marker', **kwargs + ): + super(ColorssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/marker/_line.py b/plotly/validators/pie/marker/_line.py new file mode 100644 index 0000000000..d5cdb5180e --- /dev/null +++ b/plotly/validators/pie/marker/_line.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='pie.marker', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the line enclosing each + sector. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the line enclosing + each sector. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/pie/marker/line/__init__.py b/plotly/validators/pie/marker/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/pie/marker/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/pie/marker/line/_color.py b/plotly/validators/pie/marker/line/_color.py new file mode 100644 index 0000000000..a8398fc274 --- /dev/null +++ b/plotly/validators/pie/marker/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pie.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/marker/line/_colorsrc.py b/plotly/validators/pie/marker/line/_colorsrc.py new file mode 100644 index 0000000000..51b8c579cf --- /dev/null +++ b/plotly/validators/pie/marker/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='pie.marker.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/marker/line/_width.py b/plotly/validators/pie/marker/line/_width.py new file mode 100644 index 0000000000..370749437d --- /dev/null +++ b/plotly/validators/pie/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='pie.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/marker/line/_widthsrc.py b/plotly/validators/pie/marker/line/_widthsrc.py new file mode 100644 index 0000000000..74b3355546 --- /dev/null +++ b/plotly/validators/pie/marker/line/_widthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='widthsrc', parent_name='pie.marker.line', **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/outsidetextfont/__init__.py b/plotly/validators/pie/outsidetextfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/pie/outsidetextfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/pie/outsidetextfont/_color.py b/plotly/validators/pie/outsidetextfont/_color.py new file mode 100644 index 0000000000..f0272c0559 --- /dev/null +++ b/plotly/validators/pie/outsidetextfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pie.outsidetextfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/outsidetextfont/_family.py b/plotly/validators/pie/outsidetextfont/_family.py new file mode 100644 index 0000000000..8dcf0e6e28 --- /dev/null +++ b/plotly/validators/pie/outsidetextfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='pie.outsidetextfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pie/outsidetextfont/_size.py b/plotly/validators/pie/outsidetextfont/_size.py new file mode 100644 index 0000000000..0c80cae062 --- /dev/null +++ b/plotly/validators/pie/outsidetextfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='pie.outsidetextfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/stream/__init__.py b/plotly/validators/pie/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/pie/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/pie/stream/_maxpoints.py b/plotly/validators/pie/stream/_maxpoints.py new file mode 100644 index 0000000000..977d2c8994 --- /dev/null +++ b/plotly/validators/pie/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='pie.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/pie/stream/_token.py b/plotly/validators/pie/stream/_token.py new file mode 100644 index 0000000000..93a7b13de7 --- /dev/null +++ b/plotly/validators/pie/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='pie.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pie/textfont/__init__.py b/plotly/validators/pie/textfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/pie/textfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/pie/textfont/_color.py b/plotly/validators/pie/textfont/_color.py new file mode 100644 index 0000000000..53c10cfb20 --- /dev/null +++ b/plotly/validators/pie/textfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pie.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/pie/textfont/_family.py b/plotly/validators/pie/textfont/_family.py new file mode 100644 index 0000000000..b7bf00aad6 --- /dev/null +++ b/plotly/validators/pie/textfont/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='pie.textfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pie/textfont/_size.py b/plotly/validators/pie/textfont/_size.py new file mode 100644 index 0000000000..e9c6b85168 --- /dev/null +++ b/plotly/validators/pie/textfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='pie.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/__init__.py b/plotly/validators/pointcloud/__init__.py new file mode 100644 index 0000000000..5d9cbe6112 --- /dev/null +++ b/plotly/validators/pointcloud/__init__.py @@ -0,0 +1,32 @@ +from ._ysrc import YsrcValidator +from ._yboundssrc import YboundssrcValidator +from ._ybounds import YboundsValidator +from ._yaxis import YAxisValidator +from ._y import YValidator +from ._xysrc import XysrcValidator +from ._xy import XyValidator +from ._xsrc import XsrcValidator +from ._xboundssrc import XboundssrcValidator +from ._xbounds import XboundsValidator +from ._xaxis import XAxisValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._indicessrc import IndicessrcValidator +from ._indices import IndicesValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator diff --git a/plotly/validators/pointcloud/_customdata.py b/plotly/validators/pointcloud/_customdata.py new file mode 100644 index 0000000000..ec75a34dde --- /dev/null +++ b/plotly/validators/pointcloud/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='pointcloud', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_customdatasrc.py b/plotly/validators/pointcloud/_customdatasrc.py new file mode 100644 index 0000000000..583b32d62c --- /dev/null +++ b/plotly/validators/pointcloud/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='pointcloud', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_hoverinfo.py b/plotly/validators/pointcloud/_hoverinfo.py new file mode 100644 index 0000000000..d6314d86df --- /dev/null +++ b/plotly/validators/pointcloud/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='pointcloud', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_hoverinfosrc.py b/plotly/validators/pointcloud/_hoverinfosrc.py new file mode 100644 index 0000000000..9b2e1320de --- /dev/null +++ b/plotly/validators/pointcloud/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='pointcloud', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_hoverlabel.py b/plotly/validators/pointcloud/_hoverlabel.py new file mode 100644 index 0000000000..f3a83f97b1 --- /dev/null +++ b/plotly/validators/pointcloud/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='pointcloud', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/pointcloud/_ids.py b/plotly/validators/pointcloud/_ids.py new file mode 100644 index 0000000000..828312f960 --- /dev/null +++ b/plotly/validators/pointcloud/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='pointcloud', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_idssrc.py b/plotly/validators/pointcloud/_idssrc.py new file mode 100644 index 0000000000..3f18499837 --- /dev/null +++ b/plotly/validators/pointcloud/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='pointcloud', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_indices.py b/plotly/validators/pointcloud/_indices.py new file mode 100644 index 0000000000..024d5f0031 --- /dev/null +++ b/plotly/validators/pointcloud/_indices.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IndicesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='indices', parent_name='pointcloud', **kwargs + ): + super(IndicesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_indicessrc.py b/plotly/validators/pointcloud/_indicessrc.py new file mode 100644 index 0000000000..10ad364b5c --- /dev/null +++ b/plotly/validators/pointcloud/_indicessrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IndicessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='indicessrc', parent_name='pointcloud', **kwargs + ): + super(IndicessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_legendgroup.py b/plotly/validators/pointcloud/_legendgroup.py new file mode 100644 index 0000000000..0a9b9066e8 --- /dev/null +++ b/plotly/validators/pointcloud/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='pointcloud', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_marker.py b/plotly/validators/pointcloud/_marker.py new file mode 100644 index 0000000000..3e5b7151e4 --- /dev/null +++ b/plotly/validators/pointcloud/_marker.py @@ -0,0 +1,45 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='pointcloud', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + blend + Determines if colors are blended together for a + translucency effect in case `opacity` is + specified as a value less then `1`. Setting + `blend` to `true` reduces zoom/pan speed if + used with large numbers of points. + border + plotly.graph_objs.pointcloud.marker.Border + instance or dict with compatible properties + color + Sets the marker fill color. It accepts a + specific color.If the color is not fully opaque + and there are hundreds of thousandsof points, + it may cause slower zooming and panning. + opacity + Sets the marker opacity. The default value is + `1` (fully opaque). If the markers are not + fully opaque and there are hundreds of + thousands of points, it may cause slower + zooming and panning. Opacity fades the color + even if `blend` is left on `false` even if + there is no translucency effect in that case. + sizemax + Sets the maximum size (in px) of the rendered + marker points. Effective when the `pointcloud` + shows only few points. + sizemin + Sets the minimum size (in px) of the rendered + marker points, effective when the `pointcloud` + shows a million or more points.""", + **kwargs + ) diff --git a/plotly/validators/pointcloud/_name.py b/plotly/validators/pointcloud/_name.py new file mode 100644 index 0000000000..8665bd0f6d --- /dev/null +++ b/plotly/validators/pointcloud/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='pointcloud', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_opacity.py b/plotly/validators/pointcloud/_opacity.py new file mode 100644 index 0000000000..058be66186 --- /dev/null +++ b/plotly/validators/pointcloud/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='pointcloud', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_selectedpoints.py b/plotly/validators/pointcloud/_selectedpoints.py new file mode 100644 index 0000000000..7bfe76e396 --- /dev/null +++ b/plotly/validators/pointcloud/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='pointcloud', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_showlegend.py b/plotly/validators/pointcloud/_showlegend.py new file mode 100644 index 0000000000..a285292ffe --- /dev/null +++ b/plotly/validators/pointcloud/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='pointcloud', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_stream.py b/plotly/validators/pointcloud/_stream.py new file mode 100644 index 0000000000..e428b82d9a --- /dev/null +++ b/plotly/validators/pointcloud/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='pointcloud', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/pointcloud/_text.py b/plotly/validators/pointcloud/_text.py new file mode 100644 index 0000000000..190e6c84ad --- /dev/null +++ b/plotly/validators/pointcloud/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='pointcloud', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_textsrc.py b/plotly/validators/pointcloud/_textsrc.py new file mode 100644 index 0000000000..f26ddbed18 --- /dev/null +++ b/plotly/validators/pointcloud/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='pointcloud', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_uid.py b/plotly/validators/pointcloud/_uid.py new file mode 100644 index 0000000000..69cc054667 --- /dev/null +++ b/plotly/validators/pointcloud/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='pointcloud', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_visible.py b/plotly/validators/pointcloud/_visible.py new file mode 100644 index 0000000000..c5894a72cb --- /dev/null +++ b/plotly/validators/pointcloud/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='pointcloud', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/pointcloud/_x.py b/plotly/validators/pointcloud/_x.py new file mode 100644 index 0000000000..cca06c73aa --- /dev/null +++ b/plotly/validators/pointcloud/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='pointcloud', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xaxis.py b/plotly/validators/pointcloud/_xaxis.py new file mode 100644 index 0000000000..35ef3aad31 --- /dev/null +++ b/plotly/validators/pointcloud/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='pointcloud', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xbounds.py b/plotly/validators/pointcloud/_xbounds.py new file mode 100644 index 0000000000..de42cc7e9d --- /dev/null +++ b/plotly/validators/pointcloud/_xbounds.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XboundsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='xbounds', parent_name='pointcloud', **kwargs + ): + super(XboundsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xboundssrc.py b/plotly/validators/pointcloud/_xboundssrc.py new file mode 100644 index 0000000000..fadf2e7449 --- /dev/null +++ b/plotly/validators/pointcloud/_xboundssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XboundssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='xboundssrc', parent_name='pointcloud', **kwargs + ): + super(XboundssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xsrc.py b/plotly/validators/pointcloud/_xsrc.py new file mode 100644 index 0000000000..955badbf7d --- /dev/null +++ b/plotly/validators/pointcloud/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='pointcloud', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xy.py b/plotly/validators/pointcloud/_xy.py new file mode 100644 index 0000000000..7a16f1e1fb --- /dev/null +++ b/plotly/validators/pointcloud/_xy.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XyValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='xy', parent_name='pointcloud', **kwargs): + super(XyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_xysrc.py b/plotly/validators/pointcloud/_xysrc.py new file mode 100644 index 0000000000..d70acc8d4a --- /dev/null +++ b/plotly/validators/pointcloud/_xysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class XysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='xysrc', parent_name='pointcloud', **kwargs + ): + super(XysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_y.py b/plotly/validators/pointcloud/_y.py new file mode 100644 index 0000000000..dfc46fe420 --- /dev/null +++ b/plotly/validators/pointcloud/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='pointcloud', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_yaxis.py b/plotly/validators/pointcloud/_yaxis.py new file mode 100644 index 0000000000..b64a42d186 --- /dev/null +++ b/plotly/validators/pointcloud/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='pointcloud', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_ybounds.py b/plotly/validators/pointcloud/_ybounds.py new file mode 100644 index 0000000000..4e58e10752 --- /dev/null +++ b/plotly/validators/pointcloud/_ybounds.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YboundsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ybounds', parent_name='pointcloud', **kwargs + ): + super(YboundsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_yboundssrc.py b/plotly/validators/pointcloud/_yboundssrc.py new file mode 100644 index 0000000000..87828953a6 --- /dev/null +++ b/plotly/validators/pointcloud/_yboundssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class YboundssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='yboundssrc', parent_name='pointcloud', **kwargs + ): + super(YboundssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/_ysrc.py b/plotly/validators/pointcloud/_ysrc.py new file mode 100644 index 0000000000..f9853f28c2 --- /dev/null +++ b/plotly/validators/pointcloud/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='pointcloud', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/__init__.py b/plotly/validators/pointcloud/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/pointcloud/hoverlabel/_bgcolor.py b/plotly/validators/pointcloud/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..7130e35953 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_bgcolorsrc.py b/plotly/validators/pointcloud/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..9e87b54827 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_bordercolor.py b/plotly/validators/pointcloud/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..06b746c264 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_bordercolorsrc.py b/plotly/validators/pointcloud/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..f44e3915ab --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_font.py b/plotly/validators/pointcloud/hoverlabel/_font.py new file mode 100644 index 0000000000..55dee91734 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_namelength.py b/plotly/validators/pointcloud/hoverlabel/_namelength.py new file mode 100644 index 0000000000..099fba38db --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/_namelengthsrc.py b/plotly/validators/pointcloud/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..f6703f4887 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='pointcloud.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/__init__.py b/plotly/validators/pointcloud/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/pointcloud/hoverlabel/font/_color.py b/plotly/validators/pointcloud/hoverlabel/font/_color.py new file mode 100644 index 0000000000..fa8f6c111d --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/_colorsrc.py b/plotly/validators/pointcloud/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..0ffd80cdd3 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/_family.py b/plotly/validators/pointcloud/hoverlabel/font/_family.py new file mode 100644 index 0000000000..197cbc31d2 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/_familysrc.py b/plotly/validators/pointcloud/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..e0da7b3416 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/_size.py b/plotly/validators/pointcloud/hoverlabel/font/_size.py new file mode 100644 index 0000000000..476c14b880 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/hoverlabel/font/_sizesrc.py b/plotly/validators/pointcloud/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..f379c7cc83 --- /dev/null +++ b/plotly/validators/pointcloud/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='pointcloud.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/__init__.py b/plotly/validators/pointcloud/marker/__init__.py new file mode 100644 index 0000000000..a077540823 --- /dev/null +++ b/plotly/validators/pointcloud/marker/__init__.py @@ -0,0 +1,6 @@ +from ._sizemin import SizeminValidator +from ._sizemax import SizemaxValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator +from ._border import BorderValidator +from ._blend import BlendValidator diff --git a/plotly/validators/pointcloud/marker/_blend.py b/plotly/validators/pointcloud/marker/_blend.py new file mode 100644 index 0000000000..078dea73f9 --- /dev/null +++ b/plotly/validators/pointcloud/marker/_blend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BlendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='blend', parent_name='pointcloud.marker', **kwargs + ): + super(BlendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/_border.py b/plotly/validators/pointcloud/marker/_border.py new file mode 100644 index 0000000000..b6a2d0e6c4 --- /dev/null +++ b/plotly/validators/pointcloud/marker/_border.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class BorderValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='border', parent_name='pointcloud.marker', **kwargs + ): + super(BorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Border', + data_docs=""" + arearatio + Specifies what fraction of the marker area is + covered with the border. + color + Sets the stroke color. It accepts a specific + color. If the color is not fully opaque and + there are hundreds of thousands of points, it + may cause slower zooming and panning.""", + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/_color.py b/plotly/validators/pointcloud/marker/_color.py new file mode 100644 index 0000000000..2f8560ae1d --- /dev/null +++ b/plotly/validators/pointcloud/marker/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='pointcloud.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/_opacity.py b/plotly/validators/pointcloud/marker/_opacity.py new file mode 100644 index 0000000000..67375cbb23 --- /dev/null +++ b/plotly/validators/pointcloud/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='pointcloud.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/_sizemax.py b/plotly/validators/pointcloud/marker/_sizemax.py new file mode 100644 index 0000000000..182636c9b0 --- /dev/null +++ b/plotly/validators/pointcloud/marker/_sizemax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizemaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemax', parent_name='pointcloud.marker', **kwargs + ): + super(SizemaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0.1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/_sizemin.py b/plotly/validators/pointcloud/marker/_sizemin.py new file mode 100644 index 0000000000..1cb21258f8 --- /dev/null +++ b/plotly/validators/pointcloud/marker/_sizemin.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='pointcloud.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=2, + min=0.1, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/border/__init__.py b/plotly/validators/pointcloud/marker/border/__init__.py new file mode 100644 index 0000000000..408a3b9ba9 --- /dev/null +++ b/plotly/validators/pointcloud/marker/border/__init__.py @@ -0,0 +1,2 @@ +from ._color import ColorValidator +from ._arearatio import ArearatioValidator diff --git a/plotly/validators/pointcloud/marker/border/_arearatio.py b/plotly/validators/pointcloud/marker/border/_arearatio.py new file mode 100644 index 0000000000..dac4745b57 --- /dev/null +++ b/plotly/validators/pointcloud/marker/border/_arearatio.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ArearatioValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='arearatio', + parent_name='pointcloud.marker.border', + **kwargs + ): + super(ArearatioValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/marker/border/_color.py b/plotly/validators/pointcloud/marker/border/_color.py new file mode 100644 index 0000000000..306cf91de0 --- /dev/null +++ b/plotly/validators/pointcloud/marker/border/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='pointcloud.marker.border', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/pointcloud/stream/__init__.py b/plotly/validators/pointcloud/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/pointcloud/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/pointcloud/stream/_maxpoints.py b/plotly/validators/pointcloud/stream/_maxpoints.py new file mode 100644 index 0000000000..9fc4a85c50 --- /dev/null +++ b/plotly/validators/pointcloud/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='pointcloud.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/pointcloud/stream/_token.py b/plotly/validators/pointcloud/stream/_token.py new file mode 100644 index 0000000000..c6f9f8d5e5 --- /dev/null +++ b/plotly/validators/pointcloud/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='pointcloud.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/sankey/__init__.py b/plotly/validators/sankey/__init__.py new file mode 100644 index 0000000000..79070565a1 --- /dev/null +++ b/plotly/validators/sankey/__init__.py @@ -0,0 +1,23 @@ +from ._visible import VisibleValidator +from ._valuesuffix import ValuesuffixValidator +from ._valueformat import ValueformatValidator +from ._uid import UidValidator +from ._textfont import TextfontValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._orientation import OrientationValidator +from ._opacity import OpacityValidator +from ._node import NodeValidator +from ._name import NameValidator +from ._link import LinkValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._domain import DomainValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._arrangement import ArrangementValidator diff --git a/plotly/validators/sankey/_arrangement.py b/plotly/validators/sankey/_arrangement.py new file mode 100644 index 0000000000..2d0c270a72 --- /dev/null +++ b/plotly/validators/sankey/_arrangement.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ArrangementValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='arrangement', parent_name='sankey', **kwargs + ): + super(ArrangementValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['snap', 'perpendicular', 'freeform', 'fixed'], + **kwargs + ) diff --git a/plotly/validators/sankey/_customdata.py b/plotly/validators/sankey/_customdata.py new file mode 100644 index 0000000000..85e02d10ba --- /dev/null +++ b/plotly/validators/sankey/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='sankey', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/_customdatasrc.py b/plotly/validators/sankey/_customdatasrc.py new file mode 100644 index 0000000000..0a38947a61 --- /dev/null +++ b/plotly/validators/sankey/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='sankey', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_domain.py b/plotly/validators/sankey/_domain.py new file mode 100644 index 0000000000..8167415726 --- /dev/null +++ b/plotly/validators/sankey/_domain.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='domain', parent_name='sankey', **kwargs): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this sankey trace . + row + If there is a layout grid, use the domain for + this row in the grid for this sankey trace . + x + Sets the horizontal domain of this sankey trace + (in plot fraction). + y + Sets the vertical domain of this sankey trace + (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/sankey/_hoverinfo.py b/plotly/validators/sankey/_hoverinfo.py new file mode 100644 index 0000000000..cf9c41559a --- /dev/null +++ b/plotly/validators/sankey/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='sankey', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['label', 'text', 'value', 'percent', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_hoverinfosrc.py b/plotly/validators/sankey/_hoverinfosrc.py new file mode 100644 index 0000000000..f80d2a2c72 --- /dev/null +++ b/plotly/validators/sankey/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='sankey', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_hoverlabel.py b/plotly/validators/sankey/_hoverlabel.py new file mode 100644 index 0000000000..48b326431c --- /dev/null +++ b/plotly/validators/sankey/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='sankey', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/sankey/_ids.py b/plotly/validators/sankey/_ids.py new file mode 100644 index 0000000000..19aa72e944 --- /dev/null +++ b/plotly/validators/sankey/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='sankey', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/_idssrc.py b/plotly/validators/sankey/_idssrc.py new file mode 100644 index 0000000000..e0208f3950 --- /dev/null +++ b/plotly/validators/sankey/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='sankey', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_legendgroup.py b/plotly/validators/sankey/_legendgroup.py new file mode 100644 index 0000000000..f8a29f7c58 --- /dev/null +++ b/plotly/validators/sankey/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='sankey', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_link.py b/plotly/validators/sankey/_link.py new file mode 100644 index 0000000000..db294f5b6b --- /dev/null +++ b/plotly/validators/sankey/_link.py @@ -0,0 +1,48 @@ +import _plotly_utils.basevalidators + + +class LinkValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='link', parent_name='sankey', **kwargs): + super(LinkValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Link', + data_docs=""" + color + Sets the `link` color. It can be a single + value, or an array for specifying color for + each `link`. If `link.color` is omitted, then + by default, a translucent grey link will be + used. + colorsrc + Sets the source reference on plot.ly for color + . + label + The shown name of the link. + labelsrc + Sets the source reference on plot.ly for label + . + line + plotly.graph_objs.sankey.link.Line instance or + dict with compatible properties + source + An integer number `[0..nodes.length - 1]` that + represents the source node. + sourcesrc + Sets the source reference on plot.ly for + source . + target + An integer number `[0..nodes.length - 1]` that + represents the target node. + targetsrc + Sets the source reference on plot.ly for + target . + value + A numeric value representing the flow volume + value. + valuesrc + Sets the source reference on plot.ly for value + .""", + **kwargs + ) diff --git a/plotly/validators/sankey/_name.py b/plotly/validators/sankey/_name.py new file mode 100644 index 0000000000..99ffb17272 --- /dev/null +++ b/plotly/validators/sankey/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='sankey', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_node.py b/plotly/validators/sankey/_node.py new file mode 100644 index 0000000000..f232d8fc7b --- /dev/null +++ b/plotly/validators/sankey/_node.py @@ -0,0 +1,36 @@ +import _plotly_utils.basevalidators + + +class NodeValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='node', parent_name='sankey', **kwargs): + super(NodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Node', + data_docs=""" + color + Sets the `node` color. It can be a single + value, or an array for specifying color for + each `node`. If `node.color` is omitted, then + the default `Plotly` color palette will be + cycled through to have a variety of colors. + These defaults are not fully opaque, to allow + some visibility of what is beneath the node. + colorsrc + Sets the source reference on plot.ly for color + . + label + The shown name of the node. + labelsrc + Sets the source reference on plot.ly for label + . + line + plotly.graph_objs.sankey.node.Line instance or + dict with compatible properties + pad + Sets the padding (in px) between the `nodes`. + thickness + Sets the thickness (in px) of the `nodes`.""", + **kwargs + ) diff --git a/plotly/validators/sankey/_opacity.py b/plotly/validators/sankey/_opacity.py new file mode 100644 index 0000000000..4abc244c2c --- /dev/null +++ b/plotly/validators/sankey/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='sankey', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/_orientation.py b/plotly/validators/sankey/_orientation.py new file mode 100644 index 0000000000..5f5685ebe5 --- /dev/null +++ b/plotly/validators/sankey/_orientation.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='orientation', parent_name='sankey', **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/sankey/_selectedpoints.py b/plotly/validators/sankey/_selectedpoints.py new file mode 100644 index 0000000000..8b5b8593e4 --- /dev/null +++ b/plotly/validators/sankey/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='sankey', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_showlegend.py b/plotly/validators/sankey/_showlegend.py new file mode 100644 index 0000000000..6904f428cb --- /dev/null +++ b/plotly/validators/sankey/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='sankey', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_stream.py b/plotly/validators/sankey/_stream.py new file mode 100644 index 0000000000..acfa050021 --- /dev/null +++ b/plotly/validators/sankey/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='sankey', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/sankey/_textfont.py b/plotly/validators/sankey/_textfont.py new file mode 100644 index 0000000000..aaf024ec42 --- /dev/null +++ b/plotly/validators/sankey/_textfont.py @@ -0,0 +1,33 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='textfont', parent_name='sankey', **kwargs): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/sankey/_uid.py b/plotly/validators/sankey/_uid.py new file mode 100644 index 0000000000..a6ca44c259 --- /dev/null +++ b/plotly/validators/sankey/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='sankey', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/_valueformat.py b/plotly/validators/sankey/_valueformat.py new file mode 100644 index 0000000000..41ce42f7c6 --- /dev/null +++ b/plotly/validators/sankey/_valueformat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValueformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='valueformat', parent_name='sankey', **kwargs + ): + super(ValueformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/_valuesuffix.py b/plotly/validators/sankey/_valuesuffix.py new file mode 100644 index 0000000000..c1aeb319dd --- /dev/null +++ b/plotly/validators/sankey/_valuesuffix.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuesuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='valuesuffix', parent_name='sankey', **kwargs + ): + super(ValuesuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/_visible.py b/plotly/validators/sankey/_visible.py new file mode 100644 index 0000000000..1545826991 --- /dev/null +++ b/plotly/validators/sankey/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='sankey', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/sankey/domain/__init__.py b/plotly/validators/sankey/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/sankey/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/sankey/domain/_column.py b/plotly/validators/sankey/domain/_column.py new file mode 100644 index 0000000000..a3f9a1e78e --- /dev/null +++ b/plotly/validators/sankey/domain/_column.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='column', parent_name='sankey.domain', **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/domain/_row.py b/plotly/validators/sankey/domain/_row.py new file mode 100644 index 0000000000..db8cc67add --- /dev/null +++ b/plotly/validators/sankey/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='sankey.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/domain/_x.py b/plotly/validators/sankey/domain/_x.py new file mode 100644 index 0000000000..0a933cabf2 --- /dev/null +++ b/plotly/validators/sankey/domain/_x.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='x', parent_name='sankey.domain', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/domain/_y.py b/plotly/validators/sankey/domain/_y.py new file mode 100644 index 0000000000..1cba2d730f --- /dev/null +++ b/plotly/validators/sankey/domain/_y.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='y', parent_name='sankey.domain', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/__init__.py b/plotly/validators/sankey/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/sankey/hoverlabel/_bgcolor.py b/plotly/validators/sankey/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..b0c5770a86 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='sankey.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_bgcolorsrc.py b/plotly/validators/sankey/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..dc03e3fde5 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='sankey.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_bordercolor.py b/plotly/validators/sankey/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..87f79ff969 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='sankey.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_bordercolorsrc.py b/plotly/validators/sankey/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..33d627e668 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='sankey.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_font.py b/plotly/validators/sankey/hoverlabel/_font.py new file mode 100644 index 0000000000..6a56776f6d --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='sankey.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_namelength.py b/plotly/validators/sankey/hoverlabel/_namelength.py new file mode 100644 index 0000000000..5d4679d262 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='sankey.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/_namelengthsrc.py b/plotly/validators/sankey/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..1c6c86773d --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='sankey.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/__init__.py b/plotly/validators/sankey/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/hoverlabel/font/_color.py b/plotly/validators/sankey/hoverlabel/font/_color.py new file mode 100644 index 0000000000..634f5660f5 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/_colorsrc.py b/plotly/validators/sankey/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..b2016456f2 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/_family.py b/plotly/validators/sankey/hoverlabel/font/_family.py new file mode 100644 index 0000000000..f542cb6e7b --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/_familysrc.py b/plotly/validators/sankey/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..eafaaeba7f --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/_size.py b/plotly/validators/sankey/hoverlabel/font/_size.py new file mode 100644 index 0000000000..5080a69743 --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/hoverlabel/font/_sizesrc.py b/plotly/validators/sankey/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..286ce77ddf --- /dev/null +++ b/plotly/validators/sankey/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='sankey.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/__init__.py b/plotly/validators/sankey/link/__init__.py new file mode 100644 index 0000000000..cd99129670 --- /dev/null +++ b/plotly/validators/sankey/link/__init__.py @@ -0,0 +1,11 @@ +from ._valuesrc import ValuesrcValidator +from ._value import ValueValidator +from ._targetsrc import TargetsrcValidator +from ._target import TargetValidator +from ._sourcesrc import SourcesrcValidator +from ._source import SourceValidator +from ._line import LineValidator +from ._labelsrc import LabelsrcValidator +from ._label import LabelValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/link/_color.py b/plotly/validators/sankey/link/_color.py new file mode 100644 index 0000000000..e5ce2b1cd9 --- /dev/null +++ b/plotly/validators/sankey/link/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='sankey.link', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_colorsrc.py b/plotly/validators/sankey/link/_colorsrc.py new file mode 100644 index 0000000000..6bcce65c4f --- /dev/null +++ b/plotly/validators/sankey/link/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='sankey.link', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_label.py b/plotly/validators/sankey/link/_label.py new file mode 100644 index 0000000000..bfd4778434 --- /dev/null +++ b/plotly/validators/sankey/link/_label.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='label', parent_name='sankey.link', **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_labelsrc.py b/plotly/validators/sankey/link/_labelsrc.py new file mode 100644 index 0000000000..ba5efc397b --- /dev/null +++ b/plotly/validators/sankey/link/_labelsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='labelsrc', parent_name='sankey.link', **kwargs + ): + super(LabelsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_line.py b/plotly/validators/sankey/link/_line.py new file mode 100644 index 0000000000..b580be3bd7 --- /dev/null +++ b/plotly/validators/sankey/link/_line.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='sankey.link', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the `line` around each + `link`. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the `line` around + each `link`. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/sankey/link/_source.py b/plotly/validators/sankey/link/_source.py new file mode 100644 index 0000000000..f260d89fe3 --- /dev/null +++ b/plotly/validators/sankey/link/_source.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SourceValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='source', parent_name='sankey.link', **kwargs + ): + super(SourceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_sourcesrc.py b/plotly/validators/sankey/link/_sourcesrc.py new file mode 100644 index 0000000000..6b779d8e8f --- /dev/null +++ b/plotly/validators/sankey/link/_sourcesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SourcesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sourcesrc', parent_name='sankey.link', **kwargs + ): + super(SourcesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_target.py b/plotly/validators/sankey/link/_target.py new file mode 100644 index 0000000000..03e31e8bd8 --- /dev/null +++ b/plotly/validators/sankey/link/_target.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TargetValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='target', parent_name='sankey.link', **kwargs + ): + super(TargetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_targetsrc.py b/plotly/validators/sankey/link/_targetsrc.py new file mode 100644 index 0000000000..2de66b37c0 --- /dev/null +++ b/plotly/validators/sankey/link/_targetsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TargetsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='targetsrc', parent_name='sankey.link', **kwargs + ): + super(TargetsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_value.py b/plotly/validators/sankey/link/_value.py new file mode 100644 index 0000000000..86b912215d --- /dev/null +++ b/plotly/validators/sankey/link/_value.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='value', parent_name='sankey.link', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/link/_valuesrc.py b/plotly/validators/sankey/link/_valuesrc.py new file mode 100644 index 0000000000..5f91146726 --- /dev/null +++ b/plotly/validators/sankey/link/_valuesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='valuesrc', parent_name='sankey.link', **kwargs + ): + super(ValuesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/line/__init__.py b/plotly/validators/sankey/link/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/sankey/link/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/link/line/_color.py b/plotly/validators/sankey/link/line/_color.py new file mode 100644 index 0000000000..e520c4a428 --- /dev/null +++ b/plotly/validators/sankey/link/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='sankey.link.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/link/line/_colorsrc.py b/plotly/validators/sankey/link/line/_colorsrc.py new file mode 100644 index 0000000000..7efd47ee6a --- /dev/null +++ b/plotly/validators/sankey/link/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='sankey.link.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/link/line/_width.py b/plotly/validators/sankey/link/line/_width.py new file mode 100644 index 0000000000..8446d3b672 --- /dev/null +++ b/plotly/validators/sankey/link/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='sankey.link.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/link/line/_widthsrc.py b/plotly/validators/sankey/link/line/_widthsrc.py new file mode 100644 index 0000000000..cf3474bc10 --- /dev/null +++ b/plotly/validators/sankey/link/line/_widthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='widthsrc', parent_name='sankey.link.line', **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/node/__init__.py b/plotly/validators/sankey/node/__init__.py new file mode 100644 index 0000000000..3589e8aeb5 --- /dev/null +++ b/plotly/validators/sankey/node/__init__.py @@ -0,0 +1,7 @@ +from ._thickness import ThicknessValidator +from ._pad import PadValidator +from ._line import LineValidator +from ._labelsrc import LabelsrcValidator +from ._label import LabelValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/node/_color.py b/plotly/validators/sankey/node/_color.py new file mode 100644 index 0000000000..b4d89a04bb --- /dev/null +++ b/plotly/validators/sankey/node/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='sankey.node', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/node/_colorsrc.py b/plotly/validators/sankey/node/_colorsrc.py new file mode 100644 index 0000000000..4e9760a83e --- /dev/null +++ b/plotly/validators/sankey/node/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='sankey.node', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/node/_label.py b/plotly/validators/sankey/node/_label.py new file mode 100644 index 0000000000..d9906dd123 --- /dev/null +++ b/plotly/validators/sankey/node/_label.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='label', parent_name='sankey.node', **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/sankey/node/_labelsrc.py b/plotly/validators/sankey/node/_labelsrc.py new file mode 100644 index 0000000000..5bb27ff28f --- /dev/null +++ b/plotly/validators/sankey/node/_labelsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='labelsrc', parent_name='sankey.node', **kwargs + ): + super(LabelsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/node/_line.py b/plotly/validators/sankey/node/_line.py new file mode 100644 index 0000000000..5b0c04a820 --- /dev/null +++ b/plotly/validators/sankey/node/_line.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='sankey.node', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of the `line` around each + `node`. + colorsrc + Sets the source reference on plot.ly for color + . + width + Sets the width (in px) of the `line` around + each `node`. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/sankey/node/_pad.py b/plotly/validators/sankey/node/_pad.py new file mode 100644 index 0000000000..15265bf83a --- /dev/null +++ b/plotly/validators/sankey/node/_pad.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='pad', parent_name='sankey.node', **kwargs): + super(PadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/node/_thickness.py b/plotly/validators/sankey/node/_thickness.py new file mode 100644 index 0000000000..b66dcc2396 --- /dev/null +++ b/plotly/validators/sankey/node/_thickness.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='sankey.node', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/node/line/__init__.py b/plotly/validators/sankey/node/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/sankey/node/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/node/line/_color.py b/plotly/validators/sankey/node/line/_color.py new file mode 100644 index 0000000000..132cab85b5 --- /dev/null +++ b/plotly/validators/sankey/node/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='sankey.node.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/node/line/_colorsrc.py b/plotly/validators/sankey/node/line/_colorsrc.py new file mode 100644 index 0000000000..dc54cb5ac2 --- /dev/null +++ b/plotly/validators/sankey/node/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='sankey.node.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/node/line/_width.py b/plotly/validators/sankey/node/line/_width.py new file mode 100644 index 0000000000..57f9dde075 --- /dev/null +++ b/plotly/validators/sankey/node/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='sankey.node.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/node/line/_widthsrc.py b/plotly/validators/sankey/node/line/_widthsrc.py new file mode 100644 index 0000000000..9e9fa56234 --- /dev/null +++ b/plotly/validators/sankey/node/line/_widthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='widthsrc', parent_name='sankey.node.line', **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/stream/__init__.py b/plotly/validators/sankey/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/sankey/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/sankey/stream/_maxpoints.py b/plotly/validators/sankey/stream/_maxpoints.py new file mode 100644 index 0000000000..285e226f2d --- /dev/null +++ b/plotly/validators/sankey/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='sankey.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/sankey/stream/_token.py b/plotly/validators/sankey/stream/_token.py new file mode 100644 index 0000000000..0df6cdd53c --- /dev/null +++ b/plotly/validators/sankey/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='sankey.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/sankey/textfont/__init__.py b/plotly/validators/sankey/textfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/sankey/textfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/sankey/textfont/_color.py b/plotly/validators/sankey/textfont/_color.py new file mode 100644 index 0000000000..e6a10fec6c --- /dev/null +++ b/plotly/validators/sankey/textfont/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='sankey.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/sankey/textfont/_family.py b/plotly/validators/sankey/textfont/_family.py new file mode 100644 index 0000000000..7356e42871 --- /dev/null +++ b/plotly/validators/sankey/textfont/_family.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='sankey.textfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/sankey/textfont/_size.py b/plotly/validators/sankey/textfont/_size.py new file mode 100644 index 0000000000..587a62a7eb --- /dev/null +++ b/plotly/validators/sankey/textfont/_size.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='sankey.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/__init__.py b/plotly/validators/scatter/__init__.py new file mode 100644 index 0000000000..69298f88a4 --- /dev/null +++ b/plotly/validators/scatter/__init__.py @@ -0,0 +1,50 @@ +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._tsrc import TsrcValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._t import TValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._rsrc import RsrcValidator +from ._r import RValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._error_y import ErrorYValidator +from ._error_x import ErrorXValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator +from ._cliponaxis import CliponaxisValidator diff --git a/plotly/validators/scatter/_cliponaxis.py b/plotly/validators/scatter/_cliponaxis.py new file mode 100644 index 0000000000..39363ffdf3 --- /dev/null +++ b/plotly/validators/scatter/_cliponaxis.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CliponaxisValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cliponaxis', parent_name='scatter', **kwargs + ): + super(CliponaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_connectgaps.py b/plotly/validators/scatter/_connectgaps.py new file mode 100644 index 0000000000..71d85fe48e --- /dev/null +++ b/plotly/validators/scatter/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scatter', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_customdata.py b/plotly/validators/scatter/_customdata.py new file mode 100644 index 0000000000..ad5b805ce0 --- /dev/null +++ b/plotly/validators/scatter/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scatter', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_customdatasrc.py b/plotly/validators/scatter/_customdatasrc.py new file mode 100644 index 0000000000..37721e1376 --- /dev/null +++ b/plotly/validators/scatter/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='scatter', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_dx.py b/plotly/validators/scatter/_dx.py new file mode 100644 index 0000000000..d1a1f24910 --- /dev/null +++ b/plotly/validators/scatter/_dx.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='scatter', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_dy.py b/plotly/validators/scatter/_dy.py new file mode 100644 index 0000000000..91cd707a02 --- /dev/null +++ b/plotly/validators/scatter/_dy.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='scatter', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_error_x.py b/plotly/validators/scatter/_error_x.py new file mode 100644 index 0000000000..9416cdb1f0 --- /dev/null +++ b/plotly/validators/scatter/_error_x.py @@ -0,0 +1,70 @@ +import _plotly_utils.basevalidators + + +class ErrorXValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='error_x', parent_name='scatter', **kwargs): + super(ErrorXValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorX', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scatter/_error_y.py b/plotly/validators/scatter/_error_y.py new file mode 100644 index 0000000000..49cdace432 --- /dev/null +++ b/plotly/validators/scatter/_error_y.py @@ -0,0 +1,68 @@ +import _plotly_utils.basevalidators + + +class ErrorYValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='error_y', parent_name='scatter', **kwargs): + super(ErrorYValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorY', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scatter/_fill.py b/plotly/validators/scatter/_fill.py new file mode 100644 index 0000000000..1ccb43aaae --- /dev/null +++ b/plotly/validators/scatter/_fill.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='fill', parent_name='scatter', **kwargs): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', 'toself', + 'tonext' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/_fillcolor.py b/plotly/validators/scatter/_fillcolor.py new file mode 100644 index 0000000000..0a569aa9fe --- /dev/null +++ b/plotly/validators/scatter/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scatter', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/_hoverinfo.py b/plotly/validators/scatter/_hoverinfo.py new file mode 100644 index 0000000000..48e7534c03 --- /dev/null +++ b/plotly/validators/scatter/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scatter', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_hoverinfosrc.py b/plotly/validators/scatter/_hoverinfosrc.py new file mode 100644 index 0000000000..cc8ae461eb --- /dev/null +++ b/plotly/validators/scatter/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='scatter', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_hoverlabel.py b/plotly/validators/scatter/_hoverlabel.py new file mode 100644 index 0000000000..c2b6c67787 --- /dev/null +++ b/plotly/validators/scatter/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scatter', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scatter/_hoveron.py b/plotly/validators/scatter/_hoveron.py new file mode 100644 index 0000000000..996364e2c3 --- /dev/null +++ b/plotly/validators/scatter/_hoveron.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoveron', parent_name='scatter', **kwargs): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_hovertext.py b/plotly/validators/scatter/_hovertext.py new file mode 100644 index 0000000000..d083643260 --- /dev/null +++ b/plotly/validators/scatter/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scatter', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_hovertextsrc.py b/plotly/validators/scatter/_hovertextsrc.py new file mode 100644 index 0000000000..e65653d6d8 --- /dev/null +++ b/plotly/validators/scatter/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='scatter', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_ids.py b/plotly/validators/scatter/_ids.py new file mode 100644 index 0000000000..54a499f088 --- /dev/null +++ b/plotly/validators/scatter/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='scatter', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_idssrc.py b/plotly/validators/scatter/_idssrc.py new file mode 100644 index 0000000000..1f441a8be9 --- /dev/null +++ b/plotly/validators/scatter/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='scatter', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_legendgroup.py b/plotly/validators/scatter/_legendgroup.py new file mode 100644 index 0000000000..b579eab72c --- /dev/null +++ b/plotly/validators/scatter/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scatter', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_line.py b/plotly/validators/scatter/_line.py new file mode 100644 index 0000000000..8c4b5038ce --- /dev/null +++ b/plotly/validators/scatter/_line.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='scatter', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + simplify + Simplifies lines by removing nearly-collinear + points. When transitioning lines, it may be + desirable to disable this so that the number of + points along the resulting SVG path is + unaffected. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scatter/_marker.py b/plotly/validators/scatter/_marker.py new file mode 100644 index 0000000000..5897029a2e --- /dev/null +++ b/plotly/validators/scatter/_marker.py @@ -0,0 +1,124 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='scatter', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatter.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatter.marker.Line instance + or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scatter/_mode.py b/plotly/validators/scatter/_mode.py new file mode 100644 index 0000000000..fe63e7c5f4 --- /dev/null +++ b/plotly/validators/scatter/_mode.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='mode', parent_name='scatter', **kwargs): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_name.py b/plotly/validators/scatter/_name.py new file mode 100644 index 0000000000..a3cc62f267 --- /dev/null +++ b/plotly/validators/scatter/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='scatter', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_opacity.py b/plotly/validators/scatter/_opacity.py new file mode 100644 index 0000000000..8d46dbb0d9 --- /dev/null +++ b/plotly/validators/scatter/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='scatter', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/_r.py b/plotly/validators/scatter/_r.py new file mode 100644 index 0000000000..943884122e --- /dev/null +++ b/plotly/validators/scatter/_r.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='r', parent_name='scatter', **kwargs): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_rsrc.py b/plotly/validators/scatter/_rsrc.py new file mode 100644 index 0000000000..4195f5a8e8 --- /dev/null +++ b/plotly/validators/scatter/_rsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='rsrc', parent_name='scatter', **kwargs): + super(RsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_selected.py b/plotly/validators/scatter/_selected.py new file mode 100644 index 0000000000..08092e001e --- /dev/null +++ b/plotly/validators/scatter/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scatter', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scatter.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatter.selected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatter/_selectedpoints.py b/plotly/validators/scatter/_selectedpoints.py new file mode 100644 index 0000000000..bebb91e1a4 --- /dev/null +++ b/plotly/validators/scatter/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='scatter', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_showlegend.py b/plotly/validators/scatter/_showlegend.py new file mode 100644 index 0000000000..eccad73730 --- /dev/null +++ b/plotly/validators/scatter/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scatter', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_stream.py b/plotly/validators/scatter/_stream.py new file mode 100644 index 0000000000..9c2534408c --- /dev/null +++ b/plotly/validators/scatter/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='scatter', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scatter/_t.py b/plotly/validators/scatter/_t.py new file mode 100644 index 0000000000..0b950c73a7 --- /dev/null +++ b/plotly/validators/scatter/_t.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='t', parent_name='scatter', **kwargs): + super(TValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_text.py b/plotly/validators/scatter/_text.py new file mode 100644 index 0000000000..31e26004a2 --- /dev/null +++ b/plotly/validators/scatter/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='scatter', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_textfont.py b/plotly/validators/scatter/_textfont.py new file mode 100644 index 0000000000..7ee31f1068 --- /dev/null +++ b/plotly/validators/scatter/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scatter', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatter/_textposition.py b/plotly/validators/scatter/_textposition.py new file mode 100644 index 0000000000..5213fcd6a7 --- /dev/null +++ b/plotly/validators/scatter/_textposition.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='scatter', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/_textpositionsrc.py b/plotly/validators/scatter/_textpositionsrc.py new file mode 100644 index 0000000000..f6cae84f71 --- /dev/null +++ b/plotly/validators/scatter/_textpositionsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textpositionsrc', parent_name='scatter', **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_textsrc.py b/plotly/validators/scatter/_textsrc.py new file mode 100644 index 0000000000..440a9c9c46 --- /dev/null +++ b/plotly/validators/scatter/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='scatter', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_tsrc.py b/plotly/validators/scatter/_tsrc.py new file mode 100644 index 0000000000..e805a54e2a --- /dev/null +++ b/plotly/validators/scatter/_tsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='tsrc', parent_name='scatter', **kwargs): + super(TsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_uid.py b/plotly/validators/scatter/_uid.py new file mode 100644 index 0000000000..71fe7ad172 --- /dev/null +++ b/plotly/validators/scatter/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='scatter', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_unselected.py b/plotly/validators/scatter/_unselected.py new file mode 100644 index 0000000000..8d4cee412a --- /dev/null +++ b/plotly/validators/scatter/_unselected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scatter', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scatter.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatter.unselected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatter/_visible.py b/plotly/validators/scatter/_visible.py new file mode 100644 index 0000000000..99f9024055 --- /dev/null +++ b/plotly/validators/scatter/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='scatter', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scatter/_x.py b/plotly/validators/scatter/_x.py new file mode 100644 index 0000000000..176566388b --- /dev/null +++ b/plotly/validators/scatter/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='scatter', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_x0.py b/plotly/validators/scatter/_x0.py new file mode 100644 index 0000000000..5bb408ee68 --- /dev/null +++ b/plotly/validators/scatter/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='scatter', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_xaxis.py b/plotly/validators/scatter/_xaxis.py new file mode 100644 index 0000000000..4f39f1f683 --- /dev/null +++ b/plotly/validators/scatter/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='scatter', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_xcalendar.py b/plotly/validators/scatter/_xcalendar.py new file mode 100644 index 0000000000..40cdcfda5f --- /dev/null +++ b/plotly/validators/scatter/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='scatter', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/_xsrc.py b/plotly/validators/scatter/_xsrc.py new file mode 100644 index 0000000000..3926be1303 --- /dev/null +++ b/plotly/validators/scatter/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='scatter', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_y.py b/plotly/validators/scatter/_y.py new file mode 100644 index 0000000000..e322b02cd9 --- /dev/null +++ b/plotly/validators/scatter/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='scatter', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/_y0.py b/plotly/validators/scatter/_y0.py new file mode 100644 index 0000000000..e86065b2d2 --- /dev/null +++ b/plotly/validators/scatter/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='scatter', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_yaxis.py b/plotly/validators/scatter/_yaxis.py new file mode 100644 index 0000000000..8989913139 --- /dev/null +++ b/plotly/validators/scatter/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='scatter', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/_ycalendar.py b/plotly/validators/scatter/_ycalendar.py new file mode 100644 index 0000000000..e9560d140b --- /dev/null +++ b/plotly/validators/scatter/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='scatter', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/_ysrc.py b/plotly/validators/scatter/_ysrc.py new file mode 100644 index 0000000000..7c09e796b4 --- /dev/null +++ b/plotly/validators/scatter/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='scatter', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/__init__.py b/plotly/validators/scatter/error_x/__init__.py new file mode 100644 index 0000000000..c4605e0187 --- /dev/null +++ b/plotly/validators/scatter/error_x/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_ystyle import CopyYstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scatter/error_x/_array.py b/plotly/validators/scatter/error_x/_array.py new file mode 100644 index 0000000000..d3a503d2ba --- /dev/null +++ b/plotly/validators/scatter/error_x/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scatter.error_x', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_arrayminus.py b/plotly/validators/scatter/error_x/_arrayminus.py new file mode 100644 index 0000000000..8fd67793d9 --- /dev/null +++ b/plotly/validators/scatter/error_x/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scatter.error_x', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_arrayminussrc.py b/plotly/validators/scatter/error_x/_arrayminussrc.py new file mode 100644 index 0000000000..a5dc65985d --- /dev/null +++ b/plotly/validators/scatter/error_x/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scatter.error_x', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_arraysrc.py b/plotly/validators/scatter/error_x/_arraysrc.py new file mode 100644 index 0000000000..34fa1f3583 --- /dev/null +++ b/plotly/validators/scatter/error_x/_arraysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arraysrc', parent_name='scatter.error_x', **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_color.py b/plotly/validators/scatter/error_x/_color.py new file mode 100644 index 0000000000..c522c35744 --- /dev/null +++ b/plotly/validators/scatter/error_x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.error_x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_copy_ystyle.py b/plotly/validators/scatter/error_x/_copy_ystyle.py new file mode 100644 index 0000000000..2bfad72dd9 --- /dev/null +++ b/plotly/validators/scatter/error_x/_copy_ystyle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CopyYstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='copy_ystyle', + parent_name='scatter.error_x', + **kwargs + ): + super(CopyYstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_symmetric.py b/plotly/validators/scatter/error_x/_symmetric.py new file mode 100644 index 0000000000..306ad7a819 --- /dev/null +++ b/plotly/validators/scatter/error_x/_symmetric.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='symmetric', parent_name='scatter.error_x', **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_thickness.py b/plotly/validators/scatter/error_x/_thickness.py new file mode 100644 index 0000000000..0a8ec2c632 --- /dev/null +++ b/plotly/validators/scatter/error_x/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='scatter.error_x', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_traceref.py b/plotly/validators/scatter/error_x/_traceref.py new file mode 100644 index 0000000000..6a38309c46 --- /dev/null +++ b/plotly/validators/scatter/error_x/_traceref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='traceref', parent_name='scatter.error_x', **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_tracerefminus.py b/plotly/validators/scatter/error_x/_tracerefminus.py new file mode 100644 index 0000000000..32900c4a8c --- /dev/null +++ b/plotly/validators/scatter/error_x/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scatter.error_x', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_type.py b/plotly/validators/scatter/error_x/_type.py new file mode 100644 index 0000000000..eb22c9317b --- /dev/null +++ b/plotly/validators/scatter/error_x/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scatter.error_x', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_value.py b/plotly/validators/scatter/error_x/_value.py new file mode 100644 index 0000000000..23fd13f766 --- /dev/null +++ b/plotly/validators/scatter/error_x/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scatter.error_x', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_valueminus.py b/plotly/validators/scatter/error_x/_valueminus.py new file mode 100644 index 0000000000..f6858165ee --- /dev/null +++ b/plotly/validators/scatter/error_x/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scatter.error_x', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_visible.py b/plotly/validators/scatter/error_x/_visible.py new file mode 100644 index 0000000000..422ba0a35e --- /dev/null +++ b/plotly/validators/scatter/error_x/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter.error_x', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_x/_width.py b/plotly/validators/scatter/error_x/_width.py new file mode 100644 index 0000000000..51d182da7d --- /dev/null +++ b/plotly/validators/scatter/error_x/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter.error_x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/__init__.py b/plotly/validators/scatter/error_y/__init__.py new file mode 100644 index 0000000000..2fc70c4058 --- /dev/null +++ b/plotly/validators/scatter/error_y/__init__.py @@ -0,0 +1,14 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scatter/error_y/_array.py b/plotly/validators/scatter/error_y/_array.py new file mode 100644 index 0000000000..caee62a5aa --- /dev/null +++ b/plotly/validators/scatter/error_y/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scatter.error_y', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_arrayminus.py b/plotly/validators/scatter/error_y/_arrayminus.py new file mode 100644 index 0000000000..d7228a14b5 --- /dev/null +++ b/plotly/validators/scatter/error_y/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scatter.error_y', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_arrayminussrc.py b/plotly/validators/scatter/error_y/_arrayminussrc.py new file mode 100644 index 0000000000..7853c3d634 --- /dev/null +++ b/plotly/validators/scatter/error_y/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scatter.error_y', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_arraysrc.py b/plotly/validators/scatter/error_y/_arraysrc.py new file mode 100644 index 0000000000..1438de1913 --- /dev/null +++ b/plotly/validators/scatter/error_y/_arraysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='arraysrc', parent_name='scatter.error_y', **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_color.py b/plotly/validators/scatter/error_y/_color.py new file mode 100644 index 0000000000..9dd60dce1f --- /dev/null +++ b/plotly/validators/scatter/error_y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.error_y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_symmetric.py b/plotly/validators/scatter/error_y/_symmetric.py new file mode 100644 index 0000000000..a160f91178 --- /dev/null +++ b/plotly/validators/scatter/error_y/_symmetric.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='symmetric', parent_name='scatter.error_y', **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_thickness.py b/plotly/validators/scatter/error_y/_thickness.py new file mode 100644 index 0000000000..ff4eba94ce --- /dev/null +++ b/plotly/validators/scatter/error_y/_thickness.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='thickness', parent_name='scatter.error_y', **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_traceref.py b/plotly/validators/scatter/error_y/_traceref.py new file mode 100644 index 0000000000..bdf61a3010 --- /dev/null +++ b/plotly/validators/scatter/error_y/_traceref.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='traceref', parent_name='scatter.error_y', **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_tracerefminus.py b/plotly/validators/scatter/error_y/_tracerefminus.py new file mode 100644 index 0000000000..9587d62c5d --- /dev/null +++ b/plotly/validators/scatter/error_y/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scatter.error_y', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_type.py b/plotly/validators/scatter/error_y/_type.py new file mode 100644 index 0000000000..750f444132 --- /dev/null +++ b/plotly/validators/scatter/error_y/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scatter.error_y', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_value.py b/plotly/validators/scatter/error_y/_value.py new file mode 100644 index 0000000000..3868c8c61e --- /dev/null +++ b/plotly/validators/scatter/error_y/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scatter.error_y', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_valueminus.py b/plotly/validators/scatter/error_y/_valueminus.py new file mode 100644 index 0000000000..6a22ddea63 --- /dev/null +++ b/plotly/validators/scatter/error_y/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scatter.error_y', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_visible.py b/plotly/validators/scatter/error_y/_visible.py new file mode 100644 index 0000000000..414b15f330 --- /dev/null +++ b/plotly/validators/scatter/error_y/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter.error_y', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/error_y/_width.py b/plotly/validators/scatter/error_y/_width.py new file mode 100644 index 0000000000..447cdce3dd --- /dev/null +++ b/plotly/validators/scatter/error_y/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter.error_y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/__init__.py b/plotly/validators/scatter/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatter/hoverlabel/_bgcolor.py b/plotly/validators/scatter/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..4a31040a7d --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_bgcolorsrc.py b/plotly/validators/scatter/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..db7174bc6c --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_bordercolor.py b/plotly/validators/scatter/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..3d892e5568 --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_bordercolorsrc.py b/plotly/validators/scatter/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..97730957ae --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_font.py b/plotly/validators/scatter/hoverlabel/_font.py new file mode 100644 index 0000000000..6a21ee2d4a --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='scatter.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_namelength.py b/plotly/validators/scatter/hoverlabel/_namelength.py new file mode 100644 index 0000000000..a6bfff8b30 --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/_namelengthsrc.py b/plotly/validators/scatter/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..4e9412d7af --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scatter.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/__init__.py b/plotly/validators/scatter/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/hoverlabel/font/_color.py b/plotly/validators/scatter/hoverlabel/font/_color.py new file mode 100644 index 0000000000..141972857a --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/_colorsrc.py b/plotly/validators/scatter/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..72121366fd --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/_family.py b/plotly/validators/scatter/hoverlabel/font/_family.py new file mode 100644 index 0000000000..577466ecc6 --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/_familysrc.py b/plotly/validators/scatter/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..a96eb572b2 --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/_size.py b/plotly/validators/scatter/hoverlabel/font/_size.py new file mode 100644 index 0000000000..5ddaa4c66f --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/hoverlabel/font/_sizesrc.py b/plotly/validators/scatter/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..f3d29c8dae --- /dev/null +++ b/plotly/validators/scatter/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatter.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/line/__init__.py b/plotly/validators/scatter/line/__init__.py new file mode 100644 index 0000000000..3700fa473f --- /dev/null +++ b/plotly/validators/scatter/line/__init__.py @@ -0,0 +1,6 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._simplify import SimplifyValidator +from ._shape import ShapeValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/line/_color.py b/plotly/validators/scatter/line/_color.py new file mode 100644 index 0000000000..41a417d81d --- /dev/null +++ b/plotly/validators/scatter/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/line/_dash.py b/plotly/validators/scatter/line/_dash.py new file mode 100644 index 0000000000..ad2277356b --- /dev/null +++ b/plotly/validators/scatter/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='scatter.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/line/_shape.py b/plotly/validators/scatter/line/_shape.py new file mode 100644 index 0000000000..b2768e4d61 --- /dev/null +++ b/plotly/validators/scatter/line/_shape.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShapeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='shape', parent_name='scatter.line', **kwargs + ): + super(ShapeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['linear', 'spline', 'hv', 'vh', 'hvh', 'vhv'], + **kwargs + ) diff --git a/plotly/validators/scatter/line/_simplify.py b/plotly/validators/scatter/line/_simplify.py new file mode 100644 index 0000000000..f48a13ea88 --- /dev/null +++ b/plotly/validators/scatter/line/_simplify.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SimplifyValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='simplify', parent_name='scatter.line', **kwargs + ): + super(SimplifyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/line/_smoothing.py b/plotly/validators/scatter/line/_smoothing.py new file mode 100644 index 0000000000..5d5534f1c5 --- /dev/null +++ b/plotly/validators/scatter/line/_smoothing.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='smoothing', parent_name='scatter.line', **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/line/_width.py b/plotly/validators/scatter/line/_width.py new file mode 100644 index 0000000000..ceb46d56c5 --- /dev/null +++ b/plotly/validators/scatter/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/__init__.py b/plotly/validators/scatter/marker/__init__.py new file mode 100644 index 0000000000..7b7dcf37e9 --- /dev/null +++ b/plotly/validators/scatter/marker/__init__.py @@ -0,0 +1,22 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._maxdisplayed import MaxdisplayedValidator +from ._line import LineValidator +from ._gradient import GradientValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatter/marker/_autocolorscale.py b/plotly/validators/scatter/marker/_autocolorscale.py new file mode 100644 index 0000000000..34352b21e2 --- /dev/null +++ b/plotly/validators/scatter/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatter.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_cauto.py b/plotly/validators/scatter/marker/_cauto.py new file mode 100644 index 0000000000..e22e8cde86 --- /dev/null +++ b/plotly/validators/scatter/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scatter.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_cmax.py b/plotly/validators/scatter/marker/_cmax.py new file mode 100644 index 0000000000..d79bf3bbb2 --- /dev/null +++ b/plotly/validators/scatter/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scatter.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_cmin.py b/plotly/validators/scatter/marker/_cmin.py new file mode 100644 index 0000000000..6e0f514610 --- /dev/null +++ b/plotly/validators/scatter/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scatter.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_color.py b/plotly/validators/scatter/marker/_color.py new file mode 100644 index 0000000000..9d42161927 --- /dev/null +++ b/plotly/validators/scatter/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatter.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_colorbar.py b/plotly/validators/scatter/marker/_colorbar.py new file mode 100644 index 0000000000..cca2daab4e --- /dev/null +++ b/plotly/validators/scatter/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='scatter.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter.marker.colorbar.Tickf + ormatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_colorscale.py b/plotly/validators/scatter/marker/_colorscale.py new file mode 100644 index 0000000000..919207c61d --- /dev/null +++ b/plotly/validators/scatter/marker/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='scatter.marker', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_colorsrc.py b/plotly/validators/scatter/marker/_colorsrc.py new file mode 100644 index 0000000000..cf5fc7a00c --- /dev/null +++ b/plotly/validators/scatter/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='scatter.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_gradient.py b/plotly/validators/scatter/marker/_gradient.py new file mode 100644 index 0000000000..afda3f01a4 --- /dev/null +++ b/plotly/validators/scatter/marker/_gradient.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class GradientValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='gradient', parent_name='scatter.marker', **kwargs + ): + super(GradientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Gradient', + data_docs=""" + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + .""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_line.py b/plotly/validators/scatter/marker/_line.py new file mode 100644 index 0000000000..771f8d7528 --- /dev/null +++ b/plotly/validators/scatter/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatter.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_maxdisplayed.py b/plotly/validators/scatter/marker/_maxdisplayed.py new file mode 100644 index 0000000000..1a96580bf3 --- /dev/null +++ b/plotly/validators/scatter/marker/_maxdisplayed.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MaxdisplayedValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxdisplayed', + parent_name='scatter.marker', + **kwargs + ): + super(MaxdisplayedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_opacity.py b/plotly/validators/scatter/marker/_opacity.py new file mode 100644 index 0000000000..027f62f579 --- /dev/null +++ b/plotly/validators/scatter/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatter.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_opacitysrc.py b/plotly/validators/scatter/marker/_opacitysrc.py new file mode 100644 index 0000000000..72d1a061d5 --- /dev/null +++ b/plotly/validators/scatter/marker/_opacitysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='opacitysrc', parent_name='scatter.marker', **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_reversescale.py b/plotly/validators/scatter/marker/_reversescale.py new file mode 100644 index 0000000000..762bba8d75 --- /dev/null +++ b/plotly/validators/scatter/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatter.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_showscale.py b/plotly/validators/scatter/marker/_showscale.py new file mode 100644 index 0000000000..0212bc0441 --- /dev/null +++ b/plotly/validators/scatter/marker/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='scatter.marker', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_size.py b/plotly/validators/scatter/marker/_size.py new file mode 100644 index 0000000000..b189c83835 --- /dev/null +++ b/plotly/validators/scatter/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scatter.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_sizemin.py b/plotly/validators/scatter/marker/_sizemin.py new file mode 100644 index 0000000000..37cebbbb8c --- /dev/null +++ b/plotly/validators/scatter/marker/_sizemin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='scatter.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_sizemode.py b/plotly/validators/scatter/marker/_sizemode.py new file mode 100644 index 0000000000..b8c3f88f13 --- /dev/null +++ b/plotly/validators/scatter/marker/_sizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='sizemode', parent_name='scatter.marker', **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_sizeref.py b/plotly/validators/scatter/marker/_sizeref.py new file mode 100644 index 0000000000..e3f6ebca7f --- /dev/null +++ b/plotly/validators/scatter/marker/_sizeref.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizeref', parent_name='scatter.marker', **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_sizesrc.py b/plotly/validators/scatter/marker/_sizesrc.py new file mode 100644 index 0000000000..6e6887f9f7 --- /dev/null +++ b/plotly/validators/scatter/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='scatter.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_symbol.py b/plotly/validators/scatter/marker/_symbol.py new file mode 100644 index 0000000000..f0d67a9ae6 --- /dev/null +++ b/plotly/validators/scatter/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='scatter.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/_symbolsrc.py b/plotly/validators/scatter/marker/_symbolsrc.py new file mode 100644 index 0000000000..5da994ca06 --- /dev/null +++ b/plotly/validators/scatter/marker/_symbolsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='symbolsrc', parent_name='scatter.marker', **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/__init__.py b/plotly/validators/scatter/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatter/marker/colorbar/_bgcolor.py b/plotly/validators/scatter/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..ec26617827 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_bordercolor.py b/plotly/validators/scatter/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..04da426216 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_borderwidth.py b/plotly/validators/scatter/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..e23020a2df --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_dtick.py b/plotly/validators/scatter/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..fd0565f58a --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_exponentformat.py b/plotly/validators/scatter/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..d83320683a --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_len.py b/plotly/validators/scatter/marker/colorbar/_len.py new file mode 100644 index 0000000000..41813a0a8c --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_lenmode.py b/plotly/validators/scatter/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..9bc9af5a96 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_nticks.py b/plotly/validators/scatter/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..bf717e12db --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_outlinecolor.py b/plotly/validators/scatter/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..b050ef5a31 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_outlinewidth.py b/plotly/validators/scatter/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..6fb019bb76 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_separatethousands.py b/plotly/validators/scatter/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..f2b56b19e5 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_showexponent.py b/plotly/validators/scatter/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..02ef207cec --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_showticklabels.py b/plotly/validators/scatter/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..bf3af83644 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_showtickprefix.py b/plotly/validators/scatter/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..4aa9100adc --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_showticksuffix.py b/plotly/validators/scatter/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..a35d53b883 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_thickness.py b/plotly/validators/scatter/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..b6fabf1c56 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_thicknessmode.py b/plotly/validators/scatter/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..c4cddf5687 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tick0.py b/plotly/validators/scatter/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..2a70ffaea3 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickangle.py b/plotly/validators/scatter/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..0851e8d319 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickcolor.py b/plotly/validators/scatter/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..44f0683db5 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickfont.py b/plotly/validators/scatter/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..8585f957f8 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickformat.py b/plotly/validators/scatter/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..f2fd2b3023 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickformatstops.py b/plotly/validators/scatter/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..9fbd3593a4 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ticklen.py b/plotly/validators/scatter/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..f7b606e7f8 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickmode.py b/plotly/validators/scatter/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..347470601b --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickprefix.py b/plotly/validators/scatter/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..63d394d9e1 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ticks.py b/plotly/validators/scatter/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..100ffac207 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ticksuffix.py b/plotly/validators/scatter/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..1eb745d440 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ticktext.py b/plotly/validators/scatter/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..e6e83b5bfe --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ticktextsrc.py b/plotly/validators/scatter/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..973944e7b6 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickvals.py b/plotly/validators/scatter/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..d22f177d4d --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickvalssrc.py b/plotly/validators/scatter/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..eb26a52036 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_tickwidth.py b/plotly/validators/scatter/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..0cf0ab5067 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_title.py b/plotly/validators/scatter/marker/colorbar/_title.py new file mode 100644 index 0000000000..a38dcbce25 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_titlefont.py b/plotly/validators/scatter/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..ff5a954578 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_titleside.py b/plotly/validators/scatter/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..02c08dfe73 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_x.py b/plotly/validators/scatter/marker/colorbar/_x.py new file mode 100644 index 0000000000..0efe71b50d --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='scatter.marker.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_xanchor.py b/plotly/validators/scatter/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..39800a1849 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_xpad.py b/plotly/validators/scatter/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..f6362f54ea --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_y.py b/plotly/validators/scatter/marker/colorbar/_y.py new file mode 100644 index 0000000000..6a6ff10f89 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='scatter.marker.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_yanchor.py b/plotly/validators/scatter/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..9e4118830a --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/_ypad.py b/plotly/validators/scatter/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..205ead5479 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scatter.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/tickfont/__init__.py b/plotly/validators/scatter/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/marker/colorbar/tickfont/_color.py b/plotly/validators/scatter/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..b99dbbd6db --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/tickfont/_family.py b/plotly/validators/scatter/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..b80871fe2c --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/tickfont/_size.py b/plotly/validators/scatter/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..08a8e2f420 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scatter/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scatter/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scatter/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..5d16490c1d --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scatter.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scatter/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..d0ee42a761 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scatter.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/titlefont/__init__.py b/plotly/validators/scatter/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/marker/colorbar/titlefont/_color.py b/plotly/validators/scatter/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..d664c6d54a --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/titlefont/_family.py b/plotly/validators/scatter/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..43a3191e16 --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter/marker/colorbar/titlefont/_size.py b/plotly/validators/scatter/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..36b6dc701f --- /dev/null +++ b/plotly/validators/scatter/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/gradient/__init__.py b/plotly/validators/scatter/marker/gradient/__init__.py new file mode 100644 index 0000000000..434557c8fe --- /dev/null +++ b/plotly/validators/scatter/marker/gradient/__init__.py @@ -0,0 +1,4 @@ +from ._typesrc import TypesrcValidator +from ._type import TypeValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/marker/gradient/_color.py b/plotly/validators/scatter/marker/gradient/_color.py new file mode 100644 index 0000000000..57f552d617 --- /dev/null +++ b/plotly/validators/scatter/marker/gradient/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.marker.gradient', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/gradient/_colorsrc.py b/plotly/validators/scatter/marker/gradient/_colorsrc.py new file mode 100644 index 0000000000..8b90bae6c0 --- /dev/null +++ b/plotly/validators/scatter/marker/gradient/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter.marker.gradient', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/gradient/_type.py b/plotly/validators/scatter/marker/gradient/_type.py new file mode 100644 index 0000000000..0eae13a836 --- /dev/null +++ b/plotly/validators/scatter/marker/gradient/_type.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='scatter.marker.gradient', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['radial', 'horizontal', 'vertical', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter/marker/gradient/_typesrc.py b/plotly/validators/scatter/marker/gradient/_typesrc.py new file mode 100644 index 0000000000..fc44e14c91 --- /dev/null +++ b/plotly/validators/scatter/marker/gradient/_typesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TypesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='typesrc', + parent_name='scatter.marker.gradient', + **kwargs + ): + super(TypesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/__init__.py b/plotly/validators/scatter/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scatter/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatter/marker/line/_autocolorscale.py b/plotly/validators/scatter/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..0563e198e2 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatter.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_cauto.py b/plotly/validators/scatter/marker/line/_cauto.py new file mode 100644 index 0000000000..884702a41a --- /dev/null +++ b/plotly/validators/scatter/marker/line/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scatter.marker.line', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_cmax.py b/plotly/validators/scatter/marker/line/_cmax.py new file mode 100644 index 0000000000..b83bb0334e --- /dev/null +++ b/plotly/validators/scatter/marker/line/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scatter.marker.line', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_cmin.py b/plotly/validators/scatter/marker/line/_cmin.py new file mode 100644 index 0000000000..b588f75f45 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scatter.marker.line', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_color.py b/plotly/validators/scatter/marker/line/_color.py new file mode 100644 index 0000000000..1f1acff8d0 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatter.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_colorscale.py b/plotly/validators/scatter/marker/line/_colorscale.py new file mode 100644 index 0000000000..88d3da6d5a --- /dev/null +++ b/plotly/validators/scatter/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatter.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_colorsrc.py b/plotly/validators/scatter/marker/line/_colorsrc.py new file mode 100644 index 0000000000..598bbf3557 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_reversescale.py b/plotly/validators/scatter/marker/line/_reversescale.py new file mode 100644 index 0000000000..9e4faa0a6e --- /dev/null +++ b/plotly/validators/scatter/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatter.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_width.py b/plotly/validators/scatter/marker/line/_width.py new file mode 100644 index 0000000000..108770c589 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/marker/line/_widthsrc.py b/plotly/validators/scatter/marker/line/_widthsrc.py new file mode 100644 index 0000000000..cb12bc4c81 --- /dev/null +++ b/plotly/validators/scatter/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scatter.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/selected/__init__.py b/plotly/validators/scatter/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatter/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatter/selected/_marker.py b/plotly/validators/scatter/selected/_marker.py new file mode 100644 index 0000000000..b25c0b4fc6 --- /dev/null +++ b/plotly/validators/scatter/selected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatter.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatter/selected/_textfont.py b/plotly/validators/scatter/selected/_textfont.py new file mode 100644 index 0000000000..72873cd2aa --- /dev/null +++ b/plotly/validators/scatter/selected/_textfont.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scatter.selected', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatter/selected/marker/__init__.py b/plotly/validators/scatter/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatter/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/selected/marker/_color.py b/plotly/validators/scatter/selected/marker/_color.py new file mode 100644 index 0000000000..203a7c2b6d --- /dev/null +++ b/plotly/validators/scatter/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/selected/marker/_opacity.py b/plotly/validators/scatter/selected/marker/_opacity.py new file mode 100644 index 0000000000..8f082eb7cd --- /dev/null +++ b/plotly/validators/scatter/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatter.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/selected/marker/_size.py b/plotly/validators/scatter/selected/marker/_size.py new file mode 100644 index 0000000000..61b1de59d7 --- /dev/null +++ b/plotly/validators/scatter/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/selected/textfont/__init__.py b/plotly/validators/scatter/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatter/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatter/selected/textfont/_color.py b/plotly/validators/scatter/selected/textfont/_color.py new file mode 100644 index 0000000000..8c3a3170b0 --- /dev/null +++ b/plotly/validators/scatter/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/stream/__init__.py b/plotly/validators/scatter/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scatter/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scatter/stream/_maxpoints.py b/plotly/validators/scatter/stream/_maxpoints.py new file mode 100644 index 0000000000..b382a75170 --- /dev/null +++ b/plotly/validators/scatter/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='scatter.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/stream/_token.py b/plotly/validators/scatter/stream/_token.py new file mode 100644 index 0000000000..c053818fbc --- /dev/null +++ b/plotly/validators/scatter/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='scatter.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/__init__.py b/plotly/validators/scatter/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatter/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/textfont/_color.py b/plotly/validators/scatter/textfont/_color.py new file mode 100644 index 0000000000..b248315ea8 --- /dev/null +++ b/plotly/validators/scatter/textfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/_colorsrc.py b/plotly/validators/scatter/textfont/_colorsrc.py new file mode 100644 index 0000000000..e180baf430 --- /dev/null +++ b/plotly/validators/scatter/textfont/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='scatter.textfont', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/_family.py b/plotly/validators/scatter/textfont/_family.py new file mode 100644 index 0000000000..bd1b9df869 --- /dev/null +++ b/plotly/validators/scatter/textfont/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='scatter.textfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/_familysrc.py b/plotly/validators/scatter/textfont/_familysrc.py new file mode 100644 index 0000000000..aa553c52b9 --- /dev/null +++ b/plotly/validators/scatter/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatter.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/_size.py b/plotly/validators/scatter/textfont/_size.py new file mode 100644 index 0000000000..1d5ae0a800 --- /dev/null +++ b/plotly/validators/scatter/textfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scatter.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/textfont/_sizesrc.py b/plotly/validators/scatter/textfont/_sizesrc.py new file mode 100644 index 0000000000..bf7db1a2e5 --- /dev/null +++ b/plotly/validators/scatter/textfont/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='scatter.textfont', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/__init__.py b/plotly/validators/scatter/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatter/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatter/unselected/_marker.py b/plotly/validators/scatter/unselected/_marker.py new file mode 100644 index 0000000000..f0c94a43b5 --- /dev/null +++ b/plotly/validators/scatter/unselected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatter.unselected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/_textfont.py b/plotly/validators/scatter/unselected/_textfont.py new file mode 100644 index 0000000000..880d59e12d --- /dev/null +++ b/plotly/validators/scatter/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatter.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/marker/__init__.py b/plotly/validators/scatter/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatter/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter/unselected/marker/_color.py b/plotly/validators/scatter/unselected/marker/_color.py new file mode 100644 index 0000000000..fd9e455e4d --- /dev/null +++ b/plotly/validators/scatter/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/marker/_opacity.py b/plotly/validators/scatter/unselected/marker/_opacity.py new file mode 100644 index 0000000000..59fbe6becb --- /dev/null +++ b/plotly/validators/scatter/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatter.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/marker/_size.py b/plotly/validators/scatter/unselected/marker/_size.py new file mode 100644 index 0000000000..e90d45fdef --- /dev/null +++ b/plotly/validators/scatter/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter/unselected/textfont/__init__.py b/plotly/validators/scatter/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatter/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatter/unselected/textfont/_color.py b/plotly/validators/scatter/unselected/textfont/_color.py new file mode 100644 index 0000000000..5f041e3916 --- /dev/null +++ b/plotly/validators/scatter/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/__init__.py b/plotly/validators/scatter3d/__init__.py new file mode 100644 index 0000000000..67d8b77b58 --- /dev/null +++ b/plotly/validators/scatter3d/__init__.py @@ -0,0 +1,42 @@ +from ._zsrc import ZsrcValidator +from ._zcalendar import ZcalendarValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._surfacecolor import SurfacecolorValidator +from ._surfaceaxis import SurfaceaxisValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._scene import SceneValidator +from ._projection import ProjectionValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._error_z import ErrorZValidator +from ._error_y import ErrorYValidator +from ._error_x import ErrorXValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator diff --git a/plotly/validators/scatter3d/_connectgaps.py b/plotly/validators/scatter3d/_connectgaps.py new file mode 100644 index 0000000000..18abe400a6 --- /dev/null +++ b/plotly/validators/scatter3d/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scatter3d', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_customdata.py b/plotly/validators/scatter3d/_customdata.py new file mode 100644 index 0000000000..923a5a4571 --- /dev/null +++ b/plotly/validators/scatter3d/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scatter3d', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_customdatasrc.py b/plotly/validators/scatter3d/_customdatasrc.py new file mode 100644 index 0000000000..6b34e74051 --- /dev/null +++ b/plotly/validators/scatter3d/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='scatter3d', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_error_x.py b/plotly/validators/scatter3d/_error_x.py new file mode 100644 index 0000000000..a4304dc6eb --- /dev/null +++ b/plotly/validators/scatter3d/_error_x.py @@ -0,0 +1,72 @@ +import _plotly_utils.basevalidators + + +class ErrorXValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_x', parent_name='scatter3d', **kwargs + ): + super(ErrorXValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorX', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_error_y.py b/plotly/validators/scatter3d/_error_y.py new file mode 100644 index 0000000000..16b1fee106 --- /dev/null +++ b/plotly/validators/scatter3d/_error_y.py @@ -0,0 +1,72 @@ +import _plotly_utils.basevalidators + + +class ErrorYValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_y', parent_name='scatter3d', **kwargs + ): + super(ErrorYValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorY', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_zstyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_error_z.py b/plotly/validators/scatter3d/_error_z.py new file mode 100644 index 0000000000..3a48f3ffe9 --- /dev/null +++ b/plotly/validators/scatter3d/_error_z.py @@ -0,0 +1,70 @@ +import _plotly_utils.basevalidators + + +class ErrorZValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_z', parent_name='scatter3d', **kwargs + ): + super(ErrorZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorZ', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_hoverinfo.py b/plotly/validators/scatter3d/_hoverinfo.py new file mode 100644 index 0000000000..eea4401457 --- /dev/null +++ b/plotly/validators/scatter3d/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scatter3d', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_hoverinfosrc.py b/plotly/validators/scatter3d/_hoverinfosrc.py new file mode 100644 index 0000000000..a07bcd4676 --- /dev/null +++ b/plotly/validators/scatter3d/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='scatter3d', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_hoverlabel.py b/plotly/validators/scatter3d/_hoverlabel.py new file mode 100644 index 0000000000..e655ce961f --- /dev/null +++ b/plotly/validators/scatter3d/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scatter3d', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_hovertext.py b/plotly/validators/scatter3d/_hovertext.py new file mode 100644 index 0000000000..fe65590f90 --- /dev/null +++ b/plotly/validators/scatter3d/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scatter3d', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_hovertextsrc.py b/plotly/validators/scatter3d/_hovertextsrc.py new file mode 100644 index 0000000000..10ffb2816c --- /dev/null +++ b/plotly/validators/scatter3d/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='scatter3d', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_ids.py b/plotly/validators/scatter3d/_ids.py new file mode 100644 index 0000000000..a8be1e0143 --- /dev/null +++ b/plotly/validators/scatter3d/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='scatter3d', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_idssrc.py b/plotly/validators/scatter3d/_idssrc.py new file mode 100644 index 0000000000..2d27b90352 --- /dev/null +++ b/plotly/validators/scatter3d/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scatter3d', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_legendgroup.py b/plotly/validators/scatter3d/_legendgroup.py new file mode 100644 index 0000000000..c0de94437e --- /dev/null +++ b/plotly/validators/scatter3d/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scatter3d', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_line.py b/plotly/validators/scatter3d/_line.py new file mode 100644 index 0000000000..2a9d75ba3c --- /dev/null +++ b/plotly/validators/scatter3d/_line.py @@ -0,0 +1,83 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='scatter3d', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `line.color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `line.color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmin` must be set as well. + cmin + Has an effect only if `line.color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `line.color` array index, and if set, + `line.cmax` must be set as well. + color + Sets the line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `line.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `line.cmin` and `line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + dash + Sets the dash style of the lines. + reversescale + Has an effect only if `line.color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + showscale + Has an effect only if `line.color` is set to a + numerical array. Determines whether or not a + colorbar is displayed. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_marker.py b/plotly/validators/scatter3d/_marker.py new file mode 100644 index 0000000000..8c355b9c03 --- /dev/null +++ b/plotly/validators/scatter3d/_marker.py @@ -0,0 +1,117 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatter3d', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatter3d.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scatter3d.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. Note that the marker + opacity for scatter3d traces must be a scalar + value for performance reasons. To set a + blending opacity value (i.e. which is not + transparent), set *marker.color* to an rgba + color and use its alpha channel. + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_mode.py b/plotly/validators/scatter3d/_mode.py new file mode 100644 index 0000000000..950d0c1d53 --- /dev/null +++ b/plotly/validators/scatter3d/_mode.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='mode', parent_name='scatter3d', **kwargs): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_name.py b/plotly/validators/scatter3d/_name.py new file mode 100644 index 0000000000..6536449c3f --- /dev/null +++ b/plotly/validators/scatter3d/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='scatter3d', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_opacity.py b/plotly/validators/scatter3d/_opacity.py new file mode 100644 index 0000000000..4ee5f5171a --- /dev/null +++ b/plotly/validators/scatter3d/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatter3d', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_projection.py b/plotly/validators/scatter3d/_projection.py new file mode 100644 index 0000000000..caf1cfc9cc --- /dev/null +++ b/plotly/validators/scatter3d/_projection.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class ProjectionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='projection', parent_name='scatter3d', **kwargs + ): + super(ProjectionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Projection', + data_docs=""" + x + plotly.graph_objs.scatter3d.projection.X + instance or dict with compatible properties + y + plotly.graph_objs.scatter3d.projection.Y + instance or dict with compatible properties + z + plotly.graph_objs.scatter3d.projection.Z + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_scene.py b/plotly/validators/scatter3d/_scene.py new file mode 100644 index 0000000000..801dc00a34 --- /dev/null +++ b/plotly/validators/scatter3d/_scene.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SceneValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='scene', parent_name='scatter3d', **kwargs): + super(SceneValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='scene', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_selectedpoints.py b/plotly/validators/scatter3d/_selectedpoints.py new file mode 100644 index 0000000000..9dcad5de12 --- /dev/null +++ b/plotly/validators/scatter3d/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='scatter3d', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_showlegend.py b/plotly/validators/scatter3d/_showlegend.py new file mode 100644 index 0000000000..12de31be3c --- /dev/null +++ b/plotly/validators/scatter3d/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scatter3d', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_stream.py b/plotly/validators/scatter3d/_stream.py new file mode 100644 index 0000000000..506d723fc3 --- /dev/null +++ b/plotly/validators/scatter3d/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scatter3d', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_surfaceaxis.py b/plotly/validators/scatter3d/_surfaceaxis.py new file mode 100644 index 0000000000..6414310c47 --- /dev/null +++ b/plotly/validators/scatter3d/_surfaceaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SurfaceaxisValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='surfaceaxis', parent_name='scatter3d', **kwargs + ): + super(SurfaceaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[-1, 0, 1, 2], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_surfacecolor.py b/plotly/validators/scatter3d/_surfacecolor.py new file mode 100644 index 0000000000..bbcde73db8 --- /dev/null +++ b/plotly/validators/scatter3d/_surfacecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SurfacecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='surfacecolor', parent_name='scatter3d', **kwargs + ): + super(SurfacecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_text.py b/plotly/validators/scatter3d/_text.py new file mode 100644 index 0000000000..3f95c79ce5 --- /dev/null +++ b/plotly/validators/scatter3d/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='scatter3d', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_textfont.py b/plotly/validators/scatter3d/_textfont.py new file mode 100644 index 0000000000..c897915a60 --- /dev/null +++ b/plotly/validators/scatter3d/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scatter3d', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/_textposition.py b/plotly/validators/scatter3d/_textposition.py new file mode 100644 index 0000000000..4c2b787e2b --- /dev/null +++ b/plotly/validators/scatter3d/_textposition.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='scatter3d', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_textpositionsrc.py b/plotly/validators/scatter3d/_textpositionsrc.py new file mode 100644 index 0000000000..a68164c083 --- /dev/null +++ b/plotly/validators/scatter3d/_textpositionsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textpositionsrc', parent_name='scatter3d', **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_textsrc.py b/plotly/validators/scatter3d/_textsrc.py new file mode 100644 index 0000000000..585087d500 --- /dev/null +++ b/plotly/validators/scatter3d/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scatter3d', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_uid.py b/plotly/validators/scatter3d/_uid.py new file mode 100644 index 0000000000..a366030f13 --- /dev/null +++ b/plotly/validators/scatter3d/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='scatter3d', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_visible.py b/plotly/validators/scatter3d/_visible.py new file mode 100644 index 0000000000..91c5030e45 --- /dev/null +++ b/plotly/validators/scatter3d/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter3d', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_x.py b/plotly/validators/scatter3d/_x.py new file mode 100644 index 0000000000..f055cd0e1d --- /dev/null +++ b/plotly/validators/scatter3d/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='scatter3d', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_xcalendar.py b/plotly/validators/scatter3d/_xcalendar.py new file mode 100644 index 0000000000..3b4aeb4712 --- /dev/null +++ b/plotly/validators/scatter3d/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='scatter3d', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_xsrc.py b/plotly/validators/scatter3d/_xsrc.py new file mode 100644 index 0000000000..fa8b202138 --- /dev/null +++ b/plotly/validators/scatter3d/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='scatter3d', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_y.py b/plotly/validators/scatter3d/_y.py new file mode 100644 index 0000000000..3106429164 --- /dev/null +++ b/plotly/validators/scatter3d/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='scatter3d', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_ycalendar.py b/plotly/validators/scatter3d/_ycalendar.py new file mode 100644 index 0000000000..9158392fa6 --- /dev/null +++ b/plotly/validators/scatter3d/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='scatter3d', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_ysrc.py b/plotly/validators/scatter3d/_ysrc.py new file mode 100644 index 0000000000..8e9e8a5e8b --- /dev/null +++ b/plotly/validators/scatter3d/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='scatter3d', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_z.py b/plotly/validators/scatter3d/_z.py new file mode 100644 index 0000000000..4be931e815 --- /dev/null +++ b/plotly/validators/scatter3d/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='scatter3d', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/_zcalendar.py b/plotly/validators/scatter3d/_zcalendar.py new file mode 100644 index 0000000000..f4f2e85223 --- /dev/null +++ b/plotly/validators/scatter3d/_zcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ZcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='zcalendar', parent_name='scatter3d', **kwargs + ): + super(ZcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/_zsrc.py b/plotly/validators/scatter3d/_zsrc.py new file mode 100644 index 0000000000..703e8a101d --- /dev/null +++ b/plotly/validators/scatter3d/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='scatter3d', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/__init__.py b/plotly/validators/scatter3d/error_x/__init__.py new file mode 100644 index 0000000000..a9450d059b --- /dev/null +++ b/plotly/validators/scatter3d/error_x/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_zstyle import CopyZstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scatter3d/error_x/_array.py b/plotly/validators/scatter3d/error_x/_array.py new file mode 100644 index 0000000000..0e059f7165 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scatter3d.error_x', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_arrayminus.py b/plotly/validators/scatter3d/error_x/_arrayminus.py new file mode 100644 index 0000000000..d1448cfa95 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scatter3d.error_x', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_arrayminussrc.py b/plotly/validators/scatter3d/error_x/_arrayminussrc.py new file mode 100644 index 0000000000..8bed869eb4 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scatter3d.error_x', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_arraysrc.py b/plotly/validators/scatter3d/error_x/_arraysrc.py new file mode 100644 index 0000000000..b1f765ac39 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='scatter3d.error_x', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_color.py b/plotly/validators/scatter3d/error_x/_color.py new file mode 100644 index 0000000000..0c735de23b --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.error_x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_copy_zstyle.py b/plotly/validators/scatter3d/error_x/_copy_zstyle.py new file mode 100644 index 0000000000..2210ceb752 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_copy_zstyle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CopyZstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='copy_zstyle', + parent_name='scatter3d.error_x', + **kwargs + ): + super(CopyZstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_symmetric.py b/plotly/validators/scatter3d/error_x/_symmetric.py new file mode 100644 index 0000000000..30a6ddfe40 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='scatter3d.error_x', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_thickness.py b/plotly/validators/scatter3d/error_x/_thickness.py new file mode 100644 index 0000000000..c8f07f005f --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatter3d.error_x', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_traceref.py b/plotly/validators/scatter3d/error_x/_traceref.py new file mode 100644 index 0000000000..f215b7c418 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='scatter3d.error_x', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_tracerefminus.py b/plotly/validators/scatter3d/error_x/_tracerefminus.py new file mode 100644 index 0000000000..ddbb59ade5 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scatter3d.error_x', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_type.py b/plotly/validators/scatter3d/error_x/_type.py new file mode 100644 index 0000000000..dea4bf8184 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scatter3d.error_x', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_value.py b/plotly/validators/scatter3d/error_x/_value.py new file mode 100644 index 0000000000..db1f336f92 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scatter3d.error_x', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_valueminus.py b/plotly/validators/scatter3d/error_x/_valueminus.py new file mode 100644 index 0000000000..d8424f2e99 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scatter3d.error_x', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_visible.py b/plotly/validators/scatter3d/error_x/_visible.py new file mode 100644 index 0000000000..c0120a8947 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter3d.error_x', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_x/_width.py b/plotly/validators/scatter3d/error_x/_width.py new file mode 100644 index 0000000000..d61b70d443 --- /dev/null +++ b/plotly/validators/scatter3d/error_x/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter3d.error_x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/__init__.py b/plotly/validators/scatter3d/error_y/__init__.py new file mode 100644 index 0000000000..a9450d059b --- /dev/null +++ b/plotly/validators/scatter3d/error_y/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_zstyle import CopyZstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scatter3d/error_y/_array.py b/plotly/validators/scatter3d/error_y/_array.py new file mode 100644 index 0000000000..4fc5840e71 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scatter3d.error_y', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_arrayminus.py b/plotly/validators/scatter3d/error_y/_arrayminus.py new file mode 100644 index 0000000000..9ea4f1e2db --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scatter3d.error_y', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_arrayminussrc.py b/plotly/validators/scatter3d/error_y/_arrayminussrc.py new file mode 100644 index 0000000000..8d2ea40de6 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scatter3d.error_y', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_arraysrc.py b/plotly/validators/scatter3d/error_y/_arraysrc.py new file mode 100644 index 0000000000..d7e17923fb --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='scatter3d.error_y', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_color.py b/plotly/validators/scatter3d/error_y/_color.py new file mode 100644 index 0000000000..80595728a8 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.error_y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_copy_zstyle.py b/plotly/validators/scatter3d/error_y/_copy_zstyle.py new file mode 100644 index 0000000000..fb941e3a67 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_copy_zstyle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CopyZstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='copy_zstyle', + parent_name='scatter3d.error_y', + **kwargs + ): + super(CopyZstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_symmetric.py b/plotly/validators/scatter3d/error_y/_symmetric.py new file mode 100644 index 0000000000..3382962aaf --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='scatter3d.error_y', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_thickness.py b/plotly/validators/scatter3d/error_y/_thickness.py new file mode 100644 index 0000000000..61f4130a60 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatter3d.error_y', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_traceref.py b/plotly/validators/scatter3d/error_y/_traceref.py new file mode 100644 index 0000000000..c0c6313b12 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='scatter3d.error_y', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_tracerefminus.py b/plotly/validators/scatter3d/error_y/_tracerefminus.py new file mode 100644 index 0000000000..b13fdcf9c3 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scatter3d.error_y', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_type.py b/plotly/validators/scatter3d/error_y/_type.py new file mode 100644 index 0000000000..6ea86d689f --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scatter3d.error_y', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_value.py b/plotly/validators/scatter3d/error_y/_value.py new file mode 100644 index 0000000000..99fa96fda1 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scatter3d.error_y', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_valueminus.py b/plotly/validators/scatter3d/error_y/_valueminus.py new file mode 100644 index 0000000000..e5f5979dd7 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scatter3d.error_y', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_visible.py b/plotly/validators/scatter3d/error_y/_visible.py new file mode 100644 index 0000000000..d748a27c31 --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter3d.error_y', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_y/_width.py b/plotly/validators/scatter3d/error_y/_width.py new file mode 100644 index 0000000000..ce2c18d7be --- /dev/null +++ b/plotly/validators/scatter3d/error_y/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter3d.error_y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/__init__.py b/plotly/validators/scatter3d/error_z/__init__.py new file mode 100644 index 0000000000..2fc70c4058 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/__init__.py @@ -0,0 +1,14 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scatter3d/error_z/_array.py b/plotly/validators/scatter3d/error_z/_array.py new file mode 100644 index 0000000000..8f892e8058 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scatter3d.error_z', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_arrayminus.py b/plotly/validators/scatter3d/error_z/_arrayminus.py new file mode 100644 index 0000000000..c2de192750 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scatter3d.error_z', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_arrayminussrc.py b/plotly/validators/scatter3d/error_z/_arrayminussrc.py new file mode 100644 index 0000000000..ec01c83835 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scatter3d.error_z', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_arraysrc.py b/plotly/validators/scatter3d/error_z/_arraysrc.py new file mode 100644 index 0000000000..39c1c9e42a --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='scatter3d.error_z', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_color.py b/plotly/validators/scatter3d/error_z/_color.py new file mode 100644 index 0000000000..76419e9057 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.error_z', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_symmetric.py b/plotly/validators/scatter3d/error_z/_symmetric.py new file mode 100644 index 0000000000..23903375fc --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='scatter3d.error_z', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_thickness.py b/plotly/validators/scatter3d/error_z/_thickness.py new file mode 100644 index 0000000000..bff14b4693 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatter3d.error_z', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_traceref.py b/plotly/validators/scatter3d/error_z/_traceref.py new file mode 100644 index 0000000000..87fcb84ec8 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='scatter3d.error_z', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_tracerefminus.py b/plotly/validators/scatter3d/error_z/_tracerefminus.py new file mode 100644 index 0000000000..cf3ffe33b6 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scatter3d.error_z', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_type.py b/plotly/validators/scatter3d/error_z/_type.py new file mode 100644 index 0000000000..a144f464f1 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scatter3d.error_z', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_value.py b/plotly/validators/scatter3d/error_z/_value.py new file mode 100644 index 0000000000..b8862a3ed3 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scatter3d.error_z', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_valueminus.py b/plotly/validators/scatter3d/error_z/_valueminus.py new file mode 100644 index 0000000000..d304574de1 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scatter3d.error_z', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_visible.py b/plotly/validators/scatter3d/error_z/_visible.py new file mode 100644 index 0000000000..2a6a24a047 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatter3d.error_z', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/error_z/_width.py b/plotly/validators/scatter3d/error_z/_width.py new file mode 100644 index 0000000000..2e7a701e02 --- /dev/null +++ b/plotly/validators/scatter3d/error_z/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter3d.error_z', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/__init__.py b/plotly/validators/scatter3d/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatter3d/hoverlabel/_bgcolor.py b/plotly/validators/scatter3d/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..137079fee6 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_bgcolorsrc.py b/plotly/validators/scatter3d/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..c3df141d27 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_bordercolor.py b/plotly/validators/scatter3d/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..ca5c6b4f10 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_bordercolorsrc.py b/plotly/validators/scatter3d/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..a2776b8096 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_font.py b/plotly/validators/scatter3d/hoverlabel/_font.py new file mode 100644 index 0000000000..33580c0b94 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='scatter3d.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_namelength.py b/plotly/validators/scatter3d/hoverlabel/_namelength.py new file mode 100644 index 0000000000..debcb37eff --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/_namelengthsrc.py b/plotly/validators/scatter3d/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..5748dfbc22 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scatter3d.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/__init__.py b/plotly/validators/scatter3d/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter3d/hoverlabel/font/_color.py b/plotly/validators/scatter3d/hoverlabel/font/_color.py new file mode 100644 index 0000000000..972424c7ee --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/_colorsrc.py b/plotly/validators/scatter3d/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..0622f30561 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/_family.py b/plotly/validators/scatter3d/hoverlabel/font/_family.py new file mode 100644 index 0000000000..263b990593 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/_familysrc.py b/plotly/validators/scatter3d/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..9aac391482 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/_size.py b/plotly/validators/scatter3d/hoverlabel/font/_size.py new file mode 100644 index 0000000000..e0f1497074 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/hoverlabel/font/_sizesrc.py b/plotly/validators/scatter3d/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..f11b9c0338 --- /dev/null +++ b/plotly/validators/scatter3d/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatter3d.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/__init__.py b/plotly/validators/scatter3d/line/__init__.py new file mode 100644 index 0000000000..70bca45087 --- /dev/null +++ b/plotly/validators/scatter3d/line/__init__.py @@ -0,0 +1,11 @@ +from ._width import WidthValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._dash import DashValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatter3d/line/_autocolorscale.py b/plotly/validators/scatter3d/line/_autocolorscale.py new file mode 100644 index 0000000000..f058c90c2c --- /dev/null +++ b/plotly/validators/scatter3d/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatter3d.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_cauto.py b/plotly/validators/scatter3d/line/_cauto.py new file mode 100644 index 0000000000..6d3cdbefe7 --- /dev/null +++ b/plotly/validators/scatter3d/line/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scatter3d.line', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_cmax.py b/plotly/validators/scatter3d/line/_cmax.py new file mode 100644 index 0000000000..52c5f673cb --- /dev/null +++ b/plotly/validators/scatter3d/line/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scatter3d.line', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_cmin.py b/plotly/validators/scatter3d/line/_cmin.py new file mode 100644 index 0000000000..30245d34f3 --- /dev/null +++ b/plotly/validators/scatter3d/line/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scatter3d.line', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_color.py b/plotly/validators/scatter3d/line/_color.py new file mode 100644 index 0000000000..ccf9af9ae7 --- /dev/null +++ b/plotly/validators/scatter3d/line/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scatter3d.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_colorscale.py b/plotly/validators/scatter3d/line/_colorscale.py new file mode 100644 index 0000000000..bfb2d36786 --- /dev/null +++ b/plotly/validators/scatter3d/line/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='scatter3d.line', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_colorsrc.py b/plotly/validators/scatter3d/line/_colorsrc.py new file mode 100644 index 0000000000..e8673a95ca --- /dev/null +++ b/plotly/validators/scatter3d/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='scatter3d.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_dash.py b/plotly/validators/scatter3d/line/_dash.py new file mode 100644 index 0000000000..555ff8d38a --- /dev/null +++ b/plotly/validators/scatter3d/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='dash', parent_name='scatter3d.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_reversescale.py b/plotly/validators/scatter3d/line/_reversescale.py new file mode 100644 index 0000000000..255e81b064 --- /dev/null +++ b/plotly/validators/scatter3d/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatter3d.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_showscale.py b/plotly/validators/scatter3d/line/_showscale.py new file mode 100644 index 0000000000..534d53f00a --- /dev/null +++ b/plotly/validators/scatter3d/line/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='scatter3d.line', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/line/_width.py b/plotly/validators/scatter3d/line/_width.py new file mode 100644 index 0000000000..aa6a2723df --- /dev/null +++ b/plotly/validators/scatter3d/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatter3d.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/__init__.py b/plotly/validators/scatter3d/marker/__init__.py new file mode 100644 index 0000000000..316e378d10 --- /dev/null +++ b/plotly/validators/scatter3d/marker/__init__.py @@ -0,0 +1,19 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatter3d/marker/_autocolorscale.py b/plotly/validators/scatter3d/marker/_autocolorscale.py new file mode 100644 index 0000000000..2f6cd04c9d --- /dev/null +++ b/plotly/validators/scatter3d/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatter3d.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_cauto.py b/plotly/validators/scatter3d/marker/_cauto.py new file mode 100644 index 0000000000..a62c7cc61b --- /dev/null +++ b/plotly/validators/scatter3d/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scatter3d.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_cmax.py b/plotly/validators/scatter3d/marker/_cmax.py new file mode 100644 index 0000000000..805635b459 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scatter3d.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_cmin.py b/plotly/validators/scatter3d/marker/_cmin.py new file mode 100644 index 0000000000..364665784b --- /dev/null +++ b/plotly/validators/scatter3d/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scatter3d.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_color.py b/plotly/validators/scatter3d/marker/_color.py new file mode 100644 index 0000000000..80a7614855 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scatter3d.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_colorbar.py b/plotly/validators/scatter3d/marker/_colorbar.py new file mode 100644 index 0000000000..880048631b --- /dev/null +++ b/plotly/validators/scatter3d/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='scatter3d.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatter3d.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_colorscale.py b/plotly/validators/scatter3d/marker/_colorscale.py new file mode 100644 index 0000000000..4875da4d1b --- /dev/null +++ b/plotly/validators/scatter3d/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatter3d.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_colorsrc.py b/plotly/validators/scatter3d/marker/_colorsrc.py new file mode 100644 index 0000000000..d584db5549 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='scatter3d.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_line.py b/plotly/validators/scatter3d/marker/_line.py new file mode 100644 index 0000000000..cc4caa09af --- /dev/null +++ b/plotly/validators/scatter3d/marker/_line.py @@ -0,0 +1,81 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatter3d.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_opacity.py b/plotly/validators/scatter3d/marker/_opacity.py new file mode 100644 index 0000000000..5eb030012b --- /dev/null +++ b/plotly/validators/scatter3d/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatter3d.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_reversescale.py b/plotly/validators/scatter3d/marker/_reversescale.py new file mode 100644 index 0000000000..6bf0370def --- /dev/null +++ b/plotly/validators/scatter3d/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatter3d.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_showscale.py b/plotly/validators/scatter3d/marker/_showscale.py new file mode 100644 index 0000000000..52fe4d3f8d --- /dev/null +++ b/plotly/validators/scatter3d/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scatter3d.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_size.py b/plotly/validators/scatter3d/marker/_size.py new file mode 100644 index 0000000000..52a678b02e --- /dev/null +++ b/plotly/validators/scatter3d/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scatter3d.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_sizemin.py b/plotly/validators/scatter3d/marker/_sizemin.py new file mode 100644 index 0000000000..1269cf6374 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_sizemin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='scatter3d.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_sizemode.py b/plotly/validators/scatter3d/marker/_sizemode.py new file mode 100644 index 0000000000..ae03f8051e --- /dev/null +++ b/plotly/validators/scatter3d/marker/_sizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='sizemode', parent_name='scatter3d.marker', **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_sizeref.py b/plotly/validators/scatter3d/marker/_sizeref.py new file mode 100644 index 0000000000..40f34c25ec --- /dev/null +++ b/plotly/validators/scatter3d/marker/_sizeref.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizeref', parent_name='scatter3d.marker', **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_sizesrc.py b/plotly/validators/scatter3d/marker/_sizesrc.py new file mode 100644 index 0000000000..df20f68a81 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='scatter3d.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_symbol.py b/plotly/validators/scatter3d/marker/_symbol.py new file mode 100644 index 0000000000..e87595d785 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_symbol.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='scatter3d.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'circle', 'circle-open', 'square', 'square-open', 'diamond', + 'diamond-open', 'cross', 'x' + ], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/_symbolsrc.py b/plotly/validators/scatter3d/marker/_symbolsrc.py new file mode 100644 index 0000000000..59217c8176 --- /dev/null +++ b/plotly/validators/scatter3d/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scatter3d.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/__init__.py b/plotly/validators/scatter3d/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatter3d/marker/colorbar/_bgcolor.py b/plotly/validators/scatter3d/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..0e18ff3bd8 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_bordercolor.py b/plotly/validators/scatter3d/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..e62dd9bcaa --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_borderwidth.py b/plotly/validators/scatter3d/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..81d1188dba --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_dtick.py b/plotly/validators/scatter3d/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..a3237d7c66 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_exponentformat.py b/plotly/validators/scatter3d/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..5152a91bf2 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_len.py b/plotly/validators/scatter3d/marker/colorbar/_len.py new file mode 100644 index 0000000000..bdfd91c7b4 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_lenmode.py b/plotly/validators/scatter3d/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..2e2c091baf --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_nticks.py b/plotly/validators/scatter3d/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..dbab6669d1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_outlinecolor.py b/plotly/validators/scatter3d/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..cd12e7c15a --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_outlinewidth.py b/plotly/validators/scatter3d/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..9a1b2606bf --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_separatethousands.py b/plotly/validators/scatter3d/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..61727932c2 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_showexponent.py b/plotly/validators/scatter3d/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..048244038f --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_showticklabels.py b/plotly/validators/scatter3d/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..fae7a37d91 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_showtickprefix.py b/plotly/validators/scatter3d/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..e90aaf02d3 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_showticksuffix.py b/plotly/validators/scatter3d/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..5409d1d7c7 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_thickness.py b/plotly/validators/scatter3d/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..2b623b21a8 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_thicknessmode.py b/plotly/validators/scatter3d/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..1922174443 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tick0.py b/plotly/validators/scatter3d/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..5382bcefa1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickangle.py b/plotly/validators/scatter3d/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..7fa8bfa9d7 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickcolor.py b/plotly/validators/scatter3d/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..de9ff0d5c9 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickfont.py b/plotly/validators/scatter3d/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..41cef57bfa --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickformat.py b/plotly/validators/scatter3d/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..2e2abcbcfb --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickformatstops.py b/plotly/validators/scatter3d/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..6b6dbd12d1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ticklen.py b/plotly/validators/scatter3d/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..3c4fd6f79d --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickmode.py b/plotly/validators/scatter3d/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..c47daff5d2 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickprefix.py b/plotly/validators/scatter3d/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..229fa1cd0b --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ticks.py b/plotly/validators/scatter3d/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..1925f36fb3 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ticksuffix.py b/plotly/validators/scatter3d/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..23050dbbde --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ticktext.py b/plotly/validators/scatter3d/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..f5af27d678 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ticktextsrc.py b/plotly/validators/scatter3d/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..0cdbe96c51 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickvals.py b/plotly/validators/scatter3d/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..c22dba3ac8 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickvalssrc.py b/plotly/validators/scatter3d/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..b334fcc15d --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_tickwidth.py b/plotly/validators/scatter3d/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..1155254311 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_title.py b/plotly/validators/scatter3d/marker/colorbar/_title.py new file mode 100644 index 0000000000..63664c0325 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_titlefont.py b/plotly/validators/scatter3d/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..07c14ae778 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_titleside.py b/plotly/validators/scatter3d/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..0cc88d921a --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_x.py b/plotly/validators/scatter3d/marker/colorbar/_x.py new file mode 100644 index 0000000000..5c2ea9fef1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_xanchor.py b/plotly/validators/scatter3d/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..01a4d2256d --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_xpad.py b/plotly/validators/scatter3d/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..e372411cfc --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_y.py b/plotly/validators/scatter3d/marker/colorbar/_y.py new file mode 100644 index 0000000000..c49c0241b2 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_yanchor.py b/plotly/validators/scatter3d/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..9d7a282067 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/_ypad.py b/plotly/validators/scatter3d/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..5b96c93870 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scatter3d.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/tickfont/__init__.py b/plotly/validators/scatter3d/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter3d/marker/colorbar/tickfont/_color.py b/plotly/validators/scatter3d/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..0cf91fe96b --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter3d.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/tickfont/_family.py b/plotly/validators/scatter3d/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..455622bbdc --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter3d.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/tickfont/_size.py b/plotly/validators/scatter3d/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..710d97103a --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter3d.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..7af41ba6c2 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scatter3d.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..aff39203bb --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scatter3d.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/titlefont/__init__.py b/plotly/validators/scatter3d/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter3d/marker/colorbar/titlefont/_color.py b/plotly/validators/scatter3d/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..8bc843624c --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter3d.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/titlefont/_family.py b/plotly/validators/scatter3d/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..1ba5a7e317 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatter3d.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/colorbar/titlefont/_size.py b/plotly/validators/scatter3d/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..5effd48794 --- /dev/null +++ b/plotly/validators/scatter3d/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatter3d.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/__init__.py b/plotly/validators/scatter3d/marker/line/__init__.py new file mode 100644 index 0000000000..bc4a51343d --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/__init__.py @@ -0,0 +1,9 @@ +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatter3d/marker/line/_autocolorscale.py b/plotly/validators/scatter3d/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..4423215bda --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_cauto.py b/plotly/validators/scatter3d/marker/line/_cauto.py new file mode 100644 index 0000000000..da514ef0bf --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_cmax.py b/plotly/validators/scatter3d/marker/line/_cmax.py new file mode 100644 index 0000000000..4759f392ae --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_cmin.py b/plotly/validators/scatter3d/marker/line/_cmin.py new file mode 100644 index 0000000000..618b5c1797 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_color.py b/plotly/validators/scatter3d/marker/line/_color.py new file mode 100644 index 0000000000..b1ad0d6b52 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scatter3d.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_colorscale.py b/plotly/validators/scatter3d/marker/line/_colorscale.py new file mode 100644 index 0000000000..b7a32429f1 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_colorsrc.py b/plotly/validators/scatter3d/marker/line/_colorsrc.py new file mode 100644 index 0000000000..cf66f67686 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_reversescale.py b/plotly/validators/scatter3d/marker/line/_reversescale.py new file mode 100644 index 0000000000..9a1017eb81 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/marker/line/_width.py b/plotly/validators/scatter3d/marker/line/_width.py new file mode 100644 index 0000000000..7734322679 --- /dev/null +++ b/plotly/validators/scatter3d/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scatter3d.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/__init__.py b/plotly/validators/scatter3d/projection/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/scatter3d/projection/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/scatter3d/projection/_x.py b/plotly/validators/scatter3d/projection/_x.py new file mode 100644 index 0000000000..12c0381631 --- /dev/null +++ b/plotly/validators/scatter3d/projection/_x.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='x', parent_name='scatter3d.projection', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='X', + data_docs=""" + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the x axis.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/_y.py b/plotly/validators/scatter3d/projection/_y.py new file mode 100644 index 0000000000..ef07453674 --- /dev/null +++ b/plotly/validators/scatter3d/projection/_y.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='y', parent_name='scatter3d.projection', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Y', + data_docs=""" + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the y axis.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/_z.py b/plotly/validators/scatter3d/projection/_z.py new file mode 100644 index 0000000000..735d6edcd5 --- /dev/null +++ b/plotly/validators/scatter3d/projection/_z.py @@ -0,0 +1,23 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='z', parent_name='scatter3d.projection', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Z', + data_docs=""" + opacity + Sets the projection color. + scale + Sets the scale factor determining the size of + the projection marker points. + show + Sets whether or not projections are shown along + the z axis.""", + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/x/__init__.py b/plotly/validators/scatter3d/projection/x/__init__.py new file mode 100644 index 0000000000..5f3d9448b0 --- /dev/null +++ b/plotly/validators/scatter3d/projection/x/__init__.py @@ -0,0 +1,3 @@ +from ._show import ShowValidator +from ._scale import ScaleValidator +from ._opacity import OpacityValidator diff --git a/plotly/validators/scatter3d/projection/x/_opacity.py b/plotly/validators/scatter3d/projection/x/_opacity.py new file mode 100644 index 0000000000..3659ad0562 --- /dev/null +++ b/plotly/validators/scatter3d/projection/x/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatter3d.projection.x', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/x/_scale.py b/plotly/validators/scatter3d/projection/x/_scale.py new file mode 100644 index 0000000000..0bccf6c979 --- /dev/null +++ b/plotly/validators/scatter3d/projection/x/_scale.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ScaleValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='scale', + parent_name='scatter3d.projection.x', + **kwargs + ): + super(ScaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/x/_show.py b/plotly/validators/scatter3d/projection/x/_show.py new file mode 100644 index 0000000000..6d92184828 --- /dev/null +++ b/plotly/validators/scatter3d/projection/x/_show.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='show', + parent_name='scatter3d.projection.x', + **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/y/__init__.py b/plotly/validators/scatter3d/projection/y/__init__.py new file mode 100644 index 0000000000..5f3d9448b0 --- /dev/null +++ b/plotly/validators/scatter3d/projection/y/__init__.py @@ -0,0 +1,3 @@ +from ._show import ShowValidator +from ._scale import ScaleValidator +from ._opacity import OpacityValidator diff --git a/plotly/validators/scatter3d/projection/y/_opacity.py b/plotly/validators/scatter3d/projection/y/_opacity.py new file mode 100644 index 0000000000..70f1ded757 --- /dev/null +++ b/plotly/validators/scatter3d/projection/y/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatter3d.projection.y', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/y/_scale.py b/plotly/validators/scatter3d/projection/y/_scale.py new file mode 100644 index 0000000000..21ec0bdcea --- /dev/null +++ b/plotly/validators/scatter3d/projection/y/_scale.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ScaleValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='scale', + parent_name='scatter3d.projection.y', + **kwargs + ): + super(ScaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/y/_show.py b/plotly/validators/scatter3d/projection/y/_show.py new file mode 100644 index 0000000000..c82b73e4d8 --- /dev/null +++ b/plotly/validators/scatter3d/projection/y/_show.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='show', + parent_name='scatter3d.projection.y', + **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/z/__init__.py b/plotly/validators/scatter3d/projection/z/__init__.py new file mode 100644 index 0000000000..5f3d9448b0 --- /dev/null +++ b/plotly/validators/scatter3d/projection/z/__init__.py @@ -0,0 +1,3 @@ +from ._show import ShowValidator +from ._scale import ScaleValidator +from ._opacity import OpacityValidator diff --git a/plotly/validators/scatter3d/projection/z/_opacity.py b/plotly/validators/scatter3d/projection/z/_opacity.py new file mode 100644 index 0000000000..20a8a5d037 --- /dev/null +++ b/plotly/validators/scatter3d/projection/z/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatter3d.projection.z', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/z/_scale.py b/plotly/validators/scatter3d/projection/z/_scale.py new file mode 100644 index 0000000000..2fcef7f82e --- /dev/null +++ b/plotly/validators/scatter3d/projection/z/_scale.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ScaleValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='scale', + parent_name='scatter3d.projection.z', + **kwargs + ): + super(ScaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/projection/z/_show.py b/plotly/validators/scatter3d/projection/z/_show.py new file mode 100644 index 0000000000..7d845561aa --- /dev/null +++ b/plotly/validators/scatter3d/projection/z/_show.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='show', + parent_name='scatter3d.projection.z', + **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/stream/__init__.py b/plotly/validators/scatter3d/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scatter3d/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scatter3d/stream/_maxpoints.py b/plotly/validators/scatter3d/stream/_maxpoints.py new file mode 100644 index 0000000000..ca795b41f2 --- /dev/null +++ b/plotly/validators/scatter3d/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scatter3d.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/stream/_token.py b/plotly/validators/scatter3d/stream/_token.py new file mode 100644 index 0000000000..3c21760bfc --- /dev/null +++ b/plotly/validators/scatter3d/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='scatter3d.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/__init__.py b/plotly/validators/scatter3d/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatter3d/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatter3d/textfont/_color.py b/plotly/validators/scatter3d/textfont/_color.py new file mode 100644 index 0000000000..8ba353f9b3 --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatter3d.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/_colorsrc.py b/plotly/validators/scatter3d/textfont/_colorsrc.py new file mode 100644 index 0000000000..a06981c32e --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatter3d.textfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/_family.py b/plotly/validators/scatter3d/textfont/_family.py new file mode 100644 index 0000000000..cedbb51d81 --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='scatter3d.textfont', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/_familysrc.py b/plotly/validators/scatter3d/textfont/_familysrc.py new file mode 100644 index 0000000000..c81f10d83d --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatter3d.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/_size.py b/plotly/validators/scatter3d/textfont/_size.py new file mode 100644 index 0000000000..216530ecc1 --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scatter3d.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatter3d/textfont/_sizesrc.py b/plotly/validators/scatter3d/textfont/_sizesrc.py new file mode 100644 index 0000000000..a83bd221d5 --- /dev/null +++ b/plotly/validators/scatter3d/textfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatter3d.textfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/__init__.py b/plotly/validators/scattercarpet/__init__.py new file mode 100644 index 0000000000..03e2f3bb08 --- /dev/null +++ b/plotly/validators/scattercarpet/__init__.py @@ -0,0 +1,36 @@ +from ._yaxis import YAxisValidator +from ._xaxis import XAxisValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator +from ._carpet import CarpetValidator +from ._bsrc import BsrcValidator +from ._b import BValidator +from ._asrc import AsrcValidator +from ._a import AValidator diff --git a/plotly/validators/scattercarpet/_a.py b/plotly/validators/scattercarpet/_a.py new file mode 100644 index 0000000000..0ad7a3fbc5 --- /dev/null +++ b/plotly/validators/scattercarpet/_a.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class AValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='a', parent_name='scattercarpet', **kwargs): + super(AValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_asrc.py b/plotly/validators/scattercarpet/_asrc.py new file mode 100644 index 0000000000..a2a81bae46 --- /dev/null +++ b/plotly/validators/scattercarpet/_asrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='asrc', parent_name='scattercarpet', **kwargs + ): + super(AsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_b.py b/plotly/validators/scattercarpet/_b.py new file mode 100644 index 0000000000..f22bf17ab4 --- /dev/null +++ b/plotly/validators/scattercarpet/_b.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='b', parent_name='scattercarpet', **kwargs): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_bsrc.py b/plotly/validators/scattercarpet/_bsrc.py new file mode 100644 index 0000000000..f10ef64335 --- /dev/null +++ b/plotly/validators/scattercarpet/_bsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bsrc', parent_name='scattercarpet', **kwargs + ): + super(BsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_carpet.py b/plotly/validators/scattercarpet/_carpet.py new file mode 100644 index 0000000000..1e15c07e26 --- /dev/null +++ b/plotly/validators/scattercarpet/_carpet.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CarpetValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='carpet', parent_name='scattercarpet', **kwargs + ): + super(CarpetValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_connectgaps.py b/plotly/validators/scattercarpet/_connectgaps.py new file mode 100644 index 0000000000..8b148fcc69 --- /dev/null +++ b/plotly/validators/scattercarpet/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scattercarpet', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_customdata.py b/plotly/validators/scattercarpet/_customdata.py new file mode 100644 index 0000000000..aa6c38ebe1 --- /dev/null +++ b/plotly/validators/scattercarpet/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scattercarpet', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_customdatasrc.py b/plotly/validators/scattercarpet/_customdatasrc.py new file mode 100644 index 0000000000..e584b8bfe3 --- /dev/null +++ b/plotly/validators/scattercarpet/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='scattercarpet', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_fill.py b/plotly/validators/scattercarpet/_fill.py new file mode 100644 index 0000000000..ca87eca75d --- /dev/null +++ b/plotly/validators/scattercarpet/_fill.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='fill', parent_name='scattercarpet', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'toself', 'tonext'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_fillcolor.py b/plotly/validators/scattercarpet/_fillcolor.py new file mode 100644 index 0000000000..5c69cfec0b --- /dev/null +++ b/plotly/validators/scattercarpet/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scattercarpet', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_hoverinfo.py b/plotly/validators/scattercarpet/_hoverinfo.py new file mode 100644 index 0000000000..39828a4350 --- /dev/null +++ b/plotly/validators/scattercarpet/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scattercarpet', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['a', 'b', 'text', 'name', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_hoverinfosrc.py b/plotly/validators/scattercarpet/_hoverinfosrc.py new file mode 100644 index 0000000000..26fa1e4b5c --- /dev/null +++ b/plotly/validators/scattercarpet/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='scattercarpet', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_hoverlabel.py b/plotly/validators/scattercarpet/_hoverlabel.py new file mode 100644 index 0000000000..b03798c79f --- /dev/null +++ b/plotly/validators/scattercarpet/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scattercarpet', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_hoveron.py b/plotly/validators/scattercarpet/_hoveron.py new file mode 100644 index 0000000000..352a3b5421 --- /dev/null +++ b/plotly/validators/scattercarpet/_hoveron.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoveron', parent_name='scattercarpet', **kwargs + ): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_ids.py b/plotly/validators/scattercarpet/_ids.py new file mode 100644 index 0000000000..80e1b0775d --- /dev/null +++ b/plotly/validators/scattercarpet/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='scattercarpet', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_idssrc.py b/plotly/validators/scattercarpet/_idssrc.py new file mode 100644 index 0000000000..b6f14a13e8 --- /dev/null +++ b/plotly/validators/scattercarpet/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scattercarpet', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_legendgroup.py b/plotly/validators/scattercarpet/_legendgroup.py new file mode 100644 index 0000000000..ce3f938137 --- /dev/null +++ b/plotly/validators/scattercarpet/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scattercarpet', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_line.py b/plotly/validators/scattercarpet/_line.py new file mode 100644 index 0000000000..892667ca4f --- /dev/null +++ b/plotly/validators/scattercarpet/_line.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scattercarpet', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_marker.py b/plotly/validators/scattercarpet/_marker.py new file mode 100644 index 0000000000..31f8b1b11b --- /dev/null +++ b/plotly/validators/scattercarpet/_marker.py @@ -0,0 +1,126 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scattercarpet', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattercarpet.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scattercarpet.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattercarpet.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_mode.py b/plotly/validators/scattercarpet/_mode.py new file mode 100644 index 0000000000..df404090be --- /dev/null +++ b/plotly/validators/scattercarpet/_mode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='mode', parent_name='scattercarpet', **kwargs + ): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_name.py b/plotly/validators/scattercarpet/_name.py new file mode 100644 index 0000000000..50cb9631f0 --- /dev/null +++ b/plotly/validators/scattercarpet/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='scattercarpet', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_opacity.py b/plotly/validators/scattercarpet/_opacity.py new file mode 100644 index 0000000000..2cc5ba1a40 --- /dev/null +++ b/plotly/validators/scattercarpet/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattercarpet', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_selected.py b/plotly/validators/scattercarpet/_selected.py new file mode 100644 index 0000000000..3158748c92 --- /dev/null +++ b/plotly/validators/scattercarpet/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scattercarpet', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scattercarpet.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.selected.Textfo + nt instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_selectedpoints.py b/plotly/validators/scattercarpet/_selectedpoints.py new file mode 100644 index 0000000000..5c5a8de709 --- /dev/null +++ b/plotly/validators/scattercarpet/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='scattercarpet', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_showlegend.py b/plotly/validators/scattercarpet/_showlegend.py new file mode 100644 index 0000000000..5ab2d82858 --- /dev/null +++ b/plotly/validators/scattercarpet/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scattercarpet', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_stream.py b/plotly/validators/scattercarpet/_stream.py new file mode 100644 index 0000000000..04be53a505 --- /dev/null +++ b/plotly/validators/scattercarpet/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scattercarpet', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_text.py b/plotly/validators/scattercarpet/_text.py new file mode 100644 index 0000000000..1d7c9e5fc6 --- /dev/null +++ b/plotly/validators/scattercarpet/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='scattercarpet', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_textfont.py b/plotly/validators/scattercarpet/_textfont.py new file mode 100644 index 0000000000..59dfd0e20f --- /dev/null +++ b/plotly/validators/scattercarpet/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scattercarpet', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_textposition.py b/plotly/validators/scattercarpet/_textposition.py new file mode 100644 index 0000000000..4a3b04e5ee --- /dev/null +++ b/plotly/validators/scattercarpet/_textposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='textposition', + parent_name='scattercarpet', + **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_textpositionsrc.py b/plotly/validators/scattercarpet/_textpositionsrc.py new file mode 100644 index 0000000000..ba19ddf2f7 --- /dev/null +++ b/plotly/validators/scattercarpet/_textpositionsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='textpositionsrc', + parent_name='scattercarpet', + **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_textsrc.py b/plotly/validators/scattercarpet/_textsrc.py new file mode 100644 index 0000000000..00ab5634b9 --- /dev/null +++ b/plotly/validators/scattercarpet/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scattercarpet', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_uid.py b/plotly/validators/scattercarpet/_uid.py new file mode 100644 index 0000000000..5fbf1062f8 --- /dev/null +++ b/plotly/validators/scattercarpet/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='scattercarpet', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_unselected.py b/plotly/validators/scattercarpet/_unselected.py new file mode 100644 index 0000000000..f2ee31e0bb --- /dev/null +++ b/plotly/validators/scattercarpet/_unselected.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scattercarpet', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scattercarpet.unselected.Mark + er instance or dict with compatible properties + textfont + plotly.graph_objs.scattercarpet.unselected.Text + font instance or dict with compatible + properties""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_visible.py b/plotly/validators/scattercarpet/_visible.py new file mode 100644 index 0000000000..babc9f7364 --- /dev/null +++ b/plotly/validators/scattercarpet/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattercarpet', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_xaxis.py b/plotly/validators/scattercarpet/_xaxis.py new file mode 100644 index 0000000000..c3ea6df7cd --- /dev/null +++ b/plotly/validators/scattercarpet/_xaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='xaxis', parent_name='scattercarpet', **kwargs + ): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/_yaxis.py b/plotly/validators/scattercarpet/_yaxis.py new file mode 100644 index 0000000000..fd1e19738f --- /dev/null +++ b/plotly/validators/scattercarpet/_yaxis.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='yaxis', parent_name='scattercarpet', **kwargs + ): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/__init__.py b/plotly/validators/scattercarpet/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattercarpet/hoverlabel/_bgcolor.py b/plotly/validators/scattercarpet/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..deb33e53ea --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_bgcolorsrc.py b/plotly/validators/scattercarpet/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..1e3d0fab42 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_bordercolor.py b/plotly/validators/scattercarpet/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..9002bbafc0 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_bordercolorsrc.py b/plotly/validators/scattercarpet/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..1c14116aa6 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_font.py b/plotly/validators/scattercarpet/hoverlabel/_font.py new file mode 100644 index 0000000000..3ad5e4e103 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_namelength.py b/plotly/validators/scattercarpet/hoverlabel/_namelength.py new file mode 100644 index 0000000000..e309822a5c --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/_namelengthsrc.py b/plotly/validators/scattercarpet/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..ce332d77cf --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scattercarpet.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/__init__.py b/plotly/validators/scattercarpet/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_color.py b/plotly/validators/scattercarpet/hoverlabel/font/_color.py new file mode 100644 index 0000000000..be5c0f1a57 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_colorsrc.py b/plotly/validators/scattercarpet/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..49f599eaca --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_family.py b/plotly/validators/scattercarpet/hoverlabel/font/_family.py new file mode 100644 index 0000000000..e4da28c832 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_familysrc.py b/plotly/validators/scattercarpet/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..884eb7a735 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_size.py b/plotly/validators/scattercarpet/hoverlabel/font/_size.py new file mode 100644 index 0000000000..d7b21785a2 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/hoverlabel/font/_sizesrc.py b/plotly/validators/scattercarpet/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..009e1ffa07 --- /dev/null +++ b/plotly/validators/scattercarpet/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattercarpet.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/line/__init__.py b/plotly/validators/scattercarpet/line/__init__.py new file mode 100644 index 0000000000..633e654df0 --- /dev/null +++ b/plotly/validators/scattercarpet/line/__init__.py @@ -0,0 +1,5 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._shape import ShapeValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/line/_color.py b/plotly/validators/scattercarpet/line/_color.py new file mode 100644 index 0000000000..e55f250799 --- /dev/null +++ b/plotly/validators/scattercarpet/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattercarpet.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/line/_dash.py b/plotly/validators/scattercarpet/line/_dash.py new file mode 100644 index 0000000000..ff46afea79 --- /dev/null +++ b/plotly/validators/scattercarpet/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='scattercarpet.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/line/_shape.py b/plotly/validators/scattercarpet/line/_shape.py new file mode 100644 index 0000000000..6039b41451 --- /dev/null +++ b/plotly/validators/scattercarpet/line/_shape.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShapeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='shape', parent_name='scattercarpet.line', **kwargs + ): + super(ShapeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['linear', 'spline'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/line/_smoothing.py b/plotly/validators/scattercarpet/line/_smoothing.py new file mode 100644 index 0000000000..daeb98ab3c --- /dev/null +++ b/plotly/validators/scattercarpet/line/_smoothing.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='smoothing', + parent_name='scattercarpet.line', + **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/line/_width.py b/plotly/validators/scattercarpet/line/_width.py new file mode 100644 index 0000000000..85d47172de --- /dev/null +++ b/plotly/validators/scattercarpet/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattercarpet.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/__init__.py b/plotly/validators/scattercarpet/marker/__init__.py new file mode 100644 index 0000000000..7b7dcf37e9 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/__init__.py @@ -0,0 +1,22 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._maxdisplayed import MaxdisplayedValidator +from ._line import LineValidator +from ._gradient import GradientValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattercarpet/marker/_autocolorscale.py b/plotly/validators/scattercarpet/marker/_autocolorscale.py new file mode 100644 index 0000000000..f87f97dbdd --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattercarpet.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_cauto.py b/plotly/validators/scattercarpet/marker/_cauto.py new file mode 100644 index 0000000000..c26a58f63e --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scattercarpet.marker', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_cmax.py b/plotly/validators/scattercarpet/marker/_cmax.py new file mode 100644 index 0000000000..d8f395ecaa --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scattercarpet.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_cmin.py b/plotly/validators/scattercarpet/marker/_cmin.py new file mode 100644 index 0000000000..2349add318 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scattercarpet.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_color.py b/plotly/validators/scattercarpet/marker/_color.py new file mode 100644 index 0000000000..844ac9c3e8 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scattercarpet.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_colorbar.py b/plotly/validators/scattercarpet/marker/_colorbar.py new file mode 100644 index 0000000000..e250a7c944 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattercarpet.marker.colorbar + .Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_colorscale.py b/plotly/validators/scattercarpet/marker/_colorscale.py new file mode 100644 index 0000000000..b21b284ce8 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_colorsrc.py b/plotly/validators/scattercarpet/marker/_colorsrc.py new file mode 100644 index 0000000000..4240ea6922 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_gradient.py b/plotly/validators/scattercarpet/marker/_gradient.py new file mode 100644 index 0000000000..4ef8f69922 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_gradient.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class GradientValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='gradient', + parent_name='scattercarpet.marker', + **kwargs + ): + super(GradientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Gradient', + data_docs=""" + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_line.py b/plotly/validators/scattercarpet/marker/_line.py new file mode 100644 index 0000000000..b8dec5acb6 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_line.py @@ -0,0 +1,83 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scattercarpet.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `color` is set to a + numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `color` is set to a + numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `color` is set to a + numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmin` must be + set as well. + cmin + Has an effect only if `color` is set to a + numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `color` array index, and if set, `cmax` must be + set as well. + color + Sets the color. It accepts either a specific + color or an array of numbers that are mapped to + the colorscale relative to the max and min + values of the array or relative to `cmin` and + `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `cmin` and `cmax`. Alternatively, + `colorscale` may be a palette name string of + the following list: Greys, YlGnBu, Greens, + YlOrRd, Bluered, RdBu, Reds, Blues, Picnic, + Rainbow, Portland, Jet, Hot, Blackbody, Earth, + Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `color` is set to a + numerical array. Reverses the color mapping if + true (`cmin` will correspond to the last color + in the array and `cmax` will correspond to the + first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_maxdisplayed.py b/plotly/validators/scattercarpet/marker/_maxdisplayed.py new file mode 100644 index 0000000000..a6662b6a29 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_maxdisplayed.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MaxdisplayedValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxdisplayed', + parent_name='scattercarpet.marker', + **kwargs + ): + super(MaxdisplayedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_opacity.py b/plotly/validators/scattercarpet/marker/_opacity.py new file mode 100644 index 0000000000..5b16c9acaf --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_opacity.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattercarpet.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_opacitysrc.py b/plotly/validators/scattercarpet/marker/_opacitysrc.py new file mode 100644 index 0000000000..70171deadf --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scattercarpet.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_reversescale.py b/plotly/validators/scattercarpet/marker/_reversescale.py new file mode 100644 index 0000000000..a983cb432f --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_showscale.py b/plotly/validators/scattercarpet/marker/_showscale.py new file mode 100644 index 0000000000..e92627d258 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scattercarpet.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_size.py b/plotly/validators/scattercarpet/marker/_size.py new file mode 100644 index 0000000000..18fadea295 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scattercarpet.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_sizemin.py b/plotly/validators/scattercarpet/marker/_sizemin.py new file mode 100644 index 0000000000..7288d63eb7 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_sizemin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizemin', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_sizemode.py b/plotly/validators/scattercarpet/marker/_sizemode.py new file mode 100644 index 0000000000..05ce4de03b --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_sizeref.py b/plotly/validators/scattercarpet/marker/_sizeref.py new file mode 100644 index 0000000000..3d373b92dc --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_sizeref.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizeref', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_sizesrc.py b/plotly/validators/scattercarpet/marker/_sizesrc.py new file mode 100644 index 0000000000..678aef144e --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_symbol.py b/plotly/validators/scattercarpet/marker/_symbol.py new file mode 100644 index 0000000000..fa2706d310 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_symbol.py @@ -0,0 +1,77 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/_symbolsrc.py b/plotly/validators/scattercarpet/marker/_symbolsrc.py new file mode 100644 index 0000000000..bb03e27e6a --- /dev/null +++ b/plotly/validators/scattercarpet/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scattercarpet.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/__init__.py b/plotly/validators/scattercarpet/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattercarpet/marker/colorbar/_bgcolor.py b/plotly/validators/scattercarpet/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..999c510b82 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_bordercolor.py b/plotly/validators/scattercarpet/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..b4bf017fb9 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_borderwidth.py b/plotly/validators/scattercarpet/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..40df922a42 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_dtick.py b/plotly/validators/scattercarpet/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..864c21dd0f --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_exponentformat.py b/plotly/validators/scattercarpet/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..61277e6104 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_len.py b/plotly/validators/scattercarpet/marker/colorbar/_len.py new file mode 100644 index 0000000000..9cd71e6429 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_lenmode.py b/plotly/validators/scattercarpet/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..127f1d1230 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_nticks.py b/plotly/validators/scattercarpet/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..2af8f78289 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_outlinecolor.py b/plotly/validators/scattercarpet/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..d0b3303087 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_outlinewidth.py b/plotly/validators/scattercarpet/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..554f7dda0f --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_separatethousands.py b/plotly/validators/scattercarpet/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..9a110e0724 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_showexponent.py b/plotly/validators/scattercarpet/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..51d56afc82 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_showticklabels.py b/plotly/validators/scattercarpet/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..5a1cbacf0c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_showtickprefix.py b/plotly/validators/scattercarpet/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..e05105d984 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_showticksuffix.py b/plotly/validators/scattercarpet/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..9cb9c13552 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_thickness.py b/plotly/validators/scattercarpet/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..21f1650b8a --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_thicknessmode.py b/plotly/validators/scattercarpet/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..ee4b872079 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tick0.py b/plotly/validators/scattercarpet/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..878c573e1b --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickangle.py b/plotly/validators/scattercarpet/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..d04bc74aad --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickcolor.py b/plotly/validators/scattercarpet/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..9e0c83e2d3 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickfont.py b/plotly/validators/scattercarpet/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..0678a0d663 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickformat.py b/plotly/validators/scattercarpet/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..43f25a5274 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickformatstops.py b/plotly/validators/scattercarpet/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..3089a7cb2d --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ticklen.py b/plotly/validators/scattercarpet/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..31c2bee38c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickmode.py b/plotly/validators/scattercarpet/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..cf11e6694c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickprefix.py b/plotly/validators/scattercarpet/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..fcffc159c5 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ticks.py b/plotly/validators/scattercarpet/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..b009c34bb5 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ticksuffix.py b/plotly/validators/scattercarpet/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..b9753cbe10 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ticktext.py b/plotly/validators/scattercarpet/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..9a44293e75 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ticktextsrc.py b/plotly/validators/scattercarpet/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..0610debe29 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickvals.py b/plotly/validators/scattercarpet/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..eb0136cc76 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickvalssrc.py b/plotly/validators/scattercarpet/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..df3ac4580e --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_tickwidth.py b/plotly/validators/scattercarpet/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..7f3a8c9f29 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_title.py b/plotly/validators/scattercarpet/marker/colorbar/_title.py new file mode 100644 index 0000000000..bdbd7f4396 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_titlefont.py b/plotly/validators/scattercarpet/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..e46ba2a011 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_titleside.py b/plotly/validators/scattercarpet/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..4f92f75a85 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_x.py b/plotly/validators/scattercarpet/marker/colorbar/_x.py new file mode 100644 index 0000000000..7ae9b73017 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_xanchor.py b/plotly/validators/scattercarpet/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..6c67cdaad4 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_xpad.py b/plotly/validators/scattercarpet/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..3904290184 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_y.py b/plotly/validators/scattercarpet/marker/colorbar/_y.py new file mode 100644 index 0000000000..184a38a241 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_yanchor.py b/plotly/validators/scattercarpet/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..c42c9fa3c3 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/_ypad.py b/plotly/validators/scattercarpet/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..a8a92a8a5b --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scattercarpet.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickfont/__init__.py b/plotly/validators/scattercarpet/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickfont/_color.py b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..5f89ae7f76 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickfont/_family.py b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..51f905fda3 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattercarpet.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickfont/_size.py b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..a3709fe69b --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..a050d0a05c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scattercarpet.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..cad281e090 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scattercarpet.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/titlefont/__init__.py b/plotly/validators/scattercarpet/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/marker/colorbar/titlefont/_color.py b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..78635cb106 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/titlefont/_family.py b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..3057dd5532 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattercarpet.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/colorbar/titlefont/_size.py b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..8ab7f1a6ba --- /dev/null +++ b/plotly/validators/scattercarpet/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/gradient/__init__.py b/plotly/validators/scattercarpet/marker/gradient/__init__.py new file mode 100644 index 0000000000..434557c8fe --- /dev/null +++ b/plotly/validators/scattercarpet/marker/gradient/__init__.py @@ -0,0 +1,4 @@ +from ._typesrc import TypesrcValidator +from ._type import TypeValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/marker/gradient/_color.py b/plotly/validators/scattercarpet/marker/gradient/_color.py new file mode 100644 index 0000000000..56d71cf15d --- /dev/null +++ b/plotly/validators/scattercarpet/marker/gradient/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.marker.gradient', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/gradient/_colorsrc.py b/plotly/validators/scattercarpet/marker/gradient/_colorsrc.py new file mode 100644 index 0000000000..7fcbf07acd --- /dev/null +++ b/plotly/validators/scattercarpet/marker/gradient/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattercarpet.marker.gradient', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/gradient/_type.py b/plotly/validators/scattercarpet/marker/gradient/_type.py new file mode 100644 index 0000000000..50f03e26c3 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/gradient/_type.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='scattercarpet.marker.gradient', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['radial', 'horizontal', 'vertical', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/gradient/_typesrc.py b/plotly/validators/scattercarpet/marker/gradient/_typesrc.py new file mode 100644 index 0000000000..d42d1f75ed --- /dev/null +++ b/plotly/validators/scattercarpet/marker/gradient/_typesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TypesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='typesrc', + parent_name='scattercarpet.marker.gradient', + **kwargs + ): + super(TypesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/__init__.py b/plotly/validators/scattercarpet/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattercarpet/marker/line/_autocolorscale.py b/plotly/validators/scattercarpet/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..dd02ff3e6a --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_cauto.py b/plotly/validators/scattercarpet/marker/line/_cauto.py new file mode 100644 index 0000000000..de91092d8d --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_cmax.py b/plotly/validators/scattercarpet/marker/line/_cmax.py new file mode 100644 index 0000000000..3715f30412 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_cmin.py b/plotly/validators/scattercarpet/marker/line/_cmin.py new file mode 100644 index 0000000000..81447ca4f6 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_color.py b/plotly/validators/scattercarpet/marker/line/_color.py new file mode 100644 index 0000000000..c3ce238586 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scattercarpet.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_colorscale.py b/plotly/validators/scattercarpet/marker/line/_colorscale.py new file mode 100644 index 0000000000..6192b86da2 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_colorsrc.py b/plotly/validators/scattercarpet/marker/line/_colorsrc.py new file mode 100644 index 0000000000..589b65896d --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_reversescale.py b/plotly/validators/scattercarpet/marker/line/_reversescale.py new file mode 100644 index 0000000000..0007b3e5e3 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_width.py b/plotly/validators/scattercarpet/marker/line/_width.py new file mode 100644 index 0000000000..99835d4953 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/marker/line/_widthsrc.py b/plotly/validators/scattercarpet/marker/line/_widthsrc.py new file mode 100644 index 0000000000..b713951742 --- /dev/null +++ b/plotly/validators/scattercarpet/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scattercarpet.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/__init__.py b/plotly/validators/scattercarpet/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scattercarpet/selected/_marker.py b/plotly/validators/scattercarpet/selected/_marker.py new file mode 100644 index 0000000000..3a8675a7fa --- /dev/null +++ b/plotly/validators/scattercarpet/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattercarpet.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/_textfont.py b/plotly/validators/scattercarpet/selected/_textfont.py new file mode 100644 index 0000000000..dac5573385 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scattercarpet.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/marker/__init__.py b/plotly/validators/scattercarpet/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/selected/marker/_color.py b/plotly/validators/scattercarpet/selected/marker/_color.py new file mode 100644 index 0000000000..659cdd5cd7 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/marker/_opacity.py b/plotly/validators/scattercarpet/selected/marker/_opacity.py new file mode 100644 index 0000000000..66a38de364 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattercarpet.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/marker/_size.py b/plotly/validators/scattercarpet/selected/marker/_size.py new file mode 100644 index 0000000000..7afa5b4b6a --- /dev/null +++ b/plotly/validators/scattercarpet/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/selected/textfont/__init__.py b/plotly/validators/scattercarpet/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/selected/textfont/_color.py b/plotly/validators/scattercarpet/selected/textfont/_color.py new file mode 100644 index 0000000000..9fa51777e0 --- /dev/null +++ b/plotly/validators/scattercarpet/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/stream/__init__.py b/plotly/validators/scattercarpet/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scattercarpet/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scattercarpet/stream/_maxpoints.py b/plotly/validators/scattercarpet/stream/_maxpoints.py new file mode 100644 index 0000000000..5a144515ee --- /dev/null +++ b/plotly/validators/scattercarpet/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scattercarpet.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/stream/_token.py b/plotly/validators/scattercarpet/stream/_token.py new file mode 100644 index 0000000000..2be82c7774 --- /dev/null +++ b/plotly/validators/scattercarpet/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='scattercarpet.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/__init__.py b/plotly/validators/scattercarpet/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/textfont/_color.py b/plotly/validators/scattercarpet/textfont/_color.py new file mode 100644 index 0000000000..1fc3283e55 --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/_colorsrc.py b/plotly/validators/scattercarpet/textfont/_colorsrc.py new file mode 100644 index 0000000000..3774b7e31c --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/_family.py b/plotly/validators/scattercarpet/textfont/_family.py new file mode 100644 index 0000000000..7a1eb5b8e5 --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/_familysrc.py b/plotly/validators/scattercarpet/textfont/_familysrc.py new file mode 100644 index 0000000000..55c728b329 --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/_size.py b/plotly/validators/scattercarpet/textfont/_size.py new file mode 100644 index 0000000000..5dda38cf75 --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/textfont/_sizesrc.py b/plotly/validators/scattercarpet/textfont/_sizesrc.py new file mode 100644 index 0000000000..26f1955afb --- /dev/null +++ b/plotly/validators/scattercarpet/textfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattercarpet.textfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/__init__.py b/plotly/validators/scattercarpet/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scattercarpet/unselected/_marker.py b/plotly/validators/scattercarpet/unselected/_marker.py new file mode 100644 index 0000000000..8d33895c89 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattercarpet.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/_textfont.py b/plotly/validators/scattercarpet/unselected/_textfont.py new file mode 100644 index 0000000000..e70852b18e --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scattercarpet.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/marker/__init__.py b/plotly/validators/scattercarpet/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/unselected/marker/_color.py b/plotly/validators/scattercarpet/unselected/marker/_color.py new file mode 100644 index 0000000000..bc8eaf78a3 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/marker/_opacity.py b/plotly/validators/scattercarpet/unselected/marker/_opacity.py new file mode 100644 index 0000000000..66a277db5f --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattercarpet.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/marker/_size.py b/plotly/validators/scattercarpet/unselected/marker/_size.py new file mode 100644 index 0000000000..3f49ae6875 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattercarpet.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattercarpet/unselected/textfont/__init__.py b/plotly/validators/scattercarpet/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scattercarpet/unselected/textfont/_color.py b/plotly/validators/scattercarpet/unselected/textfont/_color.py new file mode 100644 index 0000000000..3e75e1db77 --- /dev/null +++ b/plotly/validators/scattercarpet/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattercarpet.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/__init__.py b/plotly/validators/scattergeo/__init__.py new file mode 100644 index 0000000000..d8be16fdfc --- /dev/null +++ b/plotly/validators/scattergeo/__init__.py @@ -0,0 +1,38 @@ +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._lonsrc import LonsrcValidator +from ._lon import LonValidator +from ._locationssrc import LocationssrcValidator +from ._locations import LocationsValidator +from ._locationmode import LocationmodeValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._latsrc import LatsrcValidator +from ._lat import LatValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._geo import GeoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator diff --git a/plotly/validators/scattergeo/_connectgaps.py b/plotly/validators/scattergeo/_connectgaps.py new file mode 100644 index 0000000000..018f1575da --- /dev/null +++ b/plotly/validators/scattergeo/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scattergeo', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_customdata.py b/plotly/validators/scattergeo/_customdata.py new file mode 100644 index 0000000000..7ac5981af6 --- /dev/null +++ b/plotly/validators/scattergeo/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scattergeo', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_customdatasrc.py b/plotly/validators/scattergeo/_customdatasrc.py new file mode 100644 index 0000000000..47ab7bbb04 --- /dev/null +++ b/plotly/validators/scattergeo/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='scattergeo', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_fill.py b/plotly/validators/scattergeo/_fill.py new file mode 100644 index 0000000000..491706a46d --- /dev/null +++ b/plotly/validators/scattergeo/_fill.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='fill', parent_name='scattergeo', **kwargs): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'toself'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/_fillcolor.py b/plotly/validators/scattergeo/_fillcolor.py new file mode 100644 index 0000000000..c92d505f9b --- /dev/null +++ b/plotly/validators/scattergeo/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scattergeo', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_geo.py b/plotly/validators/scattergeo/_geo.py new file mode 100644 index 0000000000..73b515ea93 --- /dev/null +++ b/plotly/validators/scattergeo/_geo.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class GeoValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='geo', parent_name='scattergeo', **kwargs): + super(GeoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='geo', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_hoverinfo.py b/plotly/validators/scattergeo/_hoverinfo.py new file mode 100644 index 0000000000..de9ac73851 --- /dev/null +++ b/plotly/validators/scattergeo/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scattergeo', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['lon', 'lat', 'location', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_hoverinfosrc.py b/plotly/validators/scattergeo/_hoverinfosrc.py new file mode 100644 index 0000000000..66b69ca094 --- /dev/null +++ b/plotly/validators/scattergeo/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='scattergeo', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_hoverlabel.py b/plotly/validators/scattergeo/_hoverlabel.py new file mode 100644 index 0000000000..17a93d605b --- /dev/null +++ b/plotly/validators/scattergeo/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scattergeo', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_hovertext.py b/plotly/validators/scattergeo/_hovertext.py new file mode 100644 index 0000000000..c172c73f02 --- /dev/null +++ b/plotly/validators/scattergeo/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scattergeo', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_hovertextsrc.py b/plotly/validators/scattergeo/_hovertextsrc.py new file mode 100644 index 0000000000..ee402872d8 --- /dev/null +++ b/plotly/validators/scattergeo/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='scattergeo', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_ids.py b/plotly/validators/scattergeo/_ids.py new file mode 100644 index 0000000000..6715ecd603 --- /dev/null +++ b/plotly/validators/scattergeo/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='scattergeo', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_idssrc.py b/plotly/validators/scattergeo/_idssrc.py new file mode 100644 index 0000000000..aec0347f4c --- /dev/null +++ b/plotly/validators/scattergeo/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scattergeo', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_lat.py b/plotly/validators/scattergeo/_lat.py new file mode 100644 index 0000000000..63ebef7132 --- /dev/null +++ b/plotly/validators/scattergeo/_lat.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LatValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='lat', parent_name='scattergeo', **kwargs): + super(LatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_latsrc.py b/plotly/validators/scattergeo/_latsrc.py new file mode 100644 index 0000000000..548fa73e28 --- /dev/null +++ b/plotly/validators/scattergeo/_latsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LatsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='latsrc', parent_name='scattergeo', **kwargs + ): + super(LatsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_legendgroup.py b/plotly/validators/scattergeo/_legendgroup.py new file mode 100644 index 0000000000..92a2f3d347 --- /dev/null +++ b/plotly/validators/scattergeo/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scattergeo', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_line.py b/plotly/validators/scattergeo/_line.py new file mode 100644 index 0000000000..4189df3179 --- /dev/null +++ b/plotly/validators/scattergeo/_line.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='scattergeo', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_locationmode.py b/plotly/validators/scattergeo/_locationmode.py new file mode 100644 index 0000000000..2b3b77c205 --- /dev/null +++ b/plotly/validators/scattergeo/_locationmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LocationmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='locationmode', parent_name='scattergeo', **kwargs + ): + super(LocationmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['ISO-3', 'USA-states', 'country names'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/_locations.py b/plotly/validators/scattergeo/_locations.py new file mode 100644 index 0000000000..5526de6105 --- /dev/null +++ b/plotly/validators/scattergeo/_locations.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LocationsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='locations', parent_name='scattergeo', **kwargs + ): + super(LocationsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_locationssrc.py b/plotly/validators/scattergeo/_locationssrc.py new file mode 100644 index 0000000000..7e44fc2b69 --- /dev/null +++ b/plotly/validators/scattergeo/_locationssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LocationssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='locationssrc', parent_name='scattergeo', **kwargs + ): + super(LocationssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_lon.py b/plotly/validators/scattergeo/_lon.py new file mode 100644 index 0000000000..1e49329255 --- /dev/null +++ b/plotly/validators/scattergeo/_lon.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class LonValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='lon', parent_name='scattergeo', **kwargs): + super(LonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_lonsrc.py b/plotly/validators/scattergeo/_lonsrc.py new file mode 100644 index 0000000000..7c6e1f62c6 --- /dev/null +++ b/plotly/validators/scattergeo/_lonsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LonsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='lonsrc', parent_name='scattergeo', **kwargs + ): + super(LonsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_marker.py b/plotly/validators/scattergeo/_marker.py new file mode 100644 index 0000000000..40eb291acb --- /dev/null +++ b/plotly/validators/scattergeo/_marker.py @@ -0,0 +1,123 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scattergeo', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergeo.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scattergeo.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scattergeo.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_mode.py b/plotly/validators/scattergeo/_mode.py new file mode 100644 index 0000000000..c1c486c194 --- /dev/null +++ b/plotly/validators/scattergeo/_mode.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='mode', parent_name='scattergeo', **kwargs): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_name.py b/plotly/validators/scattergeo/_name.py new file mode 100644 index 0000000000..c6b491353e --- /dev/null +++ b/plotly/validators/scattergeo/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='scattergeo', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_opacity.py b/plotly/validators/scattergeo/_opacity.py new file mode 100644 index 0000000000..e3ff230a98 --- /dev/null +++ b/plotly/validators/scattergeo/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattergeo', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_selected.py b/plotly/validators/scattergeo/_selected.py new file mode 100644 index 0000000000..64e5c03a6c --- /dev/null +++ b/plotly/validators/scattergeo/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scattergeo', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scattergeo.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.selected.Textfont + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_selectedpoints.py b/plotly/validators/scattergeo/_selectedpoints.py new file mode 100644 index 0000000000..5880f69115 --- /dev/null +++ b/plotly/validators/scattergeo/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='scattergeo', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_showlegend.py b/plotly/validators/scattergeo/_showlegend.py new file mode 100644 index 0000000000..348a794307 --- /dev/null +++ b/plotly/validators/scattergeo/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scattergeo', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_stream.py b/plotly/validators/scattergeo/_stream.py new file mode 100644 index 0000000000..23ba34c341 --- /dev/null +++ b/plotly/validators/scattergeo/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scattergeo', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_text.py b/plotly/validators/scattergeo/_text.py new file mode 100644 index 0000000000..3e54bad10d --- /dev/null +++ b/plotly/validators/scattergeo/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='scattergeo', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_textfont.py b/plotly/validators/scattergeo/_textfont.py new file mode 100644 index 0000000000..7d44672b68 --- /dev/null +++ b/plotly/validators/scattergeo/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scattergeo', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_textposition.py b/plotly/validators/scattergeo/_textposition.py new file mode 100644 index 0000000000..10a95e1f85 --- /dev/null +++ b/plotly/validators/scattergeo/_textposition.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='scattergeo', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scattergeo/_textpositionsrc.py b/plotly/validators/scattergeo/_textpositionsrc.py new file mode 100644 index 0000000000..a77f60efcc --- /dev/null +++ b/plotly/validators/scattergeo/_textpositionsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='textpositionsrc', + parent_name='scattergeo', + **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_textsrc.py b/plotly/validators/scattergeo/_textsrc.py new file mode 100644 index 0000000000..f9442fa593 --- /dev/null +++ b/plotly/validators/scattergeo/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scattergeo', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_uid.py b/plotly/validators/scattergeo/_uid.py new file mode 100644 index 0000000000..83f5364eda --- /dev/null +++ b/plotly/validators/scattergeo/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='scattergeo', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/_unselected.py b/plotly/validators/scattergeo/_unselected.py new file mode 100644 index 0000000000..b34ed0488c --- /dev/null +++ b/plotly/validators/scattergeo/_unselected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scattergeo', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scattergeo.unselected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scattergeo.unselected.Textfon + t instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/_visible.py b/plotly/validators/scattergeo/_visible.py new file mode 100644 index 0000000000..20a29a2386 --- /dev/null +++ b/plotly/validators/scattergeo/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattergeo', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/__init__.py b/plotly/validators/scattergeo/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattergeo/hoverlabel/_bgcolor.py b/plotly/validators/scattergeo/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..deca9877d2 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_bgcolorsrc.py b/plotly/validators/scattergeo/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..196dc12efd --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_bordercolor.py b/plotly/validators/scattergeo/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..73e515cea3 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_bordercolorsrc.py b/plotly/validators/scattergeo/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..ef90a88f63 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_font.py b/plotly/validators/scattergeo/hoverlabel/_font.py new file mode 100644 index 0000000000..8d1ace4b93 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_namelength.py b/plotly/validators/scattergeo/hoverlabel/_namelength.py new file mode 100644 index 0000000000..6953ed38d2 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/_namelengthsrc.py b/plotly/validators/scattergeo/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..72c02c6270 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scattergeo.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/__init__.py b/plotly/validators/scattergeo/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/hoverlabel/font/_color.py b/plotly/validators/scattergeo/hoverlabel/font/_color.py new file mode 100644 index 0000000000..29c4819d2d --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/_colorsrc.py b/plotly/validators/scattergeo/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..369178bb98 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/_family.py b/plotly/validators/scattergeo/hoverlabel/font/_family.py new file mode 100644 index 0000000000..4b899c2523 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/_familysrc.py b/plotly/validators/scattergeo/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..da392e8e97 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/_size.py b/plotly/validators/scattergeo/hoverlabel/font/_size.py new file mode 100644 index 0000000000..d9042a4889 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/hoverlabel/font/_sizesrc.py b/plotly/validators/scattergeo/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..845af381b2 --- /dev/null +++ b/plotly/validators/scattergeo/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattergeo.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/line/__init__.py b/plotly/validators/scattergeo/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/scattergeo/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/line/_color.py b/plotly/validators/scattergeo/line/_color.py new file mode 100644 index 0000000000..2109397261 --- /dev/null +++ b/plotly/validators/scattergeo/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergeo.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/line/_dash.py b/plotly/validators/scattergeo/line/_dash.py new file mode 100644 index 0000000000..af35be4a6a --- /dev/null +++ b/plotly/validators/scattergeo/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='scattergeo.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scattergeo/line/_width.py b/plotly/validators/scattergeo/line/_width.py new file mode 100644 index 0000000000..5fd8e5eb1f --- /dev/null +++ b/plotly/validators/scattergeo/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattergeo.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/__init__.py b/plotly/validators/scattergeo/marker/__init__.py new file mode 100644 index 0000000000..e12933f9b9 --- /dev/null +++ b/plotly/validators/scattergeo/marker/__init__.py @@ -0,0 +1,21 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._gradient import GradientValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattergeo/marker/_autocolorscale.py b/plotly/validators/scattergeo/marker/_autocolorscale.py new file mode 100644 index 0000000000..993c1e93ed --- /dev/null +++ b/plotly/validators/scattergeo/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattergeo.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_cauto.py b/plotly/validators/scattergeo/marker/_cauto.py new file mode 100644 index 0000000000..17c3279dbc --- /dev/null +++ b/plotly/validators/scattergeo/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scattergeo.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_cmax.py b/plotly/validators/scattergeo/marker/_cmax.py new file mode 100644 index 0000000000..ba4c8cd2f5 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scattergeo.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_cmin.py b/plotly/validators/scattergeo/marker/_cmin.py new file mode 100644 index 0000000000..9b619992e1 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scattergeo.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_color.py b/plotly/validators/scattergeo/marker/_color.py new file mode 100644 index 0000000000..4e5720bc29 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergeo.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scattergeo.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_colorbar.py b/plotly/validators/scattergeo/marker/_colorbar.py new file mode 100644 index 0000000000..46168f5e63 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scattergeo.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergeo.marker.colorbar.Ti + ckformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_colorscale.py b/plotly/validators/scattergeo/marker/_colorscale.py new file mode 100644 index 0000000000..0d3a158256 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattergeo.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_colorsrc.py b/plotly/validators/scattergeo/marker/_colorsrc.py new file mode 100644 index 0000000000..beb3910cfa --- /dev/null +++ b/plotly/validators/scattergeo/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergeo.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_gradient.py b/plotly/validators/scattergeo/marker/_gradient.py new file mode 100644 index 0000000000..2751f08776 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_gradient.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class GradientValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='gradient', + parent_name='scattergeo.marker', + **kwargs + ): + super(GradientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Gradient', + data_docs=""" + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_line.py b/plotly/validators/scattergeo/marker/_line.py new file mode 100644 index 0000000000..f7460ad72a --- /dev/null +++ b/plotly/validators/scattergeo/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scattergeo.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_opacity.py b/plotly/validators/scattergeo/marker/_opacity.py new file mode 100644 index 0000000000..7472b3e56f --- /dev/null +++ b/plotly/validators/scattergeo/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattergeo.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_opacitysrc.py b/plotly/validators/scattergeo/marker/_opacitysrc.py new file mode 100644 index 0000000000..6adc879ace --- /dev/null +++ b/plotly/validators/scattergeo/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scattergeo.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_reversescale.py b/plotly/validators/scattergeo/marker/_reversescale.py new file mode 100644 index 0000000000..f49c6c4bb7 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattergeo.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_showscale.py b/plotly/validators/scattergeo/marker/_showscale.py new file mode 100644 index 0000000000..f7a7e09c72 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scattergeo.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_size.py b/plotly/validators/scattergeo/marker/_size.py new file mode 100644 index 0000000000..69e6301355 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scattergeo.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_sizemin.py b/plotly/validators/scattergeo/marker/_sizemin.py new file mode 100644 index 0000000000..30f06c7dcb --- /dev/null +++ b/plotly/validators/scattergeo/marker/_sizemin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='scattergeo.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_sizemode.py b/plotly/validators/scattergeo/marker/_sizemode.py new file mode 100644 index 0000000000..323035b5bb --- /dev/null +++ b/plotly/validators/scattergeo/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scattergeo.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_sizeref.py b/plotly/validators/scattergeo/marker/_sizeref.py new file mode 100644 index 0000000000..d3769777bd --- /dev/null +++ b/plotly/validators/scattergeo/marker/_sizeref.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizeref', parent_name='scattergeo.marker', **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_sizesrc.py b/plotly/validators/scattergeo/marker/_sizesrc.py new file mode 100644 index 0000000000..473eb10797 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='scattergeo.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_symbol.py b/plotly/validators/scattergeo/marker/_symbol.py new file mode 100644 index 0000000000..0b6a7e7eb3 --- /dev/null +++ b/plotly/validators/scattergeo/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='scattergeo.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/_symbolsrc.py b/plotly/validators/scattergeo/marker/_symbolsrc.py new file mode 100644 index 0000000000..4efdfe7fdd --- /dev/null +++ b/plotly/validators/scattergeo/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scattergeo.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/__init__.py b/plotly/validators/scattergeo/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattergeo/marker/colorbar/_bgcolor.py b/plotly/validators/scattergeo/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..73cc48508f --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_bordercolor.py b/plotly/validators/scattergeo/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..8f7ce90cbc --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_borderwidth.py b/plotly/validators/scattergeo/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..a87b8910f5 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_dtick.py b/plotly/validators/scattergeo/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..a2c62519b8 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_exponentformat.py b/plotly/validators/scattergeo/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..827addc9ff --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_len.py b/plotly/validators/scattergeo/marker/colorbar/_len.py new file mode 100644 index 0000000000..b2802d267f --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_lenmode.py b/plotly/validators/scattergeo/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..25fe487278 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_nticks.py b/plotly/validators/scattergeo/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..92e91e05b8 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_outlinecolor.py b/plotly/validators/scattergeo/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..b218670d74 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_outlinewidth.py b/plotly/validators/scattergeo/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..d6cdc8f7fa --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_separatethousands.py b/plotly/validators/scattergeo/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..2abd2fc09f --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_showexponent.py b/plotly/validators/scattergeo/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..9d9b2bd426 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_showticklabels.py b/plotly/validators/scattergeo/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..b6de5cb878 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_showtickprefix.py b/plotly/validators/scattergeo/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..4a5f4389be --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_showticksuffix.py b/plotly/validators/scattergeo/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..6386bb1997 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_thickness.py b/plotly/validators/scattergeo/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..e8e0a66dba --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_thicknessmode.py b/plotly/validators/scattergeo/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..1567a5b6fe --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tick0.py b/plotly/validators/scattergeo/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..77e45c4a5b --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickangle.py b/plotly/validators/scattergeo/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..943000d7bf --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickcolor.py b/plotly/validators/scattergeo/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..3de5554b07 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickfont.py b/plotly/validators/scattergeo/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..e483488397 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickformat.py b/plotly/validators/scattergeo/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..a64a290e47 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickformatstops.py b/plotly/validators/scattergeo/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..d8f140c3cd --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ticklen.py b/plotly/validators/scattergeo/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..0eb4286568 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickmode.py b/plotly/validators/scattergeo/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..61e368391c --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickprefix.py b/plotly/validators/scattergeo/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..cef5aca084 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ticks.py b/plotly/validators/scattergeo/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..ded35697ba --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ticksuffix.py b/plotly/validators/scattergeo/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..0db1508b5a --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ticktext.py b/plotly/validators/scattergeo/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..1ab77146ab --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ticktextsrc.py b/plotly/validators/scattergeo/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..f54bf889de --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickvals.py b/plotly/validators/scattergeo/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..0d43ae8044 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickvalssrc.py b/plotly/validators/scattergeo/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..3d043bed88 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_tickwidth.py b/plotly/validators/scattergeo/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..bca983ff98 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_title.py b/plotly/validators/scattergeo/marker/colorbar/_title.py new file mode 100644 index 0000000000..c87dd0443a --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_titlefont.py b/plotly/validators/scattergeo/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..d405fc6403 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_titleside.py b/plotly/validators/scattergeo/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..c50ad3c630 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_x.py b/plotly/validators/scattergeo/marker/colorbar/_x.py new file mode 100644 index 0000000000..0b9e4185b0 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_xanchor.py b/plotly/validators/scattergeo/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..86aedbb2b4 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_xpad.py b/plotly/validators/scattergeo/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..a5b62ca0f4 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_y.py b/plotly/validators/scattergeo/marker/colorbar/_y.py new file mode 100644 index 0000000000..f70ffb6cc9 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_yanchor.py b/plotly/validators/scattergeo/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..30e8258ecf --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/_ypad.py b/plotly/validators/scattergeo/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..8862a8e842 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scattergeo.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/tickfont/__init__.py b/plotly/validators/scattergeo/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/marker/colorbar/tickfont/_color.py b/plotly/validators/scattergeo/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..8e429ee6ce --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/tickfont/_family.py b/plotly/validators/scattergeo/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..d05d3b74db --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergeo.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/tickfont/_size.py b/plotly/validators/scattergeo/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..0bf769c391 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergeo.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..2071425b30 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scattergeo.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..c9c2feb880 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scattergeo.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/titlefont/__init__.py b/plotly/validators/scattergeo/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/marker/colorbar/titlefont/_color.py b/plotly/validators/scattergeo/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..dace19c398 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/titlefont/_family.py b/plotly/validators/scattergeo/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..be6ec92c84 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergeo.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/colorbar/titlefont/_size.py b/plotly/validators/scattergeo/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..5c4089aad4 --- /dev/null +++ b/plotly/validators/scattergeo/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergeo.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/gradient/__init__.py b/plotly/validators/scattergeo/marker/gradient/__init__.py new file mode 100644 index 0000000000..434557c8fe --- /dev/null +++ b/plotly/validators/scattergeo/marker/gradient/__init__.py @@ -0,0 +1,4 @@ +from ._typesrc import TypesrcValidator +from ._type import TypeValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/marker/gradient/_color.py b/plotly/validators/scattergeo/marker/gradient/_color.py new file mode 100644 index 0000000000..fddf75d581 --- /dev/null +++ b/plotly/validators/scattergeo/marker/gradient/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.marker.gradient', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/gradient/_colorsrc.py b/plotly/validators/scattergeo/marker/gradient/_colorsrc.py new file mode 100644 index 0000000000..a2820266d2 --- /dev/null +++ b/plotly/validators/scattergeo/marker/gradient/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergeo.marker.gradient', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/gradient/_type.py b/plotly/validators/scattergeo/marker/gradient/_type.py new file mode 100644 index 0000000000..399d0e90a8 --- /dev/null +++ b/plotly/validators/scattergeo/marker/gradient/_type.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='scattergeo.marker.gradient', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['radial', 'horizontal', 'vertical', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/gradient/_typesrc.py b/plotly/validators/scattergeo/marker/gradient/_typesrc.py new file mode 100644 index 0000000000..e385cd6076 --- /dev/null +++ b/plotly/validators/scattergeo/marker/gradient/_typesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TypesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='typesrc', + parent_name='scattergeo.marker.gradient', + **kwargs + ): + super(TypesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/__init__.py b/plotly/validators/scattergeo/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattergeo/marker/line/_autocolorscale.py b/plotly/validators/scattergeo/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..baf8468bee --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_cauto.py b/plotly/validators/scattergeo/marker/line/_cauto.py new file mode 100644 index 0000000000..d2cd4f5a11 --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_cmax.py b/plotly/validators/scattergeo/marker/line/_cmax.py new file mode 100644 index 0000000000..881bef2c14 --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_cmin.py b/plotly/validators/scattergeo/marker/line/_cmin.py new file mode 100644 index 0000000000..7216bf707c --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_color.py b/plotly/validators/scattergeo/marker/line/_color.py new file mode 100644 index 0000000000..68da4a0328 --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scattergeo.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_colorscale.py b/plotly/validators/scattergeo/marker/line/_colorscale.py new file mode 100644 index 0000000000..5dca58421a --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_colorsrc.py b/plotly/validators/scattergeo/marker/line/_colorsrc.py new file mode 100644 index 0000000000..8ff13a9adb --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_reversescale.py b/plotly/validators/scattergeo/marker/line/_reversescale.py new file mode 100644 index 0000000000..e35b02ea3e --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_width.py b/plotly/validators/scattergeo/marker/line/_width.py new file mode 100644 index 0000000000..5f756bb336 --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/marker/line/_widthsrc.py b/plotly/validators/scattergeo/marker/line/_widthsrc.py new file mode 100644 index 0000000000..fe0aaff00e --- /dev/null +++ b/plotly/validators/scattergeo/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scattergeo.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/__init__.py b/plotly/validators/scattergeo/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scattergeo/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scattergeo/selected/_marker.py b/plotly/validators/scattergeo/selected/_marker.py new file mode 100644 index 0000000000..45d4fc45ce --- /dev/null +++ b/plotly/validators/scattergeo/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattergeo.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/_textfont.py b/plotly/validators/scattergeo/selected/_textfont.py new file mode 100644 index 0000000000..c0aac1bc61 --- /dev/null +++ b/plotly/validators/scattergeo/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scattergeo.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/marker/__init__.py b/plotly/validators/scattergeo/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattergeo/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/selected/marker/_color.py b/plotly/validators/scattergeo/selected/marker/_color.py new file mode 100644 index 0000000000..88505f6e26 --- /dev/null +++ b/plotly/validators/scattergeo/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/marker/_opacity.py b/plotly/validators/scattergeo/selected/marker/_opacity.py new file mode 100644 index 0000000000..160b83caef --- /dev/null +++ b/plotly/validators/scattergeo/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattergeo.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/marker/_size.py b/plotly/validators/scattergeo/selected/marker/_size.py new file mode 100644 index 0000000000..7cc431b9de --- /dev/null +++ b/plotly/validators/scattergeo/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergeo.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/selected/textfont/__init__.py b/plotly/validators/scattergeo/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scattergeo/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/selected/textfont/_color.py b/plotly/validators/scattergeo/selected/textfont/_color.py new file mode 100644 index 0000000000..870c2be1ba --- /dev/null +++ b/plotly/validators/scattergeo/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/stream/__init__.py b/plotly/validators/scattergeo/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scattergeo/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scattergeo/stream/_maxpoints.py b/plotly/validators/scattergeo/stream/_maxpoints.py new file mode 100644 index 0000000000..45b7fcda27 --- /dev/null +++ b/plotly/validators/scattergeo/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scattergeo.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/stream/_token.py b/plotly/validators/scattergeo/stream/_token.py new file mode 100644 index 0000000000..b0651c6f95 --- /dev/null +++ b/plotly/validators/scattergeo/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='scattergeo.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/__init__.py b/plotly/validators/scattergeo/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattergeo/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/textfont/_color.py b/plotly/validators/scattergeo/textfont/_color.py new file mode 100644 index 0000000000..f225226e75 --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergeo.textfont', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/_colorsrc.py b/plotly/validators/scattergeo/textfont/_colorsrc.py new file mode 100644 index 0000000000..3b05f9ab66 --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergeo.textfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/_family.py b/plotly/validators/scattergeo/textfont/_family.py new file mode 100644 index 0000000000..8acf808eef --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergeo.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/_familysrc.py b/plotly/validators/scattergeo/textfont/_familysrc.py new file mode 100644 index 0000000000..ead4629f7e --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattergeo.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/_size.py b/plotly/validators/scattergeo/textfont/_size.py new file mode 100644 index 0000000000..2225c956a9 --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scattergeo.textfont', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/textfont/_sizesrc.py b/plotly/validators/scattergeo/textfont/_sizesrc.py new file mode 100644 index 0000000000..c489fbe717 --- /dev/null +++ b/plotly/validators/scattergeo/textfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattergeo.textfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/__init__.py b/plotly/validators/scattergeo/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scattergeo/unselected/_marker.py b/plotly/validators/scattergeo/unselected/_marker.py new file mode 100644 index 0000000000..b72c8635cf --- /dev/null +++ b/plotly/validators/scattergeo/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattergeo.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/_textfont.py b/plotly/validators/scattergeo/unselected/_textfont.py new file mode 100644 index 0000000000..d159cdc0e8 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scattergeo.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/marker/__init__.py b/plotly/validators/scattergeo/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/unselected/marker/_color.py b/plotly/validators/scattergeo/unselected/marker/_color.py new file mode 100644 index 0000000000..7745de2f45 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/marker/_opacity.py b/plotly/validators/scattergeo/unselected/marker/_opacity.py new file mode 100644 index 0000000000..6ea646f4b6 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattergeo.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/marker/_size.py b/plotly/validators/scattergeo/unselected/marker/_size.py new file mode 100644 index 0000000000..9802fba4ae --- /dev/null +++ b/plotly/validators/scattergeo/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergeo.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergeo/unselected/textfont/__init__.py b/plotly/validators/scattergeo/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scattergeo/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scattergeo/unselected/textfont/_color.py b/plotly/validators/scattergeo/unselected/textfont/_color.py new file mode 100644 index 0000000000..2427b509bf --- /dev/null +++ b/plotly/validators/scattergeo/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergeo.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/__init__.py b/plotly/validators/scattergl/__init__.py new file mode 100644 index 0000000000..77e016a67f --- /dev/null +++ b/plotly/validators/scattergl/__init__.py @@ -0,0 +1,40 @@ +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._error_y import ErrorYValidator +from ._error_x import ErrorXValidator +from ._dy import DyValidator +from ._dx import DxValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator diff --git a/plotly/validators/scattergl/_connectgaps.py b/plotly/validators/scattergl/_connectgaps.py new file mode 100644 index 0000000000..3ee02ea19c --- /dev/null +++ b/plotly/validators/scattergl/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scattergl', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_customdata.py b/plotly/validators/scattergl/_customdata.py new file mode 100644 index 0000000000..cda62aedf1 --- /dev/null +++ b/plotly/validators/scattergl/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scattergl', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/_customdatasrc.py b/plotly/validators/scattergl/_customdatasrc.py new file mode 100644 index 0000000000..133d0bc6c1 --- /dev/null +++ b/plotly/validators/scattergl/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='scattergl', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_dx.py b/plotly/validators/scattergl/_dx.py new file mode 100644 index 0000000000..5b62ab0617 --- /dev/null +++ b/plotly/validators/scattergl/_dx.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dx', parent_name='scattergl', **kwargs): + super(DxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_dy.py b/plotly/validators/scattergl/_dy.py new file mode 100644 index 0000000000..0ceba5f210 --- /dev/null +++ b/plotly/validators/scattergl/_dy.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class DyValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='dy', parent_name='scattergl', **kwargs): + super(DyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_error_x.py b/plotly/validators/scattergl/_error_x.py new file mode 100644 index 0000000000..b1f7dc4e74 --- /dev/null +++ b/plotly/validators/scattergl/_error_x.py @@ -0,0 +1,72 @@ +import _plotly_utils.basevalidators + + +class ErrorXValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_x', parent_name='scattergl', **kwargs + ): + super(ErrorXValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorX', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + copy_ystyle + + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_error_y.py b/plotly/validators/scattergl/_error_y.py new file mode 100644 index 0000000000..95526e3a90 --- /dev/null +++ b/plotly/validators/scattergl/_error_y.py @@ -0,0 +1,70 @@ +import _plotly_utils.basevalidators + + +class ErrorYValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='error_y', parent_name='scattergl', **kwargs + ): + super(ErrorYValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ErrorY', + data_docs=""" + array + Sets the data corresponding the length of each + error bar. Values are plotted relative to the + underlying data. + arrayminus + Sets the data corresponding the length of each + error bar in the bottom (left) direction for + vertical (horizontal) bars Values are plotted + relative to the underlying data. + arrayminussrc + Sets the source reference on plot.ly for + arrayminus . + arraysrc + Sets the source reference on plot.ly for array + . + color + Sets the stoke color of the error bars. + symmetric + Determines whether or not the error bars have + the same length in both direction (top/bottom + for vertical bars, left/right for horizontal + bars. + thickness + Sets the thickness (in px) of the error bars. + traceref + + tracerefminus + + type + Determines the rule used to generate the error + bars. If *constant`, the bar lengths are of a + constant value. Set this constant in `value`. + If *percent*, the bar lengths correspond to a + percentage of underlying data. Set this + percentage in `value`. If *sqrt*, the bar + lengths correspond to the sqaure of the + underlying data. If *array*, the bar lengths + are set with data set `array`. + value + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars. + valueminus + Sets the value of either the percentage (if + `type` is set to *percent*) or the constant (if + `type` is set to *constant*) corresponding to + the lengths of the error bars in the bottom + (left) direction for vertical (horizontal) bars + visible + Determines whether or not this set of error + bars is visible. + width + Sets the width (in px) of the cross-bar at both + ends of the error bars.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_fill.py b/plotly/validators/scattergl/_fill.py new file mode 100644 index 0000000000..4d0467787d --- /dev/null +++ b/plotly/validators/scattergl/_fill.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='fill', parent_name='scattergl', **kwargs): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', 'toself', + 'tonext' + ], + **kwargs + ) diff --git a/plotly/validators/scattergl/_fillcolor.py b/plotly/validators/scattergl/_fillcolor.py new file mode 100644 index 0000000000..737cd96a81 --- /dev/null +++ b/plotly/validators/scattergl/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scattergl', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/_hoverinfo.py b/plotly/validators/scattergl/_hoverinfo.py new file mode 100644 index 0000000000..fab5b66b59 --- /dev/null +++ b/plotly/validators/scattergl/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scattergl', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_hoverinfosrc.py b/plotly/validators/scattergl/_hoverinfosrc.py new file mode 100644 index 0000000000..2456a94dac --- /dev/null +++ b/plotly/validators/scattergl/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='scattergl', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_hoverlabel.py b/plotly/validators/scattergl/_hoverlabel.py new file mode 100644 index 0000000000..4b8f24673a --- /dev/null +++ b/plotly/validators/scattergl/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scattergl', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_hoveron.py b/plotly/validators/scattergl/_hoveron.py new file mode 100644 index 0000000000..193d5e6726 --- /dev/null +++ b/plotly/validators/scattergl/_hoveron.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoveron', parent_name='scattergl', **kwargs + ): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_ids.py b/plotly/validators/scattergl/_ids.py new file mode 100644 index 0000000000..c22109006d --- /dev/null +++ b/plotly/validators/scattergl/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='scattergl', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/_idssrc.py b/plotly/validators/scattergl/_idssrc.py new file mode 100644 index 0000000000..cf3ea27a69 --- /dev/null +++ b/plotly/validators/scattergl/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scattergl', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_legendgroup.py b/plotly/validators/scattergl/_legendgroup.py new file mode 100644 index 0000000000..1f0e8e2538 --- /dev/null +++ b/plotly/validators/scattergl/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scattergl', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_line.py b/plotly/validators/scattergl/_line.py new file mode 100644 index 0000000000..e4935c797c --- /dev/null +++ b/plotly/validators/scattergl/_line.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='scattergl', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_marker.py b/plotly/validators/scattergl/_marker.py new file mode 100644 index 0000000000..3afb273791 --- /dev/null +++ b/plotly/validators/scattergl/_marker.py @@ -0,0 +1,120 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scattergl', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattergl.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scattergl.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_mode.py b/plotly/validators/scattergl/_mode.py new file mode 100644 index 0000000000..84b1c4adf9 --- /dev/null +++ b/plotly/validators/scattergl/_mode.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='mode', parent_name='scattergl', **kwargs): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_name.py b/plotly/validators/scattergl/_name.py new file mode 100644 index 0000000000..4b57b2e30a --- /dev/null +++ b/plotly/validators/scattergl/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='scattergl', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_opacity.py b/plotly/validators/scattergl/_opacity.py new file mode 100644 index 0000000000..2eb8f0efbb --- /dev/null +++ b/plotly/validators/scattergl/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattergl', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/_selected.py b/plotly/validators/scattergl/_selected.py new file mode 100644 index 0000000000..c357e497db --- /dev/null +++ b/plotly/validators/scattergl/_selected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scattergl', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scattergl.selected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_selectedpoints.py b/plotly/validators/scattergl/_selectedpoints.py new file mode 100644 index 0000000000..2479877ee3 --- /dev/null +++ b/plotly/validators/scattergl/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='scattergl', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_showlegend.py b/plotly/validators/scattergl/_showlegend.py new file mode 100644 index 0000000000..79b9beb18a --- /dev/null +++ b/plotly/validators/scattergl/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scattergl', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_stream.py b/plotly/validators/scattergl/_stream.py new file mode 100644 index 0000000000..40a22f2b07 --- /dev/null +++ b/plotly/validators/scattergl/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scattergl', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_text.py b/plotly/validators/scattergl/_text.py new file mode 100644 index 0000000000..3db81cdc99 --- /dev/null +++ b/plotly/validators/scattergl/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='scattergl', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_textsrc.py b/plotly/validators/scattergl/_textsrc.py new file mode 100644 index 0000000000..4a4ee4ccba --- /dev/null +++ b/plotly/validators/scattergl/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scattergl', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_uid.py b/plotly/validators/scattergl/_uid.py new file mode 100644 index 0000000000..d0259c226b --- /dev/null +++ b/plotly/validators/scattergl/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='scattergl', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_unselected.py b/plotly/validators/scattergl/_unselected.py new file mode 100644 index 0000000000..7b5572ee5e --- /dev/null +++ b/plotly/validators/scattergl/_unselected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scattergl', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scattergl.unselected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattergl/_visible.py b/plotly/validators/scattergl/_visible.py new file mode 100644 index 0000000000..85aeb159fb --- /dev/null +++ b/plotly/validators/scattergl/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattergl', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scattergl/_x.py b/plotly/validators/scattergl/_x.py new file mode 100644 index 0000000000..83a1cc2b5e --- /dev/null +++ b/plotly/validators/scattergl/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='scattergl', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/_x0.py b/plotly/validators/scattergl/_x0.py new file mode 100644 index 0000000000..dfd5889c37 --- /dev/null +++ b/plotly/validators/scattergl/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='scattergl', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_xaxis.py b/plotly/validators/scattergl/_xaxis.py new file mode 100644 index 0000000000..faf703226a --- /dev/null +++ b/plotly/validators/scattergl/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='scattergl', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_xcalendar.py b/plotly/validators/scattergl/_xcalendar.py new file mode 100644 index 0000000000..00f2c23447 --- /dev/null +++ b/plotly/validators/scattergl/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='scattergl', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scattergl/_xsrc.py b/plotly/validators/scattergl/_xsrc.py new file mode 100644 index 0000000000..a9a29b0120 --- /dev/null +++ b/plotly/validators/scattergl/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='scattergl', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_y.py b/plotly/validators/scattergl/_y.py new file mode 100644 index 0000000000..08b5b3abfe --- /dev/null +++ b/plotly/validators/scattergl/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='scattergl', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/_y0.py b/plotly/validators/scattergl/_y0.py new file mode 100644 index 0000000000..39874a8186 --- /dev/null +++ b/plotly/validators/scattergl/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='scattergl', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_yaxis.py b/plotly/validators/scattergl/_yaxis.py new file mode 100644 index 0000000000..afb17b348e --- /dev/null +++ b/plotly/validators/scattergl/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='scattergl', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/_ycalendar.py b/plotly/validators/scattergl/_ycalendar.py new file mode 100644 index 0000000000..000591896b --- /dev/null +++ b/plotly/validators/scattergl/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='scattergl', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/scattergl/_ysrc.py b/plotly/validators/scattergl/_ysrc.py new file mode 100644 index 0000000000..b00fe88ec6 --- /dev/null +++ b/plotly/validators/scattergl/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='scattergl', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/__init__.py b/plotly/validators/scattergl/error_x/__init__.py new file mode 100644 index 0000000000..c4605e0187 --- /dev/null +++ b/plotly/validators/scattergl/error_x/__init__.py @@ -0,0 +1,15 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._copy_ystyle import CopyYstyleValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scattergl/error_x/_array.py b/plotly/validators/scattergl/error_x/_array.py new file mode 100644 index 0000000000..607fec1939 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scattergl.error_x', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_arrayminus.py b/plotly/validators/scattergl/error_x/_arrayminus.py new file mode 100644 index 0000000000..843a641083 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scattergl.error_x', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_arrayminussrc.py b/plotly/validators/scattergl/error_x/_arrayminussrc.py new file mode 100644 index 0000000000..c7381d50c7 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scattergl.error_x', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_arraysrc.py b/plotly/validators/scattergl/error_x/_arraysrc.py new file mode 100644 index 0000000000..18497a8ec7 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='scattergl.error_x', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_color.py b/plotly/validators/scattergl/error_x/_color.py new file mode 100644 index 0000000000..18e3256cdb --- /dev/null +++ b/plotly/validators/scattergl/error_x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergl.error_x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_copy_ystyle.py b/plotly/validators/scattergl/error_x/_copy_ystyle.py new file mode 100644 index 0000000000..317858b8d1 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_copy_ystyle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CopyYstyleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='copy_ystyle', + parent_name='scattergl.error_x', + **kwargs + ): + super(CopyYstyleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_symmetric.py b/plotly/validators/scattergl/error_x/_symmetric.py new file mode 100644 index 0000000000..24eec35c83 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='scattergl.error_x', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_thickness.py b/plotly/validators/scattergl/error_x/_thickness.py new file mode 100644 index 0000000000..8b178e5b0d --- /dev/null +++ b/plotly/validators/scattergl/error_x/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattergl.error_x', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_traceref.py b/plotly/validators/scattergl/error_x/_traceref.py new file mode 100644 index 0000000000..923822943c --- /dev/null +++ b/plotly/validators/scattergl/error_x/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='scattergl.error_x', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_tracerefminus.py b/plotly/validators/scattergl/error_x/_tracerefminus.py new file mode 100644 index 0000000000..34e71a0139 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scattergl.error_x', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_type.py b/plotly/validators/scattergl/error_x/_type.py new file mode 100644 index 0000000000..e5388f2d6b --- /dev/null +++ b/plotly/validators/scattergl/error_x/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scattergl.error_x', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_value.py b/plotly/validators/scattergl/error_x/_value.py new file mode 100644 index 0000000000..985da1b0fc --- /dev/null +++ b/plotly/validators/scattergl/error_x/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scattergl.error_x', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_valueminus.py b/plotly/validators/scattergl/error_x/_valueminus.py new file mode 100644 index 0000000000..a330253746 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scattergl.error_x', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_visible.py b/plotly/validators/scattergl/error_x/_visible.py new file mode 100644 index 0000000000..b24b4aacd1 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattergl.error_x', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_x/_width.py b/plotly/validators/scattergl/error_x/_width.py new file mode 100644 index 0000000000..fe795caf71 --- /dev/null +++ b/plotly/validators/scattergl/error_x/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattergl.error_x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/__init__.py b/plotly/validators/scattergl/error_y/__init__.py new file mode 100644 index 0000000000..2fc70c4058 --- /dev/null +++ b/plotly/validators/scattergl/error_y/__init__.py @@ -0,0 +1,14 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._valueminus import ValueminusValidator +from ._value import ValueValidator +from ._type import TypeValidator +from ._tracerefminus import TracerefminusValidator +from ._traceref import TracerefValidator +from ._thickness import ThicknessValidator +from ._symmetric import SymmetricValidator +from ._color import ColorValidator +from ._arraysrc import ArraysrcValidator +from ._arrayminussrc import ArrayminussrcValidator +from ._arrayminus import ArrayminusValidator +from ._array import ArrayValidator diff --git a/plotly/validators/scattergl/error_y/_array.py b/plotly/validators/scattergl/error_y/_array.py new file mode 100644 index 0000000000..7c67619099 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_array.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ArrayValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='array', parent_name='scattergl.error_y', **kwargs + ): + super(ArrayValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_arrayminus.py b/plotly/validators/scattergl/error_y/_arrayminus.py new file mode 100644 index 0000000000..fa7c849165 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_arrayminus.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminusValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='arrayminus', + parent_name='scattergl.error_y', + **kwargs + ): + super(ArrayminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_arrayminussrc.py b/plotly/validators/scattergl/error_y/_arrayminussrc.py new file mode 100644 index 0000000000..70f62ef397 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_arrayminussrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArrayminussrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arrayminussrc', + parent_name='scattergl.error_y', + **kwargs + ): + super(ArrayminussrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_arraysrc.py b/plotly/validators/scattergl/error_y/_arraysrc.py new file mode 100644 index 0000000000..0ffadd17c2 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_arraysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ArraysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='arraysrc', + parent_name='scattergl.error_y', + **kwargs + ): + super(ArraysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_color.py b/plotly/validators/scattergl/error_y/_color.py new file mode 100644 index 0000000000..f3a8dd1970 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergl.error_y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_symmetric.py b/plotly/validators/scattergl/error_y/_symmetric.py new file mode 100644 index 0000000000..21ebddd09a --- /dev/null +++ b/plotly/validators/scattergl/error_y/_symmetric.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymmetricValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='symmetric', + parent_name='scattergl.error_y', + **kwargs + ): + super(SymmetricValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_thickness.py b/plotly/validators/scattergl/error_y/_thickness.py new file mode 100644 index 0000000000..7621974da6 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattergl.error_y', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_traceref.py b/plotly/validators/scattergl/error_y/_traceref.py new file mode 100644 index 0000000000..56d35a45b1 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_traceref.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='traceref', + parent_name='scattergl.error_y', + **kwargs + ): + super(TracerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_tracerefminus.py b/plotly/validators/scattergl/error_y/_tracerefminus.py new file mode 100644 index 0000000000..214d249bd3 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_tracerefminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TracerefminusValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='tracerefminus', + parent_name='scattergl.error_y', + **kwargs + ): + super(TracerefminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_type.py b/plotly/validators/scattergl/error_y/_type.py new file mode 100644 index 0000000000..edc6612910 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_type.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='type', parent_name='scattergl.error_y', **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['percent', 'constant', 'sqrt', 'data'], + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_value.py b/plotly/validators/scattergl/error_y/_value.py new file mode 100644 index 0000000000..07f4d2b7bf --- /dev/null +++ b/plotly/validators/scattergl/error_y/_value.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='value', parent_name='scattergl.error_y', **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_valueminus.py b/plotly/validators/scattergl/error_y/_valueminus.py new file mode 100644 index 0000000000..d1df09e28f --- /dev/null +++ b/plotly/validators/scattergl/error_y/_valueminus.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ValueminusValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='valueminus', + parent_name='scattergl.error_y', + **kwargs + ): + super(ValueminusValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_visible.py b/plotly/validators/scattergl/error_y/_visible.py new file mode 100644 index 0000000000..c58d37150c --- /dev/null +++ b/plotly/validators/scattergl/error_y/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattergl.error_y', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/error_y/_width.py b/plotly/validators/scattergl/error_y/_width.py new file mode 100644 index 0000000000..855d3a6cb5 --- /dev/null +++ b/plotly/validators/scattergl/error_y/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattergl.error_y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/__init__.py b/plotly/validators/scattergl/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattergl/hoverlabel/_bgcolor.py b/plotly/validators/scattergl/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..b216e66b3e --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_bgcolorsrc.py b/plotly/validators/scattergl/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..576b09e85b --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_bordercolor.py b/plotly/validators/scattergl/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..215566473f --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_bordercolorsrc.py b/plotly/validators/scattergl/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..6d7fcccf35 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_font.py b/plotly/validators/scattergl/hoverlabel/_font.py new file mode 100644 index 0000000000..0f76f32171 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='scattergl.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_namelength.py b/plotly/validators/scattergl/hoverlabel/_namelength.py new file mode 100644 index 0000000000..f7a82b7610 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/_namelengthsrc.py b/plotly/validators/scattergl/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..7660ae55a3 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scattergl.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/__init__.py b/plotly/validators/scattergl/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/hoverlabel/font/_color.py b/plotly/validators/scattergl/hoverlabel/font/_color.py new file mode 100644 index 0000000000..a9da402267 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/_colorsrc.py b/plotly/validators/scattergl/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..5166042650 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/_family.py b/plotly/validators/scattergl/hoverlabel/font/_family.py new file mode 100644 index 0000000000..602f845f26 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/_familysrc.py b/plotly/validators/scattergl/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..a000749828 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/_size.py b/plotly/validators/scattergl/hoverlabel/font/_size.py new file mode 100644 index 0000000000..8cffe260ff --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/hoverlabel/font/_sizesrc.py b/plotly/validators/scattergl/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..53a3486937 --- /dev/null +++ b/plotly/validators/scattergl/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattergl.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/line/__init__.py b/plotly/validators/scattergl/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/scattergl/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/line/_color.py b/plotly/validators/scattergl/line/_color.py new file mode 100644 index 0000000000..dfd8170094 --- /dev/null +++ b/plotly/validators/scattergl/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergl.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/line/_dash.py b/plotly/validators/scattergl/line/_dash.py new file mode 100644 index 0000000000..13804f5cf3 --- /dev/null +++ b/plotly/validators/scattergl/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='dash', parent_name='scattergl.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scattergl/line/_width.py b/plotly/validators/scattergl/line/_width.py new file mode 100644 index 0000000000..9faa0a7950 --- /dev/null +++ b/plotly/validators/scattergl/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattergl.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/__init__.py b/plotly/validators/scattergl/marker/__init__.py new file mode 100644 index 0000000000..254b91a979 --- /dev/null +++ b/plotly/validators/scattergl/marker/__init__.py @@ -0,0 +1,20 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattergl/marker/_autocolorscale.py b/plotly/validators/scattergl/marker/_autocolorscale.py new file mode 100644 index 0000000000..5c4558b255 --- /dev/null +++ b/plotly/validators/scattergl/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattergl.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_cauto.py b/plotly/validators/scattergl/marker/_cauto.py new file mode 100644 index 0000000000..b12d7d7717 --- /dev/null +++ b/plotly/validators/scattergl/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scattergl.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_cmax.py b/plotly/validators/scattergl/marker/_cmax.py new file mode 100644 index 0000000000..d6b93ea8ab --- /dev/null +++ b/plotly/validators/scattergl/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scattergl.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_cmin.py b/plotly/validators/scattergl/marker/_cmin.py new file mode 100644 index 0000000000..a47877895c --- /dev/null +++ b/plotly/validators/scattergl/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scattergl.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_color.py b/plotly/validators/scattergl/marker/_color.py new file mode 100644 index 0000000000..78ce9301a6 --- /dev/null +++ b/plotly/validators/scattergl/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattergl.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scattergl.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_colorbar.py b/plotly/validators/scattergl/marker/_colorbar.py new file mode 100644 index 0000000000..ffc7733fd2 --- /dev/null +++ b/plotly/validators/scattergl/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='scattergl.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattergl.marker.colorbar.Tic + kformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_colorscale.py b/plotly/validators/scattergl/marker/_colorscale.py new file mode 100644 index 0000000000..d0468a8375 --- /dev/null +++ b/plotly/validators/scattergl/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattergl.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_colorsrc.py b/plotly/validators/scattergl/marker/_colorsrc.py new file mode 100644 index 0000000000..e2d6fbe5bb --- /dev/null +++ b/plotly/validators/scattergl/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='scattergl.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_line.py b/plotly/validators/scattergl/marker/_line.py new file mode 100644 index 0000000000..e1ef68dd69 --- /dev/null +++ b/plotly/validators/scattergl/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scattergl.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_opacity.py b/plotly/validators/scattergl/marker/_opacity.py new file mode 100644 index 0000000000..8e33b7b021 --- /dev/null +++ b/plotly/validators/scattergl/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattergl.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_opacitysrc.py b/plotly/validators/scattergl/marker/_opacitysrc.py new file mode 100644 index 0000000000..8da17ca020 --- /dev/null +++ b/plotly/validators/scattergl/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scattergl.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_reversescale.py b/plotly/validators/scattergl/marker/_reversescale.py new file mode 100644 index 0000000000..e08774d414 --- /dev/null +++ b/plotly/validators/scattergl/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattergl.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_showscale.py b/plotly/validators/scattergl/marker/_showscale.py new file mode 100644 index 0000000000..e56e0a5b52 --- /dev/null +++ b/plotly/validators/scattergl/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scattergl.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_size.py b/plotly/validators/scattergl/marker/_size.py new file mode 100644 index 0000000000..b682f866e5 --- /dev/null +++ b/plotly/validators/scattergl/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scattergl.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_sizemin.py b/plotly/validators/scattergl/marker/_sizemin.py new file mode 100644 index 0000000000..c09e3c3685 --- /dev/null +++ b/plotly/validators/scattergl/marker/_sizemin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='scattergl.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_sizemode.py b/plotly/validators/scattergl/marker/_sizemode.py new file mode 100644 index 0000000000..da109ec8ff --- /dev/null +++ b/plotly/validators/scattergl/marker/_sizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='sizemode', parent_name='scattergl.marker', **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_sizeref.py b/plotly/validators/scattergl/marker/_sizeref.py new file mode 100644 index 0000000000..841b3d39a1 --- /dev/null +++ b/plotly/validators/scattergl/marker/_sizeref.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizeref', parent_name='scattergl.marker', **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_sizesrc.py b/plotly/validators/scattergl/marker/_sizesrc.py new file mode 100644 index 0000000000..b794401851 --- /dev/null +++ b/plotly/validators/scattergl/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='scattergl.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_symbol.py b/plotly/validators/scattergl/marker/_symbol.py new file mode 100644 index 0000000000..f20cc544b8 --- /dev/null +++ b/plotly/validators/scattergl/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='scattergl.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/_symbolsrc.py b/plotly/validators/scattergl/marker/_symbolsrc.py new file mode 100644 index 0000000000..061f0b29e1 --- /dev/null +++ b/plotly/validators/scattergl/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scattergl.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/__init__.py b/plotly/validators/scattergl/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattergl/marker/colorbar/_bgcolor.py b/plotly/validators/scattergl/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..b20815bc73 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_bordercolor.py b/plotly/validators/scattergl/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..6a0a78a323 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_borderwidth.py b/plotly/validators/scattergl/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..ab3e51dea7 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_dtick.py b/plotly/validators/scattergl/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..456b81e7bd --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_exponentformat.py b/plotly/validators/scattergl/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..dd5e565c08 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_len.py b/plotly/validators/scattergl/marker/colorbar/_len.py new file mode 100644 index 0000000000..b5db86d0f5 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_lenmode.py b/plotly/validators/scattergl/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..1e294ad93b --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_nticks.py b/plotly/validators/scattergl/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..197705cceb --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_outlinecolor.py b/plotly/validators/scattergl/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..b197116bf8 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_outlinewidth.py b/plotly/validators/scattergl/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..5d843cd236 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_separatethousands.py b/plotly/validators/scattergl/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..c12d586115 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_showexponent.py b/plotly/validators/scattergl/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..e69768080d --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_showticklabels.py b/plotly/validators/scattergl/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..50e4ed16fc --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_showtickprefix.py b/plotly/validators/scattergl/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..52ced5411f --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_showticksuffix.py b/plotly/validators/scattergl/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..5b156f31de --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_thickness.py b/plotly/validators/scattergl/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..db7b714c99 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_thicknessmode.py b/plotly/validators/scattergl/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..3e6a3f6f2c --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tick0.py b/plotly/validators/scattergl/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..0d1bb633bd --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickangle.py b/plotly/validators/scattergl/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..25374ecabe --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickcolor.py b/plotly/validators/scattergl/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..8f10cad9eb --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickfont.py b/plotly/validators/scattergl/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..d9a81cfe73 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickformat.py b/plotly/validators/scattergl/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..5ba3b5f692 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickformatstops.py b/plotly/validators/scattergl/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..f5dc2b6c4e --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ticklen.py b/plotly/validators/scattergl/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..98bc38793c --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickmode.py b/plotly/validators/scattergl/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..74cd92c399 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickprefix.py b/plotly/validators/scattergl/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..ee6de104dd --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ticks.py b/plotly/validators/scattergl/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..7e848ec2b2 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ticksuffix.py b/plotly/validators/scattergl/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..64061ab7ce --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ticktext.py b/plotly/validators/scattergl/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..58a139e7ba --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ticktextsrc.py b/plotly/validators/scattergl/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..b724a121ea --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickvals.py b/plotly/validators/scattergl/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..0c0d818685 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickvalssrc.py b/plotly/validators/scattergl/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..7086671810 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_tickwidth.py b/plotly/validators/scattergl/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..9e54d686ed --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_title.py b/plotly/validators/scattergl/marker/colorbar/_title.py new file mode 100644 index 0000000000..e3541b206f --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_titlefont.py b/plotly/validators/scattergl/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..463ea6543f --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_titleside.py b/plotly/validators/scattergl/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..b522dbf8ec --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_x.py b/plotly/validators/scattergl/marker/colorbar/_x.py new file mode 100644 index 0000000000..98c0a358fe --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_xanchor.py b/plotly/validators/scattergl/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..98dcd287e2 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_xpad.py b/plotly/validators/scattergl/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..41f34654f8 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_y.py b/plotly/validators/scattergl/marker/colorbar/_y.py new file mode 100644 index 0000000000..b86cd79756 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_yanchor.py b/plotly/validators/scattergl/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..2208f2992f --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/_ypad.py b/plotly/validators/scattergl/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..8513bf8fb1 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scattergl.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/tickfont/__init__.py b/plotly/validators/scattergl/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/marker/colorbar/tickfont/_color.py b/plotly/validators/scattergl/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..49e56c5485 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/tickfont/_family.py b/plotly/validators/scattergl/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..2566b5ad03 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergl.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/tickfont/_size.py b/plotly/validators/scattergl/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..71f06dd400 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergl.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scattergl/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scattergl/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scattergl/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..119b595ca0 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scattergl.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scattergl/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..480600ccc8 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scattergl.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/titlefont/__init__.py b/plotly/validators/scattergl/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/marker/colorbar/titlefont/_color.py b/plotly/validators/scattergl/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..14600b5898 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/titlefont/_family.py b/plotly/validators/scattergl/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..aa48e282c7 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattergl.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/colorbar/titlefont/_size.py b/plotly/validators/scattergl/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..d94eb2ccc9 --- /dev/null +++ b/plotly/validators/scattergl/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergl.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/__init__.py b/plotly/validators/scattergl/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattergl/marker/line/_autocolorscale.py b/plotly/validators/scattergl/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..5cdbbe3103 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattergl.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_cauto.py b/plotly/validators/scattergl/marker/line/_cauto.py new file mode 100644 index 0000000000..6ef8f61395 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scattergl.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_cmax.py b/plotly/validators/scattergl/marker/line/_cmax.py new file mode 100644 index 0000000000..79087a3b0c --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scattergl.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_cmin.py b/plotly/validators/scattergl/marker/line/_cmin.py new file mode 100644 index 0000000000..cd3061f7c6 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scattergl.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_color.py b/plotly/validators/scattergl/marker/line/_color.py new file mode 100644 index 0000000000..aa7e43fed1 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scattergl.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_colorscale.py b/plotly/validators/scattergl/marker/line/_colorscale.py new file mode 100644 index 0000000000..cb0fe8cd84 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattergl.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_colorsrc.py b/plotly/validators/scattergl/marker/line/_colorsrc.py new file mode 100644 index 0000000000..738d847e73 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattergl.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_reversescale.py b/plotly/validators/scattergl/marker/line/_reversescale.py new file mode 100644 index 0000000000..034c989b1d --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattergl.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_width.py b/plotly/validators/scattergl/marker/line/_width.py new file mode 100644 index 0000000000..939b5422d4 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scattergl.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/marker/line/_widthsrc.py b/plotly/validators/scattergl/marker/line/_widthsrc.py new file mode 100644 index 0000000000..39df1d59d6 --- /dev/null +++ b/plotly/validators/scattergl/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scattergl.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/selected/__init__.py b/plotly/validators/scattergl/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/scattergl/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/scattergl/selected/_marker.py b/plotly/validators/scattergl/selected/_marker.py new file mode 100644 index 0000000000..0176f92aaf --- /dev/null +++ b/plotly/validators/scattergl/selected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scattergl.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/selected/marker/__init__.py b/plotly/validators/scattergl/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattergl/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/selected/marker/_color.py b/plotly/validators/scattergl/selected/marker/_color.py new file mode 100644 index 0000000000..860085f11b --- /dev/null +++ b/plotly/validators/scattergl/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/selected/marker/_opacity.py b/plotly/validators/scattergl/selected/marker/_opacity.py new file mode 100644 index 0000000000..d374f7d592 --- /dev/null +++ b/plotly/validators/scattergl/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattergl.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/selected/marker/_size.py b/plotly/validators/scattergl/selected/marker/_size.py new file mode 100644 index 0000000000..dc18119c6d --- /dev/null +++ b/plotly/validators/scattergl/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergl.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/stream/__init__.py b/plotly/validators/scattergl/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scattergl/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scattergl/stream/_maxpoints.py b/plotly/validators/scattergl/stream/_maxpoints.py new file mode 100644 index 0000000000..eb5e91a48c --- /dev/null +++ b/plotly/validators/scattergl/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scattergl.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattergl/stream/_token.py b/plotly/validators/scattergl/stream/_token.py new file mode 100644 index 0000000000..071edc5f53 --- /dev/null +++ b/plotly/validators/scattergl/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='scattergl.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattergl/unselected/__init__.py b/plotly/validators/scattergl/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/scattergl/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/scattergl/unselected/_marker.py b/plotly/validators/scattergl/unselected/_marker.py new file mode 100644 index 0000000000..0f961e043e --- /dev/null +++ b/plotly/validators/scattergl/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattergl.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattergl/unselected/marker/__init__.py b/plotly/validators/scattergl/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattergl/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattergl/unselected/marker/_color.py b/plotly/validators/scattergl/unselected/marker/_color.py new file mode 100644 index 0000000000..b53f5b605f --- /dev/null +++ b/plotly/validators/scattergl/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattergl.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/unselected/marker/_opacity.py b/plotly/validators/scattergl/unselected/marker/_opacity.py new file mode 100644 index 0000000000..2ad3888b4d --- /dev/null +++ b/plotly/validators/scattergl/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattergl.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattergl/unselected/marker/_size.py b/plotly/validators/scattergl/unselected/marker/_size.py new file mode 100644 index 0000000000..97d566234a --- /dev/null +++ b/plotly/validators/scattergl/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattergl.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/__init__.py b/plotly/validators/scattermapbox/__init__.py new file mode 100644 index 0000000000..29980b84ff --- /dev/null +++ b/plotly/validators/scattermapbox/__init__.py @@ -0,0 +1,34 @@ +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._subplot import SubplotValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._lonsrc import LonsrcValidator +from ._lon import LonValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._latsrc import LatsrcValidator +from ._lat import LatValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator diff --git a/plotly/validators/scattermapbox/_connectgaps.py b/plotly/validators/scattermapbox/_connectgaps.py new file mode 100644 index 0000000000..d5b9b2b266 --- /dev/null +++ b/plotly/validators/scattermapbox/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scattermapbox', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_customdata.py b/plotly/validators/scattermapbox/_customdata.py new file mode 100644 index 0000000000..2f3d36f5bc --- /dev/null +++ b/plotly/validators/scattermapbox/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scattermapbox', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_customdatasrc.py b/plotly/validators/scattermapbox/_customdatasrc.py new file mode 100644 index 0000000000..ac1aba9444 --- /dev/null +++ b/plotly/validators/scattermapbox/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='scattermapbox', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_fill.py b/plotly/validators/scattermapbox/_fill.py new file mode 100644 index 0000000000..9b439b137c --- /dev/null +++ b/plotly/validators/scattermapbox/_fill.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='fill', parent_name='scattermapbox', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'toself'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_fillcolor.py b/plotly/validators/scattermapbox/_fillcolor.py new file mode 100644 index 0000000000..167fa86095 --- /dev/null +++ b/plotly/validators/scattermapbox/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scattermapbox', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_hoverinfo.py b/plotly/validators/scattermapbox/_hoverinfo.py new file mode 100644 index 0000000000..5c66fc392b --- /dev/null +++ b/plotly/validators/scattermapbox/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scattermapbox', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['lon', 'lat', 'text', 'name', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_hoverinfosrc.py b/plotly/validators/scattermapbox/_hoverinfosrc.py new file mode 100644 index 0000000000..238384e748 --- /dev/null +++ b/plotly/validators/scattermapbox/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='scattermapbox', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_hoverlabel.py b/plotly/validators/scattermapbox/_hoverlabel.py new file mode 100644 index 0000000000..afbe3ee72a --- /dev/null +++ b/plotly/validators/scattermapbox/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scattermapbox', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_hovertext.py b/plotly/validators/scattermapbox/_hovertext.py new file mode 100644 index 0000000000..bd495f1a95 --- /dev/null +++ b/plotly/validators/scattermapbox/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scattermapbox', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_hovertextsrc.py b/plotly/validators/scattermapbox/_hovertextsrc.py new file mode 100644 index 0000000000..d880588263 --- /dev/null +++ b/plotly/validators/scattermapbox/_hovertextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hovertextsrc', + parent_name='scattermapbox', + **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_ids.py b/plotly/validators/scattermapbox/_ids.py new file mode 100644 index 0000000000..99f63e7152 --- /dev/null +++ b/plotly/validators/scattermapbox/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='scattermapbox', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_idssrc.py b/plotly/validators/scattermapbox/_idssrc.py new file mode 100644 index 0000000000..28871ea337 --- /dev/null +++ b/plotly/validators/scattermapbox/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scattermapbox', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_lat.py b/plotly/validators/scattermapbox/_lat.py new file mode 100644 index 0000000000..d0cb3cc431 --- /dev/null +++ b/plotly/validators/scattermapbox/_lat.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LatValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='lat', parent_name='scattermapbox', **kwargs + ): + super(LatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_latsrc.py b/plotly/validators/scattermapbox/_latsrc.py new file mode 100644 index 0000000000..8a0fc1697d --- /dev/null +++ b/plotly/validators/scattermapbox/_latsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LatsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='latsrc', parent_name='scattermapbox', **kwargs + ): + super(LatsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_legendgroup.py b/plotly/validators/scattermapbox/_legendgroup.py new file mode 100644 index 0000000000..30f90f8647 --- /dev/null +++ b/plotly/validators/scattermapbox/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scattermapbox', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_line.py b/plotly/validators/scattermapbox/_line.py new file mode 100644 index 0000000000..9613275a71 --- /dev/null +++ b/plotly/validators/scattermapbox/_line.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scattermapbox', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_lon.py b/plotly/validators/scattermapbox/_lon.py new file mode 100644 index 0000000000..c316d6057f --- /dev/null +++ b/plotly/validators/scattermapbox/_lon.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LonValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='lon', parent_name='scattermapbox', **kwargs + ): + super(LonValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_lonsrc.py b/plotly/validators/scattermapbox/_lonsrc.py new file mode 100644 index 0000000000..5f4243035f --- /dev/null +++ b/plotly/validators/scattermapbox/_lonsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LonsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='lonsrc', parent_name='scattermapbox', **kwargs + ): + super(LonsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_marker.py b/plotly/validators/scattermapbox/_marker.py new file mode 100644 index 0000000000..3b34691744 --- /dev/null +++ b/plotly/validators/scattermapbox/_marker.py @@ -0,0 +1,115 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scattermapbox', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scattermapbox.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol. Full list: + https://www.mapbox.com/maki-icons/ Note that + the array `marker.color` and `marker.size` are + only available for *circle* symbols. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_mode.py b/plotly/validators/scattermapbox/_mode.py new file mode 100644 index 0000000000..17b7078e26 --- /dev/null +++ b/plotly/validators/scattermapbox/_mode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='mode', parent_name='scattermapbox', **kwargs + ): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_name.py b/plotly/validators/scattermapbox/_name.py new file mode 100644 index 0000000000..faf0ff8d2a --- /dev/null +++ b/plotly/validators/scattermapbox/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='scattermapbox', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_opacity.py b/plotly/validators/scattermapbox/_opacity.py new file mode 100644 index 0000000000..566228449f --- /dev/null +++ b/plotly/validators/scattermapbox/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scattermapbox', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_selected.py b/plotly/validators/scattermapbox/_selected.py new file mode 100644 index 0000000000..a302671694 --- /dev/null +++ b/plotly/validators/scattermapbox/_selected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scattermapbox', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scattermapbox.selected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_selectedpoints.py b/plotly/validators/scattermapbox/_selectedpoints.py new file mode 100644 index 0000000000..8f3207cf13 --- /dev/null +++ b/plotly/validators/scattermapbox/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='scattermapbox', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_showlegend.py b/plotly/validators/scattermapbox/_showlegend.py new file mode 100644 index 0000000000..62361cf39a --- /dev/null +++ b/plotly/validators/scattermapbox/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scattermapbox', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_stream.py b/plotly/validators/scattermapbox/_stream.py new file mode 100644 index 0000000000..9ee0a73790 --- /dev/null +++ b/plotly/validators/scattermapbox/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scattermapbox', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_subplot.py b/plotly/validators/scattermapbox/_subplot.py new file mode 100644 index 0000000000..0d5f5ea8dd --- /dev/null +++ b/plotly/validators/scattermapbox/_subplot.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SubplotValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='subplot', parent_name='scattermapbox', **kwargs + ): + super(SubplotValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='mapbox', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_text.py b/plotly/validators/scattermapbox/_text.py new file mode 100644 index 0000000000..9800713e7e --- /dev/null +++ b/plotly/validators/scattermapbox/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='scattermapbox', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_textfont.py b/plotly/validators/scattermapbox/_textfont.py new file mode 100644 index 0000000000..76e828bd07 --- /dev/null +++ b/plotly/validators/scattermapbox/_textfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scattermapbox', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_textposition.py b/plotly/validators/scattermapbox/_textposition.py new file mode 100644 index 0000000000..be629ce205 --- /dev/null +++ b/plotly/validators/scattermapbox/_textposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='textposition', + parent_name='scattermapbox', + **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_textsrc.py b/plotly/validators/scattermapbox/_textsrc.py new file mode 100644 index 0000000000..14fc2dc5db --- /dev/null +++ b/plotly/validators/scattermapbox/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scattermapbox', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_uid.py b/plotly/validators/scattermapbox/_uid.py new file mode 100644 index 0000000000..c14621e671 --- /dev/null +++ b/plotly/validators/scattermapbox/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='scattermapbox', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_unselected.py b/plotly/validators/scattermapbox/_unselected.py new file mode 100644 index 0000000000..f7a733d156 --- /dev/null +++ b/plotly/validators/scattermapbox/_unselected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scattermapbox', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scattermapbox.unselected.Mark + er instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/_visible.py b/plotly/validators/scattermapbox/_visible.py new file mode 100644 index 0000000000..3c553abfb6 --- /dev/null +++ b/plotly/validators/scattermapbox/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scattermapbox', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/__init__.py b/plotly/validators/scattermapbox/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattermapbox/hoverlabel/_bgcolor.py b/plotly/validators/scattermapbox/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..29a698622e --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_bgcolorsrc.py b/plotly/validators/scattermapbox/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..18cbfd2591 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_bordercolor.py b/plotly/validators/scattermapbox/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..512c577aa7 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_bordercolorsrc.py b/plotly/validators/scattermapbox/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..16b7e89805 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_font.py b/plotly/validators/scattermapbox/hoverlabel/_font.py new file mode 100644 index 0000000000..671a27d78f --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_namelength.py b/plotly/validators/scattermapbox/hoverlabel/_namelength.py new file mode 100644 index 0000000000..c0f19c47f3 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/_namelengthsrc.py b/plotly/validators/scattermapbox/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..fa77250369 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scattermapbox.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/__init__.py b/plotly/validators/scattermapbox/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_color.py b/plotly/validators/scattermapbox/hoverlabel/font/_color.py new file mode 100644 index 0000000000..ab196ac33d --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_colorsrc.py b/plotly/validators/scattermapbox/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..e5692cafb7 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_family.py b/plotly/validators/scattermapbox/hoverlabel/font/_family.py new file mode 100644 index 0000000000..c523f4c89b --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_familysrc.py b/plotly/validators/scattermapbox/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..8c645264b4 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_size.py b/plotly/validators/scattermapbox/hoverlabel/font/_size.py new file mode 100644 index 0000000000..7605a3ad13 --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/hoverlabel/font/_sizesrc.py b/plotly/validators/scattermapbox/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..1437f3a8ff --- /dev/null +++ b/plotly/validators/scattermapbox/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattermapbox.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/line/__init__.py b/plotly/validators/scattermapbox/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/scattermapbox/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/line/_color.py b/plotly/validators/scattermapbox/line/_color.py new file mode 100644 index 0000000000..ecbe27ff58 --- /dev/null +++ b/plotly/validators/scattermapbox/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scattermapbox.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/line/_width.py b/plotly/validators/scattermapbox/line/_width.py new file mode 100644 index 0000000000..b5709a58f9 --- /dev/null +++ b/plotly/validators/scattermapbox/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scattermapbox.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/__init__.py b/plotly/validators/scattermapbox/marker/__init__.py new file mode 100644 index 0000000000..afa7193944 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/__init__.py @@ -0,0 +1,19 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scattermapbox/marker/_autocolorscale.py b/plotly/validators/scattermapbox/marker/_autocolorscale.py new file mode 100644 index 0000000000..e9e17c88dd --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scattermapbox.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_cauto.py b/plotly/validators/scattermapbox/marker/_cauto.py new file mode 100644 index 0000000000..6474fd5aa4 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scattermapbox.marker', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_cmax.py b/plotly/validators/scattermapbox/marker/_cmax.py new file mode 100644 index 0000000000..f9530eec95 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scattermapbox.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_cmin.py b/plotly/validators/scattermapbox/marker/_cmin.py new file mode 100644 index 0000000000..02eca67682 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scattermapbox.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_color.py b/plotly/validators/scattermapbox/marker/_color.py new file mode 100644 index 0000000000..ea5aac0bc2 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scattermapbox.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_colorbar.py b/plotly/validators/scattermapbox/marker/_colorbar.py new file mode 100644 index 0000000000..60d9d4940f --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scattermapbox.marker.colorbar + .Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_colorscale.py b/plotly/validators/scattermapbox/marker/_colorscale.py new file mode 100644 index 0000000000..5e779ed03f --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_colorsrc.py b/plotly/validators/scattermapbox/marker/_colorsrc.py new file mode 100644 index 0000000000..f1008ade1c --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_opacity.py b/plotly/validators/scattermapbox/marker/_opacity.py new file mode 100644 index 0000000000..417ba8d025 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_opacity.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattermapbox.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_opacitysrc.py b/plotly/validators/scattermapbox/marker/_opacitysrc.py new file mode 100644 index 0000000000..2f1779a5e9 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scattermapbox.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_reversescale.py b/plotly/validators/scattermapbox/marker/_reversescale.py new file mode 100644 index 0000000000..623cd73c07 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_showscale.py b/plotly/validators/scattermapbox/marker/_showscale.py new file mode 100644 index 0000000000..2ee63328ef --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scattermapbox.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_size.py b/plotly/validators/scattermapbox/marker/_size.py new file mode 100644 index 0000000000..8e931229c6 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scattermapbox.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_sizemin.py b/plotly/validators/scattermapbox/marker/_sizemin.py new file mode 100644 index 0000000000..cfdd4c6862 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_sizemin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizemin', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_sizemode.py b/plotly/validators/scattermapbox/marker/_sizemode.py new file mode 100644 index 0000000000..9c43f429bb --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_sizeref.py b/plotly/validators/scattermapbox/marker/_sizeref.py new file mode 100644 index 0000000000..2a9f132576 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_sizeref.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizeref', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_sizesrc.py b/plotly/validators/scattermapbox/marker/_sizesrc.py new file mode 100644 index 0000000000..0bfb3c144c --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_symbol.py b/plotly/validators/scattermapbox/marker/_symbol.py new file mode 100644 index 0000000000..174283bd36 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_symbol.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/_symbolsrc.py b/plotly/validators/scattermapbox/marker/_symbolsrc.py new file mode 100644 index 0000000000..64c0886ee8 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scattermapbox.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/__init__.py b/plotly/validators/scattermapbox/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scattermapbox/marker/colorbar/_bgcolor.py b/plotly/validators/scattermapbox/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..c17fb1a3fa --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_bordercolor.py b/plotly/validators/scattermapbox/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..6eba95cbc8 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_borderwidth.py b/plotly/validators/scattermapbox/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..8a333d38a6 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_dtick.py b/plotly/validators/scattermapbox/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..2b3188707e --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_exponentformat.py b/plotly/validators/scattermapbox/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..897c80cdab --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_len.py b/plotly/validators/scattermapbox/marker/colorbar/_len.py new file mode 100644 index 0000000000..3e6f7556ae --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_lenmode.py b/plotly/validators/scattermapbox/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..21d3118f4b --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_nticks.py b/plotly/validators/scattermapbox/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..53540ed4b7 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_outlinecolor.py b/plotly/validators/scattermapbox/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..64c0e1c80b --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_outlinewidth.py b/plotly/validators/scattermapbox/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..bd6eb31ba0 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_separatethousands.py b/plotly/validators/scattermapbox/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..a6f0f77675 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_showexponent.py b/plotly/validators/scattermapbox/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..9d84fa79ff --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_showticklabels.py b/plotly/validators/scattermapbox/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..5ee71cb825 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_showtickprefix.py b/plotly/validators/scattermapbox/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..ee5cc22f32 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_showticksuffix.py b/plotly/validators/scattermapbox/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..d678824d30 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_thickness.py b/plotly/validators/scattermapbox/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..99d8dcca59 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_thicknessmode.py b/plotly/validators/scattermapbox/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..6da6dfb445 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tick0.py b/plotly/validators/scattermapbox/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..c8f82ec430 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickangle.py b/plotly/validators/scattermapbox/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..55b92559fd --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickcolor.py b/plotly/validators/scattermapbox/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..00c5678502 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickfont.py b/plotly/validators/scattermapbox/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..f29f069667 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickformat.py b/plotly/validators/scattermapbox/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..ff3903a4c1 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickformatstops.py b/plotly/validators/scattermapbox/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..3a1c030241 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ticklen.py b/plotly/validators/scattermapbox/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..e210b32a19 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickmode.py b/plotly/validators/scattermapbox/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..73b86ca155 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickprefix.py b/plotly/validators/scattermapbox/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..0afdb6012c --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ticks.py b/plotly/validators/scattermapbox/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..71cabf67b7 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ticksuffix.py b/plotly/validators/scattermapbox/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..bcb6e05537 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ticktext.py b/plotly/validators/scattermapbox/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..ce337abb04 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ticktextsrc.py b/plotly/validators/scattermapbox/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..134a0790f6 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickvals.py b/plotly/validators/scattermapbox/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..f69259c044 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickvalssrc.py b/plotly/validators/scattermapbox/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..f02f3b3c1d --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_tickwidth.py b/plotly/validators/scattermapbox/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..ef309d3dd7 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_title.py b/plotly/validators/scattermapbox/marker/colorbar/_title.py new file mode 100644 index 0000000000..d02369d94f --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_titlefont.py b/plotly/validators/scattermapbox/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..c033d568cd --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_titleside.py b/plotly/validators/scattermapbox/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..94f04104eb --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_x.py b/plotly/validators/scattermapbox/marker/colorbar/_x.py new file mode 100644 index 0000000000..7cb9f3a8e6 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_xanchor.py b/plotly/validators/scattermapbox/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..80ca195683 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_xpad.py b/plotly/validators/scattermapbox/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..5cd2298aa8 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_y.py b/plotly/validators/scattermapbox/marker/colorbar/_y.py new file mode 100644 index 0000000000..96ab3f7153 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_yanchor.py b/plotly/validators/scattermapbox/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..e0c0be2d14 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/_ypad.py b/plotly/validators/scattermapbox/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..f2678b0f91 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scattermapbox.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickfont/__init__.py b/plotly/validators/scattermapbox/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickfont/_color.py b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..464683569f --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickfont/_family.py b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..237aedfad3 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattermapbox.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickfont/_size.py b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..b5a3f5dcdc --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..b652ac10e4 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scattermapbox.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..5430c58e47 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scattermapbox.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/titlefont/__init__.py b/plotly/validators/scattermapbox/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/marker/colorbar/titlefont/_color.py b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..17904f2408 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/titlefont/_family.py b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..358e068fae --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattermapbox.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattermapbox/marker/colorbar/titlefont/_size.py b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..9cf7d99f03 --- /dev/null +++ b/plotly/validators/scattermapbox/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/selected/__init__.py b/plotly/validators/scattermapbox/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/scattermapbox/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/scattermapbox/selected/_marker.py b/plotly/validators/scattermapbox/selected/_marker.py new file mode 100644 index 0000000000..56ad675e59 --- /dev/null +++ b/plotly/validators/scattermapbox/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattermapbox.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/selected/marker/__init__.py b/plotly/validators/scattermapbox/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattermapbox/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/selected/marker/_color.py b/plotly/validators/scattermapbox/selected/marker/_color.py new file mode 100644 index 0000000000..a605ee2de5 --- /dev/null +++ b/plotly/validators/scattermapbox/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/selected/marker/_opacity.py b/plotly/validators/scattermapbox/selected/marker/_opacity.py new file mode 100644 index 0000000000..161ee94b96 --- /dev/null +++ b/plotly/validators/scattermapbox/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattermapbox.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/selected/marker/_size.py b/plotly/validators/scattermapbox/selected/marker/_size.py new file mode 100644 index 0000000000..375f938325 --- /dev/null +++ b/plotly/validators/scattermapbox/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/stream/__init__.py b/plotly/validators/scattermapbox/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scattermapbox/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scattermapbox/stream/_maxpoints.py b/plotly/validators/scattermapbox/stream/_maxpoints.py new file mode 100644 index 0000000000..ad627f7ea9 --- /dev/null +++ b/plotly/validators/scattermapbox/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scattermapbox.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/stream/_token.py b/plotly/validators/scattermapbox/stream/_token.py new file mode 100644 index 0000000000..0a886f863a --- /dev/null +++ b/plotly/validators/scattermapbox/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='scattermapbox.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattermapbox/textfont/__init__.py b/plotly/validators/scattermapbox/textfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scattermapbox/textfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/textfont/_color.py b/plotly/validators/scattermapbox/textfont/_color.py new file mode 100644 index 0000000000..45a8f084c3 --- /dev/null +++ b/plotly/validators/scattermapbox/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/textfont/_family.py b/plotly/validators/scattermapbox/textfont/_family.py new file mode 100644 index 0000000000..4c752b39c4 --- /dev/null +++ b/plotly/validators/scattermapbox/textfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scattermapbox.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scattermapbox/textfont/_size.py b/plotly/validators/scattermapbox/textfont/_size.py new file mode 100644 index 0000000000..e5061e9ea8 --- /dev/null +++ b/plotly/validators/scattermapbox/textfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.textfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/unselected/__init__.py b/plotly/validators/scattermapbox/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/scattermapbox/unselected/_marker.py b/plotly/validators/scattermapbox/unselected/_marker.py new file mode 100644 index 0000000000..0035ab654d --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scattermapbox.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scattermapbox/unselected/marker/__init__.py b/plotly/validators/scattermapbox/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scattermapbox/unselected/marker/_color.py b/plotly/validators/scattermapbox/unselected/marker/_color.py new file mode 100644 index 0000000000..befd205f25 --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scattermapbox.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/unselected/marker/_opacity.py b/plotly/validators/scattermapbox/unselected/marker/_opacity.py new file mode 100644 index 0000000000..2d11aebbb7 --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scattermapbox.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scattermapbox/unselected/marker/_size.py b/plotly/validators/scattermapbox/unselected/marker/_size.py new file mode 100644 index 0000000000..d659a3ff38 --- /dev/null +++ b/plotly/validators/scattermapbox/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scattermapbox.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/__init__.py b/plotly/validators/scatterpolar/__init__.py new file mode 100644 index 0000000000..65624247b8 --- /dev/null +++ b/plotly/validators/scatterpolar/__init__.py @@ -0,0 +1,38 @@ +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._thetaunit import ThetaunitValidator +from ._thetasrc import ThetasrcValidator +from ._theta import ThetaValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._subplot import SubplotValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._rsrc import RsrcValidator +from ._r import RValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator +from ._cliponaxis import CliponaxisValidator diff --git a/plotly/validators/scatterpolar/_cliponaxis.py b/plotly/validators/scatterpolar/_cliponaxis.py new file mode 100644 index 0000000000..ad16337f5e --- /dev/null +++ b/plotly/validators/scatterpolar/_cliponaxis.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CliponaxisValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cliponaxis', parent_name='scatterpolar', **kwargs + ): + super(CliponaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_connectgaps.py b/plotly/validators/scatterpolar/_connectgaps.py new file mode 100644 index 0000000000..0d06ade59a --- /dev/null +++ b/plotly/validators/scatterpolar/_connectgaps.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='connectgaps', parent_name='scatterpolar', **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_customdata.py b/plotly/validators/scatterpolar/_customdata.py new file mode 100644 index 0000000000..632d0302b9 --- /dev/null +++ b/plotly/validators/scatterpolar/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scatterpolar', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_customdatasrc.py b/plotly/validators/scatterpolar/_customdatasrc.py new file mode 100644 index 0000000000..14f5ebdc0d --- /dev/null +++ b/plotly/validators/scatterpolar/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='scatterpolar', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_fill.py b/plotly/validators/scatterpolar/_fill.py new file mode 100644 index 0000000000..0e84f0871b --- /dev/null +++ b/plotly/validators/scatterpolar/_fill.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='fill', parent_name='scatterpolar', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'toself', 'tonext'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_fillcolor.py b/plotly/validators/scatterpolar/_fillcolor.py new file mode 100644 index 0000000000..2687725ea7 --- /dev/null +++ b/plotly/validators/scatterpolar/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scatterpolar', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hoverinfo.py b/plotly/validators/scatterpolar/_hoverinfo.py new file mode 100644 index 0000000000..0cbad331d6 --- /dev/null +++ b/plotly/validators/scatterpolar/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scatterpolar', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['r', 'theta', 'text', 'name', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hoverinfosrc.py b/plotly/validators/scatterpolar/_hoverinfosrc.py new file mode 100644 index 0000000000..7fb09bd5f4 --- /dev/null +++ b/plotly/validators/scatterpolar/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='scatterpolar', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hoverlabel.py b/plotly/validators/scatterpolar/_hoverlabel.py new file mode 100644 index 0000000000..557828212d --- /dev/null +++ b/plotly/validators/scatterpolar/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scatterpolar', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hoveron.py b/plotly/validators/scatterpolar/_hoveron.py new file mode 100644 index 0000000000..d2e874e8dc --- /dev/null +++ b/plotly/validators/scatterpolar/_hoveron.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoveron', parent_name='scatterpolar', **kwargs + ): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hovertext.py b/plotly/validators/scatterpolar/_hovertext.py new file mode 100644 index 0000000000..77fb49b7d1 --- /dev/null +++ b/plotly/validators/scatterpolar/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scatterpolar', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_hovertextsrc.py b/plotly/validators/scatterpolar/_hovertextsrc.py new file mode 100644 index 0000000000..cd0c7ee5ee --- /dev/null +++ b/plotly/validators/scatterpolar/_hovertextsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hovertextsrc', parent_name='scatterpolar', **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_ids.py b/plotly/validators/scatterpolar/_ids.py new file mode 100644 index 0000000000..58d0f87969 --- /dev/null +++ b/plotly/validators/scatterpolar/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='scatterpolar', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_idssrc.py b/plotly/validators/scatterpolar/_idssrc.py new file mode 100644 index 0000000000..25e695fba2 --- /dev/null +++ b/plotly/validators/scatterpolar/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scatterpolar', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_legendgroup.py b/plotly/validators/scatterpolar/_legendgroup.py new file mode 100644 index 0000000000..c9d80deaed --- /dev/null +++ b/plotly/validators/scatterpolar/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='scatterpolar', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_line.py b/plotly/validators/scatterpolar/_line.py new file mode 100644 index 0000000000..90d0fb94ee --- /dev/null +++ b/plotly/validators/scatterpolar/_line.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatterpolar', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_marker.py b/plotly/validators/scatterpolar/_marker.py new file mode 100644 index 0000000000..6b298129c5 --- /dev/null +++ b/plotly/validators/scatterpolar/_marker.py @@ -0,0 +1,126 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatterpolar', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolar.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatterpolar.marker.Gradient + instance or dict with compatible properties + line + plotly.graph_objs.scatterpolar.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_mode.py b/plotly/validators/scatterpolar/_mode.py new file mode 100644 index 0000000000..12c5014c8b --- /dev/null +++ b/plotly/validators/scatterpolar/_mode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='mode', parent_name='scatterpolar', **kwargs + ): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_name.py b/plotly/validators/scatterpolar/_name.py new file mode 100644 index 0000000000..f1e849262e --- /dev/null +++ b/plotly/validators/scatterpolar/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='scatterpolar', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_opacity.py b/plotly/validators/scatterpolar/_opacity.py new file mode 100644 index 0000000000..a58fde645b --- /dev/null +++ b/plotly/validators/scatterpolar/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatterpolar', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_r.py b/plotly/validators/scatterpolar/_r.py new file mode 100644 index 0000000000..248c2eb7d1 --- /dev/null +++ b/plotly/validators/scatterpolar/_r.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='r', parent_name='scatterpolar', **kwargs): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_rsrc.py b/plotly/validators/scatterpolar/_rsrc.py new file mode 100644 index 0000000000..71816c4a47 --- /dev/null +++ b/plotly/validators/scatterpolar/_rsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='rsrc', parent_name='scatterpolar', **kwargs + ): + super(RsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_selected.py b/plotly/validators/scatterpolar/_selected.py new file mode 100644 index 0000000000..83ce6f05c8 --- /dev/null +++ b/plotly/validators/scatterpolar/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scatterpolar', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scatterpolar.selected.Marker + instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.selected.Textfon + t instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_selectedpoints.py b/plotly/validators/scatterpolar/_selectedpoints.py new file mode 100644 index 0000000000..ceee77672b --- /dev/null +++ b/plotly/validators/scatterpolar/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='scatterpolar', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_showlegend.py b/plotly/validators/scatterpolar/_showlegend.py new file mode 100644 index 0000000000..7823240c13 --- /dev/null +++ b/plotly/validators/scatterpolar/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scatterpolar', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_stream.py b/plotly/validators/scatterpolar/_stream.py new file mode 100644 index 0000000000..85cd97f718 --- /dev/null +++ b/plotly/validators/scatterpolar/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scatterpolar', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_subplot.py b/plotly/validators/scatterpolar/_subplot.py new file mode 100644 index 0000000000..5f9b9c8fbb --- /dev/null +++ b/plotly/validators/scatterpolar/_subplot.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SubplotValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='subplot', parent_name='scatterpolar', **kwargs + ): + super(SubplotValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='polar', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_text.py b/plotly/validators/scatterpolar/_text.py new file mode 100644 index 0000000000..0995fb6e60 --- /dev/null +++ b/plotly/validators/scatterpolar/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='scatterpolar', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_textfont.py b/plotly/validators/scatterpolar/_textfont.py new file mode 100644 index 0000000000..3d8e272851 --- /dev/null +++ b/plotly/validators/scatterpolar/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scatterpolar', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_textposition.py b/plotly/validators/scatterpolar/_textposition.py new file mode 100644 index 0000000000..ac33bf7029 --- /dev/null +++ b/plotly/validators/scatterpolar/_textposition.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='textposition', parent_name='scatterpolar', **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_textpositionsrc.py b/plotly/validators/scatterpolar/_textpositionsrc.py new file mode 100644 index 0000000000..b347474b64 --- /dev/null +++ b/plotly/validators/scatterpolar/_textpositionsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='textpositionsrc', + parent_name='scatterpolar', + **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_textsrc.py b/plotly/validators/scatterpolar/_textsrc.py new file mode 100644 index 0000000000..445b643375 --- /dev/null +++ b/plotly/validators/scatterpolar/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scatterpolar', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_theta.py b/plotly/validators/scatterpolar/_theta.py new file mode 100644 index 0000000000..05c0c3105f --- /dev/null +++ b/plotly/validators/scatterpolar/_theta.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ThetaValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='theta', parent_name='scatterpolar', **kwargs + ): + super(ThetaValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_thetasrc.py b/plotly/validators/scatterpolar/_thetasrc.py new file mode 100644 index 0000000000..f72b75e5be --- /dev/null +++ b/plotly/validators/scatterpolar/_thetasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ThetasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='thetasrc', parent_name='scatterpolar', **kwargs + ): + super(ThetasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_thetaunit.py b/plotly/validators/scatterpolar/_thetaunit.py new file mode 100644 index 0000000000..958ac95183 --- /dev/null +++ b/plotly/validators/scatterpolar/_thetaunit.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThetaunitValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='thetaunit', parent_name='scatterpolar', **kwargs + ): + super(ThetaunitValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['radians', 'degrees', 'gradians'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_uid.py b/plotly/validators/scatterpolar/_uid.py new file mode 100644 index 0000000000..689c523fd2 --- /dev/null +++ b/plotly/validators/scatterpolar/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='scatterpolar', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_unselected.py b/plotly/validators/scatterpolar/_unselected.py new file mode 100644 index 0000000000..2b611e156b --- /dev/null +++ b/plotly/validators/scatterpolar/_unselected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scatterpolar', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scatterpolar.unselected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolar.unselected.Textf + ont instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/_visible.py b/plotly/validators/scatterpolar/_visible.py new file mode 100644 index 0000000000..54da111099 --- /dev/null +++ b/plotly/validators/scatterpolar/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatterpolar', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/__init__.py b/plotly/validators/scatterpolar/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterpolar/hoverlabel/_bgcolor.py b/plotly/validators/scatterpolar/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..4f47b725ad --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_bgcolorsrc.py b/plotly/validators/scatterpolar/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..de6210d32a --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_bordercolor.py b/plotly/validators/scatterpolar/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..0ec2734006 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_bordercolorsrc.py b/plotly/validators/scatterpolar/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..d7313d6859 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_font.py b/plotly/validators/scatterpolar/hoverlabel/_font.py new file mode 100644 index 0000000000..75ce39b2e9 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_namelength.py b/plotly/validators/scatterpolar/hoverlabel/_namelength.py new file mode 100644 index 0000000000..610410f602 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/_namelengthsrc.py b/plotly/validators/scatterpolar/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..6538c094de --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scatterpolar.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/__init__.py b/plotly/validators/scatterpolar/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_color.py b/plotly/validators/scatterpolar/hoverlabel/font/_color.py new file mode 100644 index 0000000000..737ef6dab8 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_colorsrc.py b/plotly/validators/scatterpolar/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..0fe7bf4ca5 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_family.py b/plotly/validators/scatterpolar/hoverlabel/font/_family.py new file mode 100644 index 0000000000..ff06b80e0a --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_familysrc.py b/plotly/validators/scatterpolar/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..5d63547fa7 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_size.py b/plotly/validators/scatterpolar/hoverlabel/font/_size.py new file mode 100644 index 0000000000..2eaf1cf852 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/hoverlabel/font/_sizesrc.py b/plotly/validators/scatterpolar/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..deb79cbca5 --- /dev/null +++ b/plotly/validators/scatterpolar/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterpolar.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/line/__init__.py b/plotly/validators/scatterpolar/line/__init__.py new file mode 100644 index 0000000000..633e654df0 --- /dev/null +++ b/plotly/validators/scatterpolar/line/__init__.py @@ -0,0 +1,5 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._shape import ShapeValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/line/_color.py b/plotly/validators/scatterpolar/line/_color.py new file mode 100644 index 0000000000..9ab7485d5e --- /dev/null +++ b/plotly/validators/scatterpolar/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatterpolar.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/line/_dash.py b/plotly/validators/scatterpolar/line/_dash.py new file mode 100644 index 0000000000..8e26b4f776 --- /dev/null +++ b/plotly/validators/scatterpolar/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='scatterpolar.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/line/_shape.py b/plotly/validators/scatterpolar/line/_shape.py new file mode 100644 index 0000000000..21d036649b --- /dev/null +++ b/plotly/validators/scatterpolar/line/_shape.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShapeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='shape', parent_name='scatterpolar.line', **kwargs + ): + super(ShapeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['linear', 'spline'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/line/_smoothing.py b/plotly/validators/scatterpolar/line/_smoothing.py new file mode 100644 index 0000000000..e5429b5a3c --- /dev/null +++ b/plotly/validators/scatterpolar/line/_smoothing.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='smoothing', + parent_name='scatterpolar.line', + **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/line/_width.py b/plotly/validators/scatterpolar/line/_width.py new file mode 100644 index 0000000000..0a4d41143a --- /dev/null +++ b/plotly/validators/scatterpolar/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatterpolar.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/__init__.py b/plotly/validators/scatterpolar/marker/__init__.py new file mode 100644 index 0000000000..7b7dcf37e9 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/__init__.py @@ -0,0 +1,22 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._maxdisplayed import MaxdisplayedValidator +from ._line import LineValidator +from ._gradient import GradientValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterpolar/marker/_autocolorscale.py b/plotly/validators/scatterpolar/marker/_autocolorscale.py new file mode 100644 index 0000000000..71d853c5fa --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterpolar.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_cauto.py b/plotly/validators/scatterpolar/marker/_cauto.py new file mode 100644 index 0000000000..6ac0dddee1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='scatterpolar.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_cmax.py b/plotly/validators/scatterpolar/marker/_cmax.py new file mode 100644 index 0000000000..a82ed20d57 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='scatterpolar.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_cmin.py b/plotly/validators/scatterpolar/marker/_cmin.py new file mode 100644 index 0000000000..1e27a87835 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='scatterpolar.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_color.py b/plotly/validators/scatterpolar/marker/_color.py new file mode 100644 index 0000000000..3957ec8e2e --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatterpolar.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatterpolar.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_colorbar.py b/plotly/validators/scatterpolar/marker/_colorbar.py new file mode 100644 index 0000000000..e672d60573 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scatterpolar.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolar.marker.colorbar. + Tickformatstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_colorscale.py b/plotly/validators/scatterpolar/marker/_colorscale.py new file mode 100644 index 0000000000..02ecb74311 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterpolar.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_colorsrc.py b/plotly/validators/scatterpolar/marker/_colorsrc.py new file mode 100644 index 0000000000..ff5a4b607d --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolar.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_gradient.py b/plotly/validators/scatterpolar/marker/_gradient.py new file mode 100644 index 0000000000..e68550aa86 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_gradient.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class GradientValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='gradient', + parent_name='scatterpolar.marker', + **kwargs + ): + super(GradientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Gradient', + data_docs=""" + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_line.py b/plotly/validators/scatterpolar/marker/_line.py new file mode 100644 index 0000000000..4160b6a778 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatterpolar.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_maxdisplayed.py b/plotly/validators/scatterpolar/marker/_maxdisplayed.py new file mode 100644 index 0000000000..1d3e9dcfdb --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_maxdisplayed.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MaxdisplayedValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxdisplayed', + parent_name='scatterpolar.marker', + **kwargs + ): + super(MaxdisplayedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_opacity.py b/plotly/validators/scatterpolar/marker/_opacity.py new file mode 100644 index 0000000000..323c808269 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_opacity.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolar.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_opacitysrc.py b/plotly/validators/scatterpolar/marker/_opacitysrc.py new file mode 100644 index 0000000000..a9d2de087e --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scatterpolar.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_reversescale.py b/plotly/validators/scatterpolar/marker/_reversescale.py new file mode 100644 index 0000000000..9d71e770fd --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterpolar.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_showscale.py b/plotly/validators/scatterpolar/marker/_showscale.py new file mode 100644 index 0000000000..1e3a8549e5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scatterpolar.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_size.py b/plotly/validators/scatterpolar/marker/_size.py new file mode 100644 index 0000000000..cd1205f1d1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='scatterpolar.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_sizemin.py b/plotly/validators/scatterpolar/marker/_sizemin.py new file mode 100644 index 0000000000..4c7ebfd552 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_sizemin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizemin', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_sizemode.py b/plotly/validators/scatterpolar/marker/_sizemode.py new file mode 100644 index 0000000000..e2f0cee28e --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_sizeref.py b/plotly/validators/scatterpolar/marker/_sizeref.py new file mode 100644 index 0000000000..94f94522fb --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_sizeref.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizeref', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_sizesrc.py b/plotly/validators/scatterpolar/marker/_sizesrc.py new file mode 100644 index 0000000000..1c522332b0 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_symbol.py b/plotly/validators/scatterpolar/marker/_symbol.py new file mode 100644 index 0000000000..a2e34e54e7 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_symbol.py @@ -0,0 +1,77 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/_symbolsrc.py b/plotly/validators/scatterpolar/marker/_symbolsrc.py new file mode 100644 index 0000000000..177370b05f --- /dev/null +++ b/plotly/validators/scatterpolar/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scatterpolar.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/__init__.py b/plotly/validators/scatterpolar/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterpolar/marker/colorbar/_bgcolor.py b/plotly/validators/scatterpolar/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..cdf9243fff --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_bordercolor.py b/plotly/validators/scatterpolar/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..2c155a381e --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_borderwidth.py b/plotly/validators/scatterpolar/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..2112f4bfb1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_dtick.py b/plotly/validators/scatterpolar/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..119422bc49 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_exponentformat.py b/plotly/validators/scatterpolar/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..79165b5534 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_len.py b/plotly/validators/scatterpolar/marker/colorbar/_len.py new file mode 100644 index 0000000000..e1f1bd06df --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_lenmode.py b/plotly/validators/scatterpolar/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..2f93377a5b --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_nticks.py b/plotly/validators/scatterpolar/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..0f940fb5ce --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_outlinecolor.py b/plotly/validators/scatterpolar/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..c6c5dbbbca --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_outlinewidth.py b/plotly/validators/scatterpolar/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..73337602f5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_separatethousands.py b/plotly/validators/scatterpolar/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..7067df8dc5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_showexponent.py b/plotly/validators/scatterpolar/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..1924a6e1a1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_showticklabels.py b/plotly/validators/scatterpolar/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..fde8b42f0e --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_showtickprefix.py b/plotly/validators/scatterpolar/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..794e55de4d --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_showticksuffix.py b/plotly/validators/scatterpolar/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..0cb53a4f4f --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_thickness.py b/plotly/validators/scatterpolar/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..8375689079 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_thicknessmode.py b/plotly/validators/scatterpolar/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..5e943d73ac --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tick0.py b/plotly/validators/scatterpolar/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..f14d0bdbd1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickangle.py b/plotly/validators/scatterpolar/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..1ab359641f --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickcolor.py b/plotly/validators/scatterpolar/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..e6ba7f8fad --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickfont.py b/plotly/validators/scatterpolar/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..9b8ae130f4 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickformat.py b/plotly/validators/scatterpolar/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..ae726890e3 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickformatstops.py b/plotly/validators/scatterpolar/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..f25eec3cad --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ticklen.py b/plotly/validators/scatterpolar/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..5e71f87de5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickmode.py b/plotly/validators/scatterpolar/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..6d1acadce1 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickprefix.py b/plotly/validators/scatterpolar/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..7b3b614d21 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ticks.py b/plotly/validators/scatterpolar/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..3e94e35a21 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ticksuffix.py b/plotly/validators/scatterpolar/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..bf3a3218cf --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ticktext.py b/plotly/validators/scatterpolar/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..de301a0de6 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ticktextsrc.py b/plotly/validators/scatterpolar/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..b551b1a4c7 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickvals.py b/plotly/validators/scatterpolar/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..17db4b3db9 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickvalssrc.py b/plotly/validators/scatterpolar/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..eb190f9924 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_tickwidth.py b/plotly/validators/scatterpolar/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..ecab5ab26c --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_title.py b/plotly/validators/scatterpolar/marker/colorbar/_title.py new file mode 100644 index 0000000000..9775b50556 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_titlefont.py b/plotly/validators/scatterpolar/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..8a4b4ef8cc --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_titleside.py b/plotly/validators/scatterpolar/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..6561445cdd --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_x.py b/plotly/validators/scatterpolar/marker/colorbar/_x.py new file mode 100644 index 0000000000..8ebb0f3f95 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_xanchor.py b/plotly/validators/scatterpolar/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..05842633a4 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_xpad.py b/plotly/validators/scatterpolar/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..544a29fef9 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_y.py b/plotly/validators/scatterpolar/marker/colorbar/_y.py new file mode 100644 index 0000000000..21338b4369 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_yanchor.py b/plotly/validators/scatterpolar/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..caabc55c4c --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/_ypad.py b/plotly/validators/scatterpolar/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..e16fb69bf8 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scatterpolar.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickfont/__init__.py b/plotly/validators/scatterpolar/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickfont/_color.py b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..770f923304 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickfont/_family.py b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..0f5e2710e5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolar.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickfont/_size.py b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..bb04274815 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..6c888f4489 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scatterpolar.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..50b50936f8 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scatterpolar.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/titlefont/__init__.py b/plotly/validators/scatterpolar/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/marker/colorbar/titlefont/_color.py b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..b270734bfb --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/titlefont/_family.py b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..28979f63cb --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolar.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/colorbar/titlefont/_size.py b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..f7d9050c64 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/gradient/__init__.py b/plotly/validators/scatterpolar/marker/gradient/__init__.py new file mode 100644 index 0000000000..434557c8fe --- /dev/null +++ b/plotly/validators/scatterpolar/marker/gradient/__init__.py @@ -0,0 +1,4 @@ +from ._typesrc import TypesrcValidator +from ._type import TypeValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/marker/gradient/_color.py b/plotly/validators/scatterpolar/marker/gradient/_color.py new file mode 100644 index 0000000000..40376f6eb2 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/gradient/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.marker.gradient', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/gradient/_colorsrc.py b/plotly/validators/scatterpolar/marker/gradient/_colorsrc.py new file mode 100644 index 0000000000..da5a73559f --- /dev/null +++ b/plotly/validators/scatterpolar/marker/gradient/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolar.marker.gradient', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/gradient/_type.py b/plotly/validators/scatterpolar/marker/gradient/_type.py new file mode 100644 index 0000000000..ff9734f779 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/gradient/_type.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='scatterpolar.marker.gradient', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['radial', 'horizontal', 'vertical', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/gradient/_typesrc.py b/plotly/validators/scatterpolar/marker/gradient/_typesrc.py new file mode 100644 index 0000000000..eda3f088ab --- /dev/null +++ b/plotly/validators/scatterpolar/marker/gradient/_typesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TypesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='typesrc', + parent_name='scatterpolar.marker.gradient', + **kwargs + ): + super(TypesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/__init__.py b/plotly/validators/scatterpolar/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterpolar/marker/line/_autocolorscale.py b/plotly/validators/scatterpolar/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..aea24ce29a --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_cauto.py b/plotly/validators/scatterpolar/marker/line/_cauto.py new file mode 100644 index 0000000000..dc587e38b5 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_cmax.py b/plotly/validators/scatterpolar/marker/line/_cmax.py new file mode 100644 index 0000000000..e83b7d3de2 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_cmin.py b/plotly/validators/scatterpolar/marker/line/_cmin.py new file mode 100644 index 0000000000..500c996b6d --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_color.py b/plotly/validators/scatterpolar/marker/line/_color.py new file mode 100644 index 0000000000..679e3d9cdb --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatterpolar.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_colorscale.py b/plotly/validators/scatterpolar/marker/line/_colorscale.py new file mode 100644 index 0000000000..16a39b1583 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_colorsrc.py b/plotly/validators/scatterpolar/marker/line/_colorsrc.py new file mode 100644 index 0000000000..b6d9f89f67 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_reversescale.py b/plotly/validators/scatterpolar/marker/line/_reversescale.py new file mode 100644 index 0000000000..1aff916be9 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_width.py b/plotly/validators/scatterpolar/marker/line/_width.py new file mode 100644 index 0000000000..ef1bf5083c --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/marker/line/_widthsrc.py b/plotly/validators/scatterpolar/marker/line/_widthsrc.py new file mode 100644 index 0000000000..a84bde6d00 --- /dev/null +++ b/plotly/validators/scatterpolar/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scatterpolar.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/__init__.py b/plotly/validators/scatterpolar/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterpolar/selected/_marker.py b/plotly/validators/scatterpolar/selected/_marker.py new file mode 100644 index 0000000000..40138e4875 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterpolar.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/_textfont.py b/plotly/validators/scatterpolar/selected/_textfont.py new file mode 100644 index 0000000000..30aeb59e81 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterpolar.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/marker/__init__.py b/plotly/validators/scatterpolar/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/selected/marker/_color.py b/plotly/validators/scatterpolar/selected/marker/_color.py new file mode 100644 index 0000000000..93b386fc80 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/marker/_opacity.py b/plotly/validators/scatterpolar/selected/marker/_opacity.py new file mode 100644 index 0000000000..bec789f5e1 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolar.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/marker/_size.py b/plotly/validators/scatterpolar/selected/marker/_size.py new file mode 100644 index 0000000000..78de46d46e --- /dev/null +++ b/plotly/validators/scatterpolar/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/selected/textfont/__init__.py b/plotly/validators/scatterpolar/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterpolar/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/selected/textfont/_color.py b/plotly/validators/scatterpolar/selected/textfont/_color.py new file mode 100644 index 0000000000..f44f28429d --- /dev/null +++ b/plotly/validators/scatterpolar/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/stream/__init__.py b/plotly/validators/scatterpolar/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scatterpolar/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scatterpolar/stream/_maxpoints.py b/plotly/validators/scatterpolar/stream/_maxpoints.py new file mode 100644 index 0000000000..735ae9c8f5 --- /dev/null +++ b/plotly/validators/scatterpolar/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scatterpolar.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/stream/_token.py b/plotly/validators/scatterpolar/stream/_token.py new file mode 100644 index 0000000000..5ee0851e29 --- /dev/null +++ b/plotly/validators/scatterpolar/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='scatterpolar.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/__init__.py b/plotly/validators/scatterpolar/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/textfont/_color.py b/plotly/validators/scatterpolar/textfont/_color.py new file mode 100644 index 0000000000..edf453f8eb --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/_colorsrc.py b/plotly/validators/scatterpolar/textfont/_colorsrc.py new file mode 100644 index 0000000000..1d387fabbe --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/_family.py b/plotly/validators/scatterpolar/textfont/_family.py new file mode 100644 index 0000000000..aeda10e525 --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/_familysrc.py b/plotly/validators/scatterpolar/textfont/_familysrc.py new file mode 100644 index 0000000000..1eb625a033 --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/_size.py b/plotly/validators/scatterpolar/textfont/_size.py new file mode 100644 index 0000000000..75a3d8b0a4 --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/textfont/_sizesrc.py b/plotly/validators/scatterpolar/textfont/_sizesrc.py new file mode 100644 index 0000000000..cdfbc57af2 --- /dev/null +++ b/plotly/validators/scatterpolar/textfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterpolar.textfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/__init__.py b/plotly/validators/scatterpolar/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterpolar/unselected/_marker.py b/plotly/validators/scatterpolar/unselected/_marker.py new file mode 100644 index 0000000000..e952da46d0 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterpolar.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/_textfont.py b/plotly/validators/scatterpolar/unselected/_textfont.py new file mode 100644 index 0000000000..95b6f7c7e2 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterpolar.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/marker/__init__.py b/plotly/validators/scatterpolar/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/unselected/marker/_color.py b/plotly/validators/scatterpolar/unselected/marker/_color.py new file mode 100644 index 0000000000..c682c8ace6 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/marker/_opacity.py b/plotly/validators/scatterpolar/unselected/marker/_opacity.py new file mode 100644 index 0000000000..ccc33f230c --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolar.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/marker/_size.py b/plotly/validators/scatterpolar/unselected/marker/_size.py new file mode 100644 index 0000000000..6d0db51af8 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolar.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolar/unselected/textfont/__init__.py b/plotly/validators/scatterpolar/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolar/unselected/textfont/_color.py b/plotly/validators/scatterpolar/unselected/textfont/_color.py new file mode 100644 index 0000000000..61186c51b3 --- /dev/null +++ b/plotly/validators/scatterpolar/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolar.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/__init__.py b/plotly/validators/scatterpolargl/__init__.py new file mode 100644 index 0000000000..ca20fdc223 --- /dev/null +++ b/plotly/validators/scatterpolargl/__init__.py @@ -0,0 +1,32 @@ +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._thetaunit import ThetaunitValidator +from ._thetasrc import ThetasrcValidator +from ._theta import ThetaValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._subplot import SubplotValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._rsrc import RsrcValidator +from ._r import RValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._connectgaps import ConnectgapsValidator diff --git a/plotly/validators/scatterpolargl/_connectgaps.py b/plotly/validators/scatterpolargl/_connectgaps.py new file mode 100644 index 0000000000..e19de447ae --- /dev/null +++ b/plotly/validators/scatterpolargl/_connectgaps.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='connectgaps', + parent_name='scatterpolargl', + **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_customdata.py b/plotly/validators/scatterpolargl/_customdata.py new file mode 100644 index 0000000000..c4049277f1 --- /dev/null +++ b/plotly/validators/scatterpolargl/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scatterpolargl', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_customdatasrc.py b/plotly/validators/scatterpolargl/_customdatasrc.py new file mode 100644 index 0000000000..79437319d9 --- /dev/null +++ b/plotly/validators/scatterpolargl/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='scatterpolargl', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_fill.py b/plotly/validators/scatterpolargl/_fill.py new file mode 100644 index 0000000000..2de6eb4fcf --- /dev/null +++ b/plotly/validators/scatterpolargl/_fill.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='fill', parent_name='scatterpolargl', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'none', 'tozeroy', 'tozerox', 'tonexty', 'tonextx', 'toself', + 'tonext' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_fillcolor.py b/plotly/validators/scatterpolargl/_fillcolor.py new file mode 100644 index 0000000000..f1492884ae --- /dev/null +++ b/plotly/validators/scatterpolargl/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scatterpolargl', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_hoverinfo.py b/plotly/validators/scatterpolargl/_hoverinfo.py new file mode 100644 index 0000000000..238299d25f --- /dev/null +++ b/plotly/validators/scatterpolargl/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scatterpolargl', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['r', 'theta', 'text', 'name', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_hoverinfosrc.py b/plotly/validators/scatterpolargl/_hoverinfosrc.py new file mode 100644 index 0000000000..1bb1979425 --- /dev/null +++ b/plotly/validators/scatterpolargl/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='scatterpolargl', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_hoverlabel.py b/plotly/validators/scatterpolargl/_hoverlabel.py new file mode 100644 index 0000000000..89fe6d62a2 --- /dev/null +++ b/plotly/validators/scatterpolargl/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scatterpolargl', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_hoveron.py b/plotly/validators/scatterpolargl/_hoveron.py new file mode 100644 index 0000000000..260de9ecc0 --- /dev/null +++ b/plotly/validators/scatterpolargl/_hoveron.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoveron', parent_name='scatterpolargl', **kwargs + ): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_ids.py b/plotly/validators/scatterpolargl/_ids.py new file mode 100644 index 0000000000..29c7c12b2c --- /dev/null +++ b/plotly/validators/scatterpolargl/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='scatterpolargl', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_idssrc.py b/plotly/validators/scatterpolargl/_idssrc.py new file mode 100644 index 0000000000..b53f9b199e --- /dev/null +++ b/plotly/validators/scatterpolargl/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scatterpolargl', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_legendgroup.py b/plotly/validators/scatterpolargl/_legendgroup.py new file mode 100644 index 0000000000..d2d4a2ba40 --- /dev/null +++ b/plotly/validators/scatterpolargl/_legendgroup.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='legendgroup', + parent_name='scatterpolargl', + **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_line.py b/plotly/validators/scatterpolargl/_line.py new file mode 100644 index 0000000000..4673480dac --- /dev/null +++ b/plotly/validators/scatterpolargl/_line.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatterpolargl', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the style of the lines. + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_marker.py b/plotly/validators/scatterpolargl/_marker.py new file mode 100644 index 0000000000..6d35897ed9 --- /dev/null +++ b/plotly/validators/scatterpolargl/_marker.py @@ -0,0 +1,120 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatterpolargl', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterpolargl.marker.ColorBa + r instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.scatterpolargl.marker.Line + instance or dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_mode.py b/plotly/validators/scatterpolargl/_mode.py new file mode 100644 index 0000000000..758599be50 --- /dev/null +++ b/plotly/validators/scatterpolargl/_mode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='mode', parent_name='scatterpolargl', **kwargs + ): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_name.py b/plotly/validators/scatterpolargl/_name.py new file mode 100644 index 0000000000..5d67f0fe0d --- /dev/null +++ b/plotly/validators/scatterpolargl/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='scatterpolargl', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_opacity.py b/plotly/validators/scatterpolargl/_opacity.py new file mode 100644 index 0000000000..aaffae0feb --- /dev/null +++ b/plotly/validators/scatterpolargl/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatterpolargl', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_r.py b/plotly/validators/scatterpolargl/_r.py new file mode 100644 index 0000000000..4111321682 --- /dev/null +++ b/plotly/validators/scatterpolargl/_r.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='r', parent_name='scatterpolargl', **kwargs + ): + super(RValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_rsrc.py b/plotly/validators/scatterpolargl/_rsrc.py new file mode 100644 index 0000000000..096476a047 --- /dev/null +++ b/plotly/validators/scatterpolargl/_rsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class RsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='rsrc', parent_name='scatterpolargl', **kwargs + ): + super(RsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_selected.py b/plotly/validators/scatterpolargl/_selected.py new file mode 100644 index 0000000000..155b0914fe --- /dev/null +++ b/plotly/validators/scatterpolargl/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scatterpolargl', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scatterpolargl.selected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.selected.Textf + ont instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_selectedpoints.py b/plotly/validators/scatterpolargl/_selectedpoints.py new file mode 100644 index 0000000000..a1a26ca00d --- /dev/null +++ b/plotly/validators/scatterpolargl/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='scatterpolargl', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_showlegend.py b/plotly/validators/scatterpolargl/_showlegend.py new file mode 100644 index 0000000000..3a6a6697f4 --- /dev/null +++ b/plotly/validators/scatterpolargl/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scatterpolargl', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_stream.py b/plotly/validators/scatterpolargl/_stream.py new file mode 100644 index 0000000000..c693b71149 --- /dev/null +++ b/plotly/validators/scatterpolargl/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scatterpolargl', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_subplot.py b/plotly/validators/scatterpolargl/_subplot.py new file mode 100644 index 0000000000..9283a3c57f --- /dev/null +++ b/plotly/validators/scatterpolargl/_subplot.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SubplotValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='subplot', parent_name='scatterpolargl', **kwargs + ): + super(SubplotValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='polar', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_text.py b/plotly/validators/scatterpolargl/_text.py new file mode 100644 index 0000000000..62c5fd4af4 --- /dev/null +++ b/plotly/validators/scatterpolargl/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='scatterpolargl', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_textsrc.py b/plotly/validators/scatterpolargl/_textsrc.py new file mode 100644 index 0000000000..e80da922d7 --- /dev/null +++ b/plotly/validators/scatterpolargl/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scatterpolargl', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_theta.py b/plotly/validators/scatterpolargl/_theta.py new file mode 100644 index 0000000000..dcf3d5ea62 --- /dev/null +++ b/plotly/validators/scatterpolargl/_theta.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ThetaValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='theta', parent_name='scatterpolargl', **kwargs + ): + super(ThetaValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_thetasrc.py b/plotly/validators/scatterpolargl/_thetasrc.py new file mode 100644 index 0000000000..19e4a3eb46 --- /dev/null +++ b/plotly/validators/scatterpolargl/_thetasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ThetasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='thetasrc', parent_name='scatterpolargl', **kwargs + ): + super(ThetasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_thetaunit.py b/plotly/validators/scatterpolargl/_thetaunit.py new file mode 100644 index 0000000000..cf4b06c6f2 --- /dev/null +++ b/plotly/validators/scatterpolargl/_thetaunit.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ThetaunitValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='thetaunit', parent_name='scatterpolargl', **kwargs + ): + super(ThetaunitValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + values=['radians', 'degrees', 'gradians'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_uid.py b/plotly/validators/scatterpolargl/_uid.py new file mode 100644 index 0000000000..fc916fd2d8 --- /dev/null +++ b/plotly/validators/scatterpolargl/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='scatterpolargl', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_unselected.py b/plotly/validators/scatterpolargl/_unselected.py new file mode 100644 index 0000000000..e0f04b0503 --- /dev/null +++ b/plotly/validators/scatterpolargl/_unselected.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scatterpolargl', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scatterpolargl.unselected.Mar + ker instance or dict with compatible properties + textfont + plotly.graph_objs.scatterpolargl.unselected.Tex + tfont instance or dict with compatible + properties""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/_visible.py b/plotly/validators/scatterpolargl/_visible.py new file mode 100644 index 0000000000..1bdc0f544a --- /dev/null +++ b/plotly/validators/scatterpolargl/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatterpolargl', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/__init__.py b/plotly/validators/scatterpolargl/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterpolargl/hoverlabel/_bgcolor.py b/plotly/validators/scatterpolargl/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..05e9c681d8 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_bgcolorsrc.py b/plotly/validators/scatterpolargl/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..4b3b17b44c --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_bordercolor.py b/plotly/validators/scatterpolargl/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..0a29cdf628 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_bordercolorsrc.py b/plotly/validators/scatterpolargl/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..9829f9ded1 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_font.py b/plotly/validators/scatterpolargl/hoverlabel/_font.py new file mode 100644 index 0000000000..33110e2f5d --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_namelength.py b/plotly/validators/scatterpolargl/hoverlabel/_namelength.py new file mode 100644 index 0000000000..26a88cc2eb --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/_namelengthsrc.py b/plotly/validators/scatterpolargl/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..3f1a8bd554 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scatterpolargl.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/__init__.py b/plotly/validators/scatterpolargl/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_color.py b/plotly/validators/scatterpolargl/hoverlabel/font/_color.py new file mode 100644 index 0000000000..fcc0ea4494 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_colorsrc.py b/plotly/validators/scatterpolargl/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..cb2f8600fd --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_family.py b/plotly/validators/scatterpolargl/hoverlabel/font/_family.py new file mode 100644 index 0000000000..45785d3b02 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_familysrc.py b/plotly/validators/scatterpolargl/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..bcc8bcac2d --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_size.py b/plotly/validators/scatterpolargl/hoverlabel/font/_size.py new file mode 100644 index 0000000000..3a0af237c8 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/hoverlabel/font/_sizesrc.py b/plotly/validators/scatterpolargl/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..07b0c087f2 --- /dev/null +++ b/plotly/validators/scatterpolargl/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterpolargl.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/line/__init__.py b/plotly/validators/scatterpolargl/line/__init__.py new file mode 100644 index 0000000000..d027d05e06 --- /dev/null +++ b/plotly/validators/scatterpolargl/line/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/line/_color.py b/plotly/validators/scatterpolargl/line/_color.py new file mode 100644 index 0000000000..ec116df40d --- /dev/null +++ b/plotly/validators/scatterpolargl/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatterpolargl.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/line/_dash.py b/plotly/validators/scatterpolargl/line/_dash.py new file mode 100644 index 0000000000..24fd016961 --- /dev/null +++ b/plotly/validators/scatterpolargl/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='dash', parent_name='scatterpolargl.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/line/_width.py b/plotly/validators/scatterpolargl/line/_width.py new file mode 100644 index 0000000000..56fea27fc5 --- /dev/null +++ b/plotly/validators/scatterpolargl/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatterpolargl.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/__init__.py b/plotly/validators/scatterpolargl/marker/__init__.py new file mode 100644 index 0000000000..254b91a979 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/__init__.py @@ -0,0 +1,20 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterpolargl/marker/_autocolorscale.py b/plotly/validators/scatterpolargl/marker/_autocolorscale.py new file mode 100644 index 0000000000..8897887220 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_cauto.py b/plotly/validators/scatterpolargl/marker/_cauto.py new file mode 100644 index 0000000000..1a613d5fc8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_cmax.py b/plotly/validators/scatterpolargl/marker/_cmax.py new file mode 100644 index 0000000000..633efe4820 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_cmin.py b/plotly/validators/scatterpolargl/marker/_cmin.py new file mode 100644 index 0000000000..bda52165a3 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_color.py b/plotly/validators/scatterpolargl/marker/_color.py new file mode 100644 index 0000000000..4cfc58b7a0 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scatterpolargl.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_colorbar.py b/plotly/validators/scatterpolargl/marker/_colorbar.py new file mode 100644 index 0000000000..ad93bbd2dd --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterpolargl.marker.colorba + r.Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_colorscale.py b/plotly/validators/scatterpolargl/marker/_colorscale.py new file mode 100644 index 0000000000..8bca8aa538 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_colorsrc.py b/plotly/validators/scatterpolargl/marker/_colorsrc.py new file mode 100644 index 0000000000..21f1c852a7 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_line.py b/plotly/validators/scatterpolargl/marker/_line.py new file mode 100644 index 0000000000..36c0f12ad4 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_line.py @@ -0,0 +1,87 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='line', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_opacity.py b/plotly/validators/scatterpolargl/marker/_opacity.py new file mode 100644 index 0000000000..516075baa0 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_opacity.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_opacitysrc.py b/plotly/validators/scatterpolargl/marker/_opacitysrc.py new file mode 100644 index 0000000000..f78032b424 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_reversescale.py b/plotly/validators/scatterpolargl/marker/_reversescale.py new file mode 100644 index 0000000000..8af0be23d5 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_showscale.py b/plotly/validators/scatterpolargl/marker/_showscale.py new file mode 100644 index 0000000000..d6bf4541c8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_size.py b/plotly/validators/scatterpolargl/marker/_size.py new file mode 100644 index 0000000000..967db93879 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_sizemin.py b/plotly/validators/scatterpolargl/marker/_sizemin.py new file mode 100644 index 0000000000..fb0c0a0647 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_sizemin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizemin', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_sizemode.py b/plotly/validators/scatterpolargl/marker/_sizemode.py new file mode 100644 index 0000000000..98fb0fd054 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_sizeref.py b/plotly/validators/scatterpolargl/marker/_sizeref.py new file mode 100644 index 0000000000..0a4e2f9af8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_sizeref.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizeref', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_sizesrc.py b/plotly/validators/scatterpolargl/marker/_sizesrc.py new file mode 100644 index 0000000000..79f78b9ab1 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_symbol.py b/plotly/validators/scatterpolargl/marker/_symbol.py new file mode 100644 index 0000000000..47e8d30052 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_symbol.py @@ -0,0 +1,77 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/_symbolsrc.py b/plotly/validators/scatterpolargl/marker/_symbolsrc.py new file mode 100644 index 0000000000..b314fe4b05 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scatterpolargl.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/__init__.py b/plotly/validators/scatterpolargl/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_bgcolor.py b/plotly/validators/scatterpolargl/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..3a617cb39f --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_bordercolor.py b/plotly/validators/scatterpolargl/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..94e85bbbd6 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_borderwidth.py b/plotly/validators/scatterpolargl/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..7678285c41 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_dtick.py b/plotly/validators/scatterpolargl/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..c77c2d6c03 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_exponentformat.py b/plotly/validators/scatterpolargl/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..ecf5a13995 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_len.py b/plotly/validators/scatterpolargl/marker/colorbar/_len.py new file mode 100644 index 0000000000..2d0b1d80b9 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_lenmode.py b/plotly/validators/scatterpolargl/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..f16cf5976c --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_nticks.py b/plotly/validators/scatterpolargl/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..57c68a540b --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_outlinecolor.py b/plotly/validators/scatterpolargl/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..2ae7697843 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_outlinewidth.py b/plotly/validators/scatterpolargl/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..49c0b57072 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_separatethousands.py b/plotly/validators/scatterpolargl/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..4337d0d4ce --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_showexponent.py b/plotly/validators/scatterpolargl/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..cfe9a4cf61 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_showticklabels.py b/plotly/validators/scatterpolargl/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..327a0be566 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_showtickprefix.py b/plotly/validators/scatterpolargl/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..4bc3457995 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_showticksuffix.py b/plotly/validators/scatterpolargl/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..377e30b87a --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_thickness.py b/plotly/validators/scatterpolargl/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..6abca0525e --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_thicknessmode.py b/plotly/validators/scatterpolargl/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..04cb0917de --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tick0.py b/plotly/validators/scatterpolargl/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..42c0895d6b --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickangle.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..18234d5267 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickcolor.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..df9b041d08 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickfont.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..f2acc9e0b8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickformat.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..c60353144c --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickformatstops.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..350badef87 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ticklen.py b/plotly/validators/scatterpolargl/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..0efe35aa48 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickmode.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..3d66b45e8d --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickprefix.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..4386a32865 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ticks.py b/plotly/validators/scatterpolargl/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..cbb3d62ea4 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ticksuffix.py b/plotly/validators/scatterpolargl/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..0896976839 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ticktext.py b/plotly/validators/scatterpolargl/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..73bb87a0d9 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ticktextsrc.py b/plotly/validators/scatterpolargl/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..4a5ab9bac8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickvals.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..330620a6d1 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickvalssrc.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..d802d71ff0 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_tickwidth.py b/plotly/validators/scatterpolargl/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..53ee4c9f6b --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_title.py b/plotly/validators/scatterpolargl/marker/colorbar/_title.py new file mode 100644 index 0000000000..6271a639a0 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_titlefont.py b/plotly/validators/scatterpolargl/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..b01b37f7ee --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_titleside.py b/plotly/validators/scatterpolargl/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..c1be1f5012 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_x.py b/plotly/validators/scatterpolargl/marker/colorbar/_x.py new file mode 100644 index 0000000000..5c4632544a --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_xanchor.py b/plotly/validators/scatterpolargl/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..4ff328ed62 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_xpad.py b/plotly/validators/scatterpolargl/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..2ed828f119 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_y.py b/plotly/validators/scatterpolargl/marker/colorbar/_y.py new file mode 100644 index 0000000000..27ca4e18d8 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_yanchor.py b/plotly/validators/scatterpolargl/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..1a6aadfd9f --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/_ypad.py b/plotly/validators/scatterpolargl/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..1c074bcd91 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scatterpolargl.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickfont/__init__.py b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_color.py b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..12b5b39f87 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_family.py b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..a3b4b17e63 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolargl.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_size.py b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..cd8b2dd830 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..861977553f --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scatterpolargl.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..3b611c3cbc --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scatterpolargl.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/titlefont/__init__.py b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_color.py b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..ba93f7ccdd --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_family.py b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..da6f416420 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterpolargl.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_size.py b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..b90114547a --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/__init__.py b/plotly/validators/scatterpolargl/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterpolargl/marker/line/_autocolorscale.py b/plotly/validators/scatterpolargl/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..34ac44c9b1 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_cauto.py b/plotly/validators/scatterpolargl/marker/line/_cauto.py new file mode 100644 index 0000000000..77df469a02 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_cmax.py b/plotly/validators/scatterpolargl/marker/line/_cmax.py new file mode 100644 index 0000000000..80396d44e5 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_cmin.py b/plotly/validators/scatterpolargl/marker/line/_cmin.py new file mode 100644 index 0000000000..7c4f20cbc7 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_color.py b/plotly/validators/scatterpolargl/marker/line/_color.py new file mode 100644 index 0000000000..269ddc21d1 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='scatterpolargl.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_colorscale.py b/plotly/validators/scatterpolargl/marker/line/_colorscale.py new file mode 100644 index 0000000000..c667d672a6 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_colorsrc.py b/plotly/validators/scatterpolargl/marker/line/_colorsrc.py new file mode 100644 index 0000000000..c72e35de4d --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_reversescale.py b/plotly/validators/scatterpolargl/marker/line/_reversescale.py new file mode 100644 index 0000000000..3add7133b3 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_width.py b/plotly/validators/scatterpolargl/marker/line/_width.py new file mode 100644 index 0000000000..53d7643b86 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/marker/line/_widthsrc.py b/plotly/validators/scatterpolargl/marker/line/_widthsrc.py new file mode 100644 index 0000000000..d00d4054a3 --- /dev/null +++ b/plotly/validators/scatterpolargl/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scatterpolargl.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/__init__.py b/plotly/validators/scatterpolargl/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterpolargl/selected/_marker.py b/plotly/validators/scatterpolargl/selected/_marker.py new file mode 100644 index 0000000000..bb9186b2f1 --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterpolargl.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/_textfont.py b/plotly/validators/scatterpolargl/selected/_textfont.py new file mode 100644 index 0000000000..55095b0ab5 --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterpolargl.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/marker/__init__.py b/plotly/validators/scatterpolargl/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/selected/marker/_color.py b/plotly/validators/scatterpolargl/selected/marker/_color.py new file mode 100644 index 0000000000..5fa4576f6e --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/marker/_opacity.py b/plotly/validators/scatterpolargl/selected/marker/_opacity.py new file mode 100644 index 0000000000..c39fe3526e --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolargl.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/marker/_size.py b/plotly/validators/scatterpolargl/selected/marker/_size.py new file mode 100644 index 0000000000..3e04b38e1d --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/selected/textfont/__init__.py b/plotly/validators/scatterpolargl/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/selected/textfont/_color.py b/plotly/validators/scatterpolargl/selected/textfont/_color.py new file mode 100644 index 0000000000..89def0a84f --- /dev/null +++ b/plotly/validators/scatterpolargl/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/stream/__init__.py b/plotly/validators/scatterpolargl/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scatterpolargl/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scatterpolargl/stream/_maxpoints.py b/plotly/validators/scatterpolargl/stream/_maxpoints.py new file mode 100644 index 0000000000..009ecf7655 --- /dev/null +++ b/plotly/validators/scatterpolargl/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scatterpolargl.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/stream/_token.py b/plotly/validators/scatterpolargl/stream/_token.py new file mode 100644 index 0000000000..bdd6ddf5ff --- /dev/null +++ b/plotly/validators/scatterpolargl/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='scatterpolargl.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/__init__.py b/plotly/validators/scatterpolargl/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterpolargl/unselected/_marker.py b/plotly/validators/scatterpolargl/unselected/_marker.py new file mode 100644 index 0000000000..24896d863e --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterpolargl.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/_textfont.py b/plotly/validators/scatterpolargl/unselected/_textfont.py new file mode 100644 index 0000000000..1c7af22788 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterpolargl.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/marker/__init__.py b/plotly/validators/scatterpolargl/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/unselected/marker/_color.py b/plotly/validators/scatterpolargl/unselected/marker/_color.py new file mode 100644 index 0000000000..92a980fc2a --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/marker/_opacity.py b/plotly/validators/scatterpolargl/unselected/marker/_opacity.py new file mode 100644 index 0000000000..3cb2d6a245 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterpolargl.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/marker/_size.py b/plotly/validators/scatterpolargl/unselected/marker/_size.py new file mode 100644 index 0000000000..e99c33326e --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterpolargl.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterpolargl/unselected/textfont/__init__.py b/plotly/validators/scatterpolargl/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterpolargl/unselected/textfont/_color.py b/plotly/validators/scatterpolargl/unselected/textfont/_color.py new file mode 100644 index 0000000000..162f0e8ff7 --- /dev/null +++ b/plotly/validators/scatterpolargl/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterpolargl.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/__init__.py b/plotly/validators/scatterternary/__init__.py new file mode 100644 index 0000000000..7b5bd412dc --- /dev/null +++ b/plotly/validators/scatterternary/__init__.py @@ -0,0 +1,40 @@ +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._textpositionsrc import TextpositionsrcValidator +from ._textposition import TextpositionValidator +from ._textfont import TextfontValidator +from ._text import TextValidator +from ._sum import SumValidator +from ._subplot import SubplotValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._mode import ModeValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hovertextsrc import HovertextsrcValidator +from ._hovertext import HovertextValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._fill import FillValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._csrc import CsrcValidator +from ._connectgaps import ConnectgapsValidator +from ._cliponaxis import CliponaxisValidator +from ._c import CValidator +from ._bsrc import BsrcValidator +from ._b import BValidator +from ._asrc import AsrcValidator +from ._a import AValidator diff --git a/plotly/validators/scatterternary/_a.py b/plotly/validators/scatterternary/_a.py new file mode 100644 index 0000000000..4e1e40c1d5 --- /dev/null +++ b/plotly/validators/scatterternary/_a.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='a', parent_name='scatterternary', **kwargs + ): + super(AValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_asrc.py b/plotly/validators/scatterternary/_asrc.py new file mode 100644 index 0000000000..85e71e5f1a --- /dev/null +++ b/plotly/validators/scatterternary/_asrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='asrc', parent_name='scatterternary', **kwargs + ): + super(AsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_b.py b/plotly/validators/scatterternary/_b.py new file mode 100644 index 0000000000..205a933f22 --- /dev/null +++ b/plotly/validators/scatterternary/_b.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='b', parent_name='scatterternary', **kwargs + ): + super(BValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_bsrc.py b/plotly/validators/scatterternary/_bsrc.py new file mode 100644 index 0000000000..316f786bd9 --- /dev/null +++ b/plotly/validators/scatterternary/_bsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='bsrc', parent_name='scatterternary', **kwargs + ): + super(BsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_c.py b/plotly/validators/scatterternary/_c.py new file mode 100644 index 0000000000..8ffddb7ef2 --- /dev/null +++ b/plotly/validators/scatterternary/_c.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='c', parent_name='scatterternary', **kwargs + ): + super(CValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_cliponaxis.py b/plotly/validators/scatterternary/_cliponaxis.py new file mode 100644 index 0000000000..d52478d5b0 --- /dev/null +++ b/plotly/validators/scatterternary/_cliponaxis.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CliponaxisValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cliponaxis', parent_name='scatterternary', **kwargs + ): + super(CliponaxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_connectgaps.py b/plotly/validators/scatterternary/_connectgaps.py new file mode 100644 index 0000000000..82c2f78fae --- /dev/null +++ b/plotly/validators/scatterternary/_connectgaps.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ConnectgapsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='connectgaps', + parent_name='scatterternary', + **kwargs + ): + super(ConnectgapsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_csrc.py b/plotly/validators/scatterternary/_csrc.py new file mode 100644 index 0000000000..6cf28bb644 --- /dev/null +++ b/plotly/validators/scatterternary/_csrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='csrc', parent_name='scatterternary', **kwargs + ): + super(CsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_customdata.py b/plotly/validators/scatterternary/_customdata.py new file mode 100644 index 0000000000..2c27b1be5b --- /dev/null +++ b/plotly/validators/scatterternary/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='scatterternary', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_customdatasrc.py b/plotly/validators/scatterternary/_customdatasrc.py new file mode 100644 index 0000000000..8aafd32939 --- /dev/null +++ b/plotly/validators/scatterternary/_customdatasrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='customdatasrc', + parent_name='scatterternary', + **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_fill.py b/plotly/validators/scatterternary/_fill.py new file mode 100644 index 0000000000..5a234d8c3b --- /dev/null +++ b/plotly/validators/scatterternary/_fill.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='fill', parent_name='scatterternary', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'toself', 'tonext'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/_fillcolor.py b/plotly/validators/scatterternary/_fillcolor.py new file mode 100644 index 0000000000..f7360083f0 --- /dev/null +++ b/plotly/validators/scatterternary/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='scatterternary', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hoverinfo.py b/plotly/validators/scatterternary/_hoverinfo.py new file mode 100644 index 0000000000..fa3be03f66 --- /dev/null +++ b/plotly/validators/scatterternary/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='scatterternary', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['a', 'b', 'c', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hoverinfosrc.py b/plotly/validators/scatterternary/_hoverinfosrc.py new file mode 100644 index 0000000000..92a52e07f3 --- /dev/null +++ b/plotly/validators/scatterternary/_hoverinfosrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hoverinfosrc', + parent_name='scatterternary', + **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hoverlabel.py b/plotly/validators/scatterternary/_hoverlabel.py new file mode 100644 index 0000000000..49acfdd29f --- /dev/null +++ b/plotly/validators/scatterternary/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='scatterternary', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hoveron.py b/plotly/validators/scatterternary/_hoveron.py new file mode 100644 index 0000000000..a476c49c2c --- /dev/null +++ b/plotly/validators/scatterternary/_hoveron.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoveron', parent_name='scatterternary', **kwargs + ): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + flags=['points', 'fills'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hovertext.py b/plotly/validators/scatterternary/_hovertext.py new file mode 100644 index 0000000000..1a6d4b45e6 --- /dev/null +++ b/plotly/validators/scatterternary/_hovertext.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HovertextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='hovertext', parent_name='scatterternary', **kwargs + ): + super(HovertextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_hovertextsrc.py b/plotly/validators/scatterternary/_hovertextsrc.py new file mode 100644 index 0000000000..47d3610948 --- /dev/null +++ b/plotly/validators/scatterternary/_hovertextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HovertextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='hovertextsrc', + parent_name='scatterternary', + **kwargs + ): + super(HovertextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_ids.py b/plotly/validators/scatterternary/_ids.py new file mode 100644 index 0000000000..26046cb776 --- /dev/null +++ b/plotly/validators/scatterternary/_ids.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ids', parent_name='scatterternary', **kwargs + ): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_idssrc.py b/plotly/validators/scatterternary/_idssrc.py new file mode 100644 index 0000000000..e44247ca35 --- /dev/null +++ b/plotly/validators/scatterternary/_idssrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='idssrc', parent_name='scatterternary', **kwargs + ): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_legendgroup.py b/plotly/validators/scatterternary/_legendgroup.py new file mode 100644 index 0000000000..6c037fb480 --- /dev/null +++ b/plotly/validators/scatterternary/_legendgroup.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='legendgroup', + parent_name='scatterternary', + **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_line.py b/plotly/validators/scatterternary/_line.py new file mode 100644 index 0000000000..de67a4bdee --- /dev/null +++ b/plotly/validators/scatterternary/_line.py @@ -0,0 +1,34 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='scatterternary', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the line color. + dash + Sets the dash style of lines. Set to a dash + type string (*solid*, *dot*, *dash*, + *longdash*, *dashdot*, or *longdashdot*) or a + dash length list in px (eg *5px,10px,2px,2px*). + shape + Determines the line shape. With *spline* the + lines are drawn using spline interpolation. The + other available values correspond to step-wise + line shapes. + smoothing + Has an effect only if `shape` is set to + *spline* Sets the amount of smoothing. *0* + corresponds to no smoothing (equivalent to a + *linear* shape). + width + Sets the line width (in px).""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_marker.py b/plotly/validators/scatterternary/_marker.py new file mode 100644 index 0000000000..c1fbd9b641 --- /dev/null +++ b/plotly/validators/scatterternary/_marker.py @@ -0,0 +1,126 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='scatterternary', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.scatterternary.marker.ColorBa + r instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + gradient + plotly.graph_objs.scatterternary.marker.Gradien + t instance or dict with compatible properties + line + plotly.graph_objs.scatterternary.marker.Line + instance or dict with compatible properties + maxdisplayed + Sets a maximum number of points to be drawn on + the graph. *0* corresponds to no limit. + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_mode.py b/plotly/validators/scatterternary/_mode.py new file mode 100644 index 0000000000..e3b79ca306 --- /dev/null +++ b/plotly/validators/scatterternary/_mode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ModeValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='mode', parent_name='scatterternary', **kwargs + ): + super(ModeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + extras=['none'], + flags=['lines', 'markers', 'text'], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_name.py b/plotly/validators/scatterternary/_name.py new file mode 100644 index 0000000000..be035d3bdb --- /dev/null +++ b/plotly/validators/scatterternary/_name.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='name', parent_name='scatterternary', **kwargs + ): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_opacity.py b/plotly/validators/scatterternary/_opacity.py new file mode 100644 index 0000000000..4839cf7256 --- /dev/null +++ b/plotly/validators/scatterternary/_opacity.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='scatterternary', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_selected.py b/plotly/validators/scatterternary/_selected.py new file mode 100644 index 0000000000..c5ad0cbe11 --- /dev/null +++ b/plotly/validators/scatterternary/_selected.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='selected', parent_name='scatterternary', **kwargs + ): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.scatterternary.selected.Marke + r instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.selected.Textf + ont instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_selectedpoints.py b/plotly/validators/scatterternary/_selectedpoints.py new file mode 100644 index 0000000000..ff0b629443 --- /dev/null +++ b/plotly/validators/scatterternary/_selectedpoints.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='selectedpoints', + parent_name='scatterternary', + **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_showlegend.py b/plotly/validators/scatterternary/_showlegend.py new file mode 100644 index 0000000000..5fdfa249a9 --- /dev/null +++ b/plotly/validators/scatterternary/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='scatterternary', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_stream.py b/plotly/validators/scatterternary/_stream.py new file mode 100644 index 0000000000..0a06f94d8c --- /dev/null +++ b/plotly/validators/scatterternary/_stream.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='stream', parent_name='scatterternary', **kwargs + ): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_subplot.py b/plotly/validators/scatterternary/_subplot.py new file mode 100644 index 0000000000..7b32e445ac --- /dev/null +++ b/plotly/validators/scatterternary/_subplot.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SubplotValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__( + self, plotly_name='subplot', parent_name='scatterternary', **kwargs + ): + super(SubplotValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='ternary', + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_sum.py b/plotly/validators/scatterternary/_sum.py new file mode 100644 index 0000000000..bb68e64283 --- /dev/null +++ b/plotly/validators/scatterternary/_sum.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SumValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sum', parent_name='scatterternary', **kwargs + ): + super(SumValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_text.py b/plotly/validators/scatterternary/_text.py new file mode 100644 index 0000000000..d4eb550c55 --- /dev/null +++ b/plotly/validators/scatterternary/_text.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='text', parent_name='scatterternary', **kwargs + ): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_textfont.py b/plotly/validators/scatterternary/_textfont.py new file mode 100644 index 0000000000..91b03a4aad --- /dev/null +++ b/plotly/validators/scatterternary/_textfont.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='textfont', parent_name='scatterternary', **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_textposition.py b/plotly/validators/scatterternary/_textposition.py new file mode 100644 index 0000000000..96dac63b0c --- /dev/null +++ b/plotly/validators/scatterternary/_textposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class TextpositionValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='textposition', + parent_name='scatterternary', + **kwargs + ): + super(TextpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 'top left', 'top center', 'top right', 'middle left', + 'middle center', 'middle right', 'bottom left', + 'bottom center', 'bottom right' + ], + **kwargs + ) diff --git a/plotly/validators/scatterternary/_textpositionsrc.py b/plotly/validators/scatterternary/_textpositionsrc.py new file mode 100644 index 0000000000..c7391c51c2 --- /dev/null +++ b/plotly/validators/scatterternary/_textpositionsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TextpositionsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='textpositionsrc', + parent_name='scatterternary', + **kwargs + ): + super(TextpositionsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_textsrc.py b/plotly/validators/scatterternary/_textsrc.py new file mode 100644 index 0000000000..18e9c1ef61 --- /dev/null +++ b/plotly/validators/scatterternary/_textsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='textsrc', parent_name='scatterternary', **kwargs + ): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_uid.py b/plotly/validators/scatterternary/_uid.py new file mode 100644 index 0000000000..6e085ab045 --- /dev/null +++ b/plotly/validators/scatterternary/_uid.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='uid', parent_name='scatterternary', **kwargs + ): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/_unselected.py b/plotly/validators/scatterternary/_unselected.py new file mode 100644 index 0000000000..ef5635bec8 --- /dev/null +++ b/plotly/validators/scatterternary/_unselected.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='scatterternary', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.scatterternary.unselected.Mar + ker instance or dict with compatible properties + textfont + plotly.graph_objs.scatterternary.unselected.Tex + tfont instance or dict with compatible + properties""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/_visible.py b/plotly/validators/scatterternary/_visible.py new file mode 100644 index 0000000000..bbfc1bde12 --- /dev/null +++ b/plotly/validators/scatterternary/_visible.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='visible', parent_name='scatterternary', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/__init__.py b/plotly/validators/scatterternary/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterternary/hoverlabel/_bgcolor.py b/plotly/validators/scatterternary/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..f99c513514 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_bgcolorsrc.py b/plotly/validators/scatterternary/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..ff2f7a379b --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_bordercolor.py b/plotly/validators/scatterternary/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..3f098fe3ad --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_bordercolorsrc.py b/plotly/validators/scatterternary/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..c2aa070c8d --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_font.py b/plotly/validators/scatterternary/hoverlabel/_font.py new file mode 100644 index 0000000000..21d59e2037 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_font.py @@ -0,0 +1,47 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='font', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_namelength.py b/plotly/validators/scatterternary/hoverlabel/_namelength.py new file mode 100644 index 0000000000..9a55fe6f75 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/_namelengthsrc.py b/plotly/validators/scatterternary/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..46b5553ec9 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='scatterternary.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/__init__.py b/plotly/validators/scatterternary/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/hoverlabel/font/_color.py b/plotly/validators/scatterternary/hoverlabel/font/_color.py new file mode 100644 index 0000000000..7da4133b18 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/_colorsrc.py b/plotly/validators/scatterternary/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..26a68793ae --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/_family.py b/plotly/validators/scatterternary/hoverlabel/font/_family.py new file mode 100644 index 0000000000..41e4ca7b1c --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/_familysrc.py b/plotly/validators/scatterternary/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..6629ce2054 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/_size.py b/plotly/validators/scatterternary/hoverlabel/font/_size.py new file mode 100644 index 0000000000..aa7fa5f768 --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/hoverlabel/font/_sizesrc.py b/plotly/validators/scatterternary/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..cd1b9726ea --- /dev/null +++ b/plotly/validators/scatterternary/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterternary.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/line/__init__.py b/plotly/validators/scatterternary/line/__init__.py new file mode 100644 index 0000000000..633e654df0 --- /dev/null +++ b/plotly/validators/scatterternary/line/__init__.py @@ -0,0 +1,5 @@ +from ._width import WidthValidator +from ._smoothing import SmoothingValidator +from ._shape import ShapeValidator +from ._dash import DashValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/line/_color.py b/plotly/validators/scatterternary/line/_color.py new file mode 100644 index 0000000000..8b77748678 --- /dev/null +++ b/plotly/validators/scatterternary/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='scatterternary.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/line/_dash.py b/plotly/validators/scatterternary/line/_dash.py new file mode 100644 index 0000000000..0f6b67fde3 --- /dev/null +++ b/plotly/validators/scatterternary/line/_dash.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class DashValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='dash', parent_name='scatterternary.line', **kwargs + ): + super(DashValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + values=[ + 'solid', 'dot', 'dash', 'longdash', 'dashdot', 'longdashdot' + ], + **kwargs + ) diff --git a/plotly/validators/scatterternary/line/_shape.py b/plotly/validators/scatterternary/line/_shape.py new file mode 100644 index 0000000000..a98e130961 --- /dev/null +++ b/plotly/validators/scatterternary/line/_shape.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ShapeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='shape', parent_name='scatterternary.line', **kwargs + ): + super(ShapeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='style', + values=['linear', 'spline'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/line/_smoothing.py b/plotly/validators/scatterternary/line/_smoothing.py new file mode 100644 index 0000000000..4dad572ed5 --- /dev/null +++ b/plotly/validators/scatterternary/line/_smoothing.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SmoothingValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='smoothing', + parent_name='scatterternary.line', + **kwargs + ): + super(SmoothingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1.3, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/line/_width.py b/plotly/validators/scatterternary/line/_width.py new file mode 100644 index 0000000000..e3cc5cc29d --- /dev/null +++ b/plotly/validators/scatterternary/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='scatterternary.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/__init__.py b/plotly/validators/scatterternary/marker/__init__.py new file mode 100644 index 0000000000..7b7dcf37e9 --- /dev/null +++ b/plotly/validators/scatterternary/marker/__init__.py @@ -0,0 +1,22 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._maxdisplayed import MaxdisplayedValidator +from ._line import LineValidator +from ._gradient import GradientValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterternary/marker/_autocolorscale.py b/plotly/validators/scatterternary/marker/_autocolorscale.py new file mode 100644 index 0000000000..8452be72f0 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterternary.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_cauto.py b/plotly/validators/scatterternary/marker/_cauto.py new file mode 100644 index 0000000000..11bb7b63e0 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatterternary.marker', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_cmax.py b/plotly/validators/scatterternary/marker/_cmax.py new file mode 100644 index 0000000000..f17096dc82 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatterternary.marker', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_cmin.py b/plotly/validators/scatterternary/marker/_cmin.py new file mode 100644 index 0000000000..35f232e458 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatterternary.marker', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_color.py b/plotly/validators/scatterternary/marker/_color.py new file mode 100644 index 0000000000..751c76eb80 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatterternary.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_colorbar.py b/plotly/validators/scatterternary/marker/_colorbar.py new file mode 100644 index 0000000000..456c3b4658 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_colorbar.py @@ -0,0 +1,213 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='colorbar', + parent_name='scatterternary.marker', + **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.scatterternary.marker.colorba + r.Tickformatstop instance or dict with + compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_colorscale.py b/plotly/validators/scatterternary/marker/_colorscale.py new file mode 100644 index 0000000000..0b610bae2c --- /dev/null +++ b/plotly/validators/scatterternary/marker/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterternary.marker', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_colorsrc.py b/plotly/validators/scatterternary/marker/_colorsrc.py new file mode 100644 index 0000000000..56d17afaef --- /dev/null +++ b/plotly/validators/scatterternary/marker/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterternary.marker', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_gradient.py b/plotly/validators/scatterternary/marker/_gradient.py new file mode 100644 index 0000000000..a9a8c0f93f --- /dev/null +++ b/plotly/validators/scatterternary/marker/_gradient.py @@ -0,0 +1,31 @@ +import _plotly_utils.basevalidators + + +class GradientValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='gradient', + parent_name='scatterternary.marker', + **kwargs + ): + super(GradientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Gradient', + data_docs=""" + color + Sets the final color of the gradient fill: the + center color for radial, the right for + horizontal, or the bottom for vertical. + colorsrc + Sets the source reference on plot.ly for color + . + type + Sets the type of gradient used to fill the + markers + typesrc + Sets the source reference on plot.ly for type + .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_line.py b/plotly/validators/scatterternary/marker/_line.py new file mode 100644 index 0000000000..c33e644a93 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_line.py @@ -0,0 +1,87 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='line', + parent_name='scatterternary.marker', + **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_maxdisplayed.py b/plotly/validators/scatterternary/marker/_maxdisplayed.py new file mode 100644 index 0000000000..8cd8fad7b3 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_maxdisplayed.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class MaxdisplayedValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxdisplayed', + parent_name='scatterternary.marker', + **kwargs + ): + super(MaxdisplayedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_opacity.py b/plotly/validators/scatterternary/marker/_opacity.py new file mode 100644 index 0000000000..89c5290275 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_opacity.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterternary.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_opacitysrc.py b/plotly/validators/scatterternary/marker/_opacitysrc.py new file mode 100644 index 0000000000..b4140e7fff --- /dev/null +++ b/plotly/validators/scatterternary/marker/_opacitysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='opacitysrc', + parent_name='scatterternary.marker', + **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_reversescale.py b/plotly/validators/scatterternary/marker/_reversescale.py new file mode 100644 index 0000000000..692195e11c --- /dev/null +++ b/plotly/validators/scatterternary/marker/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterternary.marker', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_showscale.py b/plotly/validators/scatterternary/marker/_showscale.py new file mode 100644 index 0000000000..7e0b5c666c --- /dev/null +++ b/plotly/validators/scatterternary/marker/_showscale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showscale', + parent_name='scatterternary.marker', + **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_size.py b/plotly/validators/scatterternary/marker/_size.py new file mode 100644 index 0000000000..1351e47b0c --- /dev/null +++ b/plotly/validators/scatterternary/marker/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_sizemin.py b/plotly/validators/scatterternary/marker/_sizemin.py new file mode 100644 index 0000000000..e397d2e403 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_sizemin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizemin', + parent_name='scatterternary.marker', + **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_sizemode.py b/plotly/validators/scatterternary/marker/_sizemode.py new file mode 100644 index 0000000000..b4b586a091 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_sizemode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='sizemode', + parent_name='scatterternary.marker', + **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_sizeref.py b/plotly/validators/scatterternary/marker/_sizeref.py new file mode 100644 index 0000000000..2fe1a5d8f4 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_sizeref.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='sizeref', + parent_name='scatterternary.marker', + **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_sizesrc.py b/plotly/validators/scatterternary/marker/_sizesrc.py new file mode 100644 index 0000000000..ab0bec8849 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterternary.marker', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_symbol.py b/plotly/validators/scatterternary/marker/_symbol.py new file mode 100644 index 0000000000..64b8443a24 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_symbol.py @@ -0,0 +1,77 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='symbol', + parent_name='scatterternary.marker', + **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/_symbolsrc.py b/plotly/validators/scatterternary/marker/_symbolsrc.py new file mode 100644 index 0000000000..0b1f1f3d23 --- /dev/null +++ b/plotly/validators/scatterternary/marker/_symbolsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='symbolsrc', + parent_name='scatterternary.marker', + **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/__init__.py b/plotly/validators/scatterternary/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/scatterternary/marker/colorbar/_bgcolor.py b/plotly/validators/scatterternary/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..de63e51495 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_bordercolor.py b/plotly/validators/scatterternary/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..f793f1017e --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_borderwidth.py b/plotly/validators/scatterternary/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..5a462f7f9f --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_dtick.py b/plotly/validators/scatterternary/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..f8c6b1fce8 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_exponentformat.py b/plotly/validators/scatterternary/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..76e94c91ae --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_len.py b/plotly/validators/scatterternary/marker/colorbar/_len.py new file mode 100644 index 0000000000..5b1c1d37c8 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_len.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='len', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_lenmode.py b/plotly/validators/scatterternary/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..025c83d54d --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_nticks.py b/plotly/validators/scatterternary/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..89194e57f1 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_outlinecolor.py b/plotly/validators/scatterternary/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..e5738acf00 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_outlinewidth.py b/plotly/validators/scatterternary/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..8f7bafa8d7 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_separatethousands.py b/plotly/validators/scatterternary/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..fb47959463 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_showexponent.py b/plotly/validators/scatterternary/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..9c5911f762 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_showticklabels.py b/plotly/validators/scatterternary/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..413b2d65a8 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_showtickprefix.py b/plotly/validators/scatterternary/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..e963110681 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_showticksuffix.py b/plotly/validators/scatterternary/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..4a99fd02c4 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_thickness.py b/plotly/validators/scatterternary/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..08e6fd44f1 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_thicknessmode.py b/plotly/validators/scatterternary/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..56b7907213 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tick0.py b/plotly/validators/scatterternary/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..d480f06022 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickangle.py b/plotly/validators/scatterternary/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..58ac07f228 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickcolor.py b/plotly/validators/scatterternary/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..18fad2a355 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickfont.py b/plotly/validators/scatterternary/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..e0348963ba --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickformat.py b/plotly/validators/scatterternary/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..6aa59538c3 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickformatstops.py b/plotly/validators/scatterternary/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..216676c8ba --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ticklen.py b/plotly/validators/scatterternary/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..39b805a20f --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickmode.py b/plotly/validators/scatterternary/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..a1d6e57017 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickprefix.py b/plotly/validators/scatterternary/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..d21eba0a89 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ticks.py b/plotly/validators/scatterternary/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..59dd51caa6 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ticksuffix.py b/plotly/validators/scatterternary/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..a42ce7e865 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ticktext.py b/plotly/validators/scatterternary/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..3b2d6b8ec1 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ticktextsrc.py b/plotly/validators/scatterternary/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..e6abddaa23 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickvals.py b/plotly/validators/scatterternary/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..4323a932cb --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='data', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickvalssrc.py b/plotly/validators/scatterternary/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..99389074d5 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_tickwidth.py b/plotly/validators/scatterternary/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..5d5dda606d --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_title.py b/plotly/validators/scatterternary/marker/colorbar/_title.py new file mode 100644 index 0000000000..8c19ffdd15 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_titlefont.py b/plotly/validators/scatterternary/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..a16e4ceaf4 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_titleside.py b/plotly/validators/scatterternary/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..a47c10c6af --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_x.py b/plotly/validators/scatterternary/marker/colorbar/_x.py new file mode 100644 index 0000000000..fe46a5d82f --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_x.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='x', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_xanchor.py b/plotly/validators/scatterternary/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..c86d24cc86 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_xpad.py b/plotly/validators/scatterternary/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..7859039afd --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_y.py b/plotly/validators/scatterternary/marker/colorbar/_y.py new file mode 100644 index 0000000000..fc2da632cb --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_y.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='y', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_yanchor.py b/plotly/validators/scatterternary/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..f9e32ceacd --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/_ypad.py b/plotly/validators/scatterternary/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..6242d53c0f --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='scatterternary.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/tickfont/__init__.py b/plotly/validators/scatterternary/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/marker/colorbar/tickfont/_color.py b/plotly/validators/scatterternary/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..f4dcc0912b --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/tickfont/_family.py b/plotly/validators/scatterternary/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..fc7a1a6748 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterternary.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/tickfont/_size.py b/plotly/validators/scatterternary/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..8e4eb39791 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..837b7be1a8 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='scatterternary.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + items=[ + { + 'valType': 'any', + 'editType': 'colorbars' + }, { + 'valType': 'any', + 'editType': 'colorbars' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_value.py b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..7fbc7f1f89 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='scatterternary.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/titlefont/__init__.py b/plotly/validators/scatterternary/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/marker/colorbar/titlefont/_color.py b/plotly/validators/scatterternary/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..307da2f631 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/titlefont/_family.py b/plotly/validators/scatterternary/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..2e449dea7c --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterternary.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/colorbar/titlefont/_size.py b/plotly/validators/scatterternary/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..3e36b25e16 --- /dev/null +++ b/plotly/validators/scatterternary/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='colorbars', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/gradient/__init__.py b/plotly/validators/scatterternary/marker/gradient/__init__.py new file mode 100644 index 0000000000..434557c8fe --- /dev/null +++ b/plotly/validators/scatterternary/marker/gradient/__init__.py @@ -0,0 +1,4 @@ +from ._typesrc import TypesrcValidator +from ._type import TypeValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/marker/gradient/_color.py b/plotly/validators/scatterternary/marker/gradient/_color.py new file mode 100644 index 0000000000..0357e88c44 --- /dev/null +++ b/plotly/validators/scatterternary/marker/gradient/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.marker.gradient', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/gradient/_colorsrc.py b/plotly/validators/scatterternary/marker/gradient/_colorsrc.py new file mode 100644 index 0000000000..9327da2406 --- /dev/null +++ b/plotly/validators/scatterternary/marker/gradient/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterternary.marker.gradient', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/gradient/_type.py b/plotly/validators/scatterternary/marker/gradient/_type.py new file mode 100644 index 0000000000..78e8f01109 --- /dev/null +++ b/plotly/validators/scatterternary/marker/gradient/_type.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TypeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='type', + parent_name='scatterternary.marker.gradient', + **kwargs + ): + super(TypeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['radial', 'horizontal', 'vertical', 'none'], + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/gradient/_typesrc.py b/plotly/validators/scatterternary/marker/gradient/_typesrc.py new file mode 100644 index 0000000000..383142fe3c --- /dev/null +++ b/plotly/validators/scatterternary/marker/gradient/_typesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TypesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='typesrc', + parent_name='scatterternary.marker.gradient', + **kwargs + ): + super(TypesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/__init__.py b/plotly/validators/scatterternary/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/scatterternary/marker/line/_autocolorscale.py b/plotly/validators/scatterternary/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..5a3e425f94 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_cauto.py b/plotly/validators/scatterternary/marker/line/_cauto.py new file mode 100644 index 0000000000..ca1f62a2b9 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_cauto.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='cauto', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_cmax.py b/plotly/validators/scatterternary/marker/line/_cmax.py new file mode 100644 index 0000000000..3fb3160135 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_cmax.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmax', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_cmin.py b/plotly/validators/scatterternary/marker/line/_cmin.py new file mode 100644 index 0000000000..b2210fdb5b --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_cmin.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='cmin', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_color.py b/plotly/validators/scatterternary/marker/line/_color.py new file mode 100644 index 0000000000..961ca3516b --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_color.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + colorscale_path='scatterternary.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_colorscale.py b/plotly/validators/scatterternary/marker/line/_colorscale.py new file mode 100644 index 0000000000..6ea747f09a --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_colorsrc.py b/plotly/validators/scatterternary/marker/line/_colorsrc.py new file mode 100644 index 0000000000..2d0c4cb300 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_reversescale.py b/plotly/validators/scatterternary/marker/line/_reversescale.py new file mode 100644 index 0000000000..64333dca21 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_width.py b/plotly/validators/scatterternary/marker/line/_width.py new file mode 100644 index 0000000000..20debd0165 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_width.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='width', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/marker/line/_widthsrc.py b/plotly/validators/scatterternary/marker/line/_widthsrc.py new file mode 100644 index 0000000000..cc218b4df3 --- /dev/null +++ b/plotly/validators/scatterternary/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='scatterternary.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/__init__.py b/plotly/validators/scatterternary/selected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterternary/selected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterternary/selected/_marker.py b/plotly/validators/scatterternary/selected/_marker.py new file mode 100644 index 0000000000..cdd33cce4e --- /dev/null +++ b/plotly/validators/scatterternary/selected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterternary.selected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/_textfont.py b/plotly/validators/scatterternary/selected/_textfont.py new file mode 100644 index 0000000000..f2d6630fbc --- /dev/null +++ b/plotly/validators/scatterternary/selected/_textfont.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterternary.selected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of selected points.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/marker/__init__.py b/plotly/validators/scatterternary/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterternary/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/selected/marker/_color.py b/plotly/validators/scatterternary/selected/marker/_color.py new file mode 100644 index 0000000000..9e5bd4c4b1 --- /dev/null +++ b/plotly/validators/scatterternary/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/marker/_opacity.py b/plotly/validators/scatterternary/selected/marker/_opacity.py new file mode 100644 index 0000000000..a68a3e99ef --- /dev/null +++ b/plotly/validators/scatterternary/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterternary.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/marker/_size.py b/plotly/validators/scatterternary/selected/marker/_size.py new file mode 100644 index 0000000000..8f36f7653a --- /dev/null +++ b/plotly/validators/scatterternary/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/selected/textfont/__init__.py b/plotly/validators/scatterternary/selected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterternary/selected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/selected/textfont/_color.py b/plotly/validators/scatterternary/selected/textfont/_color.py new file mode 100644 index 0000000000..d724e4b35a --- /dev/null +++ b/plotly/validators/scatterternary/selected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.selected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/stream/__init__.py b/plotly/validators/scatterternary/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/scatterternary/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/scatterternary/stream/_maxpoints.py b/plotly/validators/scatterternary/stream/_maxpoints.py new file mode 100644 index 0000000000..5eedaff773 --- /dev/null +++ b/plotly/validators/scatterternary/stream/_maxpoints.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='maxpoints', + parent_name='scatterternary.stream', + **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/stream/_token.py b/plotly/validators/scatterternary/stream/_token.py new file mode 100644 index 0000000000..5a141e9cdb --- /dev/null +++ b/plotly/validators/scatterternary/stream/_token.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='token', + parent_name='scatterternary.stream', + **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/__init__.py b/plotly/validators/scatterternary/textfont/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/scatterternary/textfont/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/textfont/_color.py b/plotly/validators/scatterternary/textfont/_color.py new file mode 100644 index 0000000000..5b5e4ae638 --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/_colorsrc.py b/plotly/validators/scatterternary/textfont/_colorsrc.py new file mode 100644 index 0000000000..f98c622dcd --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='scatterternary.textfont', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/_family.py b/plotly/validators/scatterternary/textfont/_family.py new file mode 100644 index 0000000000..0be6a50619 --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='scatterternary.textfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/_familysrc.py b/plotly/validators/scatterternary/textfont/_familysrc.py new file mode 100644 index 0000000000..1defc3f50a --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='scatterternary.textfont', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/_size.py b/plotly/validators/scatterternary/textfont/_size.py new file mode 100644 index 0000000000..0a386017d8 --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.textfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/textfont/_sizesrc.py b/plotly/validators/scatterternary/textfont/_sizesrc.py new file mode 100644 index 0000000000..83c379f392 --- /dev/null +++ b/plotly/validators/scatterternary/textfont/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='scatterternary.textfont', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/__init__.py b/plotly/validators/scatterternary/unselected/__init__.py new file mode 100644 index 0000000000..f1a1ef3742 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/__init__.py @@ -0,0 +1,2 @@ +from ._textfont import TextfontValidator +from ._marker import MarkerValidator diff --git a/plotly/validators/scatterternary/unselected/_marker.py b/plotly/validators/scatterternary/unselected/_marker.py new file mode 100644 index 0000000000..6d53db0951 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/_marker.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='marker', + parent_name='scatterternary.unselected', + **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/_textfont.py b/plotly/validators/scatterternary/unselected/_textfont.py new file mode 100644 index 0000000000..bba1842a77 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/_textfont.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class TextfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='textfont', + parent_name='scatterternary.unselected', + **kwargs + ): + super(TextfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Textfont', + data_docs=""" + color + Sets the text font color of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/marker/__init__.py b/plotly/validators/scatterternary/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/unselected/marker/_color.py b/plotly/validators/scatterternary/unselected/marker/_color.py new file mode 100644 index 0000000000..892651ef66 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/marker/_opacity.py b/plotly/validators/scatterternary/unselected/marker/_opacity.py new file mode 100644 index 0000000000..35e4df38b8 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='scatterternary.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/marker/_size.py b/plotly/validators/scatterternary/unselected/marker/_size.py new file mode 100644 index 0000000000..f0ea84acea --- /dev/null +++ b/plotly/validators/scatterternary/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='scatterternary.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/scatterternary/unselected/textfont/__init__.py b/plotly/validators/scatterternary/unselected/textfont/__init__.py new file mode 100644 index 0000000000..74135b3f31 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/textfont/__init__.py @@ -0,0 +1 @@ +from ._color import ColorValidator diff --git a/plotly/validators/scatterternary/unselected/textfont/_color.py b/plotly/validators/scatterternary/unselected/textfont/_color.py new file mode 100644 index 0000000000..9b44ee3cb2 --- /dev/null +++ b/plotly/validators/scatterternary/unselected/textfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='scatterternary.unselected.textfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/__init__.py b/plotly/validators/splom/__init__.py new file mode 100644 index 0000000000..31ab26e62f --- /dev/null +++ b/plotly/validators/splom/__init__.py @@ -0,0 +1,26 @@ +from ._yaxes import YaxesValidator +from ._xaxes import XaxesValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._showupperhalf import ShowupperhalfValidator +from ._showlowerhalf import ShowlowerhalfValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._marker import MarkerValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._dimensions import DimensionsValidator +from ._diagonal import DiagonalValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator diff --git a/plotly/validators/splom/_customdata.py b/plotly/validators/splom/_customdata.py new file mode 100644 index 0000000000..532fb3a54b --- /dev/null +++ b/plotly/validators/splom/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='splom', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/splom/_customdatasrc.py b/plotly/validators/splom/_customdatasrc.py new file mode 100644 index 0000000000..c4a033ec2c --- /dev/null +++ b/plotly/validators/splom/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='splom', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_diagonal.py b/plotly/validators/splom/_diagonal.py new file mode 100644 index 0000000000..6668e90573 --- /dev/null +++ b/plotly/validators/splom/_diagonal.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DiagonalValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='diagonal', parent_name='splom', **kwargs): + super(DiagonalValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Diagonal', + data_docs=""" + visible + Determines whether or not subplots on the + diagonal are displayed.""", + **kwargs + ) diff --git a/plotly/validators/splom/_dimensions.py b/plotly/validators/splom/_dimensions.py new file mode 100644 index 0000000000..8240a2d3f4 --- /dev/null +++ b/plotly/validators/splom/_dimensions.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class DimensionsValidator(_plotly_utils.basevalidators.CompoundArrayValidator): + + def __init__( + self, plotly_name='dimensions', parent_name='splom', **kwargs + ): + super(DimensionsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Dimension', + data_docs=""" + label + Sets the label corresponding to this splom + dimension. + values + Sets the dimension values to be plotted. + valuessrc + Sets the source reference on plot.ly for + values . + visible + Determines whether or not this dimension is + shown on the graph. Note that even visible + false dimension contribute to the default grid + generate by this splom trace.""", + **kwargs + ) diff --git a/plotly/validators/splom/_hoverinfo.py b/plotly/validators/splom/_hoverinfo.py new file mode 100644 index 0000000000..dd2ef3163f --- /dev/null +++ b/plotly/validators/splom/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='splom', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_hoverinfosrc.py b/plotly/validators/splom/_hoverinfosrc.py new file mode 100644 index 0000000000..8d8f5de36b --- /dev/null +++ b/plotly/validators/splom/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='splom', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_hoverlabel.py b/plotly/validators/splom/_hoverlabel.py new file mode 100644 index 0000000000..dd9ea2f912 --- /dev/null +++ b/plotly/validators/splom/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='splom', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/splom/_ids.py b/plotly/validators/splom/_ids.py new file mode 100644 index 0000000000..00d4214cfc --- /dev/null +++ b/plotly/validators/splom/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='splom', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/splom/_idssrc.py b/plotly/validators/splom/_idssrc.py new file mode 100644 index 0000000000..74d8b1e286 --- /dev/null +++ b/plotly/validators/splom/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='splom', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_legendgroup.py b/plotly/validators/splom/_legendgroup.py new file mode 100644 index 0000000000..74e3836a16 --- /dev/null +++ b/plotly/validators/splom/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='splom', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_marker.py b/plotly/validators/splom/_marker.py new file mode 100644 index 0000000000..b0a718eb28 --- /dev/null +++ b/plotly/validators/splom/_marker.py @@ -0,0 +1,118 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='splom', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + autocolorscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether the + colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.color` is set to + a numerical array and `cmin`, `cmax` are set by + the user. In this case, it controls whether the + range of colors in `colorscale` is mapped to + the range of values in the `color` array + (`cauto: true`), or the `cmin`/`cmax` values + (`cauto: false`). Defaults to `false` when + `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.color` is set to + a numerical array. Sets the upper bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmin` must be set as well. + cmin + Has an effect only if `marker.color` is set to + a numerical array. Sets the lower bound of the + color domain. Value should be associated to the + `marker.color` array index, and if set, + `marker.cmax` must be set as well. + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorbar + plotly.graph_objs.splom.marker.ColorBar + instance or dict with compatible properties + colorscale + Sets the colorscale and only has an effect if + `marker.color` is set to a numerical array. The + colorscale must be an array containing arrays + mapping a normalized value to an rgb, rgba, + hex, hsl, hsv, or named color string. At + minimum, a mapping for the lowest (0) and + highest (1) values are required. For example, + `[[0, 'rgb(0,0,255)', [1, 'rgb(255,0,0)']]`. To + control the bounds of the colorscale in color + space, use `marker.cmin` and `marker.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + line + plotly.graph_objs.splom.marker.Line instance or + dict with compatible properties + opacity + Sets the marker opacity. + opacitysrc + Sets the source reference on plot.ly for + opacity . + reversescale + Has an effect only if `marker.color` is set to + a numerical array. Reverses the color mapping + if true (`cmin` will correspond to the last + color in the array and `cmax` will correspond + to the first color). + showscale + Has an effect only if `marker.color` is set to + a numerical array. Determines whether or not a + colorbar is displayed. + size + Sets the marker size (in px). + sizemin + Has an effect only if `marker.size` is set to a + numerical array. Sets the minimum size (in px) + of the rendered marker points. + sizemode + Has an effect only if `marker.size` is set to a + numerical array. Sets the rule for which the + data in `size` is converted to pixels. + sizeref + Has an effect only if `marker.size` is set to a + numerical array. Sets the scale factor used to + determine the rendered size of marker points. + Use with `sizemin` and `sizemode`. + sizesrc + Sets the source reference on plot.ly for size + . + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name. + symbolsrc + Sets the source reference on plot.ly for + symbol .""", + **kwargs + ) diff --git a/plotly/validators/splom/_name.py b/plotly/validators/splom/_name.py new file mode 100644 index 0000000000..d7e84b79a9 --- /dev/null +++ b/plotly/validators/splom/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='splom', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_opacity.py b/plotly/validators/splom/_opacity.py new file mode 100644 index 0000000000..6f0ef4f31d --- /dev/null +++ b/plotly/validators/splom/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='splom', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/_selected.py b/plotly/validators/splom/_selected.py new file mode 100644 index 0000000000..daa7452bc4 --- /dev/null +++ b/plotly/validators/splom/_selected.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='selected', parent_name='splom', **kwargs): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.splom.selected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/splom/_selectedpoints.py b/plotly/validators/splom/_selectedpoints.py new file mode 100644 index 0000000000..1a9f006868 --- /dev/null +++ b/plotly/validators/splom/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='splom', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_showlegend.py b/plotly/validators/splom/_showlegend.py new file mode 100644 index 0000000000..54c2d1dba2 --- /dev/null +++ b/plotly/validators/splom/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='splom', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_showlowerhalf.py b/plotly/validators/splom/_showlowerhalf.py new file mode 100644 index 0000000000..62b7d89b2b --- /dev/null +++ b/plotly/validators/splom/_showlowerhalf.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlowerhalfValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlowerhalf', parent_name='splom', **kwargs + ): + super(ShowlowerhalfValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_showupperhalf.py b/plotly/validators/splom/_showupperhalf.py new file mode 100644 index 0000000000..7023d5f5a7 --- /dev/null +++ b/plotly/validators/splom/_showupperhalf.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowupperhalfValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showupperhalf', parent_name='splom', **kwargs + ): + super(ShowupperhalfValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_stream.py b/plotly/validators/splom/_stream.py new file mode 100644 index 0000000000..81eb3a6294 --- /dev/null +++ b/plotly/validators/splom/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='splom', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/splom/_text.py b/plotly/validators/splom/_text.py new file mode 100644 index 0000000000..c4578dbc15 --- /dev/null +++ b/plotly/validators/splom/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='splom', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_textsrc.py b/plotly/validators/splom/_textsrc.py new file mode 100644 index 0000000000..ca0decf58a --- /dev/null +++ b/plotly/validators/splom/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='splom', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_uid.py b/plotly/validators/splom/_uid.py new file mode 100644 index 0000000000..96db404d66 --- /dev/null +++ b/plotly/validators/splom/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='splom', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_unselected.py b/plotly/validators/splom/_unselected.py new file mode 100644 index 0000000000..152c42ee53 --- /dev/null +++ b/plotly/validators/splom/_unselected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='splom', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.splom.unselected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/splom/_visible.py b/plotly/validators/splom/_visible.py new file mode 100644 index 0000000000..a3ec11b2d0 --- /dev/null +++ b/plotly/validators/splom/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='splom', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/splom/_xaxes.py b/plotly/validators/splom/_xaxes.py new file mode 100644 index 0000000000..5f3a7845eb --- /dev/null +++ b/plotly/validators/splom/_xaxes.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XaxesValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='xaxes', parent_name='splom', **kwargs): + super(XaxesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + free_length=True, + items={ + 'valType': 'subplotid', + 'regex': '/^x([2-9]|[1-9][0-9]+)?$/', + 'editType': 'plot' + }, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/_yaxes.py b/plotly/validators/splom/_yaxes.py new file mode 100644 index 0000000000..508aa4851e --- /dev/null +++ b/plotly/validators/splom/_yaxes.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YaxesValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='yaxes', parent_name='splom', **kwargs): + super(YaxesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + free_length=True, + items={ + 'valType': 'subplotid', + 'regex': '/^y([2-9]|[1-9][0-9]+)?$/', + 'editType': 'plot' + }, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/diagonal/__init__.py b/plotly/validators/splom/diagonal/__init__.py new file mode 100644 index 0000000000..36873797fb --- /dev/null +++ b/plotly/validators/splom/diagonal/__init__.py @@ -0,0 +1 @@ +from ._visible import VisibleValidator diff --git a/plotly/validators/splom/diagonal/_visible.py b/plotly/validators/splom/diagonal/_visible.py new file mode 100644 index 0000000000..f30b514331 --- /dev/null +++ b/plotly/validators/splom/diagonal/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='splom.diagonal', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/dimension/__init__.py b/plotly/validators/splom/dimension/__init__.py new file mode 100644 index 0000000000..e96c72ed50 --- /dev/null +++ b/plotly/validators/splom/dimension/__init__.py @@ -0,0 +1,4 @@ +from ._visible import VisibleValidator +from ._valuessrc import ValuessrcValidator +from ._values import ValuesValidator +from ._label import LabelValidator diff --git a/plotly/validators/splom/dimension/_label.py b/plotly/validators/splom/dimension/_label.py new file mode 100644 index 0000000000..de2d10871b --- /dev/null +++ b/plotly/validators/splom/dimension/_label.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LabelValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='label', parent_name='splom.dimension', **kwargs + ): + super(LabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/dimension/_values.py b/plotly/validators/splom/dimension/_values.py new file mode 100644 index 0000000000..d0960b331c --- /dev/null +++ b/plotly/validators/splom/dimension/_values.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='values', parent_name='splom.dimension', **kwargs + ): + super(ValuesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/splom/dimension/_valuessrc.py b/plotly/validators/splom/dimension/_valuessrc.py new file mode 100644 index 0000000000..1eb4471a10 --- /dev/null +++ b/plotly/validators/splom/dimension/_valuessrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='valuessrc', parent_name='splom.dimension', **kwargs + ): + super(ValuessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/dimension/_visible.py b/plotly/validators/splom/dimension/_visible.py new file mode 100644 index 0000000000..fe600e84ee --- /dev/null +++ b/plotly/validators/splom/dimension/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='splom.dimension', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/__init__.py b/plotly/validators/splom/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/splom/hoverlabel/_bgcolor.py b/plotly/validators/splom/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..47342c00bb --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='splom.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_bgcolorsrc.py b/plotly/validators/splom/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..786f8ddd67 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='splom.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_bordercolor.py b/plotly/validators/splom/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..2bba5e5932 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='splom.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_bordercolorsrc.py b/plotly/validators/splom/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..70151dcaef --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='splom.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_font.py b/plotly/validators/splom/hoverlabel/_font.py new file mode 100644 index 0000000000..c1cdd94e65 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='splom.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_namelength.py b/plotly/validators/splom/hoverlabel/_namelength.py new file mode 100644 index 0000000000..8837ea463c --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='splom.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/_namelengthsrc.py b/plotly/validators/splom/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..841e6f4a3c --- /dev/null +++ b/plotly/validators/splom/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='splom.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/__init__.py b/plotly/validators/splom/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/splom/hoverlabel/font/_color.py b/plotly/validators/splom/hoverlabel/font/_color.py new file mode 100644 index 0000000000..a226f3a7dd --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/_colorsrc.py b/plotly/validators/splom/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..455dd85c4a --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/_family.py b/plotly/validators/splom/hoverlabel/font/_family.py new file mode 100644 index 0000000000..0a22a40e36 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/_familysrc.py b/plotly/validators/splom/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..7488d9b12f --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/_size.py b/plotly/validators/splom/hoverlabel/font/_size.py new file mode 100644 index 0000000000..f9d1570147 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/hoverlabel/font/_sizesrc.py b/plotly/validators/splom/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..7bf6a243c8 --- /dev/null +++ b/plotly/validators/splom/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='splom.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/__init__.py b/plotly/validators/splom/marker/__init__.py new file mode 100644 index 0000000000..254b91a979 --- /dev/null +++ b/plotly/validators/splom/marker/__init__.py @@ -0,0 +1,20 @@ +from ._symbolsrc import SymbolsrcValidator +from ._symbol import SymbolValidator +from ._sizesrc import SizesrcValidator +from ._sizeref import SizerefValidator +from ._sizemode import SizemodeValidator +from ._sizemin import SizeminValidator +from ._size import SizeValidator +from ._showscale import ShowscaleValidator +from ._reversescale import ReversescaleValidator +from ._opacitysrc import OpacitysrcValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/splom/marker/_autocolorscale.py b/plotly/validators/splom/marker/_autocolorscale.py new file mode 100644 index 0000000000..075be2c139 --- /dev/null +++ b/plotly/validators/splom/marker/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='splom.marker', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_cauto.py b/plotly/validators/splom/marker/_cauto.py new file mode 100644 index 0000000000..84c3262d4c --- /dev/null +++ b/plotly/validators/splom/marker/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='splom.marker', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_cmax.py b/plotly/validators/splom/marker/_cmax.py new file mode 100644 index 0000000000..ecdaa2e012 --- /dev/null +++ b/plotly/validators/splom/marker/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='splom.marker', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_cmin.py b/plotly/validators/splom/marker/_cmin.py new file mode 100644 index 0000000000..0de52d23bd --- /dev/null +++ b/plotly/validators/splom/marker/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='splom.marker', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_color.py b/plotly/validators/splom/marker/_color.py new file mode 100644 index 0000000000..2002ab1136 --- /dev/null +++ b/plotly/validators/splom/marker/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='splom.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='splom.marker.colorscale', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_colorbar.py b/plotly/validators/splom/marker/_colorbar.py new file mode 100644 index 0000000000..98be4afd08 --- /dev/null +++ b/plotly/validators/splom/marker/_colorbar.py @@ -0,0 +1,210 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='splom.marker', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.splom.marker.colorbar.Tickfor + matstop instance or dict with compatible + properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/splom/marker/_colorscale.py b/plotly/validators/splom/marker/_colorscale.py new file mode 100644 index 0000000000..f99b63478a --- /dev/null +++ b/plotly/validators/splom/marker/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='splom.marker', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_colorsrc.py b/plotly/validators/splom/marker/_colorsrc.py new file mode 100644 index 0000000000..15490ad811 --- /dev/null +++ b/plotly/validators/splom/marker/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='splom.marker', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_line.py b/plotly/validators/splom/marker/_line.py new file mode 100644 index 0000000000..607e42bd00 --- /dev/null +++ b/plotly/validators/splom/marker/_line.py @@ -0,0 +1,84 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='splom.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + autocolorscale + Has an effect only if `marker.line.color` is + set to a numerical array. Determines whether + the colorscale is a default palette + (`autocolorscale: true`) or the palette + determined by `marker.line.colorscale`. In case + `colorscale` is unspecified or `autocolorscale` + is true, the default palette will be chosen + according to whether numbers in the `color` + array are all positive, all negative or mixed. + cauto + Has an effect only if `marker.line.color` is + set to a numerical array and `cmin`, `cmax` are + set by the user. In this case, it controls + whether the range of colors in `colorscale` is + mapped to the range of values in the `color` + array (`cauto: true`), or the `cmin`/`cmax` + values (`cauto: false`). Defaults to `false` + when `cmin`, `cmax` are set by the user. + cmax + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the upper bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmin` must be set as well. + cmin + Has an effect only if `marker.line.color` is + set to a numerical array. Sets the lower bound + of the color domain. Value should be associated + to the `marker.line.color` array index, and if + set, `marker.line.cmax` must be set as well. + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + colorscale + Sets the colorscale and only has an effect if + `marker.line.color` is set to a numerical + array. The colorscale must be an array + containing arrays mapping a normalized value to + an rgb, rgba, hex, hsl, hsv, or named color + string. At minimum, a mapping for the lowest + (0) and highest (1) values are required. For + example, `[[0, 'rgb(0,0,255)', [1, + 'rgb(255,0,0)']]`. To control the bounds of the + colorscale in color space, use + `marker.line.cmin` and `marker.line.cmax`. + Alternatively, `colorscale` may be a palette + name string of the following list: Greys, + YlGnBu, Greens, YlOrRd, Bluered, RdBu, Reds, + Blues, Picnic, Rainbow, Portland, Jet, Hot, + Blackbody, Earth, Electric, Viridis, Cividis + colorsrc + Sets the source reference on plot.ly for color + . + reversescale + Has an effect only if `marker.line.color` is + set to a numerical array. Reverses the color + mapping if true (`cmin` will correspond to the + last color in the array and `cmax` will + correspond to the first color). + width + Sets the width (in px) of the lines bounding + the marker points. + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/splom/marker/_opacity.py b/plotly/validators/splom/marker/_opacity.py new file mode 100644 index 0000000000..6910cf8553 --- /dev/null +++ b/plotly/validators/splom/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='splom.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_opacitysrc.py b/plotly/validators/splom/marker/_opacitysrc.py new file mode 100644 index 0000000000..9aeaa116c2 --- /dev/null +++ b/plotly/validators/splom/marker/_opacitysrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacitysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='opacitysrc', parent_name='splom.marker', **kwargs + ): + super(OpacitysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_reversescale.py b/plotly/validators/splom/marker/_reversescale.py new file mode 100644 index 0000000000..b42e53124d --- /dev/null +++ b/plotly/validators/splom/marker/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='splom.marker', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_showscale.py b/plotly/validators/splom/marker/_showscale.py new file mode 100644 index 0000000000..c578cf0586 --- /dev/null +++ b/plotly/validators/splom/marker/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='splom.marker', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_size.py b/plotly/validators/splom/marker/_size.py new file mode 100644 index 0000000000..3aa5d07b37 --- /dev/null +++ b/plotly/validators/splom/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='splom.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_sizemin.py b/plotly/validators/splom/marker/_sizemin.py new file mode 100644 index 0000000000..a3a9486244 --- /dev/null +++ b/plotly/validators/splom/marker/_sizemin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizeminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizemin', parent_name='splom.marker', **kwargs + ): + super(SizeminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_sizemode.py b/plotly/validators/splom/marker/_sizemode.py new file mode 100644 index 0000000000..f9d20415ff --- /dev/null +++ b/plotly/validators/splom/marker/_sizemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SizemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='sizemode', parent_name='splom.marker', **kwargs + ): + super(SizemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['diameter', 'area'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/_sizeref.py b/plotly/validators/splom/marker/_sizeref.py new file mode 100644 index 0000000000..d9f7206fe6 --- /dev/null +++ b/plotly/validators/splom/marker/_sizeref.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizerefValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='sizeref', parent_name='splom.marker', **kwargs + ): + super(SizerefValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_sizesrc.py b/plotly/validators/splom/marker/_sizesrc.py new file mode 100644 index 0000000000..b492ecefd4 --- /dev/null +++ b/plotly/validators/splom/marker/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='splom.marker', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/_symbol.py b/plotly/validators/splom/marker/_symbol.py new file mode 100644 index 0000000000..2458c6778f --- /dev/null +++ b/plotly/validators/splom/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='splom.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/splom/marker/_symbolsrc.py b/plotly/validators/splom/marker/_symbolsrc.py new file mode 100644 index 0000000000..83f60a64d0 --- /dev/null +++ b/plotly/validators/splom/marker/_symbolsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SymbolsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='symbolsrc', parent_name='splom.marker', **kwargs + ): + super(SymbolsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/__init__.py b/plotly/validators/splom/marker/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/splom/marker/colorbar/_bgcolor.py b/plotly/validators/splom/marker/colorbar/_bgcolor.py new file mode 100644 index 0000000000..e63065dc44 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_bgcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_bordercolor.py b/plotly/validators/splom/marker/colorbar/_bordercolor.py new file mode 100644 index 0000000000..cfc04efc3e --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_borderwidth.py b/plotly/validators/splom/marker/colorbar/_borderwidth.py new file mode 100644 index 0000000000..aa5bb71f44 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_dtick.py b/plotly/validators/splom/marker/colorbar/_dtick.py new file mode 100644 index 0000000000..8aeb580077 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_dtick.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='dtick', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_exponentformat.py b/plotly/validators/splom/marker/colorbar/_exponentformat.py new file mode 100644 index 0000000000..551d079212 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_len.py b/plotly/validators/splom/marker/colorbar/_len.py new file mode 100644 index 0000000000..41e734646a --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='splom.marker.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_lenmode.py b/plotly/validators/splom/marker/colorbar/_lenmode.py new file mode 100644 index 0000000000..4b103bfe36 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_lenmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='lenmode', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_nticks.py b/plotly/validators/splom/marker/colorbar/_nticks.py new file mode 100644 index 0000000000..e68e3bd14b --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_nticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='nticks', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_outlinecolor.py b/plotly/validators/splom/marker/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..987c4e42a4 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_outlinewidth.py b/plotly/validators/splom/marker/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..255e57c79f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_separatethousands.py b/plotly/validators/splom/marker/colorbar/_separatethousands.py new file mode 100644 index 0000000000..ee67dc2d61 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_showexponent.py b/plotly/validators/splom/marker/colorbar/_showexponent.py new file mode 100644 index 0000000000..6d7fdd411c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_showticklabels.py b/plotly/validators/splom/marker/colorbar/_showticklabels.py new file mode 100644 index 0000000000..8c95510d50 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_showtickprefix.py b/plotly/validators/splom/marker/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..86f95b16d3 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_showticksuffix.py b/plotly/validators/splom/marker/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..80b850d3cb --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_thickness.py b/plotly/validators/splom/marker/colorbar/_thickness.py new file mode 100644 index 0000000000..4c3701f43c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_thicknessmode.py b/plotly/validators/splom/marker/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..ae252fee46 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tick0.py b/plotly/validators/splom/marker/colorbar/_tick0.py new file mode 100644 index 0000000000..e9051ca620 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tick0.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, + plotly_name='tick0', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickangle.py b/plotly/validators/splom/marker/colorbar/_tickangle.py new file mode 100644 index 0000000000..29444ee92d --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickcolor.py b/plotly/validators/splom/marker/colorbar/_tickcolor.py new file mode 100644 index 0000000000..dda2c81aab --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickfont.py b/plotly/validators/splom/marker/colorbar/_tickfont.py new file mode 100644 index 0000000000..dcaba5176a --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickfont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='tickfont', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickformat.py b/plotly/validators/splom/marker/colorbar/_tickformat.py new file mode 100644 index 0000000000..a7d008512d --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickformatstops.py b/plotly/validators/splom/marker/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..0fa4695ec9 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ticklen.py b/plotly/validators/splom/marker/colorbar/_ticklen.py new file mode 100644 index 0000000000..6c86099d8f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ticklen.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ticklen', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickmode.py b/plotly/validators/splom/marker/colorbar/_tickmode.py new file mode 100644 index 0000000000..e6144c8045 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickmode.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='tickmode', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickprefix.py b/plotly/validators/splom/marker/colorbar/_tickprefix.py new file mode 100644 index 0000000000..d0bd88e94f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ticks.py b/plotly/validators/splom/marker/colorbar/_ticks.py new file mode 100644 index 0000000000..5cdab80de4 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ticks.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='ticks', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ticksuffix.py b/plotly/validators/splom/marker/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..2e82b9bc40 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ticktext.py b/plotly/validators/splom/marker/colorbar/_ticktext.py new file mode 100644 index 0000000000..04333e2c1c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ticktext.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='ticktext', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ticktextsrc.py b/plotly/validators/splom/marker/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..e843daf94b --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickvals.py b/plotly/validators/splom/marker/colorbar/_tickvals.py new file mode 100644 index 0000000000..fc8683dd11 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickvals.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, + plotly_name='tickvals', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickvalssrc.py b/plotly/validators/splom/marker/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..41c0d3fe6f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_tickwidth.py b/plotly/validators/splom/marker/colorbar/_tickwidth.py new file mode 100644 index 0000000000..279f1c49ea --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_title.py b/plotly/validators/splom/marker/colorbar/_title.py new file mode 100644 index 0000000000..43008a0ee9 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_title.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='title', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_titlefont.py b/plotly/validators/splom/marker/colorbar/_titlefont.py new file mode 100644 index 0000000000..9c8b2da50f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_titleside.py b/plotly/validators/splom/marker/colorbar/_titleside.py new file mode 100644 index 0000000000..f624d63558 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_x.py b/plotly/validators/splom/marker/colorbar/_x.py new file mode 100644 index 0000000000..cb60984a17 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='splom.marker.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_xanchor.py b/plotly/validators/splom/marker/colorbar/_xanchor.py new file mode 100644 index 0000000000..d39cdf8a76 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_xanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='xanchor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_xpad.py b/plotly/validators/splom/marker/colorbar/_xpad.py new file mode 100644 index 0000000000..76e5e6e207 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_xpad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='xpad', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_y.py b/plotly/validators/splom/marker/colorbar/_y.py new file mode 100644 index 0000000000..cce3bfc26b --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='splom.marker.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_yanchor.py b/plotly/validators/splom/marker/colorbar/_yanchor.py new file mode 100644 index 0000000000..7bdec6fa6e --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_yanchor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='yanchor', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/_ypad.py b/plotly/validators/splom/marker/colorbar/_ypad.py new file mode 100644 index 0000000000..0da876038f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/_ypad.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='ypad', + parent_name='splom.marker.colorbar', + **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/tickfont/__init__.py b/plotly/validators/splom/marker/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/splom/marker/colorbar/tickfont/_color.py b/plotly/validators/splom/marker/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..ec18ed3786 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='splom.marker.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/tickfont/_family.py b/plotly/validators/splom/marker/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..568d3b37dc --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='splom.marker.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/tickfont/_size.py b/plotly/validators/splom/marker/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..ec83509f90 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='splom.marker.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/tickformatstop/__init__.py b/plotly/validators/splom/marker/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/splom/marker/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/splom/marker/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..0fe2ce6136 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='splom.marker.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/tickformatstop/_value.py b/plotly/validators/splom/marker/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..870424a692 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='splom.marker.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/titlefont/__init__.py b/plotly/validators/splom/marker/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/splom/marker/colorbar/titlefont/_color.py b/plotly/validators/splom/marker/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..4adecdf232 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='splom.marker.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/titlefont/_family.py b/plotly/validators/splom/marker/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..cd80fe4b7c --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='splom.marker.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/splom/marker/colorbar/titlefont/_size.py b/plotly/validators/splom/marker/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..657350d581 --- /dev/null +++ b/plotly/validators/splom/marker/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='splom.marker.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/__init__.py b/plotly/validators/splom/marker/line/__init__.py new file mode 100644 index 0000000000..08e7b441e7 --- /dev/null +++ b/plotly/validators/splom/marker/line/__init__.py @@ -0,0 +1,10 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._reversescale import ReversescaleValidator +from ._colorsrc import ColorsrcValidator +from ._colorscale import ColorscaleValidator +from ._color import ColorValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/splom/marker/line/_autocolorscale.py b/plotly/validators/splom/marker/line/_autocolorscale.py new file mode 100644 index 0000000000..ff03c53da2 --- /dev/null +++ b/plotly/validators/splom/marker/line/_autocolorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='autocolorscale', + parent_name='splom.marker.line', + **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_cauto.py b/plotly/validators/splom/marker/line/_cauto.py new file mode 100644 index 0000000000..bddac8c3e1 --- /dev/null +++ b/plotly/validators/splom/marker/line/_cauto.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='cauto', parent_name='splom.marker.line', **kwargs + ): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_cmax.py b/plotly/validators/splom/marker/line/_cmax.py new file mode 100644 index 0000000000..fd9d2f755c --- /dev/null +++ b/plotly/validators/splom/marker/line/_cmax.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmax', parent_name='splom.marker.line', **kwargs + ): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_cmin.py b/plotly/validators/splom/marker/line/_cmin.py new file mode 100644 index 0000000000..b87fdb4137 --- /dev/null +++ b/plotly/validators/splom/marker/line/_cmin.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='cmin', parent_name='splom.marker.line', **kwargs + ): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'cauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_color.py b/plotly/validators/splom/marker/line/_color.py new file mode 100644 index 0000000000..a5849d7e92 --- /dev/null +++ b/plotly/validators/splom/marker/line/_color.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='splom.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + colorscale_path='splom.marker.line.colorscale', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_colorscale.py b/plotly/validators/splom/marker/line/_colorscale.py new file mode 100644 index 0000000000..ab4beb2e97 --- /dev/null +++ b/plotly/validators/splom/marker/line/_colorscale.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, + plotly_name='colorscale', + parent_name='splom.marker.line', + **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_colorsrc.py b/plotly/validators/splom/marker/line/_colorsrc.py new file mode 100644 index 0000000000..f5f4524d85 --- /dev/null +++ b/plotly/validators/splom/marker/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='splom.marker.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_reversescale.py b/plotly/validators/splom/marker/line/_reversescale.py new file mode 100644 index 0000000000..d1da019839 --- /dev/null +++ b/plotly/validators/splom/marker/line/_reversescale.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='reversescale', + parent_name='splom.marker.line', + **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_width.py b/plotly/validators/splom/marker/line/_width.py new file mode 100644 index 0000000000..0fa10ec240 --- /dev/null +++ b/plotly/validators/splom/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='splom.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/marker/line/_widthsrc.py b/plotly/validators/splom/marker/line/_widthsrc.py new file mode 100644 index 0000000000..42ff1dd5f9 --- /dev/null +++ b/plotly/validators/splom/marker/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='splom.marker.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/selected/__init__.py b/plotly/validators/splom/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/splom/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/splom/selected/_marker.py b/plotly/validators/splom/selected/_marker.py new file mode 100644 index 0000000000..b90d27387b --- /dev/null +++ b/plotly/validators/splom/selected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='splom.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/splom/selected/marker/__init__.py b/plotly/validators/splom/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/splom/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/splom/selected/marker/_color.py b/plotly/validators/splom/selected/marker/_color.py new file mode 100644 index 0000000000..d4dee940b6 --- /dev/null +++ b/plotly/validators/splom/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='splom.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/selected/marker/_opacity.py b/plotly/validators/splom/selected/marker/_opacity.py new file mode 100644 index 0000000000..91b4ecfdbd --- /dev/null +++ b/plotly/validators/splom/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='splom.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/selected/marker/_size.py b/plotly/validators/splom/selected/marker/_size.py new file mode 100644 index 0000000000..d29e2e989a --- /dev/null +++ b/plotly/validators/splom/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='splom.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/stream/__init__.py b/plotly/validators/splom/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/splom/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/splom/stream/_maxpoints.py b/plotly/validators/splom/stream/_maxpoints.py new file mode 100644 index 0000000000..aa27d0f5e0 --- /dev/null +++ b/plotly/validators/splom/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='splom.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/splom/stream/_token.py b/plotly/validators/splom/stream/_token.py new file mode 100644 index 0000000000..7f11e6d183 --- /dev/null +++ b/plotly/validators/splom/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='splom.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/splom/unselected/__init__.py b/plotly/validators/splom/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/splom/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/splom/unselected/_marker.py b/plotly/validators/splom/unselected/_marker.py new file mode 100644 index 0000000000..19993ec986 --- /dev/null +++ b/plotly/validators/splom/unselected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='splom.unselected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/splom/unselected/marker/__init__.py b/plotly/validators/splom/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/splom/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/splom/unselected/marker/_color.py b/plotly/validators/splom/unselected/marker/_color.py new file mode 100644 index 0000000000..4290cfd143 --- /dev/null +++ b/plotly/validators/splom/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='splom.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/unselected/marker/_opacity.py b/plotly/validators/splom/unselected/marker/_opacity.py new file mode 100644 index 0000000000..07f6055847 --- /dev/null +++ b/plotly/validators/splom/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='splom.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/splom/unselected/marker/_size.py b/plotly/validators/splom/unselected/marker/_size.py new file mode 100644 index 0000000000..872b8067e7 --- /dev/null +++ b/plotly/validators/splom/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='splom.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/__init__.py b/plotly/validators/surface/__init__.py new file mode 100644 index 0000000000..274ea203ec --- /dev/null +++ b/plotly/validators/surface/__init__.py @@ -0,0 +1,41 @@ +from ._zsrc import ZsrcValidator +from ._zcalendar import ZcalendarValidator +from ._z import ZValidator +from ._ysrc import YsrcValidator +from ._ycalendar import YcalendarValidator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xcalendar import XcalendarValidator +from ._x import XValidator +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._surfacecolorsrc import SurfacecolorsrcValidator +from ._surfacecolor import SurfacecolorValidator +from ._stream import StreamValidator +from ._showscale import ShowscaleValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._scene import SceneValidator +from ._reversescale import ReversescaleValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._lightposition import LightpositionValidator +from ._lighting import LightingValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._hidesurface import HidesurfaceValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._contours import ContoursValidator +from ._colorscale import ColorscaleValidator +from ._colorbar import ColorBarValidator +from ._cmin import CminValidator +from ._cmax import CmaxValidator +from ._cauto import CautoValidator +from ._autocolorscale import AutocolorscaleValidator diff --git a/plotly/validators/surface/_autocolorscale.py b/plotly/validators/surface/_autocolorscale.py new file mode 100644 index 0000000000..7f9d653691 --- /dev/null +++ b/plotly/validators/surface/_autocolorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class AutocolorscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='autocolorscale', parent_name='surface', **kwargs + ): + super(AutocolorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/_cauto.py b/plotly/validators/surface/_cauto.py new file mode 100644 index 0000000000..f167c1221b --- /dev/null +++ b/plotly/validators/surface/_cauto.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CautoValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__(self, plotly_name='cauto', parent_name='surface', **kwargs): + super(CautoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_cmax.py b/plotly/validators/surface/_cmax.py new file mode 100644 index 0000000000..66cce933b2 --- /dev/null +++ b/plotly/validators/surface/_cmax.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CmaxValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmax', parent_name='surface', **kwargs): + super(CmaxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_cmin.py b/plotly/validators/surface/_cmin.py new file mode 100644 index 0000000000..ea66bde05a --- /dev/null +++ b/plotly/validators/surface/_cmin.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class CminValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='cmin', parent_name='surface', **kwargs): + super(CminValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'zauto': False}, + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_colorbar.py b/plotly/validators/surface/_colorbar.py new file mode 100644 index 0000000000..3317e8b899 --- /dev/null +++ b/plotly/validators/surface/_colorbar.py @@ -0,0 +1,209 @@ +import _plotly_utils.basevalidators + + +class ColorBarValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='colorbar', parent_name='surface', **kwargs + ): + super(ColorBarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='ColorBar', + data_docs=""" + bgcolor + Sets the color of padded area. + bordercolor + Sets the axis line color. + borderwidth + Sets the width (in px) or the border enclosing + this color bar. + dtick + Sets the step in-between ticks on this axis. + Use with `tick0`. Must be a positive number, or + special strings available to *log* and *date* + axes. If the axis `type` is *log*, then ticks + are set every 10^(n*dtick) where n is the tick + number. For example, to set a tick mark at 1, + 10, 100, 1000, ... set dtick to 1. To set tick + marks at 1, 100, 10000, ... set dtick to 2. To + set tick marks at 1, 5, 25, 125, 625, 3125, ... + set dtick to log_10(5), or 0.69897000433. *log* + has several special values; *L*, where `f` + is a positive number, gives ticks linearly + spaced in value (but not position). For example + `tick0` = 0.1, `dtick` = *L0.5* will put ticks + at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 + plus small digits between, use *D1* (all + digits) or *D2* (only 2 and 5). `tick0` is + ignored for *D1* and *D2*. If the axis `type` + is *date*, then you must convert the time to + milliseconds. For example, to set the interval + between ticks to one day, set `dtick` to + 86400000.0. *date* also has special values + *M* gives ticks spaced by a number of + months. `n` must be a positive integer. To set + ticks on the 15th of every third month, set + `tick0` to *2000-01-15* and `dtick` to *M3*. To + set ticks every 4 years, set `dtick` to *M48* + exponentformat + Determines a formatting rule for the tick + exponents. For example, consider the number + 1,000,000,000. If *none*, it appears as + 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If + *power*, 1x10^9 (with 9 in a super script). If + *SI*, 1G. If *B*, 1B. + len + Sets the length of the color bar This measure + excludes the padding of both ends. That is, the + color bar length is this length minus the + padding on both ends. + lenmode + Determines whether this color bar's length + (i.e. the measure in the color variation + direction) is set in units of plot *fraction* + or in *pixels. Use `len` to set the value. + nticks + Specifies the maximum number of ticks for the + particular axis. The actual number of ticks + will be chosen automatically to be less than or + equal to `nticks`. Has an effect only if + `tickmode` is set to *auto*. + outlinecolor + Sets the axis line color. + outlinewidth + Sets the width (in px) of the axis line. + separatethousands + If "true", even 4-digit integers are separated + showexponent + If *all*, all exponents are shown besides their + significands. If *first*, only the exponent of + the first tick is shown. If *last*, only the + exponent of the last tick is shown. If *none*, + no exponents appear. + showticklabels + Determines whether or not the tick labels are + drawn. + showtickprefix + If *all*, all tick labels are displayed with a + prefix. If *first*, only the first tick is + displayed with a prefix. If *last*, only the + last tick is displayed with a suffix. If + *none*, tick prefixes are hidden. + showticksuffix + Same as `showtickprefix` but for tick suffixes. + thickness + Sets the thickness of the color bar This + measure excludes the size of the padding, ticks + and labels. + thicknessmode + Determines whether this color bar's thickness + (i.e. the measure in the constant color + direction) is set in units of plot *fraction* + or in *pixels*. Use `thickness` to set the + value. + tick0 + Sets the placement of the first tick on this + axis. Use with `dtick`. If the axis `type` is + *log*, then you must take the log of your + starting tick (e.g. to set the starting tick to + 100, set the `tick0` to 2) except when + `dtick`=*L* (see `dtick` for more info). If + the axis `type` is *date*, it should be a date + string, like date data. If the axis `type` is + *category*, it should be a number, using the + scale where each category is assigned a serial + number from zero in the order it appears. + tickangle + Sets the angle of the tick labels with respect + to the horizontal. For example, a `tickangle` + of -90 draws the tick labels vertically. + tickcolor + Sets the tick color. + tickfont + Sets the color bar's tick label font + tickformat + Sets the tick label formatting rule using d3 + formatting mini-languages which are very + similar to those in Python. For numbers, see: h + ttps://github.com/d3/d3-format/blob/master/READ + ME.md#locale_format And for dates see: + https://github.com/d3/d3-time- + format/blob/master/README.md#locale_format We + add one item to d3's date formatter: *%{n}f* + for fractional seconds with n digits. For + example, *2016-10-13 09:15:23.456* with + tickformat *%H~%M~%S.%2f* would display + *09~15~23.46* + tickformatstops + plotly.graph_objs.surface.colorbar.Tickformatst + op instance or dict with compatible properties + ticklen + Sets the tick length (in px). + tickmode + Sets the tick mode for this axis. If *auto*, + the number of ticks is set via `nticks`. If + *linear*, the placement of the ticks is + determined by a starting position `tick0` and a + tick step `dtick` (*linear* is the default + value if `tick0` and `dtick` are provided). If + *array*, the placement of the ticks is set via + `tickvals` and the tick text is `ticktext`. + (*array* is the default value if `tickvals` is + provided). + tickprefix + Sets a tick label prefix. + ticks + Determines whether ticks are drawn or not. If + **, this axis' ticks are not drawn. If + *outside* (*inside*), this axis' are drawn + outside (inside) the axis lines. + ticksuffix + Sets a tick label suffix. + ticktext + Sets the text displayed at the ticks position + via `tickvals`. Only has an effect if + `tickmode` is set to *array*. Used with + `tickvals`. + ticktextsrc + Sets the source reference on plot.ly for + ticktext . + tickvals + Sets the values at which ticks on this axis + appear. Only has an effect if `tickmode` is set + to *array*. Used with `ticktext`. + tickvalssrc + Sets the source reference on plot.ly for + tickvals . + tickwidth + Sets the tick width (in px). + title + Sets the title of the color bar. + titlefont + Sets this color bar's title font. + titleside + Determines the location of the colorbar title + with respect to the color bar. + x + Sets the x position of the color bar (in plot + fraction). + xanchor + Sets this color bar's horizontal position + anchor. This anchor binds the `x` position to + the *left*, *center* or *right* of the color + bar. + xpad + Sets the amount of padding (in px) along the x + direction. + y + Sets the y position of the color bar (in plot + fraction). + yanchor + Sets this color bar's vertical position anchor + This anchor binds the `y` position to the + *top*, *middle* or *bottom* of the color bar. + ypad + Sets the amount of padding (in px) along the y + direction.""", + **kwargs + ) diff --git a/plotly/validators/surface/_colorscale.py b/plotly/validators/surface/_colorscale.py new file mode 100644 index 0000000000..e1babb4109 --- /dev/null +++ b/plotly/validators/surface/_colorscale.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorscaleValidator(_plotly_utils.basevalidators.ColorscaleValidator): + + def __init__( + self, plotly_name='colorscale', parent_name='surface', **kwargs + ): + super(ColorscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'autocolorscale': False}, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/_contours.py b/plotly/validators/surface/_contours.py new file mode 100644 index 0000000000..fe3df4f28a --- /dev/null +++ b/plotly/validators/surface/_contours.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class ContoursValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='contours', parent_name='surface', **kwargs + ): + super(ContoursValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Contours', + data_docs=""" + x + plotly.graph_objs.surface.contours.X instance + or dict with compatible properties + y + plotly.graph_objs.surface.contours.Y instance + or dict with compatible properties + z + plotly.graph_objs.surface.contours.Z instance + or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/surface/_customdata.py b/plotly/validators/surface/_customdata.py new file mode 100644 index 0000000000..c2dd98dc1f --- /dev/null +++ b/plotly/validators/surface/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='surface', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_customdatasrc.py b/plotly/validators/surface/_customdatasrc.py new file mode 100644 index 0000000000..5878fd6723 --- /dev/null +++ b/plotly/validators/surface/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='surface', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_hidesurface.py b/plotly/validators/surface/_hidesurface.py new file mode 100644 index 0000000000..7df00b9b6a --- /dev/null +++ b/plotly/validators/surface/_hidesurface.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HidesurfaceValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='hidesurface', parent_name='surface', **kwargs + ): + super(HidesurfaceValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_hoverinfo.py b/plotly/validators/surface/_hoverinfo.py new file mode 100644 index 0000000000..8d027a06c0 --- /dev/null +++ b/plotly/validators/surface/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='surface', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_hoverinfosrc.py b/plotly/validators/surface/_hoverinfosrc.py new file mode 100644 index 0000000000..29553a53d2 --- /dev/null +++ b/plotly/validators/surface/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='surface', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_hoverlabel.py b/plotly/validators/surface/_hoverlabel.py new file mode 100644 index 0000000000..6d1e44e4aa --- /dev/null +++ b/plotly/validators/surface/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='surface', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/surface/_ids.py b/plotly/validators/surface/_ids.py new file mode 100644 index 0000000000..ed13ab579a --- /dev/null +++ b/plotly/validators/surface/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='surface', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_idssrc.py b/plotly/validators/surface/_idssrc.py new file mode 100644 index 0000000000..c359b471ef --- /dev/null +++ b/plotly/validators/surface/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='surface', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_legendgroup.py b/plotly/validators/surface/_legendgroup.py new file mode 100644 index 0000000000..a018a8d860 --- /dev/null +++ b/plotly/validators/surface/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='surface', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_lighting.py b/plotly/validators/surface/_lighting.py new file mode 100644 index 0000000000..9e5370585b --- /dev/null +++ b/plotly/validators/surface/_lighting.py @@ -0,0 +1,33 @@ +import _plotly_utils.basevalidators + + +class LightingValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lighting', parent_name='surface', **kwargs + ): + super(LightingValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lighting', + data_docs=""" + ambient + Ambient light increases overall color + visibility but can wash out the image. + diffuse + Represents the extent that incident rays are + reflected in a range of angles. + fresnel + Represents the reflectance as a dependency of + the viewing angle; e.g. paper is reflective + when viewing it from the edge of the paper + (almost 90 degrees), causing shine. + roughness + Alters specular reflection; the rougher the + surface, the wider and less contrasty the + shine. + specular + Represents the level that incident rays are + reflected in a single direction, causing shine.""", + **kwargs + ) diff --git a/plotly/validators/surface/_lightposition.py b/plotly/validators/surface/_lightposition.py new file mode 100644 index 0000000000..dd020d1569 --- /dev/null +++ b/plotly/validators/surface/_lightposition.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class LightpositionValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='lightposition', parent_name='surface', **kwargs + ): + super(LightpositionValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Lightposition', + data_docs=""" + x + Numeric vector, representing the X coordinate + for each vertex. + y + Numeric vector, representing the Y coordinate + for each vertex. + z + Numeric vector, representing the Z coordinate + for each vertex.""", + **kwargs + ) diff --git a/plotly/validators/surface/_name.py b/plotly/validators/surface/_name.py new file mode 100644 index 0000000000..dba2321f66 --- /dev/null +++ b/plotly/validators/surface/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='surface', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_opacity.py b/plotly/validators/surface/_opacity.py new file mode 100644 index 0000000000..f5ad3a9056 --- /dev/null +++ b/plotly/validators/surface/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='surface', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/_reversescale.py b/plotly/validators/surface/_reversescale.py new file mode 100644 index 0000000000..ce583ef694 --- /dev/null +++ b/plotly/validators/surface/_reversescale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ReversescaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='reversescale', parent_name='surface', **kwargs + ): + super(ReversescaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/_scene.py b/plotly/validators/surface/_scene.py new file mode 100644 index 0000000000..9e2099512b --- /dev/null +++ b/plotly/validators/surface/_scene.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SceneValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='scene', parent_name='surface', **kwargs): + super(SceneValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='scene', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_selectedpoints.py b/plotly/validators/surface/_selectedpoints.py new file mode 100644 index 0000000000..05e0a81b15 --- /dev/null +++ b/plotly/validators/surface/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='surface', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_showlegend.py b/plotly/validators/surface/_showlegend.py new file mode 100644 index 0000000000..3dca4c38d6 --- /dev/null +++ b/plotly/validators/surface/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='surface', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_showscale.py b/plotly/validators/surface/_showscale.py new file mode 100644 index 0000000000..2afde045a5 --- /dev/null +++ b/plotly/validators/surface/_showscale.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowscaleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showscale', parent_name='surface', **kwargs + ): + super(ShowscaleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_stream.py b/plotly/validators/surface/_stream.py new file mode 100644 index 0000000000..a09c48ae2a --- /dev/null +++ b/plotly/validators/surface/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='surface', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/surface/_surfacecolor.py b/plotly/validators/surface/_surfacecolor.py new file mode 100644 index 0000000000..7ccd6fcb83 --- /dev/null +++ b/plotly/validators/surface/_surfacecolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SurfacecolorValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='surfacecolor', parent_name='surface', **kwargs + ): + super(SurfacecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_surfacecolorsrc.py b/plotly/validators/surface/_surfacecolorsrc.py new file mode 100644 index 0000000000..4d60756a00 --- /dev/null +++ b/plotly/validators/surface/_surfacecolorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SurfacecolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='surfacecolorsrc', parent_name='surface', **kwargs + ): + super(SurfacecolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_text.py b/plotly/validators/surface/_text.py new file mode 100644 index 0000000000..a737b20985 --- /dev/null +++ b/plotly/validators/surface/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='surface', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_textsrc.py b/plotly/validators/surface/_textsrc.py new file mode 100644 index 0000000000..9bd60d1695 --- /dev/null +++ b/plotly/validators/surface/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='surface', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_uid.py b/plotly/validators/surface/_uid.py new file mode 100644 index 0000000000..3b5f3565ff --- /dev/null +++ b/plotly/validators/surface/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='surface', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_visible.py b/plotly/validators/surface/_visible.py new file mode 100644 index 0000000000..37265a5213 --- /dev/null +++ b/plotly/validators/surface/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='surface', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/surface/_x.py b/plotly/validators/surface/_x.py new file mode 100644 index 0000000000..14a341dd78 --- /dev/null +++ b/plotly/validators/surface/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='surface', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_xcalendar.py b/plotly/validators/surface/_xcalendar.py new file mode 100644 index 0000000000..6f6c99f831 --- /dev/null +++ b/plotly/validators/surface/_xcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class XcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xcalendar', parent_name='surface', **kwargs + ): + super(XcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/surface/_xsrc.py b/plotly/validators/surface/_xsrc.py new file mode 100644 index 0000000000..c35a12bd5f --- /dev/null +++ b/plotly/validators/surface/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='surface', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_y.py b/plotly/validators/surface/_y.py new file mode 100644 index 0000000000..c814d3133f --- /dev/null +++ b/plotly/validators/surface/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='surface', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_ycalendar.py b/plotly/validators/surface/_ycalendar.py new file mode 100644 index 0000000000..d6e5cfaef3 --- /dev/null +++ b/plotly/validators/surface/_ycalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class YcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ycalendar', parent_name='surface', **kwargs + ): + super(YcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/surface/_ysrc.py b/plotly/validators/surface/_ysrc.py new file mode 100644 index 0000000000..ebfe74d4ad --- /dev/null +++ b/plotly/validators/surface/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='surface', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/_z.py b/plotly/validators/surface/_z.py new file mode 100644 index 0000000000..3825a390af --- /dev/null +++ b/plotly/validators/surface/_z.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='z', parent_name='surface', **kwargs): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/_zcalendar.py b/plotly/validators/surface/_zcalendar.py new file mode 100644 index 0000000000..b3e38ed8a4 --- /dev/null +++ b/plotly/validators/surface/_zcalendar.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class ZcalendarValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='zcalendar', parent_name='surface', **kwargs + ): + super(ZcalendarValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[ + 'gregorian', 'chinese', 'coptic', 'discworld', 'ethiopian', + 'hebrew', 'islamic', 'julian', 'mayan', 'nanakshahi', 'nepali', + 'persian', 'jalali', 'taiwan', 'thai', 'ummalqura' + ], + **kwargs + ) diff --git a/plotly/validators/surface/_zsrc.py b/plotly/validators/surface/_zsrc.py new file mode 100644 index 0000000000..4f46c97263 --- /dev/null +++ b/plotly/validators/surface/_zsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class ZsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='zsrc', parent_name='surface', **kwargs): + super(ZsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/__init__.py b/plotly/validators/surface/colorbar/__init__.py new file mode 100644 index 0000000000..5c903426b1 --- /dev/null +++ b/plotly/validators/surface/colorbar/__init__.py @@ -0,0 +1,42 @@ +from ._ypad import YpadValidator +from ._yanchor import YanchorValidator +from ._y import YValidator +from ._xpad import XpadValidator +from ._xanchor import XanchorValidator +from ._x import XValidator +from ._titleside import TitlesideValidator +from ._titlefont import TitlefontValidator +from ._title import TitleValidator +from ._tickwidth import TickwidthValidator +from ._tickvalssrc import TickvalssrcValidator +from ._tickvals import TickvalsValidator +from ._ticktextsrc import TicktextsrcValidator +from ._ticktext import TicktextValidator +from ._ticksuffix import TicksuffixValidator +from ._ticks import TicksValidator +from ._tickprefix import TickprefixValidator +from ._tickmode import TickmodeValidator +from ._ticklen import TicklenValidator +from ._tickformatstops import TickformatstopsValidator +from ._tickformat import TickformatValidator +from ._tickfont import TickfontValidator +from ._tickcolor import TickcolorValidator +from ._tickangle import TickangleValidator +from ._tick0 import Tick0Validator +from ._thicknessmode import ThicknessmodeValidator +from ._thickness import ThicknessValidator +from ._showticksuffix import ShowticksuffixValidator +from ._showtickprefix import ShowtickprefixValidator +from ._showticklabels import ShowticklabelsValidator +from ._showexponent import ShowexponentValidator +from ._separatethousands import SeparatethousandsValidator +from ._outlinewidth import OutlinewidthValidator +from ._outlinecolor import OutlinecolorValidator +from ._nticks import NticksValidator +from ._lenmode import LenmodeValidator +from ._len import LenValidator +from ._exponentformat import ExponentformatValidator +from ._dtick import DtickValidator +from ._borderwidth import BorderwidthValidator +from ._bordercolor import BordercolorValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/surface/colorbar/_bgcolor.py b/plotly/validators/surface/colorbar/_bgcolor.py new file mode 100644 index 0000000000..628e4978f7 --- /dev/null +++ b/plotly/validators/surface/colorbar/_bgcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='surface.colorbar', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_bordercolor.py b/plotly/validators/surface/colorbar/_bordercolor.py new file mode 100644 index 0000000000..b34d95a5f0 --- /dev/null +++ b/plotly/validators/surface/colorbar/_bordercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='surface.colorbar', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_borderwidth.py b/plotly/validators/surface/colorbar/_borderwidth.py new file mode 100644 index 0000000000..ed07da54d4 --- /dev/null +++ b/plotly/validators/surface/colorbar/_borderwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BorderwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='borderwidth', + parent_name='surface.colorbar', + **kwargs + ): + super(BorderwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_dtick.py b/plotly/validators/surface/colorbar/_dtick.py new file mode 100644 index 0000000000..78fcbf436a --- /dev/null +++ b/plotly/validators/surface/colorbar/_dtick.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class DtickValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='dtick', parent_name='surface.colorbar', **kwargs + ): + super(DtickValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_exponentformat.py b/plotly/validators/surface/colorbar/_exponentformat.py new file mode 100644 index 0000000000..0d1dda1f69 --- /dev/null +++ b/plotly/validators/surface/colorbar/_exponentformat.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ExponentformatValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='exponentformat', + parent_name='surface.colorbar', + **kwargs + ): + super(ExponentformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['none', 'e', 'E', 'power', 'SI', 'B'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_len.py b/plotly/validators/surface/colorbar/_len.py new file mode 100644 index 0000000000..4a20f88803 --- /dev/null +++ b/plotly/validators/surface/colorbar/_len.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='len', parent_name='surface.colorbar', **kwargs + ): + super(LenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_lenmode.py b/plotly/validators/surface/colorbar/_lenmode.py new file mode 100644 index 0000000000..340bc439a3 --- /dev/null +++ b/plotly/validators/surface/colorbar/_lenmode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class LenmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='lenmode', parent_name='surface.colorbar', **kwargs + ): + super(LenmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_nticks.py b/plotly/validators/surface/colorbar/_nticks.py new file mode 100644 index 0000000000..513325dff2 --- /dev/null +++ b/plotly/validators/surface/colorbar/_nticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class NticksValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='nticks', parent_name='surface.colorbar', **kwargs + ): + super(NticksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_outlinecolor.py b/plotly/validators/surface/colorbar/_outlinecolor.py new file mode 100644 index 0000000000..82c29069b3 --- /dev/null +++ b/plotly/validators/surface/colorbar/_outlinecolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutlinecolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outlinecolor', + parent_name='surface.colorbar', + **kwargs + ): + super(OutlinecolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_outlinewidth.py b/plotly/validators/surface/colorbar/_outlinewidth.py new file mode 100644 index 0000000000..a3dce91661 --- /dev/null +++ b/plotly/validators/surface/colorbar/_outlinewidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlinewidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlinewidth', + parent_name='surface.colorbar', + **kwargs + ): + super(OutlinewidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_separatethousands.py b/plotly/validators/surface/colorbar/_separatethousands.py new file mode 100644 index 0000000000..6b1937065f --- /dev/null +++ b/plotly/validators/surface/colorbar/_separatethousands.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SeparatethousandsValidator( + _plotly_utils.basevalidators.BooleanValidator +): + + def __init__( + self, + plotly_name='separatethousands', + parent_name='surface.colorbar', + **kwargs + ): + super(SeparatethousandsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_showexponent.py b/plotly/validators/surface/colorbar/_showexponent.py new file mode 100644 index 0000000000..936e7c24d9 --- /dev/null +++ b/plotly/validators/surface/colorbar/_showexponent.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ShowexponentValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='showexponent', + parent_name='surface.colorbar', + **kwargs + ): + super(ShowexponentValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_showticklabels.py b/plotly/validators/surface/colorbar/_showticklabels.py new file mode 100644 index 0000000000..af5581b4da --- /dev/null +++ b/plotly/validators/surface/colorbar/_showticklabels.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ShowticklabelsValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='showticklabels', + parent_name='surface.colorbar', + **kwargs + ): + super(ShowticklabelsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_showtickprefix.py b/plotly/validators/surface/colorbar/_showtickprefix.py new file mode 100644 index 0000000000..ebb76f5fb0 --- /dev/null +++ b/plotly/validators/surface/colorbar/_showtickprefix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowtickprefixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showtickprefix', + parent_name='surface.colorbar', + **kwargs + ): + super(ShowtickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_showticksuffix.py b/plotly/validators/surface/colorbar/_showticksuffix.py new file mode 100644 index 0000000000..d35a8cfc06 --- /dev/null +++ b/plotly/validators/surface/colorbar/_showticksuffix.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class ShowticksuffixValidator( + _plotly_utils.basevalidators.EnumeratedValidator +): + + def __init__( + self, + plotly_name='showticksuffix', + parent_name='surface.colorbar', + **kwargs + ): + super(ShowticksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['all', 'first', 'last', 'none'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_thickness.py b/plotly/validators/surface/colorbar/_thickness.py new file mode 100644 index 0000000000..b5b9455a91 --- /dev/null +++ b/plotly/validators/surface/colorbar/_thickness.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='thickness', + parent_name='surface.colorbar', + **kwargs + ): + super(ThicknessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_thicknessmode.py b/plotly/validators/surface/colorbar/_thicknessmode.py new file mode 100644 index 0000000000..53a52bc773 --- /dev/null +++ b/plotly/validators/surface/colorbar/_thicknessmode.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ThicknessmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='thicknessmode', + parent_name='surface.colorbar', + **kwargs + ): + super(ThicknessmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['fraction', 'pixels'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tick0.py b/plotly/validators/surface/colorbar/_tick0.py new file mode 100644 index 0000000000..3dfb4668de --- /dev/null +++ b/plotly/validators/surface/colorbar/_tick0.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class Tick0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='tick0', parent_name='surface.colorbar', **kwargs + ): + super(Tick0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={'tickmode': 'linear'}, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickangle.py b/plotly/validators/surface/colorbar/_tickangle.py new file mode 100644 index 0000000000..d6df8923d8 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickangle.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickangleValidator(_plotly_utils.basevalidators.AngleValidator): + + def __init__( + self, + plotly_name='tickangle', + parent_name='surface.colorbar', + **kwargs + ): + super(TickangleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickcolor.py b/plotly/validators/surface/colorbar/_tickcolor.py new file mode 100644 index 0000000000..a17c1966d9 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='tickcolor', + parent_name='surface.colorbar', + **kwargs + ): + super(TickcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickfont.py b/plotly/validators/surface/colorbar/_tickfont.py new file mode 100644 index 0000000000..4e7ef50af5 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickfont.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class TickfontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='tickfont', parent_name='surface.colorbar', **kwargs + ): + super(TickfontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickfont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickformat.py b/plotly/validators/surface/colorbar/_tickformat.py new file mode 100644 index 0000000000..d87b236517 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickformat.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickformatValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickformat', + parent_name='surface.colorbar', + **kwargs + ): + super(TickformatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickformatstops.py b/plotly/validators/surface/colorbar/_tickformatstops.py new file mode 100644 index 0000000000..df7a56fe59 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickformatstops.py @@ -0,0 +1,28 @@ +import _plotly_utils.basevalidators + + +class TickformatstopsValidator( + _plotly_utils.basevalidators.CompoundArrayValidator +): + + def __init__( + self, + plotly_name='tickformatstops', + parent_name='surface.colorbar', + **kwargs + ): + super(TickformatstopsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Tickformatstop', + data_docs=""" + dtickrange + range [*min*, *max*], where *min*, *max* - + dtick values which describe some zoom level, it + is possible to omit *min* or *max* value by + passing *null* + value + string - dtickformat for described zoom level, + the same as *tickformat*""", + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ticklen.py b/plotly/validators/surface/colorbar/_ticklen.py new file mode 100644 index 0000000000..8d34856745 --- /dev/null +++ b/plotly/validators/surface/colorbar/_ticklen.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicklenValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ticklen', parent_name='surface.colorbar', **kwargs + ): + super(TicklenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickmode.py b/plotly/validators/surface/colorbar/_tickmode.py new file mode 100644 index 0000000000..eabc522ba0 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickmode.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TickmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='tickmode', parent_name='surface.colorbar', **kwargs + ): + super(TickmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + implied_edits={}, + role='info', + values=['auto', 'linear', 'array'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickprefix.py b/plotly/validators/surface/colorbar/_tickprefix.py new file mode 100644 index 0000000000..01a971a0dd --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickprefix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickprefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='tickprefix', + parent_name='surface.colorbar', + **kwargs + ): + super(TickprefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ticks.py b/plotly/validators/surface/colorbar/_ticks.py new file mode 100644 index 0000000000..5236f12629 --- /dev/null +++ b/plotly/validators/surface/colorbar/_ticks.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class TicksValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='ticks', parent_name='surface.colorbar', **kwargs + ): + super(TicksValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['outside', 'inside', ''], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ticksuffix.py b/plotly/validators/surface/colorbar/_ticksuffix.py new file mode 100644 index 0000000000..d5a1807a2f --- /dev/null +++ b/plotly/validators/surface/colorbar/_ticksuffix.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicksuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='ticksuffix', + parent_name='surface.colorbar', + **kwargs + ): + super(TicksuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ticktext.py b/plotly/validators/surface/colorbar/_ticktext.py new file mode 100644 index 0000000000..9925210ea5 --- /dev/null +++ b/plotly/validators/surface/colorbar/_ticktext.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TicktextValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='ticktext', parent_name='surface.colorbar', **kwargs + ): + super(TicktextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ticktextsrc.py b/plotly/validators/surface/colorbar/_ticktextsrc.py new file mode 100644 index 0000000000..2ac187bdbc --- /dev/null +++ b/plotly/validators/surface/colorbar/_ticktextsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TicktextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='ticktextsrc', + parent_name='surface.colorbar', + **kwargs + ): + super(TicktextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickvals.py b/plotly/validators/surface/colorbar/_tickvals.py new file mode 100644 index 0000000000..9fe27abb9f --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickvals.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TickvalsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='tickvals', parent_name='surface.colorbar', **kwargs + ): + super(TickvalsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickvalssrc.py b/plotly/validators/surface/colorbar/_tickvalssrc.py new file mode 100644 index 0000000000..ea20f6da33 --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickvalssrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class TickvalssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='tickvalssrc', + parent_name='surface.colorbar', + **kwargs + ): + super(TickvalssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_tickwidth.py b/plotly/validators/surface/colorbar/_tickwidth.py new file mode 100644 index 0000000000..90b948aefc --- /dev/null +++ b/plotly/validators/surface/colorbar/_tickwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TickwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='tickwidth', + parent_name='surface.colorbar', + **kwargs + ): + super(TickwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_title.py b/plotly/validators/surface/colorbar/_title.py new file mode 100644 index 0000000000..efc1e046a0 --- /dev/null +++ b/plotly/validators/surface/colorbar/_title.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class TitleValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='title', parent_name='surface.colorbar', **kwargs + ): + super(TitleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_titlefont.py b/plotly/validators/surface/colorbar/_titlefont.py new file mode 100644 index 0000000000..03cc5bc1ef --- /dev/null +++ b/plotly/validators/surface/colorbar/_titlefont.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class TitlefontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='titlefont', + parent_name='surface.colorbar', + **kwargs + ): + super(TitlefontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Titlefont', + data_docs=""" + color + + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + size +""", + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_titleside.py b/plotly/validators/surface/colorbar/_titleside.py new file mode 100644 index 0000000000..e05e97bb30 --- /dev/null +++ b/plotly/validators/surface/colorbar/_titleside.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class TitlesideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, + plotly_name='titleside', + parent_name='surface.colorbar', + **kwargs + ): + super(TitlesideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['right', 'top', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_x.py b/plotly/validators/surface/colorbar/_x.py new file mode 100644 index 0000000000..c1afa4bcfe --- /dev/null +++ b/plotly/validators/surface/colorbar/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='surface.colorbar', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_xanchor.py b/plotly/validators/surface/colorbar/_xanchor.py new file mode 100644 index 0000000000..00234c37f2 --- /dev/null +++ b/plotly/validators/surface/colorbar/_xanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='xanchor', parent_name='surface.colorbar', **kwargs + ): + super(XanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_xpad.py b/plotly/validators/surface/colorbar/_xpad.py new file mode 100644 index 0000000000..9fa76b819b --- /dev/null +++ b/plotly/validators/surface/colorbar/_xpad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class XpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='xpad', parent_name='surface.colorbar', **kwargs + ): + super(XpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_y.py b/plotly/validators/surface/colorbar/_y.py new file mode 100644 index 0000000000..95bbbaf192 --- /dev/null +++ b/plotly/validators/surface/colorbar/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='surface.colorbar', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=3, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_yanchor.py b/plotly/validators/surface/colorbar/_yanchor.py new file mode 100644 index 0000000000..4604623ed1 --- /dev/null +++ b/plotly/validators/surface/colorbar/_yanchor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YanchorValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='yanchor', parent_name='surface.colorbar', **kwargs + ): + super(YanchorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + values=['top', 'middle', 'bottom'], + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/_ypad.py b/plotly/validators/surface/colorbar/_ypad.py new file mode 100644 index 0000000000..c83666ed8f --- /dev/null +++ b/plotly/validators/surface/colorbar/_ypad.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class YpadValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ypad', parent_name='surface.colorbar', **kwargs + ): + super(YpadValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/tickfont/__init__.py b/plotly/validators/surface/colorbar/tickfont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/surface/colorbar/tickfont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/colorbar/tickfont/_color.py b/plotly/validators/surface/colorbar/tickfont/_color.py new file mode 100644 index 0000000000..cea02c68e1 --- /dev/null +++ b/plotly/validators/surface/colorbar/tickfont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='surface.colorbar.tickfont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/tickfont/_family.py b/plotly/validators/surface/colorbar/tickfont/_family.py new file mode 100644 index 0000000000..65ee21d4be --- /dev/null +++ b/plotly/validators/surface/colorbar/tickfont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='surface.colorbar.tickfont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/tickfont/_size.py b/plotly/validators/surface/colorbar/tickfont/_size.py new file mode 100644 index 0000000000..6f0ec5bab5 --- /dev/null +++ b/plotly/validators/surface/colorbar/tickfont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='surface.colorbar.tickfont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/tickformatstop/__init__.py b/plotly/validators/surface/colorbar/tickformatstop/__init__.py new file mode 100644 index 0000000000..425e7ba96f --- /dev/null +++ b/plotly/validators/surface/colorbar/tickformatstop/__init__.py @@ -0,0 +1,2 @@ +from ._value import ValueValidator +from ._dtickrange import DtickrangeValidator diff --git a/plotly/validators/surface/colorbar/tickformatstop/_dtickrange.py b/plotly/validators/surface/colorbar/tickformatstop/_dtickrange.py new file mode 100644 index 0000000000..6351df937c --- /dev/null +++ b/plotly/validators/surface/colorbar/tickformatstop/_dtickrange.py @@ -0,0 +1,27 @@ +import _plotly_utils.basevalidators + + +class DtickrangeValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__( + self, + plotly_name='dtickrange', + parent_name='surface.colorbar.tickformatstop', + **kwargs + ): + super(DtickrangeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/tickformatstop/_value.py b/plotly/validators/surface/colorbar/tickformatstop/_value.py new file mode 100644 index 0000000000..c9eded0552 --- /dev/null +++ b/plotly/validators/surface/colorbar/tickformatstop/_value.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ValueValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='value', + parent_name='surface.colorbar.tickformatstop', + **kwargs + ): + super(ValueValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/titlefont/__init__.py b/plotly/validators/surface/colorbar/titlefont/__init__.py new file mode 100644 index 0000000000..199d72e71c --- /dev/null +++ b/plotly/validators/surface/colorbar/titlefont/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._family import FamilyValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/colorbar/titlefont/_color.py b/plotly/validators/surface/colorbar/titlefont/_color.py new file mode 100644 index 0000000000..dcadfc7a3b --- /dev/null +++ b/plotly/validators/surface/colorbar/titlefont/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='surface.colorbar.titlefont', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/titlefont/_family.py b/plotly/validators/surface/colorbar/titlefont/_family.py new file mode 100644 index 0000000000..48d8b206ed --- /dev/null +++ b/plotly/validators/surface/colorbar/titlefont/_family.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='surface.colorbar.titlefont', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/surface/colorbar/titlefont/_size.py b/plotly/validators/surface/colorbar/titlefont/_size.py new file mode 100644 index 0000000000..316ea7d2ac --- /dev/null +++ b/plotly/validators/surface/colorbar/titlefont/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='surface.colorbar.titlefont', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/__init__.py b/plotly/validators/surface/contours/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/surface/contours/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/surface/contours/_x.py b/plotly/validators/surface/contours/_x.py new file mode 100644 index 0000000000..629bb747d1 --- /dev/null +++ b/plotly/validators/surface/contours/_x.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='x', parent_name='surface.contours', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='X', + data_docs=""" + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the x dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.x.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the x dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/_y.py b/plotly/validators/surface/contours/_y.py new file mode 100644 index 0000000000..082fcb69c7 --- /dev/null +++ b/plotly/validators/surface/contours/_y.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='y', parent_name='surface.contours', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Y', + data_docs=""" + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the y dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.y.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the y dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/_z.py b/plotly/validators/surface/contours/_z.py new file mode 100644 index 0000000000..bc0df63cc2 --- /dev/null +++ b/plotly/validators/surface/contours/_z.py @@ -0,0 +1,38 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='z', parent_name='surface.contours', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Z', + data_docs=""" + color + Sets the color of the contour lines. + highlight + Determines whether or not contour lines about + the z dimension are highlighted on hover. + highlightcolor + Sets the color of the highlighted contour + lines. + highlightwidth + Sets the width of the highlighted contour + lines. + project + plotly.graph_objs.surface.contours.z.Project + instance or dict with compatible properties + show + Determines whether or not contour lines about + the z dimension are drawn. + usecolormap + An alternate to *color*. Determines whether or + not the contour lines are colored using the + trace *colorscale*. + width + Sets the width of the contour lines.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/__init__.py b/plotly/validators/surface/contours/x/__init__.py new file mode 100644 index 0000000000..fe30afc140 --- /dev/null +++ b/plotly/validators/surface/contours/x/__init__.py @@ -0,0 +1,8 @@ +from ._width import WidthValidator +from ._usecolormap import UsecolormapValidator +from ._show import ShowValidator +from ._project import ProjectValidator +from ._highlightwidth import HighlightwidthValidator +from ._highlightcolor import HighlightcolorValidator +from ._highlight import HighlightValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/contours/x/_color.py b/plotly/validators/surface/contours/x/_color.py new file mode 100644 index 0000000000..69c961fc19 --- /dev/null +++ b/plotly/validators/surface/contours/x/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='surface.contours.x', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_highlight.py b/plotly/validators/surface/contours/x/_highlight.py new file mode 100644 index 0000000000..96ad398185 --- /dev/null +++ b/plotly/validators/surface/contours/x/_highlight.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='highlight', + parent_name='surface.contours.x', + **kwargs + ): + super(HighlightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_highlightcolor.py b/plotly/validators/surface/contours/x/_highlightcolor.py new file mode 100644 index 0000000000..04433b2ad2 --- /dev/null +++ b/plotly/validators/surface/contours/x/_highlightcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='highlightcolor', + parent_name='surface.contours.x', + **kwargs + ): + super(HighlightcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_highlightwidth.py b/plotly/validators/surface/contours/x/_highlightwidth.py new file mode 100644 index 0000000000..2bb131b78d --- /dev/null +++ b/plotly/validators/surface/contours/x/_highlightwidth.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class HighlightwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='highlightwidth', + parent_name='surface.contours.x', + **kwargs + ): + super(HighlightwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_project.py b/plotly/validators/surface/contours/x/_project.py new file mode 100644 index 0000000000..b2e2d37f93 --- /dev/null +++ b/plotly/validators/surface/contours/x/_project.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class ProjectValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='project', + parent_name='surface.contours.x', + **kwargs + ): + super(ProjectValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Project', + data_docs=""" + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_show.py b/plotly/validators/surface/contours/x/_show.py new file mode 100644 index 0000000000..e36206a327 --- /dev/null +++ b/plotly/validators/surface/contours/x/_show.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='show', parent_name='surface.contours.x', **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_usecolormap.py b/plotly/validators/surface/contours/x/_usecolormap.py new file mode 100644 index 0000000000..13a20b880f --- /dev/null +++ b/plotly/validators/surface/contours/x/_usecolormap.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UsecolormapValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='usecolormap', + parent_name='surface.contours.x', + **kwargs + ): + super(UsecolormapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/_width.py b/plotly/validators/surface/contours/x/_width.py new file mode 100644 index 0000000000..b6c979738f --- /dev/null +++ b/plotly/validators/surface/contours/x/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='surface.contours.x', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/project/__init__.py b/plotly/validators/surface/contours/x/project/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/surface/contours/x/project/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/surface/contours/x/project/_x.py b/plotly/validators/surface/contours/x/project/_x.py new file mode 100644 index 0000000000..4de2a36b81 --- /dev/null +++ b/plotly/validators/surface/contours/x/project/_x.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='x', + parent_name='surface.contours.x.project', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/project/_y.py b/plotly/validators/surface/contours/x/project/_y.py new file mode 100644 index 0000000000..61d9224aee --- /dev/null +++ b/plotly/validators/surface/contours/x/project/_y.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='y', + parent_name='surface.contours.x.project', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/x/project/_z.py b/plotly/validators/surface/contours/x/project/_z.py new file mode 100644 index 0000000000..0646dacb01 --- /dev/null +++ b/plotly/validators/surface/contours/x/project/_z.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='z', + parent_name='surface.contours.x.project', + **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/__init__.py b/plotly/validators/surface/contours/y/__init__.py new file mode 100644 index 0000000000..fe30afc140 --- /dev/null +++ b/plotly/validators/surface/contours/y/__init__.py @@ -0,0 +1,8 @@ +from ._width import WidthValidator +from ._usecolormap import UsecolormapValidator +from ._show import ShowValidator +from ._project import ProjectValidator +from ._highlightwidth import HighlightwidthValidator +from ._highlightcolor import HighlightcolorValidator +from ._highlight import HighlightValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/contours/y/_color.py b/plotly/validators/surface/contours/y/_color.py new file mode 100644 index 0000000000..881434da97 --- /dev/null +++ b/plotly/validators/surface/contours/y/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='surface.contours.y', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_highlight.py b/plotly/validators/surface/contours/y/_highlight.py new file mode 100644 index 0000000000..2d189657eb --- /dev/null +++ b/plotly/validators/surface/contours/y/_highlight.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='highlight', + parent_name='surface.contours.y', + **kwargs + ): + super(HighlightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_highlightcolor.py b/plotly/validators/surface/contours/y/_highlightcolor.py new file mode 100644 index 0000000000..f1a95d3b6c --- /dev/null +++ b/plotly/validators/surface/contours/y/_highlightcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='highlightcolor', + parent_name='surface.contours.y', + **kwargs + ): + super(HighlightcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_highlightwidth.py b/plotly/validators/surface/contours/y/_highlightwidth.py new file mode 100644 index 0000000000..2d1fe24996 --- /dev/null +++ b/plotly/validators/surface/contours/y/_highlightwidth.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class HighlightwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='highlightwidth', + parent_name='surface.contours.y', + **kwargs + ): + super(HighlightwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_project.py b/plotly/validators/surface/contours/y/_project.py new file mode 100644 index 0000000000..d8921fdb0d --- /dev/null +++ b/plotly/validators/surface/contours/y/_project.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class ProjectValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='project', + parent_name='surface.contours.y', + **kwargs + ): + super(ProjectValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Project', + data_docs=""" + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_show.py b/plotly/validators/surface/contours/y/_show.py new file mode 100644 index 0000000000..117a7eef12 --- /dev/null +++ b/plotly/validators/surface/contours/y/_show.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='show', parent_name='surface.contours.y', **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_usecolormap.py b/plotly/validators/surface/contours/y/_usecolormap.py new file mode 100644 index 0000000000..50ee6f158b --- /dev/null +++ b/plotly/validators/surface/contours/y/_usecolormap.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UsecolormapValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='usecolormap', + parent_name='surface.contours.y', + **kwargs + ): + super(UsecolormapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/_width.py b/plotly/validators/surface/contours/y/_width.py new file mode 100644 index 0000000000..68f6400a9c --- /dev/null +++ b/plotly/validators/surface/contours/y/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='surface.contours.y', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/project/__init__.py b/plotly/validators/surface/contours/y/project/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/surface/contours/y/project/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/surface/contours/y/project/_x.py b/plotly/validators/surface/contours/y/project/_x.py new file mode 100644 index 0000000000..96e07760c5 --- /dev/null +++ b/plotly/validators/surface/contours/y/project/_x.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='x', + parent_name='surface.contours.y.project', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/project/_y.py b/plotly/validators/surface/contours/y/project/_y.py new file mode 100644 index 0000000000..914b182874 --- /dev/null +++ b/plotly/validators/surface/contours/y/project/_y.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='y', + parent_name='surface.contours.y.project', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/y/project/_z.py b/plotly/validators/surface/contours/y/project/_z.py new file mode 100644 index 0000000000..ebeffb0952 --- /dev/null +++ b/plotly/validators/surface/contours/y/project/_z.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='z', + parent_name='surface.contours.y.project', + **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/__init__.py b/plotly/validators/surface/contours/z/__init__.py new file mode 100644 index 0000000000..fe30afc140 --- /dev/null +++ b/plotly/validators/surface/contours/z/__init__.py @@ -0,0 +1,8 @@ +from ._width import WidthValidator +from ._usecolormap import UsecolormapValidator +from ._show import ShowValidator +from ._project import ProjectValidator +from ._highlightwidth import HighlightwidthValidator +from ._highlightcolor import HighlightcolorValidator +from ._highlight import HighlightValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/contours/z/_color.py b/plotly/validators/surface/contours/z/_color.py new file mode 100644 index 0000000000..9d85f5ccbc --- /dev/null +++ b/plotly/validators/surface/contours/z/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='surface.contours.z', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_highlight.py b/plotly/validators/surface/contours/z/_highlight.py new file mode 100644 index 0000000000..aaab49ac2f --- /dev/null +++ b/plotly/validators/surface/contours/z/_highlight.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='highlight', + parent_name='surface.contours.z', + **kwargs + ): + super(HighlightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_highlightcolor.py b/plotly/validators/surface/contours/z/_highlightcolor.py new file mode 100644 index 0000000000..eda351da84 --- /dev/null +++ b/plotly/validators/surface/contours/z/_highlightcolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HighlightcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='highlightcolor', + parent_name='surface.contours.z', + **kwargs + ): + super(HighlightcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_highlightwidth.py b/plotly/validators/surface/contours/z/_highlightwidth.py new file mode 100644 index 0000000000..70dd8602c9 --- /dev/null +++ b/plotly/validators/surface/contours/z/_highlightwidth.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class HighlightwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='highlightwidth', + parent_name='surface.contours.z', + **kwargs + ): + super(HighlightwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_project.py b/plotly/validators/surface/contours/z/_project.py new file mode 100644 index 0000000000..35df015799 --- /dev/null +++ b/plotly/validators/surface/contours/z/_project.py @@ -0,0 +1,39 @@ +import _plotly_utils.basevalidators + + +class ProjectValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, + plotly_name='project', + parent_name='surface.contours.z', + **kwargs + ): + super(ProjectValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Project', + data_docs=""" + x + Determines whether or not these contour lines + are projected on the x plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + y + Determines whether or not these contour lines + are projected on the y plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence. + z + Determines whether or not these contour lines + are projected on the z plane. If `highlight` is + set to *true* (the default), the projected + lines are shown on hover. If `show` is set to + *true*, the projected lines are shown in + permanence.""", + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_show.py b/plotly/validators/surface/contours/z/_show.py new file mode 100644 index 0000000000..3c911008c5 --- /dev/null +++ b/plotly/validators/surface/contours/z/_show.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='show', parent_name='surface.contours.z', **kwargs + ): + super(ShowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_usecolormap.py b/plotly/validators/surface/contours/z/_usecolormap.py new file mode 100644 index 0000000000..e676123680 --- /dev/null +++ b/plotly/validators/surface/contours/z/_usecolormap.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UsecolormapValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='usecolormap', + parent_name='surface.contours.z', + **kwargs + ): + super(UsecolormapValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/_width.py b/plotly/validators/surface/contours/z/_width.py new file mode 100644 index 0000000000..c038b1774c --- /dev/null +++ b/plotly/validators/surface/contours/z/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='surface.contours.z', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=16, + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/project/__init__.py b/plotly/validators/surface/contours/z/project/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/surface/contours/z/project/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/surface/contours/z/project/_x.py b/plotly/validators/surface/contours/z/project/_x.py new file mode 100644 index 0000000000..a3ec2d8378 --- /dev/null +++ b/plotly/validators/surface/contours/z/project/_x.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='x', + parent_name='surface.contours.z.project', + **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/project/_y.py b/plotly/validators/surface/contours/z/project/_y.py new file mode 100644 index 0000000000..d74f15ce62 --- /dev/null +++ b/plotly/validators/surface/contours/z/project/_y.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='y', + parent_name='surface.contours.z.project', + **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/contours/z/project/_z.py b/plotly/validators/surface/contours/z/project/_z.py new file mode 100644 index 0000000000..fe4f1727a8 --- /dev/null +++ b/plotly/validators/surface/contours/z/project/_z.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, + plotly_name='z', + parent_name='surface.contours.z.project', + **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/__init__.py b/plotly/validators/surface/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/surface/hoverlabel/_bgcolor.py b/plotly/validators/surface/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..b97b644fa7 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_bgcolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bgcolor', + parent_name='surface.hoverlabel', + **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_bgcolorsrc.py b/plotly/validators/surface/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..81cda4321d --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='surface.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_bordercolor.py b/plotly/validators/surface/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..2d425336ad --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='surface.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_bordercolorsrc.py b/plotly/validators/surface/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..c8aed8639d --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='surface.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_font.py b/plotly/validators/surface/hoverlabel/_font.py new file mode 100644 index 0000000000..7091216ee8 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='surface.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_namelength.py b/plotly/validators/surface/hoverlabel/_namelength.py new file mode 100644 index 0000000000..320055912c --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='surface.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/_namelengthsrc.py b/plotly/validators/surface/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..0b23af409b --- /dev/null +++ b/plotly/validators/surface/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='surface.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/__init__.py b/plotly/validators/surface/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/surface/hoverlabel/font/_color.py b/plotly/validators/surface/hoverlabel/font/_color.py new file mode 100644 index 0000000000..83c5c6f8b2 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/_colorsrc.py b/plotly/validators/surface/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..246f1099d2 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/_family.py b/plotly/validators/surface/hoverlabel/font/_family.py new file mode 100644 index 0000000000..d71c642ca8 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/_familysrc.py b/plotly/validators/surface/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..6518d72a14 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/_size.py b/plotly/validators/surface/hoverlabel/font/_size.py new file mode 100644 index 0000000000..7e7b383f35 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/hoverlabel/font/_sizesrc.py b/plotly/validators/surface/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..96e12687d1 --- /dev/null +++ b/plotly/validators/surface/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='surface.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/lighting/__init__.py b/plotly/validators/surface/lighting/__init__.py new file mode 100644 index 0000000000..41c014f1ca --- /dev/null +++ b/plotly/validators/surface/lighting/__init__.py @@ -0,0 +1,5 @@ +from ._specular import SpecularValidator +from ._roughness import RoughnessValidator +from ._fresnel import FresnelValidator +from ._diffuse import DiffuseValidator +from ._ambient import AmbientValidator diff --git a/plotly/validators/surface/lighting/_ambient.py b/plotly/validators/surface/lighting/_ambient.py new file mode 100644 index 0000000000..3770c7e6b8 --- /dev/null +++ b/plotly/validators/surface/lighting/_ambient.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AmbientValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='ambient', parent_name='surface.lighting', **kwargs + ): + super(AmbientValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lighting/_diffuse.py b/plotly/validators/surface/lighting/_diffuse.py new file mode 100644 index 0000000000..db92deae8e --- /dev/null +++ b/plotly/validators/surface/lighting/_diffuse.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class DiffuseValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='diffuse', parent_name='surface.lighting', **kwargs + ): + super(DiffuseValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lighting/_fresnel.py b/plotly/validators/surface/lighting/_fresnel.py new file mode 100644 index 0000000000..4ba7ae2b61 --- /dev/null +++ b/plotly/validators/surface/lighting/_fresnel.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class FresnelValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='fresnel', parent_name='surface.lighting', **kwargs + ): + super(FresnelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=5, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lighting/_roughness.py b/plotly/validators/surface/lighting/_roughness.py new file mode 100644 index 0000000000..61001827d3 --- /dev/null +++ b/plotly/validators/surface/lighting/_roughness.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class RoughnessValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='roughness', + parent_name='surface.lighting', + **kwargs + ): + super(RoughnessValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lighting/_specular.py b/plotly/validators/surface/lighting/_specular.py new file mode 100644 index 0000000000..762d187309 --- /dev/null +++ b/plotly/validators/surface/lighting/_specular.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SpecularValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='specular', parent_name='surface.lighting', **kwargs + ): + super(SpecularValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=2, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lightposition/__init__.py b/plotly/validators/surface/lightposition/__init__.py new file mode 100644 index 0000000000..438e2dc9c6 --- /dev/null +++ b/plotly/validators/surface/lightposition/__init__.py @@ -0,0 +1,3 @@ +from ._z import ZValidator +from ._y import YValidator +from ._x import XValidator diff --git a/plotly/validators/surface/lightposition/_x.py b/plotly/validators/surface/lightposition/_x.py new file mode 100644 index 0000000000..e061faada2 --- /dev/null +++ b/plotly/validators/surface/lightposition/_x.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='x', parent_name='surface.lightposition', **kwargs + ): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lightposition/_y.py b/plotly/validators/surface/lightposition/_y.py new file mode 100644 index 0000000000..3fa09ff7fc --- /dev/null +++ b/plotly/validators/surface/lightposition/_y.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='y', parent_name='surface.lightposition', **kwargs + ): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/lightposition/_z.py b/plotly/validators/surface/lightposition/_z.py new file mode 100644 index 0000000000..a8b65d2258 --- /dev/null +++ b/plotly/validators/surface/lightposition/_z.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class ZValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='z', parent_name='surface.lightposition', **kwargs + ): + super(ZValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=100000, + min=-100000, + role='style', + **kwargs + ) diff --git a/plotly/validators/surface/stream/__init__.py b/plotly/validators/surface/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/surface/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/surface/stream/_maxpoints.py b/plotly/validators/surface/stream/_maxpoints.py new file mode 100644 index 0000000000..b44aa8f998 --- /dev/null +++ b/plotly/validators/surface/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='surface.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/surface/stream/_token.py b/plotly/validators/surface/stream/_token.py new file mode 100644 index 0000000000..f352e3108c --- /dev/null +++ b/plotly/validators/surface/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='surface.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/table/__init__.py b/plotly/validators/table/__init__.py new file mode 100644 index 0000000000..ffbed4e0bd --- /dev/null +++ b/plotly/validators/table/__init__.py @@ -0,0 +1,22 @@ +from ._visible import VisibleValidator +from ._uid import UidValidator +from ._stream import StreamValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._legendgroup import LegendgroupValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._header import HeaderValidator +from ._domain import DomainValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._columnwidthsrc import ColumnwidthsrcValidator +from ._columnwidth import ColumnwidthValidator +from ._columnordersrc import ColumnordersrcValidator +from ._columnorder import ColumnorderValidator +from ._cells import CellsValidator diff --git a/plotly/validators/table/_cells.py b/plotly/validators/table/_cells.py new file mode 100644 index 0000000000..49e74d2547 --- /dev/null +++ b/plotly/validators/table/_cells.py @@ -0,0 +1,62 @@ +import _plotly_utils.basevalidators + + +class CellsValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='cells', parent_name='table', **kwargs): + super(CellsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Cells', + data_docs=""" + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + alignsrc + Sets the source reference on plot.ly for align + . + fill + plotly.graph_objs.table.cells.Fill instance or + dict with compatible properties + font + plotly.graph_objs.table.cells.Font instance or + dict with compatible properties + format + Sets the cell value formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + formatsrc + Sets the source reference on plot.ly for + format . + height + The height of cells. + line + plotly.graph_objs.table.cells.Line instance or + dict with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for + prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for + suffix . + values + Cell values. `values[m][n]` represents the + value of the `n`th point in column `m`, + therefore the `values[m]` vector length for all + columns must be the same (longer vectors will + be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for + values .""", + **kwargs + ) diff --git a/plotly/validators/table/_columnorder.py b/plotly/validators/table/_columnorder.py new file mode 100644 index 0000000000..fe2897e598 --- /dev/null +++ b/plotly/validators/table/_columnorder.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColumnorderValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='columnorder', parent_name='table', **kwargs + ): + super(ColumnorderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/_columnordersrc.py b/plotly/validators/table/_columnordersrc.py new file mode 100644 index 0000000000..fbaf2abd88 --- /dev/null +++ b/plotly/validators/table/_columnordersrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColumnordersrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='columnordersrc', parent_name='table', **kwargs + ): + super(ColumnordersrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_columnwidth.py b/plotly/validators/table/_columnwidth.py new file mode 100644 index 0000000000..4297384c09 --- /dev/null +++ b/plotly/validators/table/_columnwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='columnwidth', parent_name='table', **kwargs + ): + super(ColumnwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/_columnwidthsrc.py b/plotly/validators/table/_columnwidthsrc.py new file mode 100644 index 0000000000..241333e374 --- /dev/null +++ b/plotly/validators/table/_columnwidthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColumnwidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='columnwidthsrc', parent_name='table', **kwargs + ): + super(ColumnwidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_customdata.py b/plotly/validators/table/_customdata.py new file mode 100644 index 0000000000..1a7725fe14 --- /dev/null +++ b/plotly/validators/table/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='table', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/_customdatasrc.py b/plotly/validators/table/_customdatasrc.py new file mode 100644 index 0000000000..89629a1b86 --- /dev/null +++ b/plotly/validators/table/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='table', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_domain.py b/plotly/validators/table/_domain.py new file mode 100644 index 0000000000..d8390e02b9 --- /dev/null +++ b/plotly/validators/table/_domain.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class DomainValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='domain', parent_name='table', **kwargs): + super(DomainValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Domain', + data_docs=""" + column + If there is a layout grid, use the domain for + this column in the grid for this table trace . + row + If there is a layout grid, use the domain for + this row in the grid for this table trace . + x + Sets the horizontal domain of this table trace + (in plot fraction). + y + Sets the vertical domain of this table trace + (in plot fraction).""", + **kwargs + ) diff --git a/plotly/validators/table/_header.py b/plotly/validators/table/_header.py new file mode 100644 index 0000000000..a5e6442b1c --- /dev/null +++ b/plotly/validators/table/_header.py @@ -0,0 +1,62 @@ +import _plotly_utils.basevalidators + + +class HeaderValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='header', parent_name='table', **kwargs): + super(HeaderValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Header', + data_docs=""" + align + Sets the horizontal alignment of the `text` + within the box. Has an effect only if `text` + spans more two or more lines (i.e. `text` + contains one or more
HTML tags) or if an + explicit width is set to override the text + width. + alignsrc + Sets the source reference on plot.ly for align + . + fill + plotly.graph_objs.table.header.Fill instance or + dict with compatible properties + font + plotly.graph_objs.table.header.Font instance or + dict with compatible properties + format + Sets the cell value formatting rule using d3 + formatting mini-language which is similar to + those of Python. See https://github.com/d3/d3-f + ormat/blob/master/README.md#locale_format + formatsrc + Sets the source reference on plot.ly for + format . + height + The height of cells. + line + plotly.graph_objs.table.header.Line instance or + dict with compatible properties + prefix + Prefix for cell values. + prefixsrc + Sets the source reference on plot.ly for + prefix . + suffix + Suffix for cell values. + suffixsrc + Sets the source reference on plot.ly for + suffix . + values + Header cell values. `values[m][n]` represents + the value of the `n`th point in column `m`, + therefore the `values[m]` vector length for all + columns must be the same (longer vectors will + be truncated). Each value must be a finite + number or a string. + valuessrc + Sets the source reference on plot.ly for + values .""", + **kwargs + ) diff --git a/plotly/validators/table/_hoverinfo.py b/plotly/validators/table/_hoverinfo.py new file mode 100644 index 0000000000..572699c6f6 --- /dev/null +++ b/plotly/validators/table/_hoverinfo.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoverinfo', parent_name='table', **kwargs): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_hoverinfosrc.py b/plotly/validators/table/_hoverinfosrc.py new file mode 100644 index 0000000000..b1010bf1f9 --- /dev/null +++ b/plotly/validators/table/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='table', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_hoverlabel.py b/plotly/validators/table/_hoverlabel.py new file mode 100644 index 0000000000..29dba83c97 --- /dev/null +++ b/plotly/validators/table/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='table', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/table/_ids.py b/plotly/validators/table/_ids.py new file mode 100644 index 0000000000..9bab365820 --- /dev/null +++ b/plotly/validators/table/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='table', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/_idssrc.py b/plotly/validators/table/_idssrc.py new file mode 100644 index 0000000000..fff074e834 --- /dev/null +++ b/plotly/validators/table/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='table', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_legendgroup.py b/plotly/validators/table/_legendgroup.py new file mode 100644 index 0000000000..8f47f85b6e --- /dev/null +++ b/plotly/validators/table/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='table', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_name.py b/plotly/validators/table/_name.py new file mode 100644 index 0000000000..ed97312ceb --- /dev/null +++ b/plotly/validators/table/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='table', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_opacity.py b/plotly/validators/table/_opacity.py new file mode 100644 index 0000000000..856412c796 --- /dev/null +++ b/plotly/validators/table/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='table', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/table/_selectedpoints.py b/plotly/validators/table/_selectedpoints.py new file mode 100644 index 0000000000..60d3b7525a --- /dev/null +++ b/plotly/validators/table/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='table', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_showlegend.py b/plotly/validators/table/_showlegend.py new file mode 100644 index 0000000000..6fbd86bb7b --- /dev/null +++ b/plotly/validators/table/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='table', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_stream.py b/plotly/validators/table/_stream.py new file mode 100644 index 0000000000..73d8fb8321 --- /dev/null +++ b/plotly/validators/table/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='table', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/table/_uid.py b/plotly/validators/table/_uid.py new file mode 100644 index 0000000000..a83e831e54 --- /dev/null +++ b/plotly/validators/table/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='table', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/_visible.py b/plotly/validators/table/_visible.py new file mode 100644 index 0000000000..e6dadac51b --- /dev/null +++ b/plotly/validators/table/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='table', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/table/cells/__init__.py b/plotly/validators/table/cells/__init__.py new file mode 100644 index 0000000000..e3ec984db2 --- /dev/null +++ b/plotly/validators/table/cells/__init__.py @@ -0,0 +1,14 @@ +from ._valuessrc import ValuessrcValidator +from ._values import ValuesValidator +from ._suffixsrc import SuffixsrcValidator +from ._suffix import SuffixValidator +from ._prefixsrc import PrefixsrcValidator +from ._prefix import PrefixValidator +from ._line import LineValidator +from ._height import HeightValidator +from ._formatsrc import FormatsrcValidator +from ._format import FormatValidator +from ._font import FontValidator +from ._fill import FillValidator +from ._alignsrc import AlignsrcValidator +from ._align import AlignValidator diff --git a/plotly/validators/table/cells/_align.py b/plotly/validators/table/cells/_align.py new file mode 100644 index 0000000000..d9cfd36387 --- /dev/null +++ b/plotly/validators/table/cells/_align.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AlignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='align', parent_name='table.cells', **kwargs + ): + super(AlignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/table/cells/_alignsrc.py b/plotly/validators/table/cells/_alignsrc.py new file mode 100644 index 0000000000..5690711e44 --- /dev/null +++ b/plotly/validators/table/cells/_alignsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AlignsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='alignsrc', parent_name='table.cells', **kwargs + ): + super(AlignsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/_fill.py b/plotly/validators/table/cells/_fill.py new file mode 100644 index 0000000000..811aafbadf --- /dev/null +++ b/plotly/validators/table/cells/_fill.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='fill', parent_name='table.cells', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Fill', + data_docs=""" + color + Sets the cell fill color. It accepts either a + specific color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color + .""", + **kwargs + ) diff --git a/plotly/validators/table/cells/_font.py b/plotly/validators/table/cells/_font.py new file mode 100644 index 0000000000..d258bffa14 --- /dev/null +++ b/plotly/validators/table/cells/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='table.cells', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/table/cells/_format.py b/plotly/validators/table/cells/_format.py new file mode 100644 index 0000000000..43611c2449 --- /dev/null +++ b/plotly/validators/table/cells/_format.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FormatValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='format', parent_name='table.cells', **kwargs + ): + super(FormatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/cells/_formatsrc.py b/plotly/validators/table/cells/_formatsrc.py new file mode 100644 index 0000000000..47dbecbfd3 --- /dev/null +++ b/plotly/validators/table/cells/_formatsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FormatsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='formatsrc', parent_name='table.cells', **kwargs + ): + super(FormatsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/_height.py b/plotly/validators/table/cells/_height.py new file mode 100644 index 0000000000..aa0ec8205b --- /dev/null +++ b/plotly/validators/table/cells/_height.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HeightValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='height', parent_name='table.cells', **kwargs + ): + super(HeightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/_line.py b/plotly/validators/table/cells/_line.py new file mode 100644 index 0000000000..7740dec83a --- /dev/null +++ b/plotly/validators/table/cells/_line.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='table.cells', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + width + + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/table/cells/_prefix.py b/plotly/validators/table/cells/_prefix.py new file mode 100644 index 0000000000..bf4df6605d --- /dev/null +++ b/plotly/validators/table/cells/_prefix.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class PrefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='prefix', parent_name='table.cells', **kwargs + ): + super(PrefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/_prefixsrc.py b/plotly/validators/table/cells/_prefixsrc.py new file mode 100644 index 0000000000..dd76e8f5ac --- /dev/null +++ b/plotly/validators/table/cells/_prefixsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PrefixsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='prefixsrc', parent_name='table.cells', **kwargs + ): + super(PrefixsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/_suffix.py b/plotly/validators/table/cells/_suffix.py new file mode 100644 index 0000000000..c6310f9875 --- /dev/null +++ b/plotly/validators/table/cells/_suffix.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='suffix', parent_name='table.cells', **kwargs + ): + super(SuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/_suffixsrc.py b/plotly/validators/table/cells/_suffixsrc.py new file mode 100644 index 0000000000..47daad6d80 --- /dev/null +++ b/plotly/validators/table/cells/_suffixsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SuffixsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='suffixsrc', parent_name='table.cells', **kwargs + ): + super(SuffixsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/_values.py b/plotly/validators/table/cells/_values.py new file mode 100644 index 0000000000..444604c4e1 --- /dev/null +++ b/plotly/validators/table/cells/_values.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='values', parent_name='table.cells', **kwargs + ): + super(ValuesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/cells/_valuessrc.py b/plotly/validators/table/cells/_valuessrc.py new file mode 100644 index 0000000000..84ac3056bf --- /dev/null +++ b/plotly/validators/table/cells/_valuessrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='valuessrc', parent_name='table.cells', **kwargs + ): + super(ValuessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/fill/__init__.py b/plotly/validators/table/cells/fill/__init__.py new file mode 100644 index 0000000000..e60d2b4c8d --- /dev/null +++ b/plotly/validators/table/cells/fill/__init__.py @@ -0,0 +1,2 @@ +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/cells/fill/_color.py b/plotly/validators/table/cells/fill/_color.py new file mode 100644 index 0000000000..e9255231be --- /dev/null +++ b/plotly/validators/table/cells/fill/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.cells.fill', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/fill/_colorsrc.py b/plotly/validators/table/cells/fill/_colorsrc.py new file mode 100644 index 0000000000..9d16708522 --- /dev/null +++ b/plotly/validators/table/cells/fill/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='table.cells.fill', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/font/__init__.py b/plotly/validators/table/cells/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/table/cells/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/cells/font/_color.py b/plotly/validators/table/cells/font/_color.py new file mode 100644 index 0000000000..0b160dedf3 --- /dev/null +++ b/plotly/validators/table/cells/font/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.cells.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/font/_colorsrc.py b/plotly/validators/table/cells/font/_colorsrc.py new file mode 100644 index 0000000000..7e7ba3e564 --- /dev/null +++ b/plotly/validators/table/cells/font/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='table.cells.font', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/font/_family.py b/plotly/validators/table/cells/font/_family.py new file mode 100644 index 0000000000..d6eef74aaf --- /dev/null +++ b/plotly/validators/table/cells/font/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='table.cells.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/table/cells/font/_familysrc.py b/plotly/validators/table/cells/font/_familysrc.py new file mode 100644 index 0000000000..6bbcc0eb08 --- /dev/null +++ b/plotly/validators/table/cells/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='table.cells.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/font/_size.py b/plotly/validators/table/cells/font/_size.py new file mode 100644 index 0000000000..b6fe8447b0 --- /dev/null +++ b/plotly/validators/table/cells/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='table.cells.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/font/_sizesrc.py b/plotly/validators/table/cells/font/_sizesrc.py new file mode 100644 index 0000000000..6c67374a5e --- /dev/null +++ b/plotly/validators/table/cells/font/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='table.cells.font', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/line/__init__.py b/plotly/validators/table/cells/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/table/cells/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/cells/line/_color.py b/plotly/validators/table/cells/line/_color.py new file mode 100644 index 0000000000..c5ca11870c --- /dev/null +++ b/plotly/validators/table/cells/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.cells.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/line/_colorsrc.py b/plotly/validators/table/cells/line/_colorsrc.py new file mode 100644 index 0000000000..6951a446f7 --- /dev/null +++ b/plotly/validators/table/cells/line/_colorsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='colorsrc', parent_name='table.cells.line', **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/cells/line/_width.py b/plotly/validators/table/cells/line/_width.py new file mode 100644 index 0000000000..4c05a84c55 --- /dev/null +++ b/plotly/validators/table/cells/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='table.cells.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/cells/line/_widthsrc.py b/plotly/validators/table/cells/line/_widthsrc.py new file mode 100644 index 0000000000..44d667b2f3 --- /dev/null +++ b/plotly/validators/table/cells/line/_widthsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='widthsrc', parent_name='table.cells.line', **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/domain/__init__.py b/plotly/validators/table/domain/__init__.py new file mode 100644 index 0000000000..6cf3224823 --- /dev/null +++ b/plotly/validators/table/domain/__init__.py @@ -0,0 +1,4 @@ +from ._y import YValidator +from ._x import XValidator +from ._row import RowValidator +from ._column import ColumnValidator diff --git a/plotly/validators/table/domain/_column.py b/plotly/validators/table/domain/_column.py new file mode 100644 index 0000000000..ecec88ef16 --- /dev/null +++ b/plotly/validators/table/domain/_column.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColumnValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='column', parent_name='table.domain', **kwargs + ): + super(ColumnValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/table/domain/_row.py b/plotly/validators/table/domain/_row.py new file mode 100644 index 0000000000..bafa9fe40e --- /dev/null +++ b/plotly/validators/table/domain/_row.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class RowValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, plotly_name='row', parent_name='table.domain', **kwargs + ): + super(RowValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/table/domain/_x.py b/plotly/validators/table/domain/_x.py new file mode 100644 index 0000000000..5fb6e71aae --- /dev/null +++ b/plotly/validators/table/domain/_x.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='x', parent_name='table.domain', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/table/domain/_y.py b/plotly/validators/table/domain/_y.py new file mode 100644 index 0000000000..8d5b92d0a7 --- /dev/null +++ b/plotly/validators/table/domain/_y.py @@ -0,0 +1,26 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='y', parent_name='table.domain', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + }, { + 'valType': 'number', + 'min': 0, + 'max': 1, + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/__init__.py b/plotly/validators/table/header/__init__.py new file mode 100644 index 0000000000..e3ec984db2 --- /dev/null +++ b/plotly/validators/table/header/__init__.py @@ -0,0 +1,14 @@ +from ._valuessrc import ValuessrcValidator +from ._values import ValuesValidator +from ._suffixsrc import SuffixsrcValidator +from ._suffix import SuffixValidator +from ._prefixsrc import PrefixsrcValidator +from ._prefix import PrefixValidator +from ._line import LineValidator +from ._height import HeightValidator +from ._formatsrc import FormatsrcValidator +from ._format import FormatValidator +from ._font import FontValidator +from ._fill import FillValidator +from ._alignsrc import AlignsrcValidator +from ._align import AlignValidator diff --git a/plotly/validators/table/header/_align.py b/plotly/validators/table/header/_align.py new file mode 100644 index 0000000000..dd41f8d58d --- /dev/null +++ b/plotly/validators/table/header/_align.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class AlignValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='align', parent_name='table.header', **kwargs + ): + super(AlignValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + values=['left', 'center', 'right'], + **kwargs + ) diff --git a/plotly/validators/table/header/_alignsrc.py b/plotly/validators/table/header/_alignsrc.py new file mode 100644 index 0000000000..3b034e925d --- /dev/null +++ b/plotly/validators/table/header/_alignsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class AlignsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='alignsrc', parent_name='table.header', **kwargs + ): + super(AlignsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/_fill.py b/plotly/validators/table/header/_fill.py new file mode 100644 index 0000000000..452e8ad080 --- /dev/null +++ b/plotly/validators/table/header/_fill.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FillValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='fill', parent_name='table.header', **kwargs + ): + super(FillValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Fill', + data_docs=""" + color + Sets the cell fill color. It accepts either a + specific color or an array of colors. + colorsrc + Sets the source reference on plot.ly for color + .""", + **kwargs + ) diff --git a/plotly/validators/table/header/_font.py b/plotly/validators/table/header/_font.py new file mode 100644 index 0000000000..4674eaec5e --- /dev/null +++ b/plotly/validators/table/header/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='table.header', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/table/header/_format.py b/plotly/validators/table/header/_format.py new file mode 100644 index 0000000000..43fdd86365 --- /dev/null +++ b/plotly/validators/table/header/_format.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FormatValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='format', parent_name='table.header', **kwargs + ): + super(FormatValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/header/_formatsrc.py b/plotly/validators/table/header/_formatsrc.py new file mode 100644 index 0000000000..aefbcf450d --- /dev/null +++ b/plotly/validators/table/header/_formatsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FormatsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='formatsrc', parent_name='table.header', **kwargs + ): + super(FormatsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/_height.py b/plotly/validators/table/header/_height.py new file mode 100644 index 0000000000..a36df47f7a --- /dev/null +++ b/plotly/validators/table/header/_height.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HeightValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='height', parent_name='table.header', **kwargs + ): + super(HeightValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/_line.py b/plotly/validators/table/header/_line.py new file mode 100644 index 0000000000..95f6272da5 --- /dev/null +++ b/plotly/validators/table/header/_line.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='table.header', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + width + + widthsrc + Sets the source reference on plot.ly for width + .""", + **kwargs + ) diff --git a/plotly/validators/table/header/_prefix.py b/plotly/validators/table/header/_prefix.py new file mode 100644 index 0000000000..46985398ff --- /dev/null +++ b/plotly/validators/table/header/_prefix.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class PrefixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='prefix', parent_name='table.header', **kwargs + ): + super(PrefixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/_prefixsrc.py b/plotly/validators/table/header/_prefixsrc.py new file mode 100644 index 0000000000..91177a9d03 --- /dev/null +++ b/plotly/validators/table/header/_prefixsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PrefixsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='prefixsrc', parent_name='table.header', **kwargs + ): + super(PrefixsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/_suffix.py b/plotly/validators/table/header/_suffix.py new file mode 100644 index 0000000000..7ca3914e0f --- /dev/null +++ b/plotly/validators/table/header/_suffix.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SuffixValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='suffix', parent_name='table.header', **kwargs + ): + super(SuffixValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/_suffixsrc.py b/plotly/validators/table/header/_suffixsrc.py new file mode 100644 index 0000000000..06b35464d4 --- /dev/null +++ b/plotly/validators/table/header/_suffixsrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SuffixsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='suffixsrc', parent_name='table.header', **kwargs + ): + super(SuffixsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/_values.py b/plotly/validators/table/header/_values.py new file mode 100644 index 0000000000..6b2ac154fe --- /dev/null +++ b/plotly/validators/table/header/_values.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuesValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='values', parent_name='table.header', **kwargs + ): + super(ValuesValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/table/header/_valuessrc.py b/plotly/validators/table/header/_valuessrc.py new file mode 100644 index 0000000000..43b64179d4 --- /dev/null +++ b/plotly/validators/table/header/_valuessrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ValuessrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='valuessrc', parent_name='table.header', **kwargs + ): + super(ValuessrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/fill/__init__.py b/plotly/validators/table/header/fill/__init__.py new file mode 100644 index 0000000000..e60d2b4c8d --- /dev/null +++ b/plotly/validators/table/header/fill/__init__.py @@ -0,0 +1,2 @@ +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/header/fill/_color.py b/plotly/validators/table/header/fill/_color.py new file mode 100644 index 0000000000..5eeef67b24 --- /dev/null +++ b/plotly/validators/table/header/fill/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.header.fill', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/fill/_colorsrc.py b/plotly/validators/table/header/fill/_colorsrc.py new file mode 100644 index 0000000000..906adb17ba --- /dev/null +++ b/plotly/validators/table/header/fill/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='table.header.fill', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/font/__init__.py b/plotly/validators/table/header/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/table/header/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/header/font/_color.py b/plotly/validators/table/header/font/_color.py new file mode 100644 index 0000000000..ec23ed6793 --- /dev/null +++ b/plotly/validators/table/header/font/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.header.font', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/font/_colorsrc.py b/plotly/validators/table/header/font/_colorsrc.py new file mode 100644 index 0000000000..9c8ea9c062 --- /dev/null +++ b/plotly/validators/table/header/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='table.header.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/font/_family.py b/plotly/validators/table/header/font/_family.py new file mode 100644 index 0000000000..829f9af850 --- /dev/null +++ b/plotly/validators/table/header/font/_family.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='family', parent_name='table.header.font', **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/table/header/font/_familysrc.py b/plotly/validators/table/header/font/_familysrc.py new file mode 100644 index 0000000000..b091cc7ecf --- /dev/null +++ b/plotly/validators/table/header/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='table.header.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/font/_size.py b/plotly/validators/table/header/font/_size.py new file mode 100644 index 0000000000..fdd6284333 --- /dev/null +++ b/plotly/validators/table/header/font/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='table.header.font', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/font/_sizesrc.py b/plotly/validators/table/header/font/_sizesrc.py new file mode 100644 index 0000000000..0bdd341f1e --- /dev/null +++ b/plotly/validators/table/header/font/_sizesrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='sizesrc', parent_name='table.header.font', **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/line/__init__.py b/plotly/validators/table/header/line/__init__.py new file mode 100644 index 0000000000..1c7b37b04f --- /dev/null +++ b/plotly/validators/table/header/line/__init__.py @@ -0,0 +1,4 @@ +from ._widthsrc import WidthsrcValidator +from ._width import WidthValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/header/line/_color.py b/plotly/validators/table/header/line/_color.py new file mode 100644 index 0000000000..1eb8190023 --- /dev/null +++ b/plotly/validators/table/header/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='table.header.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/line/_colorsrc.py b/plotly/validators/table/header/line/_colorsrc.py new file mode 100644 index 0000000000..b8456e3cc5 --- /dev/null +++ b/plotly/validators/table/header/line/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='table.header.line', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/header/line/_width.py b/plotly/validators/table/header/line/_width.py new file mode 100644 index 0000000000..e9e38a358c --- /dev/null +++ b/plotly/validators/table/header/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='table.header.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/header/line/_widthsrc.py b/plotly/validators/table/header/line/_widthsrc.py new file mode 100644 index 0000000000..8ef2f93a5b --- /dev/null +++ b/plotly/validators/table/header/line/_widthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class WidthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='widthsrc', + parent_name='table.header.line', + **kwargs + ): + super(WidthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/__init__.py b/plotly/validators/table/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/table/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/table/hoverlabel/_bgcolor.py b/plotly/validators/table/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..36f9a3cb25 --- /dev/null +++ b/plotly/validators/table/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='table.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_bgcolorsrc.py b/plotly/validators/table/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..d2b8bff3e9 --- /dev/null +++ b/plotly/validators/table/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='table.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_bordercolor.py b/plotly/validators/table/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..d2dc18353b --- /dev/null +++ b/plotly/validators/table/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='table.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_bordercolorsrc.py b/plotly/validators/table/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..e307e1dc4e --- /dev/null +++ b/plotly/validators/table/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='table.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_font.py b/plotly/validators/table/hoverlabel/_font.py new file mode 100644 index 0000000000..232f338b42 --- /dev/null +++ b/plotly/validators/table/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='table.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_namelength.py b/plotly/validators/table/hoverlabel/_namelength.py new file mode 100644 index 0000000000..7c8f39b09c --- /dev/null +++ b/plotly/validators/table/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='table.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/_namelengthsrc.py b/plotly/validators/table/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..a5b5080fa5 --- /dev/null +++ b/plotly/validators/table/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='table.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/__init__.py b/plotly/validators/table/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/table/hoverlabel/font/_color.py b/plotly/validators/table/hoverlabel/font/_color.py new file mode 100644 index 0000000000..01aa1a244d --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/_colorsrc.py b/plotly/validators/table/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..7f488315b3 --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/_family.py b/plotly/validators/table/hoverlabel/font/_family.py new file mode 100644 index 0000000000..7b071ac934 --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/_familysrc.py b/plotly/validators/table/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..cd3e460448 --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/_size.py b/plotly/validators/table/hoverlabel/font/_size.py new file mode 100644 index 0000000000..2c06834ab8 --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/table/hoverlabel/font/_sizesrc.py b/plotly/validators/table/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..aa14b3ced8 --- /dev/null +++ b/plotly/validators/table/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='table.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/table/stream/__init__.py b/plotly/validators/table/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/table/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/table/stream/_maxpoints.py b/plotly/validators/table/stream/_maxpoints.py new file mode 100644 index 0000000000..c669592211 --- /dev/null +++ b/plotly/validators/table/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='table.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/table/stream/_token.py b/plotly/validators/table/stream/_token.py new file mode 100644 index 0000000000..c46881cb4d --- /dev/null +++ b/plotly/validators/table/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='table.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/violin/__init__.py b/plotly/validators/violin/__init__.py new file mode 100644 index 0000000000..daddeec5b9 --- /dev/null +++ b/plotly/validators/violin/__init__.py @@ -0,0 +1,43 @@ +from ._ysrc import YsrcValidator +from ._yaxis import YAxisValidator +from ._y0 import Y0Validator +from ._y import YValidator +from ._xsrc import XsrcValidator +from ._xaxis import XAxisValidator +from ._x0 import X0Validator +from ._x import XValidator +from ._visible import VisibleValidator +from ._unselected import UnselectedValidator +from ._uid import UidValidator +from ._textsrc import TextsrcValidator +from ._text import TextValidator +from ._stream import StreamValidator +from ._spanmode import SpanmodeValidator +from ._span import SpanValidator +from ._side import SideValidator +from ._showlegend import ShowlegendValidator +from ._selectedpoints import SelectedpointsValidator +from ._selected import SelectedValidator +from ._scalemode import ScalemodeValidator +from ._scalegroup import ScalegroupValidator +from ._points import PointsValidator +from ._pointpos import PointposValidator +from ._orientation import OrientationValidator +from ._opacity import OpacityValidator +from ._name import NameValidator +from ._meanline import MeanlineValidator +from ._marker import MarkerValidator +from ._line import LineValidator +from ._legendgroup import LegendgroupValidator +from ._jitter import JitterValidator +from ._idssrc import IdssrcValidator +from ._ids import IdsValidator +from ._hoveron import HoveronValidator +from ._hoverlabel import HoverlabelValidator +from ._hoverinfosrc import HoverinfosrcValidator +from ._hoverinfo import HoverinfoValidator +from ._fillcolor import FillcolorValidator +from ._customdatasrc import CustomdatasrcValidator +from ._customdata import CustomdataValidator +from ._box import BoxValidator +from ._bandwidth import BandwidthValidator diff --git a/plotly/validators/violin/_bandwidth.py b/plotly/validators/violin/_bandwidth.py new file mode 100644 index 0000000000..9deb3f8088 --- /dev/null +++ b/plotly/validators/violin/_bandwidth.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BandwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='bandwidth', parent_name='violin', **kwargs + ): + super(BandwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_box.py b/plotly/validators/violin/_box.py new file mode 100644 index 0000000000..fec445e59d --- /dev/null +++ b/plotly/validators/violin/_box.py @@ -0,0 +1,25 @@ +import _plotly_utils.basevalidators + + +class BoxValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='box', parent_name='violin', **kwargs): + super(BoxValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Box', + data_docs=""" + fillcolor + Sets the inner box plot fill color. + line + plotly.graph_objs.violin.box.Line instance or + dict with compatible properties + visible + Determines if an miniature box plot is drawn + inside the violins. + width + Sets the width of the inner box plots relative + to the violins' width. For example, with 1, the + inner box plots are as wide as the violins.""", + **kwargs + ) diff --git a/plotly/validators/violin/_customdata.py b/plotly/validators/violin/_customdata.py new file mode 100644 index 0000000000..d41260adeb --- /dev/null +++ b/plotly/validators/violin/_customdata.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdataValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__( + self, plotly_name='customdata', parent_name='violin', **kwargs + ): + super(CustomdataValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/violin/_customdatasrc.py b/plotly/validators/violin/_customdatasrc.py new file mode 100644 index 0000000000..8c37e272a2 --- /dev/null +++ b/plotly/validators/violin/_customdatasrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class CustomdatasrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='customdatasrc', parent_name='violin', **kwargs + ): + super(CustomdatasrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_fillcolor.py b/plotly/validators/violin/_fillcolor.py new file mode 100644 index 0000000000..9123ed708b --- /dev/null +++ b/plotly/validators/violin/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='violin', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/_hoverinfo.py b/plotly/validators/violin/_hoverinfo.py new file mode 100644 index 0000000000..98d9db1beb --- /dev/null +++ b/plotly/validators/violin/_hoverinfo.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class HoverinfoValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__( + self, plotly_name='hoverinfo', parent_name='violin', **kwargs + ): + super(HoverinfoValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + extras=['all', 'none', 'skip'], + flags=['x', 'y', 'z', 'text', 'name'], + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_hoverinfosrc.py b/plotly/validators/violin/_hoverinfosrc.py new file mode 100644 index 0000000000..f0391467ad --- /dev/null +++ b/plotly/validators/violin/_hoverinfosrc.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoverinfosrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, plotly_name='hoverinfosrc', parent_name='violin', **kwargs + ): + super(HoverinfosrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_hoverlabel.py b/plotly/validators/violin/_hoverlabel.py new file mode 100644 index 0000000000..cde3690e12 --- /dev/null +++ b/plotly/validators/violin/_hoverlabel.py @@ -0,0 +1,41 @@ +import _plotly_utils.basevalidators + + +class HoverlabelValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='hoverlabel', parent_name='violin', **kwargs + ): + super(HoverlabelValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Hoverlabel', + data_docs=""" + bgcolor + Sets the background color of the hover labels + for this trace + bgcolorsrc + Sets the source reference on plot.ly for + bgcolor . + bordercolor + Sets the border color of the hover labels for + this trace. + bordercolorsrc + Sets the source reference on plot.ly for + bordercolor . + font + Sets the font used in hover labels. + namelength + Sets the length (in number of characters) of + the trace name in the hover labels for this + trace. -1 shows the whole name regardless of + length. 0-3 shows the first 0-3 characters, and + an integer >3 will show the whole name if it is + less than that many characters, but if it is + longer, will truncate to `namelength - 3` + characters and add an ellipsis. + namelengthsrc + Sets the source reference on plot.ly for + namelength .""", + **kwargs + ) diff --git a/plotly/validators/violin/_hoveron.py b/plotly/validators/violin/_hoveron.py new file mode 100644 index 0000000000..78f3c0e9f5 --- /dev/null +++ b/plotly/validators/violin/_hoveron.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class HoveronValidator(_plotly_utils.basevalidators.FlaglistValidator): + + def __init__(self, plotly_name='hoveron', parent_name='violin', **kwargs): + super(HoveronValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + extras=['all'], + flags=['violins', 'points', 'kde'], + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_ids.py b/plotly/validators/violin/_ids.py new file mode 100644 index 0000000000..c52cfc10da --- /dev/null +++ b/plotly/validators/violin/_ids.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdsValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='ids', parent_name='violin', **kwargs): + super(IdsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='data', + **kwargs + ) diff --git a/plotly/validators/violin/_idssrc.py b/plotly/validators/violin/_idssrc.py new file mode 100644 index 0000000000..37e3ea0d67 --- /dev/null +++ b/plotly/validators/violin/_idssrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class IdssrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='idssrc', parent_name='violin', **kwargs): + super(IdssrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_jitter.py b/plotly/validators/violin/_jitter.py new file mode 100644 index 0000000000..5e29d46a58 --- /dev/null +++ b/plotly/validators/violin/_jitter.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class JitterValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='jitter', parent_name='violin', **kwargs): + super(JitterValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/_legendgroup.py b/plotly/validators/violin/_legendgroup.py new file mode 100644 index 0000000000..4f39b63c21 --- /dev/null +++ b/plotly/validators/violin/_legendgroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class LegendgroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='legendgroup', parent_name='violin', **kwargs + ): + super(LegendgroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_line.py b/plotly/validators/violin/_line.py new file mode 100644 index 0000000000..0c696eabd6 --- /dev/null +++ b/plotly/validators/violin/_line.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='violin', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the color of line bounding the violin(s). + width + Sets the width (in px) of line bounding the + violin(s).""", + **kwargs + ) diff --git a/plotly/validators/violin/_marker.py b/plotly/validators/violin/_marker.py new file mode 100644 index 0000000000..638c2c6b10 --- /dev/null +++ b/plotly/validators/violin/_marker.py @@ -0,0 +1,35 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='marker', parent_name='violin', **kwargs): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + line + plotly.graph_objs.violin.marker.Line instance + or dict with compatible properties + opacity + Sets the marker opacity. + outliercolor + Sets the color of the outlier sample points. + size + Sets the marker size (in px). + symbol + Sets the marker symbol type. Adding 100 is + equivalent to appending *-open* to a symbol + name. Adding 200 is equivalent to appending + *-dot* to a symbol name. Adding 300 is + equivalent to appending *-open-dot* or *dot- + open* to a symbol name.""", + **kwargs + ) diff --git a/plotly/validators/violin/_meanline.py b/plotly/validators/violin/_meanline.py new file mode 100644 index 0000000000..b3e8c4b47d --- /dev/null +++ b/plotly/validators/violin/_meanline.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MeanlineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='meanline', parent_name='violin', **kwargs): + super(MeanlineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Meanline', + data_docs=""" + color + Sets the mean line color. + visible + Determines if a line corresponding to the + sample's mean is shown inside the violins. If + `box.visible` is turned on, the mean line is + drawn inside the inner box. Otherwise, the mean + line is drawn from one side of the violin to + other. + width + Sets the mean line width.""", + **kwargs + ) diff --git a/plotly/validators/violin/_name.py b/plotly/validators/violin/_name.py new file mode 100644 index 0000000000..0a09e8c252 --- /dev/null +++ b/plotly/validators/violin/_name.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class NameValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='name', parent_name='violin', **kwargs): + super(NameValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_opacity.py b/plotly/validators/violin/_opacity.py new file mode 100644 index 0000000000..e46b2d848e --- /dev/null +++ b/plotly/validators/violin/_opacity.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='opacity', parent_name='violin', **kwargs): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/_orientation.py b/plotly/validators/violin/_orientation.py new file mode 100644 index 0000000000..0a4e0988d9 --- /dev/null +++ b/plotly/validators/violin/_orientation.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class OrientationValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='orientation', parent_name='violin', **kwargs + ): + super(OrientationValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='style', + values=['v', 'h'], + **kwargs + ) diff --git a/plotly/validators/violin/_pointpos.py b/plotly/validators/violin/_pointpos.py new file mode 100644 index 0000000000..71b63bdf75 --- /dev/null +++ b/plotly/validators/violin/_pointpos.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class PointposValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__(self, plotly_name='pointpos', parent_name='violin', **kwargs): + super(PointposValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + max=2, + min=-2, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/_points.py b/plotly/validators/violin/_points.py new file mode 100644 index 0000000000..7988db6bd2 --- /dev/null +++ b/plotly/validators/violin/_points.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class PointsValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='points', parent_name='violin', **kwargs): + super(PointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calcIfAutorange', + role='style', + values=['all', 'outliers', 'suspectedoutliers', False], + **kwargs + ) diff --git a/plotly/validators/violin/_scalegroup.py b/plotly/validators/violin/_scalegroup.py new file mode 100644 index 0000000000..fa20e3cade --- /dev/null +++ b/plotly/validators/violin/_scalegroup.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ScalegroupValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='scalegroup', parent_name='violin', **kwargs + ): + super(ScalegroupValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_scalemode.py b/plotly/validators/violin/_scalemode.py new file mode 100644 index 0000000000..12349d6698 --- /dev/null +++ b/plotly/validators/violin/_scalemode.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ScalemodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='scalemode', parent_name='violin', **kwargs + ): + super(ScalemodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['width', 'count'], + **kwargs + ) diff --git a/plotly/validators/violin/_selected.py b/plotly/validators/violin/_selected.py new file mode 100644 index 0000000000..a8d9c6a66e --- /dev/null +++ b/plotly/validators/violin/_selected.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class SelectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='selected', parent_name='violin', **kwargs): + super(SelectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Selected', + data_docs=""" + marker + plotly.graph_objs.violin.selected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/violin/_selectedpoints.py b/plotly/validators/violin/_selectedpoints.py new file mode 100644 index 0000000000..7560db6f5f --- /dev/null +++ b/plotly/validators/violin/_selectedpoints.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class SelectedpointsValidator(_plotly_utils.basevalidators.AnyValidator): + + def __init__( + self, plotly_name='selectedpoints', parent_name='violin', **kwargs + ): + super(SelectedpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_showlegend.py b/plotly/validators/violin/_showlegend.py new file mode 100644 index 0000000000..6222b0afc2 --- /dev/null +++ b/plotly/validators/violin/_showlegend.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ShowlegendValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='showlegend', parent_name='violin', **kwargs + ): + super(ShowlegendValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_side.py b/plotly/validators/violin/_side.py new file mode 100644 index 0000000000..262d713ab8 --- /dev/null +++ b/plotly/validators/violin/_side.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SideValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='side', parent_name='violin', **kwargs): + super(SideValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + values=['both', 'positive', 'negative'], + **kwargs + ) diff --git a/plotly/validators/violin/_span.py b/plotly/validators/violin/_span.py new file mode 100644 index 0000000000..7598560bff --- /dev/null +++ b/plotly/validators/violin/_span.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class SpanValidator(_plotly_utils.basevalidators.InfoArrayValidator): + + def __init__(self, plotly_name='span', parent_name='violin', **kwargs): + super(SpanValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + items=[ + { + 'valType': 'any', + 'editType': 'calc' + }, { + 'valType': 'any', + 'editType': 'calc' + } + ], + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_spanmode.py b/plotly/validators/violin/_spanmode.py new file mode 100644 index 0000000000..dca3e17e26 --- /dev/null +++ b/plotly/validators/violin/_spanmode.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class SpanmodeValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='spanmode', parent_name='violin', **kwargs): + super(SpanmodeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=['soft', 'hard', 'manual'], + **kwargs + ) diff --git a/plotly/validators/violin/_stream.py b/plotly/validators/violin/_stream.py new file mode 100644 index 0000000000..cec524d14e --- /dev/null +++ b/plotly/validators/violin/_stream.py @@ -0,0 +1,22 @@ +import _plotly_utils.basevalidators + + +class StreamValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='stream', parent_name='violin', **kwargs): + super(StreamValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Stream', + data_docs=""" + maxpoints + Sets the maximum number of points to keep on + the plots from an incoming stream. If + `maxpoints` is set to *50*, only the newest 50 + points will be displayed on the plot. + token + The stream id number links a data trace on a + plot with a stream. See + https://plot.ly/settings for more details.""", + **kwargs + ) diff --git a/plotly/validators/violin/_text.py b/plotly/validators/violin/_text.py new file mode 100644 index 0000000000..4f76eede32 --- /dev/null +++ b/plotly/validators/violin/_text.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class TextValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='text', parent_name='violin', **kwargs): + super(TextValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_textsrc.py b/plotly/validators/violin/_textsrc.py new file mode 100644 index 0000000000..2fde74ce32 --- /dev/null +++ b/plotly/validators/violin/_textsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class TextsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='textsrc', parent_name='violin', **kwargs): + super(TextsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_uid.py b/plotly/validators/violin/_uid.py new file mode 100644 index 0000000000..2460a1410d --- /dev/null +++ b/plotly/validators/violin/_uid.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class UidValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__(self, plotly_name='uid', parent_name='violin', **kwargs): + super(UidValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_unselected.py b/plotly/validators/violin/_unselected.py new file mode 100644 index 0000000000..37c23a07f1 --- /dev/null +++ b/plotly/validators/violin/_unselected.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class UnselectedValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='unselected', parent_name='violin', **kwargs + ): + super(UnselectedValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Unselected', + data_docs=""" + marker + plotly.graph_objs.violin.unselected.Marker + instance or dict with compatible properties""", + **kwargs + ) diff --git a/plotly/validators/violin/_visible.py b/plotly/validators/violin/_visible.py new file mode 100644 index 0000000000..c510c43a99 --- /dev/null +++ b/plotly/validators/violin/_visible.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__(self, plotly_name='visible', parent_name='violin', **kwargs): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + role='info', + values=[True, False, 'legendonly'], + **kwargs + ) diff --git a/plotly/validators/violin/_x.py b/plotly/validators/violin/_x.py new file mode 100644 index 0000000000..bb8eb111c5 --- /dev/null +++ b/plotly/validators/violin/_x.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='x', parent_name='violin', **kwargs): + super(XValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/violin/_x0.py b/plotly/validators/violin/_x0.py new file mode 100644 index 0000000000..560f1dc3f2 --- /dev/null +++ b/plotly/validators/violin/_x0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class X0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='x0', parent_name='violin', **kwargs): + super(X0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_xaxis.py b/plotly/validators/violin/_xaxis.py new file mode 100644 index 0000000000..eb09da1658 --- /dev/null +++ b/plotly/validators/violin/_xaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class XAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='xaxis', parent_name='violin', **kwargs): + super(XAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='x', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_xsrc.py b/plotly/validators/violin/_xsrc.py new file mode 100644 index 0000000000..359c01e5fe --- /dev/null +++ b/plotly/validators/violin/_xsrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class XsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='xsrc', parent_name='violin', **kwargs): + super(XsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_y.py b/plotly/validators/violin/_y.py new file mode 100644 index 0000000000..5b1908f691 --- /dev/null +++ b/plotly/validators/violin/_y.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YValidator(_plotly_utils.basevalidators.DataArrayValidator): + + def __init__(self, plotly_name='y', parent_name='violin', **kwargs): + super(YValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='data', + **kwargs + ) diff --git a/plotly/validators/violin/_y0.py b/plotly/validators/violin/_y0.py new file mode 100644 index 0000000000..8786b73297 --- /dev/null +++ b/plotly/validators/violin/_y0.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class Y0Validator(_plotly_utils.basevalidators.AnyValidator): + + def __init__(self, plotly_name='y0', parent_name='violin', **kwargs): + super(Y0Validator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_yaxis.py b/plotly/validators/violin/_yaxis.py new file mode 100644 index 0000000000..632eb6a13d --- /dev/null +++ b/plotly/validators/violin/_yaxis.py @@ -0,0 +1,14 @@ +import _plotly_utils.basevalidators + + +class YAxisValidator(_plotly_utils.basevalidators.SubplotidValidator): + + def __init__(self, plotly_name='yaxis', parent_name='violin', **kwargs): + super(YAxisValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + dflt='y', + edit_type='calc+clearAxisTypes', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/_ysrc.py b/plotly/validators/violin/_ysrc.py new file mode 100644 index 0000000000..5ea200ebaf --- /dev/null +++ b/plotly/validators/violin/_ysrc.py @@ -0,0 +1,13 @@ +import _plotly_utils.basevalidators + + +class YsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__(self, plotly_name='ysrc', parent_name='violin', **kwargs): + super(YsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/box/__init__.py b/plotly/validators/violin/box/__init__.py new file mode 100644 index 0000000000..445ae7b944 --- /dev/null +++ b/plotly/validators/violin/box/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._line import LineValidator +from ._fillcolor import FillcolorValidator diff --git a/plotly/validators/violin/box/_fillcolor.py b/plotly/validators/violin/box/_fillcolor.py new file mode 100644 index 0000000000..aceada31f9 --- /dev/null +++ b/plotly/validators/violin/box/_fillcolor.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class FillcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='fillcolor', parent_name='violin.box', **kwargs + ): + super(FillcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/box/_line.py b/plotly/validators/violin/box/_line.py new file mode 100644 index 0000000000..6971585f36 --- /dev/null +++ b/plotly/validators/violin/box/_line.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__(self, plotly_name='line', parent_name='violin.box', **kwargs): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the inner box plot bounding line color. + width + Sets the inner box plot bounding line width.""", + **kwargs + ) diff --git a/plotly/validators/violin/box/_visible.py b/plotly/validators/violin/box/_visible.py new file mode 100644 index 0000000000..d12cb3a1f4 --- /dev/null +++ b/plotly/validators/violin/box/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='violin.box', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/box/_width.py b/plotly/validators/violin/box/_width.py new file mode 100644 index 0000000000..1fe66dcf56 --- /dev/null +++ b/plotly/validators/violin/box/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='violin.box', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + max=1, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/box/line/__init__.py b/plotly/validators/violin/box/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/violin/box/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/box/line/_color.py b/plotly/validators/violin/box/line/_color.py new file mode 100644 index 0000000000..d3f5d3a13a --- /dev/null +++ b/plotly/validators/violin/box/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='violin.box.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/box/line/_width.py b/plotly/validators/violin/box/line/_width.py new file mode 100644 index 0000000000..304864eb8e --- /dev/null +++ b/plotly/validators/violin/box/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='violin.box.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/__init__.py b/plotly/validators/violin/hoverlabel/__init__.py new file mode 100644 index 0000000000..856f769ba3 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/__init__.py @@ -0,0 +1,7 @@ +from ._namelengthsrc import NamelengthsrcValidator +from ._namelength import NamelengthValidator +from ._font import FontValidator +from ._bordercolorsrc import BordercolorsrcValidator +from ._bordercolor import BordercolorValidator +from ._bgcolorsrc import BgcolorsrcValidator +from ._bgcolor import BgcolorValidator diff --git a/plotly/validators/violin/hoverlabel/_bgcolor.py b/plotly/validators/violin/hoverlabel/_bgcolor.py new file mode 100644 index 0000000000..4f02758e47 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_bgcolor.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class BgcolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='bgcolor', parent_name='violin.hoverlabel', **kwargs + ): + super(BgcolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_bgcolorsrc.py b/plotly/validators/violin/hoverlabel/_bgcolorsrc.py new file mode 100644 index 0000000000..002acfb29a --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_bgcolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BgcolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bgcolorsrc', + parent_name='violin.hoverlabel', + **kwargs + ): + super(BgcolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_bordercolor.py b/plotly/validators/violin/hoverlabel/_bordercolor.py new file mode 100644 index 0000000000..19a7de7e28 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_bordercolor.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class BordercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='bordercolor', + parent_name='violin.hoverlabel', + **kwargs + ): + super(BordercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_bordercolorsrc.py b/plotly/validators/violin/hoverlabel/_bordercolorsrc.py new file mode 100644 index 0000000000..503450a800 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_bordercolorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class BordercolorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='bordercolorsrc', + parent_name='violin.hoverlabel', + **kwargs + ): + super(BordercolorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_font.py b/plotly/validators/violin/hoverlabel/_font.py new file mode 100644 index 0000000000..a97c0e9443 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_font.py @@ -0,0 +1,44 @@ +import _plotly_utils.basevalidators + + +class FontValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='font', parent_name='violin.hoverlabel', **kwargs + ): + super(FontValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Font', + data_docs=""" + color + + colorsrc + Sets the source reference on plot.ly for color + . + family + HTML font family - the typeface that will be + applied by the web browser. The web browser + will only be able to apply a font if it is + available on the system which it operates. + Provide multiple font families, separated by + commas, to indicate the preference in which to + apply fonts if they aren't available on the + system. The plotly service (at https://plot.ly + or on-premise) generates images on a server, + where only a select number of fonts are + installed and supported. These include *Arial*, + *Balto*, *Courier New*, *Droid Sans*,, *Droid + Serif*, *Droid Sans Mono*, *Gravitas One*, *Old + Standard TT*, *Open Sans*, *Overpass*, *PT Sans + Narrow*, *Raleway*, *Times New Roman*. + familysrc + Sets the source reference on plot.ly for + family . + size + + sizesrc + Sets the source reference on plot.ly for size + .""", + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_namelength.py b/plotly/validators/violin/hoverlabel/_namelength.py new file mode 100644 index 0000000000..5b71a9216e --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_namelength.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class NamelengthValidator(_plotly_utils.basevalidators.IntegerValidator): + + def __init__( + self, + plotly_name='namelength', + parent_name='violin.hoverlabel', + **kwargs + ): + super(NamelengthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=-1, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/_namelengthsrc.py b/plotly/validators/violin/hoverlabel/_namelengthsrc.py new file mode 100644 index 0000000000..0324069221 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/_namelengthsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class NamelengthsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='namelengthsrc', + parent_name='violin.hoverlabel', + **kwargs + ): + super(NamelengthsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/__init__.py b/plotly/validators/violin/hoverlabel/font/__init__.py new file mode 100644 index 0000000000..1d2c591d1e --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/__init__.py @@ -0,0 +1,6 @@ +from ._sizesrc import SizesrcValidator +from ._size import SizeValidator +from ._familysrc import FamilysrcValidator +from ._family import FamilyValidator +from ._colorsrc import ColorsrcValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/hoverlabel/font/_color.py b/plotly/validators/violin/hoverlabel/font/_color.py new file mode 100644 index 0000000000..190e3ceb12 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_color.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/_colorsrc.py b/plotly/validators/violin/hoverlabel/font/_colorsrc.py new file mode 100644 index 0000000000..fb2d676bb1 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_colorsrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorsrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='colorsrc', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(ColorsrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/_family.py b/plotly/validators/violin/hoverlabel/font/_family.py new file mode 100644 index 0000000000..2b97a9bcea --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_family.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class FamilyValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, + plotly_name='family', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(FamilyValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + no_blank=True, + role='style', + strict=True, + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/_familysrc.py b/plotly/validators/violin/hoverlabel/font/_familysrc.py new file mode 100644 index 0000000000..5232436936 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_familysrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class FamilysrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='familysrc', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(FamilysrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/_size.py b/plotly/validators/violin/hoverlabel/font/_size.py new file mode 100644 index 0000000000..0d10dd0309 --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_size.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=True, + edit_type='none', + min=1, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/hoverlabel/font/_sizesrc.py b/plotly/validators/violin/hoverlabel/font/_sizesrc.py new file mode 100644 index 0000000000..c33cbe942d --- /dev/null +++ b/plotly/validators/violin/hoverlabel/font/_sizesrc.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class SizesrcValidator(_plotly_utils.basevalidators.SrcValidator): + + def __init__( + self, + plotly_name='sizesrc', + parent_name='violin.hoverlabel.font', + **kwargs + ): + super(SizesrcValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='none', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/line/__init__.py b/plotly/validators/violin/line/__init__.py new file mode 100644 index 0000000000..7806a9a1cd --- /dev/null +++ b/plotly/validators/violin/line/__init__.py @@ -0,0 +1,2 @@ +from ._width import WidthValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/line/_color.py b/plotly/validators/violin/line/_color.py new file mode 100644 index 0000000000..d3255c1d6b --- /dev/null +++ b/plotly/validators/violin/line/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='violin.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/line/_width.py b/plotly/validators/violin/line/_width.py new file mode 100644 index 0000000000..17f5e81240 --- /dev/null +++ b/plotly/validators/violin/line/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='violin.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/__init__.py b/plotly/validators/violin/marker/__init__.py new file mode 100644 index 0000000000..0bc6d87d6b --- /dev/null +++ b/plotly/validators/violin/marker/__init__.py @@ -0,0 +1,6 @@ +from ._symbol import SymbolValidator +from ._size import SizeValidator +from ._outliercolor import OutliercolorValidator +from ._opacity import OpacityValidator +from ._line import LineValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/marker/_color.py b/plotly/validators/violin/marker/_color.py new file mode 100644 index 0000000000..ed80e4e73e --- /dev/null +++ b/plotly/validators/violin/marker/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='violin.marker', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/_line.py b/plotly/validators/violin/marker/_line.py new file mode 100644 index 0000000000..f7ed17e054 --- /dev/null +++ b/plotly/validators/violin/marker/_line.py @@ -0,0 +1,30 @@ +import _plotly_utils.basevalidators + + +class LineValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='line', parent_name='violin.marker', **kwargs + ): + super(LineValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Line', + data_docs=""" + color + Sets the marker.line color. It accepts either a + specific color or an array of numbers that are + mapped to the colorscale relative to the max + and min values of the array or relative to + `cmin` and `cmax` if set. + outliercolor + Sets the border line color of the outlier + sample points. Defaults to marker.color + outlierwidth + Sets the border line width (in px) of the + outlier sample points. + width + Sets the width (in px) of the lines bounding + the marker points.""", + **kwargs + ) diff --git a/plotly/validators/violin/marker/_opacity.py b/plotly/validators/violin/marker/_opacity.py new file mode 100644 index 0000000000..2eafa50852 --- /dev/null +++ b/plotly/validators/violin/marker/_opacity.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='opacity', parent_name='violin.marker', **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/_outliercolor.py b/plotly/validators/violin/marker/_outliercolor.py new file mode 100644 index 0000000000..fe70082c40 --- /dev/null +++ b/plotly/validators/violin/marker/_outliercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutliercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outliercolor', + parent_name='violin.marker', + **kwargs + ): + super(OutliercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/_size.py b/plotly/validators/violin/marker/_size.py new file mode 100644 index 0000000000..0291c04f6d --- /dev/null +++ b/plotly/validators/violin/marker/_size.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='size', parent_name='violin.marker', **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='calcIfAutorange', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/_symbol.py b/plotly/validators/violin/marker/_symbol.py new file mode 100644 index 0000000000..7be1d7a914 --- /dev/null +++ b/plotly/validators/violin/marker/_symbol.py @@ -0,0 +1,74 @@ +import _plotly_utils.basevalidators + + +class SymbolValidator(_plotly_utils.basevalidators.EnumeratedValidator): + + def __init__( + self, plotly_name='symbol', parent_name='violin.marker', **kwargs + ): + super(SymbolValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='plot', + role='style', + values=[ + 0, 'circle', 100, 'circle-open', 200, 'circle-dot', 300, + 'circle-open-dot', 1, 'square', 101, 'square-open', 201, + 'square-dot', 301, 'square-open-dot', 2, 'diamond', 102, + 'diamond-open', 202, 'diamond-dot', 302, 'diamond-open-dot', 3, + 'cross', 103, 'cross-open', 203, 'cross-dot', 303, + 'cross-open-dot', 4, 'x', 104, 'x-open', 204, 'x-dot', 304, + 'x-open-dot', 5, 'triangle-up', 105, 'triangle-up-open', 205, + 'triangle-up-dot', 305, 'triangle-up-open-dot', 6, + 'triangle-down', 106, 'triangle-down-open', 206, + 'triangle-down-dot', 306, 'triangle-down-open-dot', 7, + 'triangle-left', 107, 'triangle-left-open', 207, + 'triangle-left-dot', 307, 'triangle-left-open-dot', 8, + 'triangle-right', 108, 'triangle-right-open', 208, + 'triangle-right-dot', 308, 'triangle-right-open-dot', 9, + 'triangle-ne', 109, 'triangle-ne-open', 209, 'triangle-ne-dot', + 309, 'triangle-ne-open-dot', 10, 'triangle-se', 110, + 'triangle-se-open', 210, 'triangle-se-dot', 310, + 'triangle-se-open-dot', 11, 'triangle-sw', 111, + 'triangle-sw-open', 211, 'triangle-sw-dot', 311, + 'triangle-sw-open-dot', 12, 'triangle-nw', 112, + 'triangle-nw-open', 212, 'triangle-nw-dot', 312, + 'triangle-nw-open-dot', 13, 'pentagon', 113, 'pentagon-open', + 213, 'pentagon-dot', 313, 'pentagon-open-dot', 14, 'hexagon', + 114, 'hexagon-open', 214, 'hexagon-dot', 314, + 'hexagon-open-dot', 15, 'hexagon2', 115, 'hexagon2-open', 215, + 'hexagon2-dot', 315, 'hexagon2-open-dot', 16, 'octagon', 116, + 'octagon-open', 216, 'octagon-dot', 316, 'octagon-open-dot', + 17, 'star', 117, 'star-open', 217, 'star-dot', 317, + 'star-open-dot', 18, 'hexagram', 118, 'hexagram-open', 218, + 'hexagram-dot', 318, 'hexagram-open-dot', 19, + 'star-triangle-up', 119, 'star-triangle-up-open', 219, + 'star-triangle-up-dot', 319, 'star-triangle-up-open-dot', 20, + 'star-triangle-down', 120, 'star-triangle-down-open', 220, + 'star-triangle-down-dot', 320, 'star-triangle-down-open-dot', + 21, 'star-square', 121, 'star-square-open', 221, + 'star-square-dot', 321, 'star-square-open-dot', 22, + 'star-diamond', 122, 'star-diamond-open', 222, + 'star-diamond-dot', 322, 'star-diamond-open-dot', 23, + 'diamond-tall', 123, 'diamond-tall-open', 223, + 'diamond-tall-dot', 323, 'diamond-tall-open-dot', 24, + 'diamond-wide', 124, 'diamond-wide-open', 224, + 'diamond-wide-dot', 324, 'diamond-wide-open-dot', 25, + 'hourglass', 125, 'hourglass-open', 26, 'bowtie', 126, + 'bowtie-open', 27, 'circle-cross', 127, 'circle-cross-open', + 28, 'circle-x', 128, 'circle-x-open', 29, 'square-cross', 129, + 'square-cross-open', 30, 'square-x', 130, 'square-x-open', 31, + 'diamond-cross', 131, 'diamond-cross-open', 32, 'diamond-x', + 132, 'diamond-x-open', 33, 'cross-thin', 133, + 'cross-thin-open', 34, 'x-thin', 134, 'x-thin-open', 35, + 'asterisk', 135, 'asterisk-open', 36, 'hash', 136, 'hash-open', + 236, 'hash-dot', 336, 'hash-open-dot', 37, 'y-up', 137, + 'y-up-open', 38, 'y-down', 138, 'y-down-open', 39, 'y-left', + 139, 'y-left-open', 40, 'y-right', 140, 'y-right-open', 41, + 'line-ew', 141, 'line-ew-open', 42, 'line-ns', 142, + 'line-ns-open', 43, 'line-ne', 143, 'line-ne-open', 44, + 'line-nw', 144, 'line-nw-open' + ], + **kwargs + ) diff --git a/plotly/validators/violin/marker/line/__init__.py b/plotly/validators/violin/marker/line/__init__.py new file mode 100644 index 0000000000..250468b9f8 --- /dev/null +++ b/plotly/validators/violin/marker/line/__init__.py @@ -0,0 +1,4 @@ +from ._width import WidthValidator +from ._outlierwidth import OutlierwidthValidator +from ._outliercolor import OutliercolorValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/marker/line/_color.py b/plotly/validators/violin/marker/line/_color.py new file mode 100644 index 0000000000..d41b0996a3 --- /dev/null +++ b/plotly/validators/violin/marker/line/_color.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='violin.marker.line', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/line/_outliercolor.py b/plotly/validators/violin/marker/line/_outliercolor.py new file mode 100644 index 0000000000..6bda7096c3 --- /dev/null +++ b/plotly/validators/violin/marker/line/_outliercolor.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class OutliercolorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='outliercolor', + parent_name='violin.marker.line', + **kwargs + ): + super(OutliercolorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/line/_outlierwidth.py b/plotly/validators/violin/marker/line/_outlierwidth.py new file mode 100644 index 0000000000..bb638ddaa7 --- /dev/null +++ b/plotly/validators/violin/marker/line/_outlierwidth.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class OutlierwidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='outlierwidth', + parent_name='violin.marker.line', + **kwargs + ): + super(OutlierwidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/marker/line/_width.py b/plotly/validators/violin/marker/line/_width.py new file mode 100644 index 0000000000..feca1f0865 --- /dev/null +++ b/plotly/validators/violin/marker/line/_width.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='violin.marker.line', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + array_ok=False, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/meanline/__init__.py b/plotly/validators/violin/meanline/__init__.py new file mode 100644 index 0000000000..14e40839e9 --- /dev/null +++ b/plotly/validators/violin/meanline/__init__.py @@ -0,0 +1,3 @@ +from ._width import WidthValidator +from ._visible import VisibleValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/meanline/_color.py b/plotly/validators/violin/meanline/_color.py new file mode 100644 index 0000000000..3ad5890b70 --- /dev/null +++ b/plotly/validators/violin/meanline/_color.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, plotly_name='color', parent_name='violin.meanline', **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/meanline/_visible.py b/plotly/validators/violin/meanline/_visible.py new file mode 100644 index 0000000000..9c1e25c007 --- /dev/null +++ b/plotly/validators/violin/meanline/_visible.py @@ -0,0 +1,15 @@ +import _plotly_utils.basevalidators + + +class VisibleValidator(_plotly_utils.basevalidators.BooleanValidator): + + def __init__( + self, plotly_name='visible', parent_name='violin.meanline', **kwargs + ): + super(VisibleValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='plot', + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/meanline/_width.py b/plotly/validators/violin/meanline/_width.py new file mode 100644 index 0000000000..60d31d9a95 --- /dev/null +++ b/plotly/validators/violin/meanline/_width.py @@ -0,0 +1,16 @@ +import _plotly_utils.basevalidators + + +class WidthValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='width', parent_name='violin.meanline', **kwargs + ): + super(WidthValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/selected/__init__.py b/plotly/validators/violin/selected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/violin/selected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/violin/selected/_marker.py b/plotly/validators/violin/selected/_marker.py new file mode 100644 index 0000000000..dc5369a1c3 --- /dev/null +++ b/plotly/validators/violin/selected/_marker.py @@ -0,0 +1,21 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='violin.selected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of selected points. + opacity + Sets the marker opacity of selected points. + size + Sets the marker size of selected points.""", + **kwargs + ) diff --git a/plotly/validators/violin/selected/marker/__init__.py b/plotly/validators/violin/selected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/violin/selected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/selected/marker/_color.py b/plotly/validators/violin/selected/marker/_color.py new file mode 100644 index 0000000000..62093255a0 --- /dev/null +++ b/plotly/validators/violin/selected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='violin.selected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/selected/marker/_opacity.py b/plotly/validators/violin/selected/marker/_opacity.py new file mode 100644 index 0000000000..cd8733b8ee --- /dev/null +++ b/plotly/validators/violin/selected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='violin.selected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/selected/marker/_size.py b/plotly/validators/violin/selected/marker/_size.py new file mode 100644 index 0000000000..3670c7c902 --- /dev/null +++ b/plotly/validators/violin/selected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='violin.selected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/stream/__init__.py b/plotly/validators/violin/stream/__init__.py new file mode 100644 index 0000000000..2f4f204759 --- /dev/null +++ b/plotly/validators/violin/stream/__init__.py @@ -0,0 +1,2 @@ +from ._token import TokenValidator +from ._maxpoints import MaxpointsValidator diff --git a/plotly/validators/violin/stream/_maxpoints.py b/plotly/validators/violin/stream/_maxpoints.py new file mode 100644 index 0000000000..eac659fbbc --- /dev/null +++ b/plotly/validators/violin/stream/_maxpoints.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class MaxpointsValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, plotly_name='maxpoints', parent_name='violin.stream', **kwargs + ): + super(MaxpointsValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + max=10000, + min=0, + role='info', + **kwargs + ) diff --git a/plotly/validators/violin/stream/_token.py b/plotly/validators/violin/stream/_token.py new file mode 100644 index 0000000000..427bb2d47a --- /dev/null +++ b/plotly/validators/violin/stream/_token.py @@ -0,0 +1,17 @@ +import _plotly_utils.basevalidators + + +class TokenValidator(_plotly_utils.basevalidators.StringValidator): + + def __init__( + self, plotly_name='token', parent_name='violin.stream', **kwargs + ): + super(TokenValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='calc', + no_blank=True, + role='info', + strict=True, + **kwargs + ) diff --git a/plotly/validators/violin/unselected/__init__.py b/plotly/validators/violin/unselected/__init__.py new file mode 100644 index 0000000000..3604b0284f --- /dev/null +++ b/plotly/validators/violin/unselected/__init__.py @@ -0,0 +1 @@ +from ._marker import MarkerValidator diff --git a/plotly/validators/violin/unselected/_marker.py b/plotly/validators/violin/unselected/_marker.py new file mode 100644 index 0000000000..799e8c5962 --- /dev/null +++ b/plotly/validators/violin/unselected/_marker.py @@ -0,0 +1,24 @@ +import _plotly_utils.basevalidators + + +class MarkerValidator(_plotly_utils.basevalidators.CompoundValidator): + + def __init__( + self, plotly_name='marker', parent_name='violin.unselected', **kwargs + ): + super(MarkerValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + data_class_str='Marker', + data_docs=""" + color + Sets the marker color of unselected points, + applied only when a selection exists. + opacity + Sets the marker opacity of unselected points, + applied only when a selection exists. + size + Sets the marker size of unselected points, + applied only when a selection exists.""", + **kwargs + ) diff --git a/plotly/validators/violin/unselected/marker/__init__.py b/plotly/validators/violin/unselected/marker/__init__.py new file mode 100644 index 0000000000..ed9a907094 --- /dev/null +++ b/plotly/validators/violin/unselected/marker/__init__.py @@ -0,0 +1,3 @@ +from ._size import SizeValidator +from ._opacity import OpacityValidator +from ._color import ColorValidator diff --git a/plotly/validators/violin/unselected/marker/_color.py b/plotly/validators/violin/unselected/marker/_color.py new file mode 100644 index 0000000000..6341782c94 --- /dev/null +++ b/plotly/validators/violin/unselected/marker/_color.py @@ -0,0 +1,18 @@ +import _plotly_utils.basevalidators + + +class ColorValidator(_plotly_utils.basevalidators.ColorValidator): + + def __init__( + self, + plotly_name='color', + parent_name='violin.unselected.marker', + **kwargs + ): + super(ColorValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/unselected/marker/_opacity.py b/plotly/validators/violin/unselected/marker/_opacity.py new file mode 100644 index 0000000000..fa224311ea --- /dev/null +++ b/plotly/validators/violin/unselected/marker/_opacity.py @@ -0,0 +1,20 @@ +import _plotly_utils.basevalidators + + +class OpacityValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='opacity', + parent_name='violin.unselected.marker', + **kwargs + ): + super(OpacityValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + max=1, + min=0, + role='style', + **kwargs + ) diff --git a/plotly/validators/violin/unselected/marker/_size.py b/plotly/validators/violin/unselected/marker/_size.py new file mode 100644 index 0000000000..6f40f5623f --- /dev/null +++ b/plotly/validators/violin/unselected/marker/_size.py @@ -0,0 +1,19 @@ +import _plotly_utils.basevalidators + + +class SizeValidator(_plotly_utils.basevalidators.NumberValidator): + + def __init__( + self, + plotly_name='size', + parent_name='violin.unselected.marker', + **kwargs + ): + super(SizeValidator, self).__init__( + plotly_name=plotly_name, + parent_name=parent_name, + edit_type='style', + min=0, + role='style', + **kwargs + ) diff --git a/plotly/version.py b/plotly/version.py index 766ce2d066..0489e95aed 100644 --- a/plotly/version.py +++ b/plotly/version.py @@ -1 +1,15 @@ -__version__ = '2.7.0' +__version__ = '3.0.0' +__frontend_version__ = '^0.1.1' + + +def stable_semver(): + """ + Get the stable portion of the semantic version string (the first three + numbers), without any of the trailing labels + + '3.0.0rc11' -> '3.0.0' + """ + from distutils.version import LooseVersion + version_components = LooseVersion(__version__).version + stable_ver_str = '.'.join(str(s) for s in version_components[0:3]) + return stable_ver_str diff --git a/plotlywidget.json b/plotlywidget.json new file mode 100644 index 0000000000..0cf990d024 --- /dev/null +++ b/plotlywidget.json @@ -0,0 +1,5 @@ +{ + "load_extensions": { + "plotlywidget/extension": true + } +} diff --git a/plotlywidget/__init__.py b/plotlywidget/__init__.py new file mode 100644 index 0000000000..1e592f7217 --- /dev/null +++ b/plotlywidget/__init__.py @@ -0,0 +1,9 @@ +def _jupyter_nbextension_paths(): + return [{ + 'section': 'notebook', + 'src': 'static', + 'dest': 'plotlywidget', + 'require': 'plotlywidget/extension' + }] + +__frontend_version__ = '^0.1' \ No newline at end of file diff --git a/requirements.txt b/requirements.txt index 4c6eebe257..f4ca537343 100644 --- a/requirements.txt +++ b/requirements.txt @@ -13,3 +13,6 @@ six==1.8.0 ## timezone definitions ## pytz==2014.9 + +## retrying requests ## +retrying==1.3.3 diff --git a/setup.py b/setup.py index d12b3c7598..f3a0f96813 100644 --- a/setup.py +++ b/setup.py @@ -1,6 +1,34 @@ -from setuptools import setup +from setuptools import setup, Command +from setuptools.command.build_py import build_py +from setuptools.command.egg_info import egg_info +from setuptools.command.sdist import sdist +from subprocess import check_call +from distutils import log -exec (open('plotly/version.py').read()) +import os +import sys +import platform +import json + +exec(open('plotly/version.py').read()) + +here = os.path.dirname(os.path.abspath(__file__)) +node_root = os.path.join(here, 'js') +is_repo = os.path.exists(os.path.join(here, '.git')) + +npm_path = os.pathsep.join([ + os.path.join(node_root, 'node_modules', '.bin'), + os.environ.get('PATH', os.defpath), +]) + + +# Load plotly.js version from js/package.json +def plotly_js_version(): + with open('js/package.json', 'rt') as f: + package_json = json.load(f) + version = package_json['dependencies']['plotly.js'] + + return version def readme(): @@ -8,6 +36,196 @@ def readme(): return f.read() +def js_prerelease(command, strict=False): + """decorator for building minified js/css prior to another command""" + class DecoratedCommand(command): + def run(self): + jsdeps = self.distribution.get_command_obj('jsdeps') + if not is_repo and all(os.path.exists(t) for t in jsdeps.targets): + # sdist, nothing to do + command.run(self) + return + + try: + self.distribution.run_command('jsdeps') + except Exception as e: + missing = [t for t in jsdeps.targets if not os.path.exists(t)] + if strict or missing: + log.warn('rebuilding js and css failed') + if missing: + log.error('missing files: %s' % missing) + raise e + else: + log.warn('rebuilding js and css failed (not a problem)') + log.warn(str(e)) + command.run(self) + update_package_data(self.distribution) + return DecoratedCommand + + +def update_package_data(distribution): + """update package_data to catch changes during setup""" + build_py = distribution.get_command_obj('build_py') + # distribution.package_data = find_package_data() + # re-init build_py options which load package_data + build_py.finalize_options() + + +class NPM(Command): + description = 'install package.json dependencies using npm' + + user_options = [] + + node_modules = os.path.join(node_root, 'node_modules') + + targets = [ + os.path.join(here, 'plotlywidget', 'static', 'extension.js'), + os.path.join(here, 'plotlywidget', 'static', 'index.js') + ] + + def initialize_options(self): + pass + + def finalize_options(self): + pass + + def get_npm_name(self): + npmName = 'npm' + if platform.system() == 'Windows': + npmName = 'npm.cmd' + + return npmName + + def has_npm(self): + npmName = self.get_npm_name(); + try: + check_call([npmName, '--version']) + return True + except: + return False + + def should_run_npm_install(self): + package_json = os.path.join(node_root, 'package.json') + node_modules_exists = os.path.exists(self.node_modules) + return self.has_npm() + + def run(self): + has_npm = self.has_npm() + if not has_npm: + log.error( + "`npm` unavailable. If you're running this command using sudo, make sure `npm` is available to sudo") + + env = os.environ.copy() + env['PATH'] = npm_path + + if self.should_run_npm_install(): + log.info("Installing build dependencies with npm. This may take a while...") + npmName = self.get_npm_name(); + check_call([npmName, 'install'], cwd=node_root, stdout=sys.stdout, stderr=sys.stderr) + os.utime(self.node_modules, None) + + for t in self.targets: + if not os.path.exists(t): + msg = 'Missing file: %s' % t + if not has_npm: + msg += '\nnpm is required to build a development version of widgetsnbextension' + raise ValueError(msg) + + # update package data in case this created new files + update_package_data(self.distribution) + + +class CodegenCommand(Command): + description = 'Generate class hierarchy from Plotly JSON schema' + user_options = [] + + def initialize_options(self): + pass + + def finalize_options(self): + pass + + def run(self): + if sys.version_info.major != 3 or sys.version_info.minor < 6: + raise ImportError( + 'Code generation must be executed with Python >= 3.6') + + from codegen import perform_codegen + perform_codegen() + + +class UpdateSchemaCommand(Command): + description = 'Download latest version of the plot-schema JSON file' + user_options = [] + + def initialize_options(self): + pass + + def finalize_options(self): + pass + + def run(self): + if sys.version_info.major != 3: + raise ImportError('Schema download must be executed with Python 3') + + import urllib.request + url = ('https://raw.githubusercontent.com/plotly/plotly.js/' + 'v%s/dist/plot-schema.json' % plotly_js_version()) + with urllib.request.urlopen(url) as response: + + with open('plotly/package_data/plot-schema.json', 'wb') as f: + f.write(response.read()) + + +class UpdateBundleCommand(Command): + description = 'Download latest version of the plot-schema JSON file' + user_options = [] + + def initialize_options(self): + pass + + def finalize_options(self): + pass + + def run(self): + if sys.version_info.major != 3: + raise ImportError('Schema download must be executed with Python 3') + + import urllib.request + url = ('https://raw.githubusercontent.com/plotly/plotly.js/' + 'v%s/dist/plotly.min.js' % plotly_js_version()) + with urllib.request.urlopen(url) as response: + + with open('plotly/package_data/plotly.min.js', 'wb') as f: + f.write(response.read()) + + +class UpdatePlotlyJsCommand(Command): + description = 'Update project to a new version of plotly.js' + user_options = [] + + def initialize_options(self): + pass + + def finalize_options(self): + pass + + def run(self): + self.run_command('updatebundle') + self.run_command('updateschema') + self.run_command('codegen') + + +graph_objs_packages = [ + d[0] for d in os.walk('plotly/graph_objs') + if not d[0].endswith('__pycache__')] + + +validator_packages = [ + d[0] for d in os.walk('plotly/validators') + if not d[0].endswith('__pycache__')] + + setup(name='plotly', version=__version__, use_2to3=False, @@ -31,6 +249,7 @@ def readme(): ], license='MIT', packages=['plotly', + 'plotlywidget', 'plotly/api', 'plotly/api/v1', 'plotly/api/v2', @@ -39,17 +258,37 @@ def readme(): 'plotly/plotly', 'plotly/plotly/chunked_requests', 'plotly/figure_factory', - 'plotly/graph_objs', 'plotly/grid_objs', 'plotly/widgets', 'plotly/offline', 'plotly/matplotlylib', 'plotly/matplotlylib/mplexporter', - 'plotly/matplotlylib/mplexporter/renderers'], - package_data={'plotly': ['package_data/*']}, + 'plotly/matplotlylib/mplexporter/renderers', + '_plotly_utils'] + graph_objs_packages + validator_packages, + package_data={'plotly': ['package_data/*'], 'plotlywidget': ['static/*']}, + data_files=[ + ('share/jupyter/nbextensions/plotlywidget', [ + 'plotlywidget/static/extension.js', + 'plotlywidget/static/index.js', + 'plotlywidget/static/index.js.map', + ]), + ('etc/jupyter/nbconfig/notebook.d', ['plotlywidget.json']), + ], install_requires=['decorator>=4.0.6', 'nbformat>=4.2', 'pytz', 'requests', + 'retrying>=1.3.3', 'six'], - zip_safe=False) + zip_safe=False, + cmdclass={ + 'build_py': js_prerelease(build_py), + 'egg_info': js_prerelease(egg_info), + 'sdist': js_prerelease(sdist, strict=True), + 'jsdeps': NPM, + 'codegen': CodegenCommand, + 'updateschema': UpdateSchemaCommand, + 'updatebundle': UpdateBundleCommand, + 'updateplotlyjs': js_prerelease(UpdatePlotlyJsCommand) + }, +) diff --git a/specs/ipyplotly_integration/Compatibility Notes.ipynb b/specs/ipyplotly_integration/Compatibility Notes.ipynb new file mode 100644 index 0000000000..09a6be7073 --- /dev/null +++ b/specs/ipyplotly_integration/Compatibility Notes.ipynb @@ -0,0 +1,353 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "This notebook will contain a running set of examples of backward compatibility considerations." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "" + ], + "text/vnd.plotly.v1+html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Imports\n", + "from plotly.offline import init_notebook_mode, plot, iplot\n", + "import plotly.graph_objs as go\n", + "\n", + "# Initialize notebook mode (Needed by iplot)\n", + "init_notebook_mode(connected=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'file:///Users/adamkulidjian/Desktop/Adam/plotly/plotly.py/specs/ipyplotly_integration/exports/tmp.html'" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# The graph_obj constructors (inluding Figure) are now pretty compatible with legacy code\n", + "fig = go.Figure([go.Scatter(x=[1, 2, 3], y=[3, 1, 6], marker=go.scatter.Marker(color='green'))])\n", + "plot(fig, filename='exports/tmp.html')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/graph_objs/_deprecations.py:426: DeprecationWarning:\n", + "\n", + "plotly.graph_objs.Marker is deprecated.\n", + "Please replace it with one of the following more specific types\n", + " - plotly.graph_objs.scatter.Marker\n", + " - plotly.graph_objs.histogram.selected.Marker\n", + " - etc.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "data": [ + { + "marker": { + "color": "green" + }, + "type": "scatter", + "uid": "83f88c0c-7589-11e8-857f-c869cda04ed6", + "x": [ + 1, + 2, + 3 + ], + "y": [ + 3, + 1, + 6 + ] + } + ], + "layout": {} + }, + "text/html": [ + "
" + ], + "text/vnd.plotly.v1+html": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "iplot(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "89e3be80b4bc48b5bda9115d75bb90db", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Instead of using iplot, we can construct a FigureWidget and it will be displayed in the notebook automatically\n", + "fig_widget = go.FigureWidget([go.Scatter(x=[1, 2, 3], y=[3, 1, 6], marker=go.Marker(color='green'))])\n", + "fig_widget" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Now we can update x-axis range in-place and see the updates reflected in the already displayed figure above\n", + "fig_widget.layout.xaxis.range = [0, 5]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Trace properties can be modified in place as well\n", + "scatt = fig_widget.data[0]\n", + "scatt.line.dash = 'longdash'" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "\n Invalid value of type 'builtins.str' received for the 'mode' property of trace.scatter\n Received value: 'marker'\n\n The 'mode' property is a flaglist and may be specified as a string containing:\n - Any combination of ['lines', 'markers', 'text'] joined with '+' characters (e.g. 'lines+markers')\n OR exactly one of ['none'] (e.g. 'none')\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Detailed value validation is performed on parameters passed to the Figure constructor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;31m# Here we set 'moded to 'marker' instead of 'markers'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mgo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mFigure\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mScatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgo\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mMarker\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'green'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'marker'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/datatypes/trace/__init__.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, cliponaxis, connectgaps, customdata, customdatasrc, dx, dy, error_x, error_y, fill, fillcolor, hoverinfo, hoverinfosrc, hoverlabel, hoveron, hovertext, hovertextsrc, ids, idssrc, legendgroup, line, marker, mode, name, opacity, r, rsrc, selected, selectedpoints, showlegend, stream, t, text, textfont, textposition, textpositionsrc, textsrc, tsrc, uid, unselected, visible, x, x0, xaxis, xcalendar, xsrc, y, y0, yaxis, ycalendar, ysrc, **kwargs)\u001b[0m\n\u001b[1;32m 26269\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mline\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 26270\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmarker\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmarker\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 26271\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 26272\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 26273\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopacity\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopacity\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m__setattr__\u001b[0;34m(self, prop, value)\u001b[0m\n\u001b[1;32m 1250\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1251\u001b[0m \u001b[0;31m# Let known properties and private properties through\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1252\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1253\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1254\u001b[0m \u001b[0;31m# Raise error on unknown public properties\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/datatypes/trace/__init__.py\u001b[0m in \u001b[0;36mmode\u001b[0;34m(self, val)\u001b[0m\n\u001b[1;32m 25235\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msetter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25236\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 25237\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'mode'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 25238\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25239\u001b[0m \u001b[0;31m# name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m 1405\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1406\u001b[0m \u001b[0;31m# Simple property\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1407\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_prop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m_set_prop\u001b[0;34m(self, prop, val)\u001b[0m\n\u001b[1;32m 1424\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1425\u001b[0m \u001b[0mvalidator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validators\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1426\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_coerce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1427\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1428\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basevalidators.py\u001b[0m in \u001b[0;36mvalidate_coerce\u001b[0;34m(self, v)\u001b[0m\n\u001b[1;32m 925\u001b[0m \u001b[0mvalidated_v\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mperform_validate_coerce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 926\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidated_v\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 927\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_invalid_val\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 928\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 929\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidated_v\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basevalidators.py\u001b[0m in \u001b[0;36mraise_invalid_val\u001b[0;34m(self, v)\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0mtyp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtype_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrepr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 106\u001b[0;31m vald_clr_desc=self.description()))\n\u001b[0m\u001b[1;32m 107\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mraise_invalid_elements\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minvalid_els\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: \n Invalid value of type 'builtins.str' received for the 'mode' property of trace.scatter\n Received value: 'marker'\n\n The 'mode' property is a flaglist and may be specified as a string containing:\n - Any combination of ['lines', 'markers', 'text'] joined with '+' characters (e.g. 'lines+markers')\n OR exactly one of ['none'] (e.g. 'none')\n" + ] + } + ], + "source": [ + "# Detailed value validation is performed on parameters passed to the Figure constructor\n", + "# Here we set 'moded to 'marker' instead of 'markers'\n", + "go.Figure([go.Scatter(x=[1, 2, 3], y=[3, 1, 6], marker=go.Marker(color='green'), mode='marker')])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "\n Invalid value of type 'builtins.str' received for the 'mode' property of trace.scatter\n Received value: 'marker'\n\n The 'mode' property is a flaglist and may be specified as a string containing:\n - Any combination of ['lines', 'markers', 'text'] joined with '+' characters (e.g. 'lines+markers')\n OR exactly one of ['none'] (e.g. 'none')\n", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# The same validation is performed on property assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mscatt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmode\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'marker'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m__setattr__\u001b[0;34m(self, prop, value)\u001b[0m\n\u001b[1;32m 1250\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1251\u001b[0m \u001b[0;31m# Let known properties and private properties through\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1252\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1253\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1254\u001b[0m \u001b[0;31m# Raise error on unknown public properties\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/datatypes/trace/__init__.py\u001b[0m in \u001b[0;36mmode\u001b[0;34m(self, val)\u001b[0m\n\u001b[1;32m 25235\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mmode\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msetter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25236\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mmode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m> 25237\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'mode'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 25238\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 25239\u001b[0m \u001b[0;31m# name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m 1405\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1406\u001b[0m \u001b[0;31m# Simple property\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1407\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_set_prop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1409\u001b[0m \u001b[0;34m@\u001b[0m\u001b[0mproperty\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basedatatypes.py\u001b[0m in \u001b[0;36m_set_prop\u001b[0;34m(self, prop, val)\u001b[0m\n\u001b[1;32m 1424\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1425\u001b[0m \u001b[0mvalidator\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_validators\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1426\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidator\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalidate_coerce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1427\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1428\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basevalidators.py\u001b[0m in \u001b[0;36mvalidate_coerce\u001b[0;34m(self, v)\u001b[0m\n\u001b[1;32m 925\u001b[0m \u001b[0mvalidated_v\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mperform_validate_coerce\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 926\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mvalidated_v\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 927\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mraise_invalid_val\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 928\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 929\u001b[0m \u001b[0mv\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mvalidated_v\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/Programming/PyDataStack/repos/plotly.py/plotly/basevalidators.py\u001b[0m in \u001b[0;36mraise_invalid_val\u001b[0;34m(self, v)\u001b[0m\n\u001b[1;32m 104\u001b[0m \u001b[0mtyp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtype_str\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 105\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrepr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 106\u001b[0;31m vald_clr_desc=self.description()))\n\u001b[0m\u001b[1;32m 107\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 108\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mraise_invalid_elements\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minvalid_els\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: \n Invalid value of type 'builtins.str' received for the 'mode' property of trace.scatter\n Received value: 'marker'\n\n The 'mode' property is a flaglist and may be specified as a string containing:\n - Any combination of ['lines', 'markers', 'text'] joined with '+' characters (e.g. 'lines+markers')\n OR exactly one of ['none'] (e.g. 'none')\n" + ] + } + ], + "source": [ + "# The same validation is performed on property assignment\n", + "scatt.mode = 'marker'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "7df79e56dce64c1ab7be9e8b1df64d49": { + "model_module": "plotlywidget", + "model_module_version": "1.0.0", + "model_name": "FigureModel", + "state": { + "_data": [ + { + "_relayout_msg_id": 2, + "_restyle_msg_id": 1, + "line": { + "dash": "longdash" + }, + "marker": { + "color": "green" + }, + "type": "scatter", + "uid": "079cc02c-15c5-11e8-862d-a0999b0c017b", + "x": [ + 1, + 2, + 3 + ], + "xaxis": "x", + "y": [ + 3, + 1, + 6 + ], + "yaxis": "y" + } + ], + "_js2py_pointsCallback": {}, + "_js2py_relayout": {}, + "_js2py_restyle": [], + "_js2py_styleDelta": null, + "_js2py_update": {}, + "_last_relayout_msg_id": 2, + "_last_restyle_msg_id": 1, + "_layout": { + "_relayout_msg_id": 1, + "xaxis": { + "range": [ + 0, + 5 + ] + } + }, + "_py2js_addTraces": [], + "_py2js_animate": [], + "_py2js_deleteTraces": {}, + "_py2js_moveTraces": [], + "_py2js_removeLayoutProps": [], + "_py2js_removeStyleProps": [], + "_py2js_requestSvg": "", + "_py2js_update": [], + "_view_count": 1, + "_view_module_version": "" + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/specs/ipyplotly_integration/DataShaderExample.ipynb b/specs/ipyplotly_integration/DataShaderExample.ipynb new file mode 100644 index 0000000000..9caf95b855 --- /dev/null +++ b/specs/ipyplotly_integration/DataShaderExample.ipynb @@ -0,0 +1,541 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "This notebook demonstrates how to use DataShader to display large datasets inside a plotly FigureWidget. Change callbacks are used to recompute the datashader image whenever the axis range or figure size changes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install Datashader" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`$ conda install datashader -y`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "ImportError", + "evalue": "No module named datashader", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 17\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0;31m# datashader\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 19\u001b[0;31m \u001b[0;32mimport\u001b[0m \u001b[0mdatashader\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 20\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0mdatashader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtransfer_functions\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0mtf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 21\u001b[0m \u001b[0;32mfrom\u001b[0m \u001b[0mdatashader\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolors\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0minferno\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mImportError\u001b[0m: No module named datashader" + ] + } + ], + "source": [ + "# ipyplotly\n", + "from plotly.graph_objs import FigureWidget\n", + "\n", + "# core\n", + "import io\n", + "import base64 \n", + "import time\n", + "\n", + "# pandas\n", + "import pandas as pd\n", + "\n", + "# numpy\n", + "import numpy as np\n", + "\n", + "# scikit learn\n", + "from sklearn import datasets\n", + "\n", + "# datashader\n", + "import datashader as ds\n", + "import datashader.transfer_functions as tf\n", + "from datashader.colors import inferno" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generate dataset\n", + "We will create a large dataset by duplicating the Iris dataset many times with random noise" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_lengthsepal_widthpetal_lengthpetal_width
count1.050000e+061.050000e+061.050000e+061.050000e+06
mean5.843334e+003.054174e+003.758513e+001.198656e+00
std8.491408e-014.760660e-011.769797e+007.867412e-01
min3.570904e+001.288017e+001.595338e-01-7.130906e-01
25%5.156203e+002.740191e+001.637389e+003.925065e-01
50%5.801178e+003.033385e+004.307065e+001.316142e+00
75%6.443619e+003.346452e+005.142117e+001.827593e+00
max8.665589e+005.200911e+007.662023e+003.353820e+00
\n", + "
" + ], + "text/plain": [ + " sepal_length sepal_width petal_length petal_width\n", + "count 1.050000e+06 1.050000e+06 1.050000e+06 1.050000e+06\n", + "mean 5.843334e+00 3.054174e+00 3.758513e+00 1.198656e+00\n", + "std 8.491408e-01 4.760660e-01 1.769797e+00 7.867412e-01\n", + "min 3.570904e+00 1.288017e+00 1.595338e-01 -7.130906e-01\n", + "25% 5.156203e+00 2.740191e+00 1.637389e+00 3.925065e-01\n", + "50% 5.801178e+00 3.033385e+00 4.307065e+00 1.316142e+00\n", + "75% 6.443619e+00 3.346452e+00 5.142117e+00 1.827593e+00\n", + "max 8.665589e+00 5.200911e+00 7.662023e+00 3.353820e+00" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "num_copies = 7000 # 1,050,000 rows\n", + "\n", + "iris_data = datasets.load_iris()\n", + "feature_names = [name.replace(' (cm)', '').replace(' ', '_') for name in iris_data.feature_names]\n", + "iris_df_orig = pd.DataFrame(iris_data.data, columns=feature_names)\n", + "target_orig = iris_data.target + 1\n", + "\n", + "# frame of features\n", + "iris_df = pd.concat(\n", + " np.random.normal(scale=0.2, size=iris_df_orig.shape) + iris_df_orig for i in range(num_copies)\n", + ").reset_index(drop=True)\n", + "\n", + "# array of targets\n", + "target = [t for i in range(num_copies) for t in target_orig]\n", + "\n", + "# dataframe that includes target as categorical\n", + "iris_target_df = pd.concat([iris_df, pd.Series(target, name='target', dtype='category')], axis=1)\n", + "\n", + "iris_df.describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define DataShader image generation function\n", + "Define a function that inputs an x/y ranges and the plot width/height and generates a DataShader image of the dataset. The image will be returned as a PIL image object" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def gen_ds_image(x_range, y_range, plot_width, plot_height):\n", + " if x_range is None or y_range is None or plot_width is None or plot_height is None:\n", + " return None\n", + " \n", + " cvs = ds.Canvas(x_range=x_range, y_range=y_range, plot_height=plot_height, plot_width=plot_width)\n", + " agg_scatter = cvs.points(iris_target_df, \n", + " 'sepal_length', 'sepal_width', \n", + " ds.count_cat('target'))\n", + " img = tf.shade(agg_scatter)\n", + " img = tf.dynspread(img, threshold=0.95, max_px=5, shape='circle')\n", + " \n", + " return img.to_pil()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Define initial ranges and plot size" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "x_range=[3, 10]\n", + "y_range=[0, 6]\n", + "plot_height=500\n", + "plot_width=700" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Test image generation function and display the PIL image\n", + "initial_img = gen_ds_image(x_range, y_range, plot_width, plot_height)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_img" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create FigureWidget with background image" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c31816a040ee41af8b9071ef55c79000", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f = FigureWidget(data=[{'x': x_range, \n", + " 'y': y_range, \n", + " 'mode': 'markers',\n", + " 'marker': {'opacity': 0}}], # invisible trace to init axes and to support autoresize\n", + " layout={'width': plot_width, 'height': plot_height})\n", + "f" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set background image\n", + "f.layout.images = [dict(\n", + " source = initial_img, # plotly now performs auto conversion of PIL image to png data URI\n", + " xref = \"x\",\n", + " yref = \"y\",\n", + " x = x_range[0],\n", + " y = y_range[1],\n", + " sizex = x_range[1] - x_range[0],\n", + " sizey = y_range[1] - y_range[0],\n", + " sizing = \"stretch\",\n", + " layer = \"below\")]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Install change callback to update image on zoom/resize" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def update_ds_image(layout, x_range, y_range, plot_width, plot_height):\n", + " img = f.layout.images[0]\n", + " \n", + " # Update with batch_update so all updates happen simultaneously\n", + " with f.batch_update():\n", + " img.x = x_range[0]\n", + " img.y = y_range[1]\n", + " img.sizex = x_range[1] - x_range[0]\n", + " img.sizey = y_range[1] - y_range[0]\n", + " img.source = gen_ds_image(x_range, y_range, plot_width, plot_height)\n", + "\n", + "# Install callback to run exactly once if one or more of the following properties changes\n", + "# - xaxis range\n", + "# - yaxis range\n", + "# - figure width\n", + "# - figure height\n", + "f.layout.on_change(update_ds_image, ('xaxis', 'range'), ('yaxis', 'range'), 'width', 'height')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image updates on drag zoom" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c31816a040ee41af8b9071ef55c79000", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f.layout.dragmode = 'zoom'\n", + "f" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image updates on change axis range" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "f.layout.xaxis.range = [3.5, 9]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image updates on change figure dimensions" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c31816a040ee41af8b9071ef55c79000", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "with f.batch_update():\n", + " f.layout.width = 1000\n", + " f.layout.height = 500 " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/specs/ipyplotly_integration/Overview.ipynb b/specs/ipyplotly_integration/Overview.ipynb new file mode 100644 index 0000000000..f39071a05c --- /dev/null +++ b/specs/ipyplotly_integration/Overview.ipynb @@ -0,0 +1,991 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Overview\n", + "\n", + "This notebook introduces the ipyplotly enhancements to the plotly.py visualization library and demonstrates some of its features.\n", + "\n", + "\n", + "## New Features\n", + "\n", + " - Traces can be added and updated interactively by simply assigning to properties\n", + " - The full Traces and Layout API is generated from the plotly schema to provide a great experience for interactive use in the notebook\n", + " - Data validation covering the full API with clear, informative error messages\n", + " - Jupyter friendly docstrings on constructor params and properties\n", + " - Support for setting array properties as numpy arrays. When numpy arrays are used, ipywidgets binary serialization protocol is used to avoid converting these to JSON strings.\n", + " - Context manager API for animation\n", + " - Programmatic export of figures to static SVG images (and PNG and PDF with cairosvg installed)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# ipyplotly\n", + "from plotly.graph_objs import FigureWidget\n", + "from plotly.callbacks import Points, InputDeviceState\n", + "\n", + "# pandas\n", + "import pandas as pd\n", + "\n", + "# numpy\n", + "import numpy as np\n", + "\n", + "# scikit learn\n", + "from sklearn import datasets\n", + "\n", + "# ipywidgets\n", + "from ipywidgets import HBox, VBox, Button\n", + "\n", + "# functools\n", + "from functools import partial" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sepal_lengthsepal_widthpetal_lengthpetal_width
05.13.51.40.2
14.93.01.40.2
24.73.21.30.2
34.63.11.50.2
45.03.61.40.2
\n", + "
" + ], + "text/plain": [ + " sepal_length sepal_width petal_length petal_width\n", + "0 5.1 3.5 1.4 0.2\n", + "1 4.9 3.0 1.4 0.2\n", + "2 4.7 3.2 1.3 0.2\n", + "3 4.6 3.1 1.5 0.2\n", + "4 5.0 3.6 1.4 0.2" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load iris dataset\n", + "iris_data = datasets.load_iris()\n", + "feature_names = [name.replace(' (cm)', '').replace(' ', '_') for name in iris_data.feature_names]\n", + "iris_df = pd.DataFrame(iris_data.data, columns=feature_names)\n", + "iris_class = iris_data.target + 1\n", + "iris_df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and display an empty FigureWidget\n", + "A FigureWidget behaves almost identically to a Figure but it is also an ipywidget that can be displayed directly in the notebook without calling `iplot`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4c3202f9b0e040ff9fc05260b3498800" + } + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f1 = FigureWidget()\n", + "f1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tab completion \n", + "Entering ``f1.add_`` displays add methods for all of the supported trace types" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# f1.add_" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Entering ``f1.add_scatter()`` displays the names of all of the top-level properties for the scatter trace type\n", + "\n", + "Entering ``f1.add_scatter()`` displays the signature pop-up. Expanding this pop-up reveals the method doc string which contains the descriptions of all of the top level properties" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# f1.add_scatter(" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Add scatter trace" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Can't clean for JSON: ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mscatt1\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_scatter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0miris_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msepal_length\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0miris_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpetal_width\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/graph_objs/_figurewidget.pyc\u001b[0m in \u001b[0;36madd_scatter\u001b[0;34m(self, cliponaxis, connectgaps, customdata, customdatasrc, dx, dy, error_x, error_y, fill, fillcolor, hoverinfo, hoverinfosrc, hoverlabel, hoveron, hovertext, hovertextsrc, ids, idssrc, legendgroup, line, marker, mode, name, opacity, r, rsrc, selected, selectedpoints, showlegend, stream, t, text, textfont, textposition, textpositionsrc, textsrc, tsrc, uid, unselected, visible, x, x0, xaxis, xcalendar, xsrc, y, y0, yaxis, ycalendar, ysrc, row, col, **kwargs)\u001b[0m\n\u001b[1;32m 5580\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5581\u001b[0m )\n\u001b[0;32m-> 5582\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd_trace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_trace\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mrow\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcol\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 5583\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5584\u001b[0m def add_scatter3d(\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basedatatypes.pyc\u001b[0m in \u001b[0;36madd_trace\u001b[0;34m(self, trace, row, col)\u001b[0m\n\u001b[1;32m 1000\u001b[0m return self.add_traces(data=[trace],\n\u001b[1;32m 1001\u001b[0m \u001b[0mrows\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1002\u001b[0;31m \u001b[0mcols\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcol\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcol\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1003\u001b[0m )[0]\n\u001b[1;32m 1004\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basedatatypes.pyc\u001b[0m in \u001b[0;36madd_traces\u001b[0;34m(self, data, rows, cols)\u001b[0m\n\u001b[1;32m 1101\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1102\u001b[0m \u001b[0;31m# Update messages\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1103\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_send_addTraces_msg\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_traces_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1104\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1105\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basewidget.pyc\u001b[0m in \u001b[0;36m_send_addTraces_msg\u001b[0;34m(self, new_traces_data)\u001b[0m\n\u001b[1;32m 277\u001b[0m \u001b[0;31m# Send message\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 278\u001b[0m \u001b[0;31m# ------------\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 279\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_py2js_addTraces\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0madd_traces_msg\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 280\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_py2js_addTraces\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basedatatypes.pyc\u001b[0m in \u001b[0;36m__setattr__\u001b[0;34m(self, prop, value)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0;31m# Let known properties and private properties through\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBaseFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0;31m# Raise error on unknown public properties\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, obj, value)\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTraitError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The \"%s\" trait is read-only.'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 584\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 585\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 586\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 587\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_validate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36mset\u001b[0;34m(self, obj, value)\u001b[0m\n\u001b[1;32m 572\u001b[0m \u001b[0;31m# we explicitly compare silent to True just in case the equality\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 573\u001b[0m \u001b[0;31m# comparison above returns something other than True/False\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 574\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_notify_trait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 576\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__set__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36m_notify_trait\u001b[0;34m(self, name, old_value, new_value)\u001b[0m\n\u001b[1;32m 1137\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnew_value\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1138\u001b[0m \u001b[0mowner\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1139\u001b[0;31m \u001b[0mtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'change'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1140\u001b[0m ))\n\u001b[1;32m 1141\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36mnotify_change\u001b[0;34m(self, change)\u001b[0m\n\u001b[1;32m 395\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_should_send_property\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchange\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'new'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[0;31m# Send new state to front-end\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 397\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 398\u001b[0m \u001b[0mLoggingConfigurable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnotify_change\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchange\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 399\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36msend_state\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 280\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffer_keys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_split_state_buffers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'method'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'update'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'state'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'buffers'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbuffer_keys\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 282\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_send\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 283\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 284\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdrop_defaults\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36m_send\u001b[0;34m(self, msg, buffers)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[0;34m\"\"\"Sends a message to the model in the front-end.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernel\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 536\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 537\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/comm/comm.pyc\u001b[0m in \u001b[0;36msend\u001b[0;34m(self, data, metadata, buffers)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;34m\"\"\"Send a message to the frontend-side version of this comm\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m self._publish_msg('comm_msg',\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m )\n\u001b[1;32m 123\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/comm/comm.pyc\u001b[0m in \u001b[0;36m_publish_msg\u001b[0;34m(self, msg_type, data, metadata, buffers, **keys)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0mmetadata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmetadata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m \u001b[0mcontent\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomm_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 66\u001b[0m self.kernel.session.send(self.kernel.iopub_socket, msg_type,\n\u001b[1;32m 67\u001b[0m \u001b[0mcontent\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 172\u001b[0m \u001b[0;31m# we don't understand it, it's probably an unserializable object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 173\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Can't clean for JSON: %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: Can't clean for JSON: " + ] + } + ], + "source": [ + "scatt1 = f1.add_scatter(x=iris_df.sepal_length, y=iris_df.petal_width)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d5079ee9c1542cfa4ecc1f8e93abd1f", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f1" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "scatt1.mode?" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# That's not what we wanted, change the mode to 'markers'\n", + "scatt1.mode = 'markers'" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set size to 8\n", + "scatt1.marker.size = 8" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Color markers by iris class\n", + "scatt1.marker.color = iris_class" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Change colorscale\n", + "scatt1.marker.cmin = 0.5\n", + "scatt1.marker.cmax = 3.5\n", + "scatt1.marker.colorscale = [[0, 'red'], [0.33, 'red'], \n", + " [0.33, 'green'], [0.67, 'green'], \n", + " [0.67, 'blue'], [1.0, 'blue']]\n", + "\n", + "scatt1.marker.showscale = True" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Fix up colorscale ticks\n", + "scatt1.marker.colorbar.ticks = 'outside'\n", + "scatt1.marker.colorbar.tickvals = [1, 2, 3]\n", + "scatt1.marker.colorbar.ticktext = iris_data.target_names.tolist()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set colorscale title\n", + "scatt1.marker.colorbar.title = 'Species'\n", + "scatt1.marker.colorbar.titlefont.size = 16\n", + "scatt1.marker.colorbar.titlefont.family = 'Rockwell'" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Add axis labels\n", + "f1.layout.xaxis.title = 'sepal_length'\n", + "f1.layout.yaxis.title = 'petal_width'" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d5079ee9c1542cfa4ecc1f8e93abd1f", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f1" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Hover info\n", + "scatt1.text = iris_data.target_names[iris_data.target]\n", + "scatt1.hoverinfo = 'text+x+y'\n", + "f1.layout.hovermode = 'closest'" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d5079ee9c1542cfa4ecc1f8e93abd1f", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Animate marker size change" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set marker size based on petal_length\n", + "with f1.batch_animate(duration=1000):\n", + " scatt1.marker.size = np.sqrt(iris_df.petal_length.values * 50)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Restore constant marker size\n", + "with f1.batch_animate(duration=1000):\n", + " scatt1.marker.size = 8" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set drag mode property callback\n", + "Make points more transparent when `dragmode` is `zoom`" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def set_opacity(marker, layout, dragmode):\n", + " if dragmode == 'zoom':\n", + " marker.opacity = 0.5\n", + " else:\n", + " marker.opacity = 1.0" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "f1.layout.on_change(partial(set_opacity, scatt1.marker), 'dragmode')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure colorscale for brushing" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "scatt1.marker.colorbar = None\n", + "scatt1.marker.colorscale = [[0, 'lightgray'], [0.5, 'lightgray'], [0.5, 'red'], [1, 'red']]\n", + "scatt1.marker.cmin = -0.5\n", + "scatt1.marker.cmax = 1.5\n", + "scatt1.marker.colorbar.ticks = 'outside'\n", + "scatt1.marker.colorbar.tickvals = [0, 1]\n", + "scatt1.marker.colorbar.ticktext = ['unselected', 'selected']" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Reset colors to zeros (unselected)\n", + "scatt1.marker.color = np.zeros(iris_class.size)\n", + "selected = np.zeros(iris_class.size)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d5079ee9c1542cfa4ecc1f8e93abd1f", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configure brushing callback" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Assigning these variables here is not required. But doing so tricks Jupyter into \n", + "# providing property tab completion on the parameters to the brush function below\n", + "trace, points, state = scatt1, Points(), InputDeviceState()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def brush(trace, points, state):\n", + " inds = np.array(points.point_inds)\n", + " if inds.size:\n", + " selected[inds] = 1\n", + " trace.marker.color = selected" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "scatt1.on_selected(brush)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now box or lasso select points on the figure and see them turn red" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Reset brush\n", + "selected = np.zeros(iris_class.size)\n", + "scatt1.marker.color = selected" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create second plot with different features" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e88d348677544c1ea2eca95ea8b30fdd", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type FigureWidget.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "FigureWidget()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f2 = FigureWidget(data=[{'type': 'scatter',\n", + " 'x': iris_df.petal_length, \n", + " 'y': iris_df.sepal_width,\n", + " 'mode': 'markers'}])\n", + "f2" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set axis titles\n", + "f2.layout.xaxis.title = 'petal_length'\n", + "f2.layout.yaxis.title = 'sepal_width'" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Grab trace reference\n", + "scatt2 = f2.data[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "collapsed": true, + "scrolled": false + }, + "outputs": [], + "source": [ + "# Set marker styles / colorbars to match between figures\n", + "scatt2.marker = scatt1.marker" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Configure brush on both plots to update both plots\n", + "def brush(trace, points, state):\n", + " inds = np.array(points.point_inds)\n", + " if inds.size:\n", + " selected = scatt1.marker.color.copy()\n", + " selected[inds] = 1\n", + " scatt1.marker.color = selected\n", + " scatt2.marker.color = selected \n", + " \n", + "scatt1.on_selected(brush)\n", + "scatt2.on_selected(brush)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "f2.layout.on_change(partial(set_opacity, scatt2.marker), 'dragmode')" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Reset brush\n", + "def reset_brush(btn):\n", + " selected = np.zeros(iris_class.size)\n", + " scatt1.marker.color = selected\n", + " scatt2.marker.color = selected" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create reset button\n", + "button = Button(description=\"clear\")\n", + "button.on_click(reset_brush)" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Hide colorbar for figure 1\n", + "scatt1.marker.showscale = False" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Set dragmode to lasso for both plots\n", + "f1.layout.dragmode = 'lasso'\n", + "f2.layout.dragmode = 'lasso'" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Display two figures and the reset button\n", + "f1.layout.width = 500\n", + "f2.layout.width = 500" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "74f7b16952584919b650fbc442c21773", + "version_major": 2, + "version_minor": 0 + }, + "text/html": [ + "

Failed to display Jupyter Widget of type VBox.

\n", + "

\n", + " If you're reading this message in the Jupyter Notebook or JupyterLab Notebook, it may mean\n", + " that the widgets JavaScript is still loading. If this message persists, it\n", + " likely means that the widgets JavaScript library is either not installed or\n", + " not enabled. See the Jupyter\n", + " Widgets Documentation for setup instructions.\n", + "

\n", + "

\n", + " If you're reading this message in another frontend (for example, a static\n", + " rendering on GitHub or NBViewer),\n", + " it may mean that your frontend doesn't currently support widgets.\n", + "

\n" + ], + "text/plain": [ + "VBox(children=(HBox(children=(FigureWidget(), FigureWidget())), Button(description='clear', style=ButtonStyle())))" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "VBox([HBox([f1, f2]), button])" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Save figure 2 to a svg image in the exports directory\n", + "f2.save_image('exports/f2.svg')" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Save figure 1 to a pdf in the exports directory (requires cairosvg be installed)\n", + "# f1.save_image('exports/f1.pdf')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/specs/ipyplotly_integration/Scatter GL Example.ipynb b/specs/ipyplotly_integration/Scatter GL Example.ipynb new file mode 100644 index 0000000000..0a2234a815 --- /dev/null +++ b/specs/ipyplotly_integration/Scatter GL Example.ipynb @@ -0,0 +1,167 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## ScatterGL Example\n", + "Data is transfered to JS side using ipywidgets binary protocol without JSON serialization" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# plotly\n", + "from plotly.graph_objs import Figure, FigureWidget, Scattergl\n", + "\n", + "# numpy\n", + "import numpy as np\n", + "\n", + "# core\n", + "import datetime\n", + "import time" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub data rate exceeded.\n", + "The notebook server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--NotebookApp.iopub_data_rate_limit`.\n" + ] + } + ], + "source": [ + "import plotly.offline as py\n", + "py.init_notebook_mode()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Create a one-million points scattergl trace\n", + "N = 1000000\n", + "scatt = Scattergl(x = np.random.randn(N), \n", + " y = np.random.randn(N),\n", + " mode = 'markers',\n", + " marker={'opacity': 0.8, 'line': {'width': 1}})\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Can't clean for JSON: ", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# Creating and displaying takes ~4 seconds\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfig\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mFigureWidget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mscatt\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/graph_objs/_figurewidget.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, layout, frames)\u001b[0m\n\u001b[1;32m 287\u001b[0m \u001b[0mrespective\u001b[0m \u001b[0mtraces\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mthe\u001b[0m \u001b[0mdata\u001b[0m \u001b[0mattribute\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 288\u001b[0m \"\"\"\n\u001b[0;32m--> 289\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mFigureWidget\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__init__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlayout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mframes\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 290\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 291\u001b[0m def add_area(\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basewidget.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, layout, frames)\u001b[0m\n\u001b[1;32m 126\u001b[0m super(BaseFigureWidget, self).__init__(data=data,\n\u001b[1;32m 127\u001b[0m \u001b[0mlayout_plotly\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlayout\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 128\u001b[0;31m frames=frames)\n\u001b[0m\u001b[1;32m 129\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;31m# Validate Frames\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basedatatypes.pyc\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data, layout_plotly, frames)\u001b[0m\n\u001b[1;32m 131\u001b[0m \u001b[0;31m# The _data property is a list of dicts containing the properties\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 132\u001b[0m \u001b[0;31m# explicitly set by the user for each trace.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 133\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_data\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mdeepcopy\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtrace\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_props\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mtrace\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 134\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;31m# ### Create data defaults ###\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/plotly/basedatatypes.pyc\u001b[0m in \u001b[0;36m__setattr__\u001b[0;34m(self, prop, value)\u001b[0m\n\u001b[1;32m 272\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mhasattr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mprop\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 273\u001b[0m \u001b[0;31m# Let known properties and private properties through\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 274\u001b[0;31m \u001b[0msuper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBaseFigure\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__setattr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprop\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 275\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 276\u001b[0m \u001b[0;31m# Raise error on unknown public properties\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36m__set__\u001b[0;34m(self, obj, value)\u001b[0m\n\u001b[1;32m 583\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mTraitError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'The \"%s\" trait is read-only.'\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 584\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 585\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 586\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 587\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_validate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36mset\u001b[0;34m(self, obj, value)\u001b[0m\n\u001b[1;32m 572\u001b[0m \u001b[0;31m# we explicitly compare silent to True just in case the equality\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 573\u001b[0m \u001b[0;31m# comparison above returns something other than True/False\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 574\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_notify_trait\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mold_value\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnew_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 575\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 576\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__set__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/traitlets/traitlets.pyc\u001b[0m in \u001b[0;36m_notify_trait\u001b[0;34m(self, name, old_value, new_value)\u001b[0m\n\u001b[1;32m 1137\u001b[0m \u001b[0mnew\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnew_value\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1138\u001b[0m \u001b[0mowner\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1139\u001b[0;31m \u001b[0mtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'change'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1140\u001b[0m ))\n\u001b[1;32m 1141\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36mnotify_change\u001b[0;34m(self, change)\u001b[0m\n\u001b[1;32m 395\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkeys\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_should_send_property\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchange\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'new'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 396\u001b[0m \u001b[0;31m# Send new state to front-end\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 397\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 398\u001b[0m \u001b[0mLoggingConfigurable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnotify_change\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mchange\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 399\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36msend_state\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 280\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffer_keys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_split_state_buffers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstate\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 281\u001b[0m \u001b[0mmsg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m'method'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'update'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'state'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstate\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'buffers'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mbuffer_keys\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 282\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_send\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 283\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 284\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdrop_defaults\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipywidgets/widgets/widget.pyc\u001b[0m in \u001b[0;36m_send\u001b[0;34m(self, msg, buffers)\u001b[0m\n\u001b[1;32m 534\u001b[0m \u001b[0;34m\"\"\"Sends a message to the model in the front-end.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 535\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkernel\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mNone\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 536\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 537\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 538\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/comm/comm.pyc\u001b[0m in \u001b[0;36msend\u001b[0;34m(self, data, metadata, buffers)\u001b[0m\n\u001b[1;32m 119\u001b[0m \u001b[0;34m\"\"\"Send a message to the frontend-side version of this comm\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 120\u001b[0m self._publish_msg('comm_msg',\n\u001b[0;32m--> 121\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmetadata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbuffers\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mbuffers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 122\u001b[0m )\n\u001b[1;32m 123\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/comm/comm.pyc\u001b[0m in \u001b[0;36m_publish_msg\u001b[0;34m(self, msg_type, data, metadata, buffers, **keys)\u001b[0m\n\u001b[1;32m 63\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mdata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0mmetadata\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mmetadata\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mNone\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mmetadata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 65\u001b[0;31m \u001b[0mcontent\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomm_id\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcomm_id\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkeys\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 66\u001b[0m self.kernel.session.send(self.kernel.iopub_socket, msg_type,\n\u001b[1;32m 67\u001b[0m \u001b[0mcontent\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 151\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 152\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 153\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 154\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 155\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 165\u001b[0m \u001b[0mout\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 166\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mv\u001b[0m \u001b[0;32min\u001b[0m \u001b[0miteritems\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 167\u001b[0;31m \u001b[0mout\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0municode_type\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mjson_clean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 168\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 169\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdatetime\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m/Library/Frameworks/Python.framework/Versions/2.7/lib/python2.7/site-packages/ipykernel/jsonutil.pyc\u001b[0m in \u001b[0;36mjson_clean\u001b[0;34m(obj)\u001b[0m\n\u001b[1;32m 171\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 172\u001b[0m \u001b[0;31m# we don't understand it, it's probably an unserializable object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 173\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Can't clean for JSON: %r\"\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mValueError\u001b[0m: Can't clean for JSON: " + ] + } + ], + "source": [ + "# Creating and displaying takes ~4 seconds\n", + "fig = FigureWidget(data=[scatt])\n", + "f" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "IOPub data rate exceeded.\n", + "The notebook server will temporarily stop sending output\n", + "to the client in order to avoid crashing it.\n", + "To change this limit, set the config variable\n", + "`--NotebookApp.iopub_data_rate_limit`.\n" + ] + } + ], + "source": [ + "# Plotting using iplot takes ~25 seconds\n", + "fig = Figure(data=[scatt])\n", + "py.iplot(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/specs/ipyplotly_integration/exports/README.md b/specs/ipyplotly_integration/exports/README.md new file mode 100644 index 0000000000..4c2ab53424 --- /dev/null +++ b/specs/ipyplotly_integration/exports/README.md @@ -0,0 +1 @@ +This is a directory to save example images diff --git a/specs/ipyplotly_integration/exports/tmp.html b/specs/ipyplotly_integration/exports/tmp.html new file mode 100644 index 0000000000..6df7c21bba --- /dev/null +++ b/specs/ipyplotly_integration/exports/tmp.html @@ -0,0 +1,14 @@ +
\ No newline at end of file diff --git a/tox.ini b/tox.ini index 468f9b4580..57609e8989 100644 --- a/tox.ini +++ b/tox.ini @@ -57,6 +57,7 @@ deps= requests==2.12.4 six==1.10.0 pytz==2016.10 + retrying==1.3.3 optional: numpy==1.11.3 optional: ipython[all]==5.1.0 optional: jupyter==1.0.0 @@ -91,6 +92,12 @@ commands= python --version nosetests {posargs} -x plotly/tests/test_core +[testenv:py36-core] +basepython={env:PLOTLY_TOX_PYTHON_36:} +commands= + python --version + nosetests {posargs} -x plotly/tests/test_core + ; OPTIONAL ENVIRONMENTS [testenv:py27-optional] basepython={env:PLOTLY_TOX_PYTHON_27:} @@ -113,3 +120,9 @@ basepython={env:PLOTLY_TOX_PYTHON_35:} commands= python --version nosetests {posargs} -x plotly/tests + +[testenv:py36-optional] +basepython={env:PLOTLY_TOX_PYTHON_36:} +commands= + python --version + nosetests {posargs} -x plotly/tests diff --git a/update_graph_objs.py b/update_graph_objs.py deleted file mode 100644 index 0414dd0c18..0000000000 --- a/update_graph_objs.py +++ /dev/null @@ -1,298 +0,0 @@ -from __future__ import print_function - -from plotly.graph_objs import graph_objs_tools -from plotly.graph_reference import ARRAYS, CLASSES - -FLAG = '# AUTO-GENERATED BELOW. DO NOT EDIT! See makefile.' - - -def get_non_generated_file_lines(): - """ - Copy each line up to our special FLAG line and return. - - :raises: (ValueError) If the FLAG isn't found. - :return: (list) The lines we're copying. - """ - - lines_to_copy = [] - flag_found = False - with open('./plotly/graph_objs/graph_objs.py', 'r') as f: - for line_to_copy in f: - if line_to_copy.startswith(FLAG): - flag_found = True - break - lines_to_copy.append(line_to_copy) - if not flag_found: - raise ValueError( - 'Failed to find flag:\n"{}"\nin graph_objs_tools.py.'.format(FLAG) - ) - return lines_to_copy - - -def print_figure_patch(f): - """Print a patch to our Figure object into the given open file.""" - - print( - ''' - def __init__(self, *args, **kwargs): - super(Figure, self).__init__(*args, **kwargs) - if 'data' not in self: - self.data = Data(_parent=self, _parent_key='data') - - def get_data(self, flatten=False): - """ - Returns the JSON for the plot with non-data elements stripped. - - Flattening may increase the utility of the result. - - :param (bool) flatten: {'a': {'b': ''}} --> {'a.b': ''} - :returns: (dict|list) Depending on (flat|unflat) - - """ - return self.data.get_data(flatten=flatten) - - def to_dataframe(self): - """ - Create a dataframe with trace names and keys as column names. - - :return: (DataFrame) - - """ - data = self.get_data(flatten=True) - from pandas import DataFrame, Series - return DataFrame( - dict([(k, Series(v)) for k, v in data.items()])) - - def print_grid(self): - """ - Print a visual layout of the figure's axes arrangement. - - This is only valid for figures that are created - with plotly.tools.make_subplots. - - """ - try: - grid_str = self.__dict__['_grid_str'] - except AttributeError: - raise Exception("Use plotly.tools.make_subplots " - "to create a subplot grid.") - print(grid_str) - - def append_trace(self, trace, row, col): - """ - Add a trace to your figure bound to axes at the row, col index. - - The row, col index is generated from figures created with - plotly.tools.make_subplots and can be viewed with - Figure.print_grid. - - :param (dict) trace: The data trace to be bound. - :param (int) row: Subplot row index (see Figure.print_grid). - :param (int) col: Subplot column index (see Figure.print_grid). - - Example: - # stack two subplots vertically - fig = tools.make_subplots(rows=2) - - This is the format of your plot grid: - [ (1,1) x1,y1 ] - [ (2,1) x2,y2 ] - - fig.append_trace(Scatter(x=[1,2,3], y=[2,1,2]), 1, 1) - fig.append_trace(Scatter(x=[1,2,3], y=[2,1,2]), 2, 1) - - """ - try: - grid_ref = self._grid_ref - except AttributeError: - raise Exception("In order to use Figure.append_trace, " - "you must first use " - "plotly.tools.make_subplots " - "to create a subplot grid.") - if row <= 0: - raise Exception("Row value is out of range. " - "Note: the starting cell is (1, 1)") - if col <= 0: - raise Exception("Col value is out of range. " - "Note: the starting cell is (1, 1)") - try: - ref = grid_ref[row-1][col-1] - except IndexError: - raise Exception("The (row, col) pair sent is out of " - "range. Use Figure.print_grid to view the " - "subplot grid. ") - if 'scene' in ref[0]: - trace['scene'] = ref[0] - if ref[0] not in self['layout']: - raise Exception("Something went wrong. " - "The scene object for ({r},{c}) " - "subplot cell " - "got deleted.".format(r=row, c=col)) - else: - xaxis_key = "xaxis{ref}".format(ref=ref[0][1:]) - yaxis_key = "yaxis{ref}".format(ref=ref[1][1:]) - if (xaxis_key not in self['layout'] - or yaxis_key not in self['layout']): - raise Exception("Something went wrong. " - "An axis object for ({r},{c}) subplot " - "cell got deleted." - .format(r=row, c=col)) - trace['xaxis'] = ref[0] - trace['yaxis'] = ref[1] - self['data'] += [trace] -''', file=f, end='' - ) - - -def print_data_patch(f): - """Print a patch to our Data object into the given open file.""" - print( - ''' - def _value_to_graph_object(self, index, value, _raise=True): - - if not isinstance(value, dict): - if _raise: - notes = ['Entry should subclass dict.'] - path = self._get_path() + (index, ) - raise exceptions.PlotlyListEntryError(self, path, - notes=notes) - else: - return - - item = value.get('type', 'scatter') - if item not in graph_reference.ARRAYS['data']['items']: - if _raise: - path = self._get_path() + (0, ) - raise exceptions.PlotlyDataTypeError(self, path) - - return GraphObjectFactory.create(item, _raise=_raise, - _parent=self, - _parent_key=index, **value) - - def get_data(self, flatten=False): - """ - Returns the JSON for the plot with non-data elements stripped. - - :param (bool) flatten: {'a': {'b': ''}} --> {'a.b': ''} - :returns: (dict|list) Depending on (flat|unflat) - - """ - if flatten: - data = [v.get_data(flatten=flatten) for v in self] - d = {} - taken_names = [] - for i, trace in enumerate(data): - - # we want to give the traces helpful names - # however, we need to be sure they're unique too... - trace_name = trace.pop('name', 'trace_{0}'.format(i)) - if trace_name in taken_names: - j = 1 - new_trace_name = "{0}_{1}".format(trace_name, j) - while new_trace_name in taken_names: - new_trace_name = ( - "{0}_{1}".format(trace_name, j) - ) - j += 1 - trace_name = new_trace_name - taken_names.append(trace_name) - - # finish up the dot-concatenation - for k, v in trace.items(): - key = "{0}.{1}".format(trace_name, k) - d[key] = v - return d - else: - return super(Data, self).get_data(flatten=flatten) -''', file=f, end='' - ) - - -def print_frames_patch(f): - """Print a patch to our Frames object into the given open file.""" - print( - ''' - def _value_to_graph_object(self, index, value, _raise=True): - if isinstance(value, six.string_types): - return value - return super(Frames, self)._value_to_graph_object(index, value, - _raise=_raise) - - def to_string(self, level=0, indent=4, eol='\\n', - pretty=True, max_chars=80): - """Get formatted string by calling `to_string` on children items.""" - if not len(self): - return "{name}()".format(name=self._get_class_name()) - string = "{name}([{eol}{indent}".format( - name=self._get_class_name(), - eol=eol, - indent=' ' * indent * (level + 1)) - for index, entry in enumerate(self): - if isinstance(entry, six.string_types): - string += repr(entry) - else: - string += entry.to_string(level=level+1, - indent=indent, - eol=eol, - pretty=pretty, - max_chars=max_chars) - if index < len(self) - 1: - string += ",{eol}{indent}".format( - eol=eol, - indent=' ' * indent * (level + 1)) - string += ( - "{eol}{indent}])").format(eol=eol, indent=' ' * indent * level) - return string -''', file=f, end='' - ) - - -def print_class(name, f): - class_dict = CLASSES[name] - print('\n', file=f) - object_name = class_dict['object_name'] - base_type = class_dict['base_type'] - - # This is for backwards compat (e.g., Trace) and future changes. - if object_name is None: - print('class {}({}):'.format(name, base_type.__name__), - file=f) - print(' pass', file=f) - return - - doc = graph_objs_tools.get_help(object_name) - if object_name in ARRAYS: - base_name = 'PlotlyList' - else: - base_name = 'PlotlyDict' - print('class {}({}):'.format(name, base_name), file=f) - doc_lines = doc.splitlines() - print(' """', file=f) - for doc_line in doc_lines: - print(' ' + doc_line, file=f) - print('\n """', file=f) - print(" _name = '{}'".format(object_name), file=f) - if name == 'Figure': - print_figure_patch(f) - elif name == 'Data': - print_data_patch(f) - elif name == 'Frames': - print_frames_patch(f) - -copied_lines = get_non_generated_file_lines() -with open('./plotly/graph_objs/graph_objs.py', 'w') as graph_objs_file: - - # Keep things *exactly* as they were above our special FLAG. - for line in copied_lines: - print(line, file=graph_objs_file, end='') - print(FLAG, file=graph_objs_file) - - # For each object in the plot schema, generate a class in the file. - class_names = list(CLASSES.keys()) - class_names.sort() - for class_name in class_names: - print_class(class_name, graph_objs_file) - - # Finish off the file by only exporting plot-schema names. - print('\n__all__ = [cls for cls in graph_reference.CLASSES.keys() ' - 'if cls in globals()]', file=graph_objs_file)